| blob | 218197b8ffd1455c9af60286d8ad3acc7959845b |
1 @c English version 2011-06-15
2 @menu
3 * Introducción a la definición de funciones::
4 * Funciones::
5 * Macros::
6 * Funciones y variables para la definición de funciones::
7 @end menu
9 @node Introducción a la definición de funciones, Funciones, Definición de Funciones, Definición de Funciones
10 @section Introducción a la definición de funciones
12 @node Funciones, Macros, Introducción a la definición de funciones, Definición de Funciones
14 @section Funciones
15 @subsection Funciones ordinarias
17 Para definir una función en Maxima es necesario utilizar el operador ':='.
19 Por ejemplo,
21 @example
22 f(x) := sin(x)
23 @end example
24 @noindent
26 define una función @code{f}. También se pueden definir funciones anónimas utilizando @code{lambda}; por ejemplo,
28 @example
29 lambda ([i, j], ...)
30 @end example
32 @noindent
33 puede utilizarse en lugar de @code{f} donde
35 @example
36 f(i,j) := block ([], ...);
37 map (lambda ([i], i+1), l)
38 @end example
40 @noindent
41 devolvería una lista con todos sus elementos aumentados en una unidad.
43 También se puede definir una función con un número variable de argumentos, sin más que añadir un argumento final al que se le asigna una lista con todos los argumentos adicionales.:
45 @example
46 (%i1) f ([u]) := u;
47 (%o1) f([u]) := u
48 (%i2) f (1, 2, 3, 4);
49 (%o2) [1, 2, 3, 4]
50 (%i3) f (a, b, [u]) := [a, b, u];
51 (%o3) f(a, b, [u]) := [a, b, u]
52 (%i4) f (1, 2, 3, 4, 5, 6);
53 (%o4) [1, 2, [3, 4, 5, 6]]
54 @end example
56 El miembro derecho de una función debe ser una expresión. Así, si se quiere una secuencia de expresiones, se debe hacer
58 @example
59 f(x) := (expr1, expr2, ...., exprn);
60 @end example
62 siendo el valor que alcance exprn el devuelto por la función.
64 Si se quiere hacer un @code{return} desde alguna de las expresiones de la función, se debe utilizar la estructura @code{block} junto con @code{return}. Por ejemplo,
66 @example
67 block ([], expr1, ..., if (a > 10) then return(a), ..., exprn)
68 @end example
70 es una expresión de pleno derecho, por lo que puede ocupar el lado derecho de la definición de una función. Aquí puede ocurrir que el retorno se produzca antes que se alcance la última expresión.
72 Los primeros corchetes del bloque (@code{[]}) pueden contener una lista de variables junto con posibles asignaciones, tal como @code{[a: 3, b, c: []]}, lo que provocará que las tres variables @code{a},@code{b} y @code{c} se consideren locales y sean independientes de otras globales con el mismo nombre; las variables locales sólo estarán activas mientras se ejecute el código que está dentro de la estructura @code{block}, o dentro de funciones que son llamadas desde dentro de @code{block}. A esto se le llama asignación dinámica, pues las variables sobreviven desde el inicio del bloque hasta que éste deje de estar operativo. Una vez se salga del bloque los valores originales de las variables, si es que los había, quedan restaurados. Es recomendable proteger las variables de esta forma. Se tendrá en cuenta que las asignaciones a las variables del bloque se hacen en paralelo, lo que significa que si como en el ejemplo anterior se hace @code{c: a} en el momento de entrar en el bloque, el valor de @code{c} será el que tenía @code{a} antes de entrar en el bloque, es decir, antes de la asignación @code{a: 3}. Así, haciendo lo siguiente
75 @example
76 block ([a: a], expr1, ... a: a+3, ..., exprn)
77 @end example
79 se prevendría de que el valor externo de @code{a} fuese alterado, pero permitiría acceder a él desde dentro del bloque. La parte derecha de las asignaciones se evalúa dentro de su contexto antes de hacer efectiva la asignación. Utilizando únicamente @code{block([x],..} haría que @code{x} se tuviese a sí misma como valor, justo como si se acabase de iniciar una nueva sesión de Maxima.
81 Los valores de los argumentos de una funcón se tratan exactamente de la misma forma que las variables de un bloque. Así, con
83 @example
84 f(x) := (expr1, ..., exprn);
85 @end example
87 y
89 @example
90 f(1);
91 @end example
93 se estaría en un contexto similar para la evaluación de las expresiones como si se hubiera hecho
95 @example
96 block ([x: 1], expr1, ..., exprn)
97 @end example
99 Dentro de las funciones, cuando el lado derecho de la definición deba ser evaluado será útil hacer uso de @code{define} y posiblemente de @code{buildq}.
101 @subsection Funciones array
103 Una función array almacena el valor de la función la primera
104 vez que es invocada con un argumento dado, devolviendo el valor
105 almacenado sin recalcularlo cuando es llamada con ese mismo argumento.
106 Estas funciones reciben también el nombre de @i{funciones memorizadoras}.
108 Los nombres de las funciones array son añadidos a la lista global
109 @code{arrays}, no a la lista global @code{functions}.
110 La función @code{arrayinfo} devuelve la lista de argumentos para
111 los que hay valores almacenados y @code{listarray} devuelve precisamente
112 estos valores almacenados.
113 Las funciones @code{dispfun} y @code{fundef} devuelven la definición
114 de la función array.
116 La función @code{arraymake} construye una llamada a una función array,
117 de forma similar a como lo hace @code{funmake} para las funciones
118 ordinarias. Por otro lado, @code{arrayapply} aplica una función array
119 a sus argumentos, tal como lo hace @code{apply} con las funciones
120 ordinarias. No existe para las funciones array nada similar a @code{map},
121 aunque @code{map(lambda([@var{x}], @var{a}[@var{x}]), @var{L})} o
122 @code{makelist(@var{a}[@var{x}], @var{x}, @var{L})},
123 siendo @var{L} una lista, podrían suplantar esta
124 carencia.
126 La función @code{remarray} borra la definición de una función array,
127 así como cualesquiera valores almacenados que tenga asociados,
128 tal como @code{remfunction} lo hace con las funciones ordinarias.
130 La llamada @code{kill(@var{a}[@var{x}])} borra el valor de la función array
131 @var{a} almacenado para el argumento @var{x};
132 la próxima vez que se llame a @var{a} con el argumento @var{x},
133 se recalculará el valor correspondiente.
134 Sin embargo, no hay forma de borrar todos los valores almacenados de
135 una sola vez, excepto mediante @code{kill(@var{a})} o @code{remarray(@var{a})},
136 con lo que se borra también la definición de la propia función.
138 @node Macros, Funciones y variables para la definición de funciones, Funciones, Definición de Funciones
139 @section Macros
142 @deffn {Función} buildq (@var{L}, @var{expr})
143 Sustituye en paralelo las variables nombradas en la lista @var{L} en la expresión @var{expr}, sin evaluar ésta.
144 La expresión resultante se simplifica pero no se evalúa hasta que @code{buildq} termine de hacer las sustituciones.
146 Los elementos de @var{L} son símbolos o expresiones de asignación del tipo @code{@var{symbol}: @var{value}},
147 evaluadas en paralelo. Esto es, el valor de una variable en la parte derecha de una asignación es el valor que toma dicha variable en el contexto desde el que se invoca a @code{buildq}. En caso de que a una variable de @var{L} no se le haga una signación explícita, su valor en @code{buildq} es el mismo que tiene en el contexto desde el que se llama a @code{buildq}.
149 Las variables referenciadas en @var{L} se sustituyen en @var{expr} en paralelo. Esto es, la sustitución para cada variable se determina antes de que se hagan las sustituciones, de forma que la sustitución de una variable no tiene efecto alguno sobre las otras.
151 Si alguna variable @var{x} aparece como @code{splice (@var{x})} en @var{expr}, entonces a @var{x} se le debe asignar una lista, la cual será interpolada en @var{expr} en lugar de hacer una simple sustitución; ver ejemplo más abajo.
153 Cualesquiera otras variables de @var{expr} que no aparezcan en @var{L} se traspasan al resultado tal cual, incluso cuando tienen asignados valores en el contexto desde el que se llama a @code{buildq}.
155 Ejemplos:
157 @code{a} queda asociada explícitamente a @code{x}, mientras que @code{b} tiene la misma asociación (29) que en el contexto de llamada y @code{c} es traspasado al resultado sin ser sustituido. La expresión resultante no se evalúa hasta que no se le obligue a ello mediante la evaluación explícita @code{''%}.
159 @c ===beg===
160 @c (a: 17, b: 29, c: 1729)$
161 @c buildq ([a: x, b], a + b + c);
162 @c ''%;
163 @c ===end===
164 @example
165 (%i1) (a: 17, b: 29, c: 1729)$
166 (%i2) buildq ([a: x, b], a + b + c);
167 (%o2) x + c + 29
168 (%i3) ''%;
169 (%o3) x + 1758
170 @end example
172 En este ejemplo, @code{e} se asocia a una lista, la cual aparece como tal en los argumentos de @code{foo} e interpolada en los argumentos de @code{bar}.
174 @c ===beg===
175 @c buildq ([e: [a, b, c]], foo (x, e, y));
176 @c buildq ([e: [a, b, c]], bar (x, splice (e), y));
177 @c ===end===
178 @example
179 (%i1) buildq ([e: [a, b, c]], foo (x, e, y));
180 (%o1) foo(x, [a, b, c], y)
181 (%i2) buildq ([e: [a, b, c]], bar (x, splice (e), y));
182 (%o2) bar(x, a, b, c, y)
183 @end example
185 Como se ve a continuación, el resultado se simplifica tras las sustituciones. Si la simplificación se realizase antes que las sustituciones, ambos resultados serían iguales.
187 @c ===beg===
188 @c buildq ([e: [a, b, c]], splice (e) + splice (e));
189 @c buildq ([e: [a, b, c]], 2 * splice (e));
190 @c ===end===
191 @example
192 (%i1) buildq ([e: [a, b, c]], splice (e) + splice (e));
193 (%o1) 2 c + 2 b + 2 a
194 (%i2) buildq ([e: [a, b, c]], 2 * splice (e));
195 (%o2) 2 a b c
196 @end example
198 Las variables de @var{L} se asocian en paralelo; si se hiciese secuencialmente, el primer resultado sería @code{foo (b, b)}. Las sustituciones se llevan a cabo en paralelo. Compárese el segundo resultado con el resultado de @code{subst}, que hace las sustituciones de forma secuencial.
200 @c ===beg===
201 @c buildq ([a: b, b: a], foo (a, b));
202 @c buildq ([u: v, v: w, w: x, x: y, y: z, z: u],
203 @c bar (u, v, w, x, y, z));
204 @c subst ([u=v, v=w, w=x, x=y, y=z, z=u],
205 @c bar (u, v, w, x, y, z));
206 @c ===end===
207 @example
208 (%i1) buildq ([a: b, b: a], foo (a, b));
209 (%o1) foo(b, a)
210 (%i2) buildq ([u: v, v: w, w: x, x: y, y: z, z: u],
211 bar (u, v, w, x, y, z));
212 (%o2) bar(v, w, x, y, z, u)
213 (%i3) subst ([u=v, v=w, w=x, x=y, y=z, z=u],
214 bar (u, v, w, x, y, z));
215 (%o3) bar(u, u, u, u, u, u)
216 @end example
218 Se construye a continuación un sistema de ecuaciones con algunas variables o expresiones en el lado izquierdo y sus valores en el derecho; @code{macroexpand} muestra la expresión devuelta por @code{show_values}.
220 @c ===beg===
221 @c show_values ([L]) ::= buildq ([L], map ("=", 'L, L));
222 @c (a: 17, b: 29, c: 1729)$
223 @c show_values (a, b, c - a - b);
224 @c macroexpand (show_values (a, b, c - a - b));
225 @c ===end===
226 @example
227 (%i1) show_values ([L]) ::= buildq ([L], map ("=", 'L, L));
228 (%o1) show_values([L]) ::= buildq([L], map("=", 'L, L))
229 (%i2) (a: 17, b: 29, c: 1729)$
230 (%i3) show_values (a, b, c - a - b);
231 (%o3) [a = 17, b = 29, c - b - a = 1683]
232 (%i4) macroexpand (show_values (a, b, c - a - b));
233 (%o4) map(=, '([a, b, c - b - a]), [a, b, c - b - a])
234 @end example
236 Dada una función con varios argumentos, se crea otra función
237 en la cual algunos argumentos son fijos.
239 @c ===beg===
240 @c curry (f, [a]) :=
241 @c buildq ([f, a], lambda ([[x]], apply (f, append (a, x))))$
242 @c by3 : curry ("*", 3);
243 @c by3 (a + b);
244 @c ===end===
246 @example
247 (%i1) curry (f, [a]) :=
248 buildq ([f, a], lambda ([[x]], apply (f, append (a, x))))$
249 (%i2) by3 : curry ("*", 3);
250 (%o2) lambda([[x]], apply(*, append([3], x)))
251 (%i3) by3 (a + b);
252 (%o3) 3 (b + a)
253 @end example
254 @end deffn
258 @deffn {Función} macroexpand (@var{expr})
259 Devuelve la macroexpansión de @var{expr}, sin evaluarla,
260 cuando @code{expr} es una llamada a una función macro; en caso contrario,
261 @code{macroexpand} devuelve @var{expr}.
263 Si la expansión de @var{expr} devuelve otra llamada a una función macro, esta llamada también se expande.
265 La función @code{macroexpand} no evalúa su argumento.
266 Sin embargo, si la expansión de una llamada a función macro tiene efectos laterales, éstos se ejecutan.
268 Véanse también @code{::=}, @code{macros} y @code{macroexpand1}.
270 Ejemplos:
272 @c ===beg===
273 @c g (x) ::= x / 99;
274 @c h (x) ::= buildq ([x], g (x - a));
275 @c a: 1234;
276 @c macroexpand (h (y));
277 @c h (y);
278 @c ===end===
279 @example
280 (%i1) g (x) ::= x / 99;
281 x
282 (%o1) g(x) ::= --
283 99
284 (%i2) h (x) ::= buildq ([x], g (x - a));
285 (%o2) h(x) ::= buildq([x], g(x - a))
286 (%i3) a: 1234;
287 (%o3) 1234
288 (%i4) macroexpand (h (y));
289 y - a
290 (%o4) -----
291 99
292 (%i5) h (y);
293 y - 1234
294 (%o5) --------
295 99
296 @end example
298 @end deffn
300 @deffn {Función} macroexpand1 (@var{expr})
301 Devuelve la macroexpansión de @var{expr}, sin evaluarla,
302 cuando @code{expr} es una llamada a una función macro; en caso contrario,
303 @code{macroexpand1} devuelve @var{expr}.
305 La función @code{macroexpand1} no evalúa su argumento.
306 Sin embargo, si la expansión de una llamada a función macro tiene efectos laterales, éstos se ejecutan.
308 Si la expansión de @var{expr} devuelve otra llamada a una función macro, esta llamada no se expande.
310 Véanse también @code{::=}, @code{macros} y @code{macroexpand}.
312 Ejemplos:
314 @c ===beg===
315 @c g (x) ::= x / 99;
316 @c h (x) ::= buildq ([x], g (x - a));
317 @c a: 1234;
318 @c macroexpand1 (h (y));
319 @c h (y);
320 @c ===end===
321 @example
322 (%i1) g (x) ::= x / 99;
323 x
324 (%o1) g(x) ::= --
325 99
326 (%i2) h (x) ::= buildq ([x], g (x - a));
327 (%o2) h(x) ::= buildq([x], g(x - a))
328 (%i3) a: 1234;
329 (%o3) 1234
330 (%i4) macroexpand1 (h (y));
331 (%o4) g(y - a)
332 (%i5) h (y);
333 y - 1234
334 (%o5) --------
335 99
336 @end example
338 @end deffn
340 @defvr {Variable global} macros
341 Valor por defecto: @code{[]}
343 La variable @code{macros} es la lista de las funciones macro definidas por el usuario.
344 El operador de definición de funciones macro @code{::=} coloca la nueva función macro en esta lista,
345 mientras que @code{kill}, @code{remove} y @code{remfunction} eliminan las funciones macro de la lista.
347 Véase también @code{infolists}.
349 @end defvr
351 @deffn {Función} splice (@var{a})
353 Interpola la lista nombrada por el átomo @var{a} dentro de una expresión, pero sólo si @code{splice} aparece dentro de @code{buildq}; en otro caso, @code{splice} se considera una función no definida. Si @var{a} aparece dentro de @code{buildq} sin @code{splice}, entonces queda sustituida por una lista dentro del resultado. El argumento de @code{splice} debe ser un átomo, no pudiendo ser una lista literal ni una expresión que devuelva una lista.
355 Normalmente @code{splice} suministra los argumentos para una función u operador. Para una función @code{f}, la expresión @code{f (splice (@var{a}))} dentro de @code{buildq} se convierte en @code{f (@var{a}[1], @var{a}[2], @var{a}[3], ...)}. Dado un operador @code{o}, la expresión @code{"o" (splice (@var{a})} dentro de @code{buildq} se convierte en
356 @code{"o" (@var{a}[1], @var{a}[2], @var{a}[3], ...)}, donde @code{o} puede ser cualquier tipo de operador, normalmente uno que admita varios argumentos. Nótese que el operador debe ir encerrado entre comillas dobles @code{"}.
358 Ejemplos:
360 @c ===beg===
361 @c buildq ([x: [1, %pi, z - y]], foo (splice (x)) / length (x));
362 @c buildq ([x: [1, %pi]], "/" (splice (x)));
363 @c matchfix ("<>", "<>");
364 @c buildq ([x: [1, %pi, z - y]], "<>" (splice (x)));
365 @c ===end===
366 @example
367 (%i1) buildq ([x: [1, %pi, z - y]], foo (splice (x)) / length (x));
368 foo(1, %pi, z - y)
369 (%o1) -----------------------
370 length([1, %pi, z - y])
371 (%i2) buildq ([x: [1, %pi]], "/" (splice (x)));
372 1
373 (%o2) ---
374 %pi
375 (%i3) matchfix ("<>", "<>");
376 (%o3) <>
377 (%i4) buildq ([x: [1, %pi, z - y]], "<>" (splice (x)));
378 (%o4) <>1, %pi, z - y<>
379 @end example
381 @end deffn
383 @node Funciones y variables para la definición de funciones, , Macros, Definición de Funciones
384 @section Funciones y variables para la definición de funciones
386 @deffn {Función} apply (@var{F}, [@var{x_1}, ..., @var{x_n}])
387 Construye y evalúa la expresión @code{@var{F}(@var{arg_1}, ..., @var{arg_n})}.
389 La función @code{apply} no hace distinciones entre funciones array y
390 funciones ordinarias; cuando @var{F} es el nombre de una función array,
391 @code{apply} evalúa @code{@var{F}(...)}, esto es, hace una llamada con
392 paréntesis en lugar de corchetes. La función @code{arrayapply}
393 evalúa una llamada a función con corchetes para estos casos.
395 Ejemplos:
397 La función @code{apply} evalúa sus argumentos.
398 En este ejemplo, @code{min} se aplica al valor de @code{L}.
400 @c ===beg===
401 @c L : [1, 5, -10.2, 4, 3];
402 @c apply (min, L);
403 @c ===end===
404 @example
405 (%i1) L : [1, 5, -10.2, 4, 3];
406 (%o1) [1, 5, - 10.2, 4, 3]
407 (%i2) apply (min, L);
408 (%o2) - 10.2
409 @end example
411 La función @code{apply} evalúa sus argumentos,
412 incluso cuando la función @var{F} no lo hace.
414 @c ===beg===
415 @c F (x) := x / 1729;
416 @c fname : F;
417 @c dispfun (F);
418 @c dispfun (fname);
419 @c apply (dispfun, [fname]);
420 @c ===end===
421 @example
422 (%i1) F (x) := x / 1729;
423 x
424 (%o1) F(x) := ----
425 1729
426 (%i2) fname : F;
427 (%o2) F
428 (%i3) dispfun (F);
429 x
430 (%t3) F(x) := ----
431 1729
433 (%o3) [%t3]
434 (%i4) dispfun (fname);
435 fname is not the name of a user function.
436 -- an error. Quitting. To debug this try debugmode(true);
437 (%i5) apply (dispfun, [fname]);
438 x
439 (%t5) F(x) := ----
440 1729
442 (%o5) [%t5]
443 @end example
445 La función @code{apply} evalúa el nombre de función @var{F}.
446 La comilla simple @code{'} evita la evaluación.
447 El nombre @code{demoivre} corresponde a una variable global y
448 también a una función.
450 @c ===beg===
451 @c demoivre;
452 @c demoivre (exp (%i * x));
453 @c apply (demoivre, [exp (%i * x)]);
454 @c apply ('demoivre, [exp (%i * x)]);
455 @c ===end===
456 @example
457 (%i1) demoivre;
458 (%o1) false
459 (%i2) demoivre (exp (%i * x));
460 (%o2) %i sin(x) + cos(x)
461 (%i3) apply (demoivre, [exp (%i * x)]);
462 demoivre evaluates to false
463 Improper name or value in functional position.
464 -- an error. Quitting. To debug this try debugmode(true);
465 (%i4) apply ('demoivre, [exp (%i * x)]);
466 (%o4) %i sin(x) + cos(x)
467 @end example
469 @end deffn
472 @deffn {Función} block ([@var{v_1}, ..., @var{v_m}], @var{expr_1}, ..., @var{expr_n})
473 @deffnx {Función} block (@var{expr_1}, ..., @var{expr_n})
475 La función @code{block} evalúa @var{expr_1}, ..., @var{expr_n} secuencialmente y devuelve el valor de la última expresión evaluada. La secuencia puede alterarse con las funciones @code{go}, @code{throw} y @code{return}. La última expresión es @var{expr_n} a menos que @code{return} o una expresión que contenga un @code{throw} sea evaluada. Las variables @var{v_1}, ..., @var{v_m} son locales en el bloque; éstas se distiguen de las globales que tengan el mismo nombre. Si no se declaran variables locales entonces se puede omitir la lista. Dentro del bloque, cualquier otra variable distinta de @var{v_1}, ..., @var{v_m} se considera global.
477 La función @code{block} guarda los valores actuales de las variables @var{v_1}, ..., @var{v_m}, si los tienen, a la entrada del bloque y luego las evalúa a sí mismas, es decir les saca el valor temporalmente. A las variables locales se les puede asignar cualquier valor dentro del bloque, pero al salir de éste, los valores inicialmente almacenados quedan restaurados, al tiempo que los asignados dentro del bloque se pierden.
479 La declaración @code{local(@var{v_1}, ..., @var{v_m})} dentro de un bloque
480 almacena las propiedades asociadas a los símbolos @var{v_1}, ..., @var{v_m},
481 borra cualesquiera otras propiedades antes de evaluar las expresiones y
482 restaura las propiedades guardadas antes de abandonar el bloque.
483 Algunas declaraciones, como @code{:=}, @code{array}, @code{dependencies}, @code{atvalue},
484 @code{matchdeclare}, @code{atomgrad}, @code{constant}, @code{nonscalar}, @code{assume}
485 y otras se implementan como propiedades de símbolos.
486 El efecto producido por @code{local} consiste en hacer que tales declaraciones tengan
487 efecto sólo dentro del bloque, en otro caso las declaraciones dentro del bloque
488 tendrían un efecto global que afectarían al exterior de @code{block}.
490 Un @code{block} puede aparecer dentro de otro @code{block}. Las variables locales se inicializan cada vez que se entra dentro de un nuevo bloque. Las variables locales de un bloque se consideran globales dentro de otro anidado dentro del primero. Si una variable es no local dentro de un bloque, su valor es el que le corresponde en el bloque superior. Este criterio se conoce con el nombre de "alcance dinámico".
492 El valor del bloque es el de la última sentencia o el argumento de la función @code{return}, que puede utilizarse para salir del bloque. La función @code{go} puede usarse para transferir el control a la sentencia del bloque que esté etiquetada con el argumento de @code{go}. Para etiquetar una sentencia basta que vaya precedida de un argumento atómico como cualquier otra sentencia dentro del bloque. Por ejemplo, @code{block ([x], x:1, tururu, x: x+1, ..., go(tururu), ...)}. El argumento de @code{go} debe ser el nombre de una etiqueta colocada dentro del bloque. No se puede utilzar @code{go} para trasladarse a una etiqueta de un bloque que no sea el que contenga a @code{go}.
494 Normalmente los bloques aparecerán al lado derecho de las definiciones de funciones, pero también pueden utilizarse en otros contextos.
496 @end deffn
498 @deffn {Función} break (@var{expr_1}, ..., @var{expr_n})
500 Calcula e imprime @var{expr_1}, ..., @var{expr_n} para luego provocar la detención de Maxima, de modo que el usuario pueda examinar y cambiar el entorno de ejecución. Pulsando posteriormente @code{exit;} el cálculo se reanuda.
502 @end deffn
504 @deffn {Función} catch (@var{expr_1}, ..., @var{expr_n})
506 Evalúa @var{expr_1}, ..., @var{expr_n} una a una; si alguna de ellas conlleva la evaluación de una expresión de la forma @code{throw (arg)}, entonces el valor de @code{catch} es el de @code{throw (arg)} y ya no se evalúan más expresiones. Esta respuesta pasa todos los niveles de anidamiento hasta el @code{catch} más próximo. Si no hay ningún @code{catch} que contenga un @code{throw} se emite un mensaje de error.
508 Si la evaluación de los argumentos no conlleva la evaluación de ningún @code{throw}, entonces el valor de @code{catch} es el devuelto por @var{expr_n}.
510 @example
511 (%i1) lambda ([x], if x < 0 then throw(x) else f(x))$
512 (%i2) g(l) := catch (map (''%, l))$
513 (%i3) g ([1, 2, 3, 7]);
514 (%o3) [f(1), f(2), f(3), f(7)]
515 (%i4) g ([1, 2, -3, 7]);
516 (%o4) - 3
517 @end example
519 La función @code{g} devuelve las imágenes por @code{f} de todos los elementos de la lista @code{l} si ésta contiene únicamente números no negativos; si no es este el caso, entonces @code{g} captura el primer negativo que encuentra y lo devuelve por medio del @code{throw}.
521 @end deffn
523 @deffn {Function} compfile (@var{filename}, @var{f_1}, @dots{}, @var{f_n})
524 @deffnx {Function} compfile (@var{filename}, functions)
525 @deffnx {Function} compfile (@var{filename}, all)
527 Traduce funciones de Maxima a código Lisp, guardándolo
528 luego en el fichero @var{filename}.
530 Con la llamada @code{compfile(@var{filename}, @var{f_1}, @dots{}, @var{f_n})}
531 se traducen las funciones especificadas, mientras que
532 @code{compfile(@var{filename}, functions)} y
533 @code{compfile(@var{filename}, all)} traducen las funciones definidas por
534 el usuario.
536 El código Lisp traducido no se evalúa, ni el fichero
537 de salida es procesado por el compilador de Lisp.
538 La función @code{translate} crea y evalúa las traducciones Lisp, mientras que
539 @code{compile_file} traduce primero de Maxima a Lisp y luego
540 ejecuta el compilador Lisp.
542 Véanse también @code{translate}, @code{translate_file} y @code{compile_file}.
544 @end deffn
546 @deffn {Función} compile (@var{f_1}, ..., @var{f_n})
547 @deffnx {Función} compile (functions)
548 @deffnx {Función} compile (all)
550 Traduce las funciones de Maxima @var{f_1}, ..., @var{f_n} a Lisp, evaluando el código resultante, y llama a la función Lisp @code{COMPILE} para cada función traducida. La función @code{compile} devuelve una lista con los nombres de las funciones compiladas.
552 Las llamadas @code{compile (all)} o @code{compile (functions)} compilan todas las funciones definidas por el usuario.
554 La función @code{compile} no evalúa sus argumentos, pero con el operador comilla-comilla (@code{'@w{}'}) sí lo hace.
556 @end deffn
558 @deffn {Función} define (@var{f}(@var{x_1}, ..., @var{x_n}), @var{expr})
559 @deffnx {Función} define (@var{f}[@var{x_1}, ..., @var{x_n}], @var{expr})
560 @deffnx {Función} define (funmake (@var{f}, [@var{x_1}, ..., @var{x_n}]), @var{expr})
561 @deffnx {Función} define (arraymake (@var{f}, [@var{x_1}, ..., @var{x_n}]), @var{expr})
562 @deffnx {Función} define (ev (@var{expr_1}), @var{expr_2})
564 Define una función de nombre @var{f} con argumentos @var{x_1}, ..., @var{x_n} y cuerpo @var{expr}.
565 @code{define} evalúa siempre su segundo argumento, a menos que se
566 indique lo contrario con el operador de comilla simple. La función así
567 definida puede ser una función ordinaria de Maxima (con sus argumentos
568 encerrados entre paréntesis) o una función array (con sus argumentos encerrados
569 entre corchetes).
571 Cuando el último o único argumento @var{x_n} es una lista de un solo
572 elemento, la función definida por @code{define} acepta un número variable
573 de argumentos. Los valores de los argumentos se van asignando uno a uno a
574 @var{x_1}, ..., @var{x_(n - 1)}, y los que queden, si los hay, se asignan
575 a @var{x_n} en forma de lista.
577 Cuando el primer argumento de @code{define} es una expresión de la
578 forma @code{@var{f}(@var{x_1}, ..., @var{x_n})} o
579 @code{@var{f}[@var{x_1}, ..., @var{x_n}]}, se evalúan los argumentos de la función,
580 pero no @var{f}, incluso cuando se trate de una función o variable ya existente
581 con ese nombre.
583 Cuando el primer argumento es una expresión con operador @code{funmake},
584 @code{arraymake} o @code{ev}, se evalúa este primer argumento, lo que
585 permite calcular la función.
587 Todas las definiciones de funciones aparecen en el mismo espacio
588 de nombres; definiendo una función @code{f} dentro de otra
589 función @code{g} no limita automáticamente el alcance de @code{f} a @code{g}.
590 Sin embargo, @code{local(f)} hace que la definición de la función @code{f}
591 sea efectiva sólo dentro del bloque o expresión compuesta en el que
592 aparece @code{local}.
594 Si un argumento formal @var{x_k} es un símbolo afectado
595 por el operador comilla simple (expresión nominal), la función definida por
596 @code{define} no evalúa el correspondiente valor de argumento.
597 En cualquier otro caso, los argumentos que se pasan son evaluados.
599 Véanse también @code{:=} y @code{::=}.
601 Ejemplos:
603 @code{define} evalúa siempre su segundo argumento, a menos que se
604 indique lo contrario con el operador de comilla simple.
606 @c ===beg===
607 @c expr : cos(y) - sin(x);
608 @c define (F1 (x, y), expr);
609 @c F1 (a, b);
610 @c F2 (x, y) := expr;
611 @c F2 (a, b);
612 @c ===end===
613 @example
614 (%i1) expr : cos(y) - sin(x);
615 (%o1) cos(y) - sin(x)
616 (%i2) define (F1 (x, y), expr);
617 (%o2) F1(x, y) := cos(y) - sin(x)
618 (%i3) F1 (a, b);
619 (%o3) cos(b) - sin(a)
620 (%i4) F2 (x, y) := expr;
621 (%o4) F2(x, y) := expr
622 (%i5) F2 (a, b);
623 (%o5) cos(y) - sin(x)
624 @end example
626 La función así
627 definida puede ser una función ordinaria de Maxima o una función array.
629 @c ===beg===
630 @c define (G1 (x, y), x.y - y.x);
631 @c define (G2 [x, y], x.y - y.x);
632 @c ===end===
633 @example
634 (%i1) define (G1 (x, y), x.y - y.x);
635 (%o1) G1(x, y) := x . y - y . x
636 (%i2) define (G2 [x, y], x.y - y.x);
637 (%o2) G2 := x . y - y . x
638 x, y
639 @end example
641 Cuando el último o único argumento @var{x_n} es una lista de un solo
642 elemento, la función definida por @code{define} acepta un número variable
643 de argumentos.
645 @c ===beg===
646 @c define (H ([L]), '(apply ("+", L)));
647 @c H (a, b, c);
648 @c ===end===
649 @example
650 (%i1) define (H ([L]), '(apply ("+", L)));
651 (%o1) H([L]) := apply("+", L)
652 (%i2) H (a, b, c);
653 (%o2) c + b + a
654 @end example
656 Cuando el primer argumento es una expresión con operador @code{funmake},
657 @code{arraymake} o @code{ev}, se evalúa este primer argumento.
659 @c ===beg===
660 @c [F : I, u : x];
661 @c funmake (F, [u]);
662 @c define (funmake (F, [u]), cos(u) + 1);
663 @c define (arraymake (F, [u]), cos(u) + 1);
664 @c define (foo (x, y), bar (y, x));
665 @c define (ev (foo (x, y)), sin(x) - cos(y));
666 @c ===end===
667 @example
668 (%i1) [F : I, u : x];
669 (%o1) [I, x]
670 (%i2) funmake (F, [u]);
671 (%o2) I(x)
672 (%i3) define (funmake (F, [u]), cos(u) + 1);
673 (%o3) I(x) := cos(x) + 1
674 (%i4) define (arraymake (F, [u]), cos(u) + 1);
675 (%o4) I := cos(x) + 1
676 x
677 (%i5) define (foo (x, y), bar (y, x));
678 (%o5) foo(x, y) := bar(y, x)
679 (%i6) define (ev (foo (x, y)), sin(x) - cos(y));
680 (%o6) bar(y, x) := sin(x) - cos(y)
681 @end example
683 @end deffn
687 @deffn {Función} define_variable (@var{name}, @var{default_value}, @var{mode})
689 Introduce una variable global en el entorno de Maxima. La función
690 @code{define_variable} puede ser útil en los paquetes escritos por
691 los usuarios que vayan a ser compilados o traducidos con frecuencia.
693 La función @code{define_variable} ejecuta los siguientes pasos:
695 @enumerate
696 @item
697 @code{mode_declare (@var{name}, @var{mode})} declara el modo de @var{name} al traductor.
698 Véase @code{mode_declare} para ver la lista de modos aceptables.
700 @item
701 Si aún no tiene asignación, se le da a la variable @var{default_value} el valor @var{name}.
703 @item
704 @code{declare (@var{name}, special)} la declara como especial.
706 @item
707 Asocia @var{name} a una función de comprobación para asegurar que
708 a @var{name} sólo se le asignan valores del modo declarado.
709 @end enumerate
712 @c FOLLOWING STATEMENT APPEARS TO BE OUT OF DATE.
713 @c EXAMINING DEFMSPEC $DEFINE_VARIABLE AND DEF%TR $DEFINE_VARIABLE IN src/trmode.lisp,
714 @c IT APPEARS THAT THE 4TH ARGUMENT IS NEVER REFERRED TO.
715 @c EXECUTING translate_file ON A MAXIMA BATCH FILE WHICH CONTAINS
716 @c define_variable (foo, 2222, integer, "THIS IS FOO");
717 @c DOES NOT PUT "THIS IS FOO" INTO THE LISP FILE NOR THE UNLISP FILE.
718 @c The optional 4th argument is a documentation string. When
719 @c @code{translate_file} is used on a package which includes documentation
720 @c strings, a second file is output in addition to the Lisp file which
721 @c will contain the documentation strings, formatted suitably for use in
722 @c manuals, usage files, or (for instance) @code{describe}.
724 La propiedad @code{value_check} se puede asociar a cualquier variable que haya
725 sido definida mediante @code{define_variable} en cualquiera de los modos diferentes
726 a @code{any}. La propiedad @code{value_check} puede ser una expresión lambda o
727 una función de una variable, que será invocada al intentar asignar un valor a la
728 variable; el argumento pasado a la función @code{value_check} es el valor que
729 se le quiere asignar a la variable.
731 La función @code{define_variable} evalúa @code{default_value} pero no
732 @code{name} ni @code{mode}; el valor que devuelve es el valor actual de
733 @code{name}, el cual es @code{default_value} si a @code{name} no se le ha
734 aplicado ninguna asignación, o el valor de dicha asignación en caso
735 contrario.
737 Ejemplos:
739 @code{foo} es una variable booleana con valor inicial @code{true}.
740 @c ===beg===
741 @c define_variable (foo, true, boolean);
742 @c foo;
743 @c foo: false;
744 @c foo: %pi;
745 @c foo;
746 @c ===end===
747 @example
748 (%i1) define_variable (foo, true, boolean);
749 (%o1) true
750 (%i2) foo;
751 (%o2) true
752 (%i3) foo: false;
753 (%o3) false
754 (%i4) foo: %pi;
755 Error: foo was declared mode boolean, has value: %pi
756 -- an error. Quitting. To debug this try debugmode(true);
757 (%i5) foo;
758 (%o5) false
759 @end example
761 @code{bar} es una variable entera, cuyo valor habrá de ser primo.
762 @c ===beg===
763 @c define_variable (bar, 2, integer);
764 @c qput (bar, prime_test, value_check);
765 @c prime_test (y) :=
766 @c if not primep(y) then error (y, "is not prime.");
767 @c bar: 1439;
768 @c bar: 1440;
769 @c bar;
770 @c ===end===
771 @example
772 (%i1) define_variable (bar, 2, integer);
773 (%o1) 2
774 (%i2) qput (bar, prime_test, value_check);
775 (%o2) prime_test
776 (%i3) prime_test (y) := if not primep(y) then
777 error (y, "is not prime.");
778 (%o3) prime_test(y) :=
779 if not primep(y) then error(y, "is not prime.")
780 (%i4) bar: 1439;
781 (%o4) 1439
782 (%i5) bar: 1440;
783 1440 is not prime.
784 #0: prime_test(y=1440)
785 -- an error. Quitting. To debug this try debugmode(true);
786 (%i6) bar;
787 (%o6) 1439
788 @end example
790 @code{baz_quux} es una variable a la que no se le podrá asignar valor alguno.
791 El modo @code{any_check} es como @code{any},
792 pero @code{any_check} activa el mecanismo @code{value_check}, cosa que @code{any}
793 no hace.
794 @c ===beg===
795 @c define_variable (baz_quux, 'baz_quux, any_check);
796 @c F: lambda ([y], if y # 'baz_quux
797 @c then error ("Cannot assign to `baz_quux'."));
798 @c qput (baz_quux, ''F, value_check);
799 @c baz_quux: 'baz_quux;
800 @c baz_quux: sqrt(2);
801 @c baz_quux;
802 @c ===end===
803 @example
804 (%i1) define_variable (baz_quux, 'baz_quux, any_check);
805 (%o1) baz_quux
806 (%i2) F: lambda ([y], if y # 'baz_quux then
807 error ("Cannot assign to `baz_quux'."));
808 (%o2) lambda([y], if y # 'baz_quux
809 then error(Cannot assign to `baz_quux'.))
810 (%i3) qput (baz_quux, ''F, value_check);
811 (%o3) lambda([y], if y # 'baz_quux
812 then error(Cannot assign to `baz_quux'.))
813 (%i4) baz_quux: 'baz_quux;
814 (%o4) baz_quux
815 (%i5) baz_quux: sqrt(2);
816 Cannot assign to `baz_quux'.
817 #0: lambda([y],if y # 'baz_quux then
818 error("Cannot assign to `baz_quux'."))(y=sqrt(2))
819 -- an error. Quitting. To debug this try debugmode(true);
820 (%i6) baz_quux;
821 (%o6) baz_quux
822 @end example
824 @end deffn
827 @deffn {Función} dispfun (@var{f_1}, ..., @var{f_n})
828 @deffnx {Función} dispfun (all)
830 Muestra la deficnión de las funciones de usuario @var{f_1}, ..., @var{f_n}. Cada argumento puede ser el nombre de una macro (definida mediante @code{::=}), una función ordinaria (definida mediante @code{:=} o @code{define}), una función arreglo (definida mediante @code{:=} o @code{define}, pero encerrando los argumentos dentro de corchetes @code{[ ]}), una función de subíndice (definida mediante @code{:=} o @code{define}, pero encerrando algunos argumentos entre corchetes y otros entre paréntesis @code{( )}), una función de subíndice seleccionada por un subíndice variable, o una función de subíndice definida con un subíndice constante.
832 La llamada @code{dispfun (all)} muestra todas las funciones de usuario tal como las dan las listas @code{functions}, @code{arrays} y @code{macros}, omitiendo las funciones con subíndices definidas con subíndices constantes.
834 La función @code{dispfun} crea una etiqueta (@code{%t1}, @code{%t2}, etc.) para cada función mostrada, y asigna la definición de la función a la etiqueta. En contraste, @code{fundef} devuelve las definiciones de las funciones.
836 La función @code{dispfun} no evalúa sus argumentos; el operador de comilla-comilla @code{'@w{}'} permite la evaluación.
838 La función @code{dispfun} devuelve la lista de etiquetas de expresiones intermedias correspondientes a las funciones mostradas.
840 Ejemplos:
842 @c ===beg===
843 @c m(x, y) ::= x^(-y);
844 @c f(x, y) := x^(-y);
845 @c g[x, y] := x^(-y);
846 @c h[x](y) := x^(-y);
847 @c i[8](y) := 8^(-y);
848 @c dispfun (m, f, g, h, h[5], h[10], i[8]);
849 @c ''%;
850 @c ===end===
851 @example
852 (%i1) m(x, y) ::= x^(-y);
853 - y
854 (%o1) m(x, y) ::= x
855 (%i2) f(x, y) := x^(-y);
856 - y
857 (%o2) f(x, y) := x
858 (%i3) g[x, y] := x^(-y);
859 - y
860 (%o3) g := x
861 x, y
862 (%i4) h[x](y) := x^(-y);
863 - y
864 (%o4) h (y) := x
865 x
866 (%i5) i[8](y) := 8^(-y);
867 - y
868 (%o5) i (y) := 8
869 8
870 (%i6) dispfun (m, f, g, h, h[5], h[10], i[8]);
871 - y
872 (%t6) m(x, y) ::= x
874 - y
875 (%t7) f(x, y) := x
877 - y
878 (%t8) g := x
879 x, y
881 - y
882 (%t9) h (y) := x
883 x
885 1
886 (%t10) h (y) := --
887 5 y
888 5
890 1
891 (%t11) h (y) := ---
892 10 y
893 10
895 - y
896 (%t12) i (y) := 8
897 8
899 (%o12) [%t6, %t7, %t8, %t9, %t10, %t11, %t12]
900 (%i12) ''%;
901 - y - y - y
902 (%o12) [m(x, y) ::= x , f(x, y) := x , g := x ,
903 x, y
904 - y 1 1 - y
905 h (y) := x , h (y) := --, h (y) := ---, i (y) := 8 ]
906 x 5 y 10 y 8
907 5 10
908 @end example
910 @end deffn
914 @deffn {Función} fullmap (@var{f}, @var{expr_1}, ...)
915 Similar a @code{map}, pero conservará el mapeado
916 descendente de todas las subexpresiones hasta que los operadores
917 principales ya no sean los mismos.
919 La función @code{fullmap} es utilizada por el simplificador de Maxima
920 en algunas transformaciones matriciales, por lo que Maxima generará en algunas ocasiones mensajes de error relacionados con @code{fullmap} aunque el usuario no haya invocado explícitamente esta función.
922 @c ===beg===
923 @c a + b * c;
924 @c fullmap (g, %);
925 @c map (g, %th(2));
926 @c ===end===
927 @example
928 (%i1) a + b * c;
929 (%o1) b c + a
930 (%i2) fullmap (g, %);
931 (%o2) g(b) g(c) + g(a)
932 (%i3) map (g, %th(2));
933 (%o3) g(b c) + g(a)
934 @end example
936 @end deffn
938 @deffn {Función} fullmapl (@var{f}, @var{list_1}, ...)
939 Similar a @code{fullmap}, pero @code{fullmapl} sólo hace mapeo
940 sobre listas y matrices.
942 @c ===beg===
943 @c fullmapl ("+", [3, [4, 5]], [[a, 1], [0, -1.5]]);
944 @c ===end===
945 @example
946 (%i1) fullmapl ("+", [3, [4, 5]], [[a, 1], [0, -1.5]]);
947 (%o1) [[a + 3, 4], [4, 3.5]]
948 @end example
950 @end deffn
953 @defvr {Variable del sistema} functions
954 Valor por defecto: @code{[]}
956 La variable @code{functions} es una lista que contiene los nombres de las funciones ordinarias de Maxima. Una función ordinaria es aquella que ha sido construida mediante cualquiera de los métodos @code{define} o @code{:=} y que es invocada utilizando paréntesis. Una función puede definirse durante una sesión de Maxima o en un fichero que posteriormente será cargado en memoria por @code{load} o @code{batch}.
958 Las funciones array, que son invocadas con corchetes (@code{F[x]}),
959 y las funciones subindicadas, que son las invocadas con corchetes y
960 paréntesis (@code{F[x](y)}) se registran en la variable global @code{arrays},
961 no en @code{functions}.
963 Las funciones Lisp no se registran en ninguna lista.
965 Ejemplos:
967 @c ===beg===
968 @c F_1 (x) := x - 100;
969 @c F_2 (x, y) := x / y;
970 @c define (F_3 (x), sqrt (x));
971 @c G_1 [x] := x - 100;
972 @c G_2 [x, y] := x / y;
973 @c define (G_3 [x], sqrt (x));
974 @c H_1 [x] (y) := x^y;
975 @c functions;
976 @c arrays;
977 @c ===end===
978 @example
979 (%i1) F_1 (x) := x - 100;
980 (%o1) F_1(x) := x - 100
981 (%i2) F_2 (x, y) := x / y;
982 x
983 (%o2) F_2(x, y) := -
984 y
985 (%i3) define (F_3 (x), sqrt (x));
986 (%o3) F_3(x) := sqrt(x)
987 (%i4) G_1 [x] := x - 100;
988 (%o4) G_1 := x - 100
989 x
990 (%i5) G_2 [x, y] := x / y;
991 x
992 (%o5) G_2 := -
993 x, y y
994 (%i6) define (G_3 [x], sqrt (x));
995 (%o6) G_3 := sqrt(x)
996 x
997 (%i7) H_1 [x] (y) := x^y;
998 y
999 (%o7) H_1 (y) := x
1000 x
1001 (%i8) functions;
1002 (%o8) [F_1(x), F_2(x, y), F_3(x)]
1003 (%i9) arrays;
1004 (%o9) [G_1, G_2, G_3, H_1]
1005 @end example
1007 @end defvr
1009 @deffn {Función} fundef (@var{f})
1011 Devuelve la definición de la función @var{f}.
1013 Cada argumento puede ser el nombre de una macro (definida mediante @code{::=}), una función ordinaria (definida mediante @code{:=} o @code{define}), una función arreglo (definida mediante @code{:=} o @code{define}, pero encerrando los argumentos dentro de corchetes @code{[ ]}), una función de subíndice (definida mediante @code{:=} o @code{define}, pero encerrando algunos argumentos entre corchetes y otros entre paréntesis @code{( )}), una función de subíndice seleccionada por un subíndice variable, o una función de subíndice definida con un subíndice constante.
1015 La función @code{fundef} no evalúa sus argumentos; el operador comilla-comilla @code{'@w{}'} permite la evaluación.
1017 La llamada de función @code{fundef (@var{f})} devuelve la definición de @var{f}. Por el contrario, @code{dispfun (@var{f})} crea una etiqueta intermedia y le asigna la definición a la etiqueta.
1019 @end deffn
1021 @deffn {Función} funmake (@var{F}, [@var{arg_1}, ..., @var{arg_n}])
1023 Devuelve una expresión @code{@var{F}(@var{arg_1}, ..., @var{arg_n})}.
1024 El valor así retornado es simplificado pero no evaluado,
1025 de forma que la función @var{F} no es invocada, incluso cuando exista.
1027 La función @code{funmake} no hace distinciones entre funciones array
1028 y funciones ordinarias; cuando @var{F} es el nombre de una función array,
1029 @code{funmake} devuelve @code{@var{F}(...)},
1030 esto es, una llamada a función con paréntesis en lugar de corchetes.
1031 La función @code{arraymake} devuelve una llamada a función con
1032 corchetes para estos casos.
1034 La función @code{funmake} evalúa sus argumentos.
1036 Ejemplos:
1038 La función @code{funmake} aplicada a una función ordinaria de Maxima.
1040 @c ===beg===
1041 @c F (x, y) := y^2 - x^2;
1042 @c funmake (F, [a + 1, b + 1]);
1043 @c ''%;
1044 @c ===end===
1045 @example
1046 (%i1) F (x, y) := y^2 - x^2;
1047 2 2
1048 (%o1) F(x, y) := y - x
1049 (%i2) funmake (F, [a + 1, b + 1]);
1050 (%o2) F(a + 1, b + 1)
1051 (%i3) ''%;
1052 2 2
1053 (%o3) (b + 1) - (a + 1)
1054 @end example
1056 La función @code{funmake} aplicada a una macro.
1058 @c ===beg===
1059 @c G (x) ::= (x - 1)/2;
1060 @c funmake (G, [u]);
1061 @c ''%;
1062 @c ===end===
1063 @example
1064 (%i1) G (x) ::= (x - 1)/2;
1065 x - 1
1066 (%o1) G(x) ::= -----
1067 2
1068 (%i2) funmake (G, [u]);
1069 (%o2) G(u)
1070 (%i3) ''%;
1071 u - 1
1072 (%o3) -----
1073 2
1074 @end example
1076 La función @code{funmake} aplicada a una función subindicada.
1078 @c ===beg===
1079 @c H [a] (x) := (x - 1)^a;
1080 @c funmake (H [n], [%e]);
1081 @c ''%;
1082 @c funmake ('(H [n]), [%e]);
1083 @c ''%;
1084 @c ===end===
1085 @example
1086 (%i1) H [a] (x) := (x - 1)^a;
1087 a
1088 (%o1) H (x) := (x - 1)
1089 a
1090 (%i2) funmake (H [n], [%e]);
1091 n
1092 (%o2) lambda([x], (x - 1) )(%e)
1093 (%i3) ''%;
1094 n
1095 (%o3) (%e - 1)
1096 (%i4) funmake ('(H [n]), [%e]);
1097 (%o4) H (%e)
1098 n
1099 (%i5) ''%;
1100 n
1101 (%o5) (%e - 1)
1102 @end example
1104 La función @code{funmake} aplicada a un símbolo
1105 que no está asociado a función alguna.
1107 @c ===beg===
1108 @c funmake (A, [u]);
1109 @c ''%;
1110 @c ===end===
1111 @example
1112 (%i1) funmake (A, [u]);
1113 (%o1) A(u)
1114 (%i2) ''%;
1115 (%o2) A(u)
1116 @end example
1118 La función @code{funmake} evalúa sus argumentos,
1119 pero no el valor retornado.
1121 @c ===beg===
1122 @c det(a,b,c) := b^2 -4*a*c;
1123 @c (x : 8, y : 10, z : 12);
1124 @c f : det;
1125 @c funmake (f, [x, y, z]);
1126 @c ''%;
1127 @c ===end===
1128 @example
1129 (%i1) det(a,b,c) := b^2 -4*a*c;
1130 2
1131 (%o1) det(a, b, c) := b - 4 a c
1132 (%i2) (x : 8, y : 10, z : 12);
1133 (%o2) 12
1134 (%i3) f : det;
1135 (%o3) det
1136 (%i4) funmake (f, [x, y, z]);
1137 (%o4) det(8, 10, 12)
1138 (%i5) ''%;
1139 (%o5) - 284
1140 @end example
1142 Maxima simplifica el valor retornado de @code{funmake}.
1144 @c ===beg===
1145 @c funmake (sin, [%pi / 2]);
1146 @c ===end===
1147 @example
1148 (%i1) funmake (sin, [%pi / 2]);
1149 (%o1) 1
1150 @end example
1152 @end deffn
1154 @deffn {Función} lambda ([@var{x_1}, ..., @var{x_m}], @var{expr_1}, ..., @var{expr_n})
1155 @deffnx {Function} lambda ([[@var{L}]], @var{expr_1}, ..., @var{expr_n})
1156 @deffnx {Function} lambda ([@var{x_1}, ..., @var{x_m}, [@var{L}]], @var{expr_1}, ..., @var{expr_n})
1157 Define y devuelve una expresión lambda (es decir, una función anónima).
1158 La función puede tener argumentos @var{x_1}, ..., @var{x_m} y/o argumentos
1159 opcionales @var{L}, que aparecerán dentro del cuerpo de la función como una lista.
1160 El valor que devuelve la función es @var{expr_n}.
1161 Una expresión lambda puede asignarse a una variable y ser evaluada como si fuese una función ordinaria. Además, puede aparecer en algunos contextos en los que sea necesario un nombre de función.
1163 Cuando se evalúa la función, se crean las variables @var{x_1}, ..., @var{x_m} sin asignación de valores. Una función @code{lambda} puede aparecer dentro de un @code{block} o de otra @code{lambda}. Las variables locales se inicializan cada vez que se entra dentro de un nuevo bloque o de otra función @code{lambda}. Las variables locales se consideran globales dentro de un bloque o función @code{lambda} anidado dentro del primero. Si una variable es no local dentro de un bloque o función @code{lambda}, su valor es el que le corresponde en el bloque o función @code{lambda} superior. Este criterio se conoce con el nombre de "alcance dinámico".
1165 Una vez establecidas las variables locales @var{expr_1} a @var{expr_n} son secuencialmente evaluadas. La variable especial @code{%%} representa el valor de la expresión inmediata anterior. Las sentencias @code{throw} y @code{catch} pueden aparecer también en la lista de expresiones.
1167 La función @code{return} no puede aparecer en una expresión @code{lambda} a menos que se encuentre acotada dentro de un bloque (@code{block}), en cuyo caso @code{return} establece el valor de retorno del bloque, pero no de la expresión @code{lambda}, a menos que el bloque resulte ser precisamente @var{expr_n}. De igual manera, @code{go} no puede aparecer en una expresión @code{lambda} si no es dentro de un @code{block}.
1169 Las funciones @code{lambda} no evalúan sus argumentos; el operador comilla-comilla @code{'@w{}'} permite su evaluación.
1171 Ejemplo:
1173 @itemize @bullet
1174 @item
1175 Una función lambda puede asignarse a una variable y ser evaluada como si fuese una función ordinaria.
1176 @end itemize
1177 @c ===beg===
1178 @c f: lambda ([x], x^2);
1179 @c f(a);
1180 @c ===end===
1181 @example
1182 (%i1) f: lambda ([x], x^2);
1183 2
1184 (%o1) lambda([x], x )
1185 (%i2) f(a);
1186 2
1187 (%o2) a
1188 @end example
1189 @itemize @bullet
1190 @item
1191 Una expresión lambda puede aparecer en algunos contextos en los que sea necesario un nombre de función.
1192 @end itemize
1193 @c ===beg===
1194 @c lambda ([x], x^2) (a);
1195 @c apply (lambda ([x], x^2), [a]);
1196 @c map (lambda ([x], x^2), [a, b, c, d, e]);
1197 @c ===end===
1198 @example
1199 (%i3) lambda ([x], x^2) (a);
1200 2
1201 (%o3) a
1202 (%i4) apply (lambda ([x], x^2), [a]);
1203 2
1204 (%o4) a
1205 (%i5) map (lambda ([x], x^2), [a, b, c, d, e]);
1206 2 2 2 2 2
1207 (%o5) [a , b , c , d , e ]
1208 @end example
1209 @itemize @bullet
1210 @item
1211 Los argumentos son variables locales. Otras variables se consideran globales. Las variables globales son evaluadas en el momento que lo es la expresión, a menos que la evaluación de las mismas sea forzada, como cuando se hace uso de @code{'@w{}'}.
1212 @end itemize
1213 @c ===beg===
1214 @c a: %pi$
1215 @c b: %e$
1216 @c g: lambda ([a], a*b);
1217 @c b: %gamma$
1218 @c g(1/2);
1219 @c g2: lambda ([a], a*''b);
1220 @c b: %e$
1221 @c g2(1/2);
1222 @c ===end===
1223 @example
1224 (%i6) a: %pi$
1225 (%i7) b: %e$
1226 (%i8) g: lambda ([a], a*b);
1227 (%o8) lambda([a], a b)
1228 (%i9) b: %gamma$
1229 (%i10) g(1/2);
1230 %gamma
1231 (%o10) ------
1232 2
1233 (%i11) g2: lambda ([a], a*''b);
1234 (%o11) lambda([a], a %gamma)
1235 (%i12) b: %e$
1236 (%i13) g2(1/2);
1237 %gamma
1238 (%o13) ------
1239 2
1240 @end example
1241 @itemize @bullet
1242 @item
1243 Las expresiones lambda pueden anidarse. Las variables locales de expresiones lambda exteriores se consideran globales en expresiones internas, a menos que se enmascaren con variables locales de igual nombre.
1244 @end itemize
1245 @c ===beg===
1246 @c h: lambda ([a, b], h2: lambda ([a], a*b), h2(1/2));
1247 @c h(%pi, %gamma);
1248 @c ===end===
1249 @example
1250 (%i14) h: lambda ([a, b], h2: lambda ([a], a*b), h2(1/2));
1251 1
1252 (%o14) lambda([a, b], h2 : lambda([a], a b), h2(-))
1253 2
1254 (%i15) h(%pi, %gamma);
1255 %gamma
1256 (%o15) ------
1257 2
1258 @end example
1259 @itemize @bullet
1260 @item
1261 Puesto que @code{lambda} no evalúa sus argumentos, la expresión lambda @code{i} de más abajo no define una función del tipo "multiplicar por @code{a}". Tal tipo de función se puede definir a través de @code{buildq}, como en la expresión lambda @code{i2} de más abajo.
1262 @end itemize
1263 @c ===beg===
1264 @c i: lambda ([a], lambda ([x], a*x));
1265 @c i(1/2);
1266 @c i2: lambda([a], buildq([a: a], lambda([x], a*x)));
1267 @c i2(1/2);
1268 @c i2(1/2)(%pi);
1269 @c ===end===
1270 @example
1271 (%i16) i: lambda ([a], lambda ([x], a*x));
1272 (%o16) lambda([a], lambda([x], a x))
1273 (%i17) i(1/2);
1274 (%o17) lambda([x], a x)
1275 (%i18) i2: lambda([a], buildq([a: a], lambda([x], a*x)));
1276 (%o18) lambda([a], buildq([a : a], lambda([x], a x)))
1277 (%i19) i2(1/2);
1278 x
1279 (%o19) lambda([x], -)
1280 2
1281 (%i20) i2(1/2)(%pi);
1282 %pi
1283 (%o20) ---
1284 2
1285 @end example
1286 @itemize @bullet
1287 @item
1288 Una expresión lambda puede tener un número variable de argumentos,
1289 los cuales se indican mediante @code{[@var{L}]}, bien sea solo o como un
1290 último argumento. Estos argumentos aparecerán dentro del cuerpo de
1291 la función en forma de lista.
1292 @end itemize
1293 @c ===beg===
1294 @c f : lambda ([aa, bb, [cc]], aa * cc + bb);
1295 @c f (foo, %i, 17, 29, 256);
1296 @c g : lambda ([[aa]], apply ("+", aa));
1297 @c g (17, 29, x, y, z, %e);
1298 @c ===end===
1299 @example
1300 (%i1) f : lambda ([aa, bb, [cc]], aa * cc + bb);
1301 (%o1) lambda([aa, bb, [cc]], aa cc + bb)
1302 (%i2) f (foo, %i, 17, 29, 256);
1303 (%o2) [17 foo + %i, 29 foo + %i, 256 foo + %i]
1304 (%i3) g : lambda ([[aa]], apply ("+", aa));
1305 (%o3) lambda([[aa]], apply(+, aa))
1306 (%i4) g (17, 29, x, y, z, %e);
1307 (%o4) z + y + x + %e + 46
1308 @end example
1309 @end deffn
1311 @deffn {Función} local (@var{v_1}, ..., @var{v_n})
1313 La declaración @code{local(@var{v_1}, ..., @var{v_m})} dentro de un bloque
1314 almacena las propiedades asociadas a los símbolos @var{v_1}, ..., @var{v_m},
1315 borra cualesquiera otras propiedades antes de evaluar las expresiones y
1316 restaura las propiedades guardadas antes de abandonar el bloque.
1318 Algunas declaraciones, como @code{:=}, @code{array}, @code{dependencies}, @code{atvalue},
1319 @code{matchdeclare}, @code{atomgrad}, @code{constant}, @code{nonscalar}, @code{assume}
1320 y otras se implementan como propiedades de símbolos.
1321 El efecto producido por @code{local} consiste en hacer que tales declaraciones tengan
1322 efecto sólo dentro del bloque, en otro caso las declaraciones dentro del bloque
1323 tendrían un efecto global que afectarían al exterior de @code{block}.
1325 La función @code{local} sólo puede usarse dentro de un @code{block}, en el
1326 cuerpo de definición de funciones o de expresiones @code{lambda} o en la
1327 función @code{ev}, siéndole permitido aparecer una sóla vez en cada una de ellas.
1329 La función @code{local} no evalúa sus argumentos y devuelve @code{done}.
1331 Ejemplo:
1333 Definición local de una función.
1335 @c ===beg===
1336 @c foo (x) := 1 - x;
1337 @c foo (100);
1338 @c block (local (foo), foo (x) := 2 * x, foo (100));
1339 @c foo (100);
1340 @c ===end===
1341 @example
1342 (%i1) foo (x) := 1 - x;
1343 (%o1) foo(x) := 1 - x
1344 (%i2) foo (100);
1345 (%o2) - 99
1346 (%i3) block (local (foo), foo (x) := 2 * x, foo (100));
1347 (%o3) 200
1348 (%i4) foo (100);
1349 (%o4) - 99
1350 @end example
1351 @end deffn
1355 @defvr {Variable opcional} macroexpansion
1356 Valor por defecto: @code{false}
1358 La variable @code{macroexpansion} controla si la expansión (esto es, el valor de retorno) de una función macro se sustituye por la llamada a la función macro. Una sustitución puede acelerar futuras evaluaciones de la expresión, bajo el coste que implica tener que almacenar la expansión.
1360 @table @code
1361 @item false
1362 La expansión de una función macro no se sustituye por la llamada a la función macro.
1363 @item expand
1364 La primera vez que se evalúa una llamada a función macro se almacena la expansión. De esta manera la expansión no se recalcula en llamadas posteriores; cualesquiera efectos laterales (como @code{print} o asignaciones a variables globales)
1365 tan solo tienen lugar la primera vez que la función macro es evaluada. La expansión en una expresión no afecta a otras expresiones que llamen a la misma función macro.
1366 @item displace
1367 La primera vez que se evalúa una llamada a una función macro, la expansión se sustituye por la llamada, modificando así la expresión desde la que se hizo la llamada a la función macro. La expansión no se recalcula en llamadas posteriores; cualesquiera efectos laterales tan solo tienen lugar la primera vez que la función macro es evaluada. La expansión en una expresión no afecta a otras expresiones que llamen a la misma función macro.
1368 @end table
1370 Ejemplos:
1372 Si @code{macroexpansion} vale @code{false},
1373 una función macro es llamada cada vez que la expresión de llamada es evaluada.
1375 @c ===beg===
1376 @c f (x) := h (x) / g (x);
1377 @c g (x) ::= block (print ("x + 99 is equal to", x),
1378 @c return (x + 99));
1379 @c h (x) ::= block (print ("x - 99 is equal to", x),
1380 @c return (x - 99));
1381 @c macroexpansion: false;
1382 @c f (a * b);
1383 @c dispfun (f);
1384 @c f (a * b);
1385 @c ===end===
1386 @example
1387 (%i1) f (x) := h (x) / g (x);
1388 h(x)
1389 (%o1) f(x) := ----
1390 g(x)
1391 (%i2) g (x) ::= block (print ("x + 99 is equal to", x),
1392 return (x + 99));
1393 (%o2) g(x) ::= block(print("x + 99 is equal to", x),
1394 return(x + 99))
1395 (%i3) h (x) ::= block (print ("x - 99 is equal to", x),
1396 return (x - 99));
1397 (%o3) h(x) ::= block(print("x - 99 is equal to", x),
1398 return(x - 99))
1399 (%i4) macroexpansion: false;
1400 (%o4) false
1401 (%i5) f (a * b);
1402 x - 99 is equal to x
1403 x + 99 is equal to x
1404 a b - 99
1405 (%o5) --------
1406 a b + 99
1407 (%i6) dispfun (f);
1408 h(x)
1409 (%t6) f(x) := ----
1410 g(x)
1412 (%o6) done
1413 (%i7) f (a * b);
1414 x - 99 is equal to x
1415 x + 99 is equal to x
1416 a b - 99
1417 (%o7) --------
1418 a b + 99
1419 @end example
1421 Si @code{macroexpansion} vale @code{expand}, una función macro tan solo es llamada una vez.
1423 @c ===beg===
1424 @c f (x) := h (x) / g (x);
1425 @c g (x) ::= block (print ("x + 99 is equal to", x),
1426 @c return (x + 99));
1427 @c h (x) ::= block (print ("x - 99 is equal to", x),
1428 @c return (x - 99));
1429 @c macroexpansion: expand;
1430 @c f (a * b);
1431 @c dispfun (f);
1432 @c f (a * b);
1433 @c ===end===
1434 @example
1435 (%i1) f (x) := h (x) / g (x);
1436 h(x)
1437 (%o1) f(x) := ----
1438 g(x)
1439 (%i2) g (x) ::= block (print ("x + 99 is equal to", x),
1440 return (x + 99));
1441 (%o2) g(x) ::= block(print("x + 99 is equal to", x),
1442 return(x + 99))
1443 (%i3) h (x) ::= block (print ("x - 99 is equal to", x),
1444 return (x - 99));
1445 (%o3) h(x) ::= block(print("x - 99 is equal to", x),
1446 return(x - 99))
1447 (%i4) macroexpansion: expand;
1448 (%o4) expand
1449 (%i5) f (a * b);
1450 x - 99 is equal to x
1451 x + 99 is equal to x
1452 a b - 99
1453 (%o5) --------
1454 a b + 99
1455 (%i6) dispfun (f);
1456 h(x)
1457 (%t6) f(x) := ----
1458 g(x)
1460 (%o6) done
1461 (%i7) f (a * b);
1462 a b - 99
1463 (%o7) --------
1464 a b + 99
1465 @end example
1467 Si @code{macroexpansion} vale @code{expand}, una función macro es llamada una vez y la expresión de llamada se modifica.
1469 @c ===beg===
1470 @c f (x) := h (x) / g (x);
1471 @c g (x) ::= block (print ("x + 99 is equal to", x), return (x + 99));
1472 @c h (x) ::= block (print ("x - 99 is equal to", x), return (x - 99));
1473 @c macroexpansion: displace;
1474 @c f (a * b);
1475 @c dispfun (f);
1476 @c f (a * b);
1477 @c ===end===
1478 @example
1479 (%i1) f (x) := h (x) / g (x);
1480 h(x)
1481 (%o1) f(x) := ----
1482 g(x)
1483 (%i2) g (x) ::= block (print ("x + 99 is equal to", x), return (x + 99));
1484 (%o2) g(x) ::= block(print("x + 99 is equal to", x),
1485 return(x + 99))
1486 (%i3) h (x) ::= block (print ("x - 99 is equal to", x), return (x - 99));
1487 (%o3) h(x) ::= block(print("x - 99 is equal to", x),
1488 return(x - 99))
1489 (%i4) macroexpansion: displace;
1490 (%o4) displace
1491 (%i5) f (a * b);
1492 x - 99 is equal to x
1493 x + 99 is equal to x
1494 a b - 99
1495 (%o5) --------
1496 a b + 99
1497 (%i6) dispfun (f);
1498 x - 99
1499 (%t6) f(x) := ------
1500 x + 99
1502 (%o6) done
1503 (%i7) f (a * b);
1504 a b - 99
1505 (%o7) --------
1506 a b + 99
1507 @end example
1509 @end defvr
1511 @defvr {Variable opcional} mode_checkp
1512 Valor por defecto: @code{true}
1514 Cuando @code{mode_checkp} vale @code{true}, @code{mode_declare} chequea los modos de las variables con valores asignados.
1515 @c NEED SOME EXAMPLES HERE.
1517 @end defvr
1519 @defvr {Variable opcional} mode_check_errorp
1520 Valor por defecto: @code{false}
1522 @c WHAT DOES THIS MEAN ??
1523 Cuando @code{mode_check_errorp} vale @code{true}, @code{mode_declare} llama a error.
1524 @c NEED SOME EXAMPLES HERE.
1526 @end defvr
1528 @defvr {Variable opcional} mode_check_warnp
1529 Valor por defecto: @code{true}
1531 @c WHAT DOES THIS MEAN ??
1532 Cuando @code{mode_check_warnp} vale @code{true}, se detallan los errores de modo.
1533 @c NEED SOME EXAMPLES HERE.
1535 @end defvr
1537 @deffn {Función} mode_declare (@var{y_1}, @var{modo_1}, ..., @var{y_n}, @var{modo_n})
1539 La función @code{mode_declare} se utiliza para declarar los modos de variables y funciones para la ulterior traducción a Lisp o compilación de funciones. Se coloca habitualmente al comienzo de la definición de una función, de un script en Maxima o se ejecuta en tiempo real.
1541 Los argumentos de @code{mode_declare} son pares formados por una variable y un modo, el cual debe ser @code{boolean}, @code{fixnum}, @code{number}, @code{rational} o @code{float}. Cada variable puede ser sustituida por una lista de variables, en cuyo caso todas ellas tendrán el mismo modo.
1543 @c aquí me salto un párrafo que no está claro en el original (Mario).
1545 Código numérico que utilice arreglos puede ejecutarse más rápido declarando el tamaño que va a ocupar el arreglo, como en:
1547 @example
1548 mode_declare (array (a [10, 10]), float)
1549 @end example
1551 para un arreglo de números en coma flotante de dimensiones 10 x 10.
1553 Se puede declarar el modo del resultado de una función poniendo @code{function (f_1, f_2, ...)} como argumento;
1554 aquí @code{f_1}, @code{f_2}, ... son los nombres de las funciones. Por ejemplo, la expresión
1556 @example
1557 mode_declare ([function (f_1, f_2, ...)], fixnum)
1558 @end example
1560 declara que el valor a devolver por @code{f_1}, @code{f_2}, ... son enteros de modo "single-word".
1562 El nombre @code{modedeclare} es sinónimo de @code{mode_declare}.
1564 @end deffn
1566 @deffn {Función} mode_identity (@var{arg_1}, @var{arg_2})
1567 Es una forma especial usada con @code{mode_declare} y @code{macros} para declarar, por ejemplo, una lista de listas de números.
1569 @c Elimino aquí un párrafo. Comentario en la versión inglesa: WHAT IS THIS ABOUT ?? (Mario)
1571 @end deffn
1575 @deffn {Función} remfunction (@var{f_1}, ..., @var{f_n})
1576 @deffnx {Función} remfunction (all)
1577 Desliga las definiciones de función de sus símbolos @var{f_1}, ..., @var{f_n}.
1578 Los argumentos pueden ser nombres de funciones ordinarias
1579 (creadas con @code{:=} o @code{define}) o de funciones macro (creadas con @code{::=}).
1581 La instrucción @code{remfunction (all)} desliga todas las definiciones de funciones.
1583 La función @code{remfunction} no evalúa sus argumentos.
1585 La función @code{remfunction} devuelve una lista con los
1586 símbolos para los que la definición de función
1587 fue desligada. Devuelve @code{false} en el lugar de cualquier
1588 símbolo para el que no hay función definida.
1590 La función @code{remfunction} no se puede aplicar a arrays de funciones ni a
1591 funciones subindicadas. Sí es aplicable en tales casos la
1592 función @code{remarray}.
1593 @end deffn
1596 @defvr {Variable opcional} savedef
1597 Valor por defecto: @code{true}
1599 Si @code{savedef} vale @code{true}, se mantiene la versión Maxima de una función definida por el usuario cuando ésta se traduce, lo que permite mostrar su código con @code{dispfun} y que la función pueda ser editada.
1601 Si @code{savedef} vale @code{false}, los nombres de las funciones traducidas se eliminan de la lista @code{functions}.
1603 @end defvr
1607 @defvr {Variable opcional} transcompile
1608 Valor por defecto: @code{true}
1610 Si @code{transcompile} vale @code{true}, @code{translate} y @code{translate_file} generan declaraciones para hacer el código traducido más apto para la compilación.
1612 La función @code{compfile} hace la asignación @code{transcompile: true}.
1614 @end defvr
1616 @deffn {Función} translate (@var{f_1}, ..., @var{f_n})
1617 @deffnx {Función} translate (functions)
1618 @deffnx {Función} translate (all)
1620 Traduce las funciones definidas por el usuario @var{f_1}, ..., @var{f_n} del lenguaje de Maxima a Lisp y evalúa las traducciones Lisp. Normalmente las funciones traducidas se ejecutan más rapidamente que las originales.
1622 Las llamadas @code{translate (all)} o @code{translate (functions)} traducen todas las funciones de usuario.
1624 Las funciones a ser traducidas deberían incluir una llamada a @code{mode_declare} al comienzo siempre que sea posible, a fin de producir código más eficiente. Por ejemplo:
1626 @example
1627 f (x_1, x_2, ...) := block ([v_1, v_2, ...],
1628 mode_declare (v_1, modo_1, v_2, modo_2, ...), ...)
1629 @end example
1631 @noindent
1633 donde @var{x_1}, @var{x_2}, ... son los parámetros que se pasan a la función y @var{v_1}, @var{v_2}, ... son las variables locales.
1635 Los nombres de las funciones traducidas son eliminados de la lista @code{functions} si @code{savedef} vale @code{false} (ver más abajo) y son añadidos a las listas @code{props}.
1637 Las funciones no deberían ser traducidas hasta no estar completamente depuradas.
1639 Se supone que las expresiones están simplificadas; en caso de no estarlo, se generará código correcto pero ineficiente. Así, el usuario no debería asignar a @code{simp} el valor @code{false}, el cual inhibe la simplificación de la expresión a ser traducida.
1641 Cuando la variable @code{translate} vale @code{true}, se traducen automáticamente las funciones de usuario a Lisp.
1643 Nótese que las funciones traducidas puede que no se ejecuten exactamente igual a como lo hacían antes de la traducción, debido a posibles incompatibilidades entre las versiones de Maxima y Lisp. En general, la función @code{rat} con más de un argumento y la función @code{ratvars} no deberían utilizarse si algunas de las variables son declaradas como expresiones racionales canónicas (CRE) mediante @code{mode_declare}. Además, la asignación @code{prederror: false} no traducirá.
1645 Si @code{savedef} vale @code{true}, entonces la versión de Maxima de una función de usuario permanecerá cuando la función sea traducida por @code{translate}. Con esto se hace posible que se muestre la definición llamando a @code{dispfun} y que la función sea editada.
1647 Si @code{transrun} vale @code{false} entonces las versiones interpretadas de todas las funciones serán ejecutadas en lugar de las versiones traducidas.
1649 El resultado devuelto por @code{translate} es una lista con los nombres de las funciones traducidas.
1651 @end deffn
1653 @deffn {Función} translate_file (@var{nombre_fichero_maxima})
1654 @deffnx {Función} translate_file (@var{nombre_fichero_maxima}, @var{nombre_fichero_lisp})
1656 Traduce un fichero en código Maxima a un fichero en código Lisp. La función @code{translate_file} devuelve una lista con los nombres de tres ficheros: el nombre del ficheero en Maxima, el nombre del fichero en Lisp y el nombre del fichero que contiene información adicional sobre la traducción. La función @code{translate_file} evalúa sus argumentos.
1658 La llamada @code{translate_file ("foo.mac"); load("foo.LISP")} es lo mismo que @code{batch ("foo.mac")}, excepto por la presencia de ciertas restricciones, como el uso de @code{'@w{}'} y @code{%}, por ejemplo.
1659 @c FIGURE OUT WHAT THE RESTRICTIONS ARE AND STATE THEM
1661 La llamada @code{translate_file (@var{nombre_fichero_maxima})} traduce un fichero en Maxima, @var{nombre_fichero_maxima}, a otro en Lisp de nombre similar. Por ejemplo, @code{foo.mac} se traduce en @code{foo.LISP}. El nombre del fichero en Maxima puede incluir el nombre de un directorio, en cuyo caso el fichero de salida Lisp se guardará en el mismo directorio desde el que se leyó la fuente Maxima.
1663 La llamada @code{translate_file (@var{nombre_fichero_maxima}, @var{nombre_fichero_lisp})} traduce el fichero Maxima @var{nombre_fichero_maxima} en el fichero Lisp @var{nombre_fichero_lisp}. La función @code{translate_file} ignora la extensión del fichero, en caso de que exista, de @code{nombre_fichero_lisp}; la extensión del fichero de salida Lisp será invariablemente @code{LISP}. El nombre del fichero Lisp puede incluir la ruta del directorio, en cuyo caso se almacenará en el directorio especificado.
1665 La función @code{translate_file} también escribe un fichero de mensajes de avisos del traductor con diversos niveles de gravedad. La extensión de este fichero es @code{UNLISP}. Este fichero puede contener información valiosa, aunque de difícil interpretación, para detectar fallos en el código traducido. El fichero @code{UNLISP} se guarda siempre en el mismo directorio desde el que se leyó la fuente de Maxima.
1667 La función @code{translate_file} emite código Lisp que incluye algunas declaraciones y definiciones que entran en efecto tan pronto como el código Lisp es compilado. Véase @code{compile_file} para más información sobre este particular.
1669 @c CHECK ALL THESE AND SEE WHICH ONES ARE OBSOLETE
1670 Véanse también @code{tr_array_as_ref},
1671 @c tr_bind_mode_hook EXISTS BUT IT APPEARS TO BE A GROTESQUE UNDOCUMENTED HACK
1672 @c WE DON'T WANT TO MENTION IT
1673 @c @code{tr_bind_mode_hook},
1674 @code{tr_bound_function_applyp},
1675 @c tr_exponent EXISTS AND WORKS AS ADVERTISED IN src/troper.lisp
1676 @c NOT OTHERWISE DOCUMENTED; ITS EFFECT SEEMS TOO WEAK TO MENTION
1677 @code{tr_exponent},
1678 @code{tr_file_tty_messagesp},
1679 @code{tr_float_can_branch_complex},
1680 @code{tr_function_call_default},
1681 @code{tr_numer},
1682 @code{tr_optimize_max_loop},
1683 @code{tr_semicompile},
1684 @code{tr_state_vars},
1685 @code{tr_warnings_get},
1686 @code{tr_warn_bad_function_calls},
1687 @code{tr_warn_fexpr},
1688 @code{tr_warn_meval},
1689 @code{tr_warn_mode},
1690 @code{tr_warn_undeclared},
1691 y @code{tr_warn_undefined_variable}.
1693 @end deffn
1695 @defvr {Variable opcional} transrun
1696 Valor por defecto: @code{true}
1698 Si @code{transrun} vale @code{false} entonces se ejecutarán las versiones interpretadas de todas las funciones, en lugar de las versiones traducidas.
1700 @end defvr
1702 @defvr {Variable opcional} tr_array_as_ref
1703 Valor por defecto: @code{true}
1705 Si @code{translate_fast_arrays} vale @code{false}, referencias de arreglos en el código Lisp creadas por @code{translate_file} se ven afectadas por @code{tr_array_as_ref}.
1707 El valor de la variable @code{tr_array_as_ref} no tiene ningún efecto cuando @code{translate_fast_arrays} vale @code{true}.
1709 @end defvr
1711 @defvr {Variable opcional} tr_bound_function_applyp
1712 Valor por defecto: @code{true}
1714 Si @code{tr_bound_function_applyp} vale @code{true}, Maxima envía un aviso si encuentra una variable con valor asignado que está siendo utilizada como una función. @code{tr_bound_function_applyp} no influye en el código generado bajo estas circunstancias.
1716 Por ejemplo, una expresión como @code{g (f, x) := f (x+1)} provocará un mensaje de esta naturaleza.
1718 @end defvr
1720 @defvr {Variable opcional} tr_file_tty_messagesp
1721 Valor por defecto: @code{false}
1723 Si @code{tr_file_tty_messagesp} vale @code{true}, los mensajes generados por @code{translate_file} durante la traducción de un fichero se muestran en la consola y se insertan en el fichero UNLISP. Si vale @code{false}, los mensajes sobre la traducción del fichero sólo se incorporan al fichero UNLISP.
1725 @end defvr
1727 @defvr {Variable opcional} tr_float_can_branch_complex
1728 Valor por defecto: @code{true}
1730 Le dice al traductor de Maxima a Lisp que las funciones @code{acos}, @code{asin}, @code{asec} y @code{acsc} pueden devolver valores complejos.
1732 @end defvr
1734 @defvr {Variable opcional} tr_function_call_default
1735 Valor por defecto: @code{general}
1737 El valor @code{false} significa llama a @code{meval}, @code{expr} significa que Lisp asignó los argumentos de la función, @code{general}, el valor por defecto, devuelve código apropiado para @code{mexprs} y @code{mlexprs} pero no para @code{macros}. La opción @code{general} asegura que las asignaciones de las variables son correctas en el código compilado. En modo @code{general}, cuando se traduce F(X), si F es una variable con valor, entonces se entiende que se quiere calcular @code{apply (f, [x])}, y como tal se traduce, con el apropiado aviso. No es necesario desactivar esto. Con los valores por defecto la falta de mensajes de aviso implica compatibilidad completa entre el código traducido y compilado con el interpretado por Maxima.
1739 @end defvr
1741 @defvr {Variable opcional} tr_numer
1742 Valor por defecto: @code{false}
1744 Si @code{tr_numer} vale @code{true} se utilizan las propiedades numéricas en aquellos átomos que las posean, como en @code{%pi}.
1746 @end defvr
1748 @defvr {Variable opcional} tr_optimize_max_loop
1749 Valor por defecto: 100
1751 El valor de @code{tr_optimize_max_loop} es el número máximo de veces que el traductor repetirá la macro-expansión y la optimización en el tratamiento de una expresión.
1753 @end defvr
1755 @defvr {Variable opcional} tr_semicompile
1756 Valor por defecto: @code{false}
1758 Si @code{tr_semicompile} vale @code{true}, las salidas de @code{translate_file} y @code{compfile} serán macro-expandidas pero no compiladas a código máquina por el compilador de Lisp.
1760 @end defvr
1762 @defvr {Variable del sistema} tr_state_vars
1763 Valor por defecto:
1765 @example
1766 [transcompile, tr_semicompile, tr_warn_undeclared, tr_warn_meval,
1767 tr_warn_fexpr, tr_warn_mode, tr_warn_undefined_variable,
1768 tr_function_call_default, tr_array_as_ref,tr_numer]
1769 @end example
1771 Es la lista de variables que afectan la forma en que se obtiene la salida del código traducido. Esta información es útil para desarrolladores que pretendan corregir posibles fallos del traductor. Comparando el código traducido con el que se debería obtener bajo unas ciertas condiciones, es posible hacer el seguimiento de los fallos.
1773 @end defvr
1775 @deffn {Función} tr_warnings_get ()
1777 Devuelve una lista con los avisos dados por el traductor.
1779 @end deffn
1781 @defvr {Variable opcional} tr_warn_bad_function_calls
1782 Valor por defecto: @code{true}
1784 Devuelve un aviso cuando se hacen llamadas a funciones que quizás no sean correctas debido a declaraciones inapropiadas realizadas durante la traducción.
1786 @end defvr
1788 @defvr {Variable opcional} tr_warn_fexpr
1789 Valor por defecto: @code{compfile}
1791 Devuelve un aviso si se encuentra con alguna FEXPR. Las FEXPR no deberían aparecer en el código traducido.
1793 @end defvr
1795 @defvr {Variable opcional} tr_warn_meval
1796 Valor por defecto: @code{compfile}
1798 Devuelve un aviso si la función @code{meval} es llamada. Si @code{meval} es invocada, es señal de la presencia de problemas en la traducción.
1800 @end defvr
1802 @defvr {Variable opcional} tr_warn_mode
1803 Valor por defecto: @code{all}
1805 Devuelve un aviso cuando a las variables se les asignan valores incompatibles con su modo.
1807 @end defvr
1809 @defvr {Variable opcional} tr_warn_undeclared
1810 Valor por defecto: @code{compile}
1812 Determina cuando enviar mensajes sobre variables no declaradas.
1814 @end defvr
1816 @defvr {Variable opcional} tr_warn_undefined_variable
1817 Valor por defecto: @code{all}
1819 Devuelve un aviso cuando se detectan variables globales no definidas.
1821 @end defvr
1823 @deffn {Función} compile_file (@var{nombre_fich})
1824 @deffnx {Función} compile_file (@var{nombre_fich}, @var{nombre_fich_compilado})
1825 @deffnx {Función} compile_file (@var{nombre_fich}, @var{nombre_fich_compilado}, @var{nombre_fich_lisp})
1827 Traduce el fichero Maxima @var{nombre_fich} a Lisp, ejecuta el compilador de Lisp y, en caso de ser exitosa la compilación, carga el código compilado en Maxima.
1829 La función @code{compile_file} devuelve una lista con los nombres de tres ficheros: el fichero original en Maxima, la traducción Lisp, notas sobre la traducción y el código compilado. Si la compilación falla, el cuarto elemento es @code{false}.
1831 Algunas declaraciones y definiciones entran en efecto tan pronto como el código Lisp es compilado (sin cargar el código compilado). Éstas incluyen funciones definidas con el operador @code{:=}, macros definidas con el operador @code{::=}, @code{alias}, @code{declare}, @code{define_variable}, @code{mode_declare} y @code{infix}, @code{matchfix},
1832 @code{nofix}, @code{postfix}, @code{prefix} y @code{compfile}.
1834 Asignaciones y llamadas a funciones no se evalúan hasta que el código compilado es cargado. En particular, dentro del fichero Maxima, asignaciones a los controles ("flags") de traducción (@code{tr_numer}, etc.) no tienen efecto durante la traducción.
1836 El @var{nombre_fich} no puede contener sentencias del tipo @code{:lisp}.
1838 La función @code{compile_file} evalúa sus argumentos.
1840 @end deffn
1843 @deffn {Función} declare_translated (@var{f_1}, @var{f_2}, ...)
1845 Cuando se traduce un fichero de código Maxima a Lisp, es importante para el traductor saber qué funciones de las que están en el fichero van a ser llamadas como traducidas o compiladas, y cuáles son simplemente funciones Maxima o que no están definidas. Se genera el código @code{(MFUNCTION-CALL fn arg1 arg2 ...)} cuando el traductor no sabe si @code{fn} va a ser una función lisp.
1847 @end deffn