| blob | 4f2a7aa1494887211333dbdbfcf8cb780a2a67cd |
1 @c English version 2011-07-25
2 @menu
3 * Lisp y Maxima::
4 * Recolector de basura::
5 * Introducción a la programación::
6 * Funciones y variables para la programación::
7 @end menu
9 @node Lisp y Maxima, Recolector de basura, Programación, Programación
10 @section Lisp y Maxima
12 Maxima fue escrito en Lisp, y es muy fácil tener acceso a funciones y variables Lisp desde Maxima y viceversa.
13 Los símbolos Lisp y los símblos Maxima están claramente diferenciados por medio de una convención de nombres.
14 Un símblo Lisp el cual comienza con un signo pesos @code{$} corresponde a un símbolo Maxima sin el signo pesos.
15 Un símbolo Maxima el cual comienza con un signo de cierre de interrogación @code{?} corresponde a un símbolo Lisp sin dicho signo.
16 Por ejemplo, el símbolo Maxima @code{foo} corresponde a el símbolo Lisp @code{$FOO},
17 mientras que el símbolo Maxima @code{?foo} corresponde a el símbolo Lisp @code{FOO},
18 tenga en cuenta que @code{?foo} esta escrito sin espacio entre @code{?} y @code{foo};
19 de otra manera se estaría invocando a @code{describe ("foo")}.
21 El guión @code{-}, asterisco @code{*}, u otros carácteres especiales en símbolos Lisp deben ser escritos mediante un backslash @code{\} si aparecen en código Maxima.
22 Por ejemplo, el identificador Lisp @code{*foo-bar*} se debe escribir @code{?\*foo\-bar\*} en Maxima.
24 Se puede ejecutar código Lisp desde una sesión de Maxima.
25 Una línea Lisp (que contenga una o más formas) puede ser ejecutada
26 por medio de un comando especial @code{:lisp}. Por ejemplo,
28 @example
29 (%i1) :lisp (foo $x $y)
30 @end example
32 @noindent
33 se llama a la función Lisp @code{foo} con variables Maxima @code{x} y
34 @code{y} como argumentos.
35 La instrucción @code{:lisp} puede aparecer en el prompt interactivo
36 o en un archivo que sea procesado por @code{batch} o @code{demo}, pero no
37 en un archivo que sea procesado por @code{load}, @code{batchload}, @code{translate_file} o @code{compile_file}.
39 La función @code{to_lisp()} abre una sesión interactiva con el interprete Lisp.
40 Escribiendo @code{(to-maxima)} se cierra la sesión con Lisp y se retorna a Maxima.
42 @c I DON'T EVEN WANT TO MENTION USING CTRL-C TO OPEN A LISP SESSION.
43 @c (1) IT TAKES EXTRA SET UP TO GET STARTED NAMELY :lisp (setq *debugger-hook* nil)
44 @c (2) IT GETS SCREWED UP EASILY -- TYPE SOMETHING WRONG AND YOU CAN'T GET BACK TO MAXIMA
45 @c (3) IT DOESN'T OFFER FUNCTIONALITY NOT PRESENT IN THE to_lisp() SESSION
47 Las funciones y variables Lisp las cuales esten para ser visibles en Maxima como funciones y variables con nombres oridinarios (sin una puntuación especial), deben tener nombres tipo Lisp que comiencen con el signo pesos
48 @code{$}.
50 Maxima distingue entre letras minúsculas y mayúsculas en identificadores.
51 Existen algunas reglas que gobiernan la traducción de nombres entre Lisp y Maxima.
53 @enumerate
54 @item
55 Un identificador Lisp que no se encuentra encerrado en barras verticales
56 corresponde a un identificador Maxima en minúscula.
57 Que el idenficador Lisp esté en mayúscula, minúscula o una combinación
58 de ambas, no afecta en nada.
59 Por ejemplo, los identificadores Lisp @code{$foo}, @code{$FOO}, y @code{$Foo},
60 todos corresponden al identificador Maxima @code{foo}. Esto es así
61 porque @code{$foo}, @code{$FOO} y @code{$Foo} se convierten por defecto al
62 símbolo @code{$FOO} de Lisp.
64 @item
65 Un identificador Lisp el cual se encuentre todo en mayúscula o todo en minúscula y encerrado entre barras verticales corresponde a un identicador Maxima con el caso contrario.
66 Esto es, de mayúsculas cambia a minúsculas y de minúsculas cambia a mayúsculas.
67 E.g., el identificador Lisp @code{|$FOO|} y @code{|$foo|}
68 corresponden los identificadores Maxima @code{foo} y @code{FOO}, respectivamente.
69 @item
70 Un identificador Lisp el cual esta escrito mezclando letras mayúsculas y minúsculas y se encuentra entre barras verticales corresponde a un identificador Maxima con la misma escritura.
71 E.g., el identificador Lisp @code{|$Foo|} corresponde a el identificador Maxima @code{Foo}.
72 @end enumerate
74 La macro Lisp @code{#$} permite el uso de expresiones Maxima dentro de código Lisp. @code{#$@var{expr}$} extiende a una expresión Lisp equivalente a la expresión Maxima @var{expr}.
76 @example
77 (msetq $foo #$[x, y]$)
78 @end example
80 @noindent
81 Esto tiene el mismo efecto que:
83 @example
84 (%i1) foo: [x, y];
85 @end example
87 @noindent
88 La función Lisp @code{displa} imprime una expresión en formato Maxima.
90 @example
91 (%i1) :lisp #$[x, y, z]$
92 ((MLIST SIMP) $X $Y $Z)
93 (%i1) :lisp (displa '((MLIST SIMP) $X $Y $Z))
94 [x, y, z]
95 NIL
96 @end example
98 Las funciones definidas en Maxima no son funciones Lisp ordinarias.
99 La función Lisp @code{mfuncall} llama a una función Maxima.
100 Por ejemplo:
102 @example
103 (%i1) foo(x,y) := x*y$
104 (%i2) :lisp (mfuncall '$foo 'a 'b)
105 ((MTIMES SIMP) A B)
106 @end example
108 Algunas funciones Lisp son compartidas en el paquete Maxima, las cuales se listan a continuación:
110 @code{complement},
111 @code{continue},
112 @code{//},
113 @code{float},
114 @code{functionp},
115 @code{array},
116 @code{exp},
117 @code{listen},
118 @code{signum},
119 @code{atan},
120 @code{asin},
121 @code{acos},
122 @code{asinh},
123 @code{acosh},
124 @code{atanh},
125 @code{tanh},
126 @code{cosh},
127 @code{sinh},
128 @code{tan},
129 @code{break},
130 y @code{gcd}.
137 @node Recolector de basura, Introducción a la programación, Lisp y Maxima, Programación
138 @section Recolector de basura
140 La computación simbólica tiende a crear una buena cantidad de basura
141 (resultados temporales que ya no serán utilizados),
142 y un manejo efectivo de esto puede ser crucial para el término exitoso de
143 algunos programas.
145 Bajo GCL (GNU Common Lisp), en aquellos sistemas UNIX donde la llamada al sistema
146 mprotect está disponible (incluyendo SUN OS 4.0 y algunas variantes de BSD)
147 se dispone de un recolector de basura estratificado. Véase la documentación
148 de GCL para ALLOCATE y GBC. A nivel Lisp, ejecutando (setq si::*notify-gbc* t)
149 pemitirá determinar qué áreas necesitan más espacio.
151 En cuanto al resto de Lisps bajo los que funciona Maxima, se remite
152 al lector a la documentación correspondiente para controlar la
153 recolección de basura.
160 @node Introducción a la programación, Funciones y variables para la programación, Recolector de basura, Programación
161 @section Introducción a la programación
163 Maxima dispone de los bucles @code{do} para hacer iteraciones, así como estructuras más primitivas del estilo de @code{go}.
166 @node Funciones y variables para la programación, , Introducción a la programación, Programación
167 @section Funciones y variables para la programación
169 @deffn {Función} backtrace ()
170 @deffnx {Función} backtrace (@var{n})
171 Devuelve la pila de llamadas, esto es, la lista de funciones que han llamado a la función actualmente activa.
173 La llamada a @code{backtrace()} devuelve la pila completa de llamadas.
175 Ejemplos:
177 @example
178 (%i1) h(x) := g(x/7)$
179 (%i2) g(x) := f(x-11)$
180 (%i3) f(x) := e(x^2)$
181 (%i4) e(x) := (backtrace(), 2*x + 13)$
182 (%i5) h(10);
183 #0: e(x=4489/49)
184 #1: f(x=-67/7)
185 #2: g(x=10/7)
186 #3: h(x=10)
187 9615
188 (%o5) ----
189 49
190 @end example
192 La llamada @code{backtrace (@var{n})} devuelve las @var{n} funciones más recientes, incluyendo a la función actualmente activa.
194 Ejemplos:
196 @example
197 (%i1) h(x) := (backtrace(1), g(x/7))$
198 (%i2) g(x) := (backtrace(1), f(x-11))$
199 (%i3) f(x) := (backtrace(1), e(x^2))$
200 (%i4) e(x) := (backtrace(1), 2*x + 13)$
201 (%i5) h(10);
202 #0: h(x=10)
203 #0: g(x=10/7)
204 #0: f(x=-67/7)
205 #0: e(x=4489/49)
206 9615
207 (%o5) ----
208 49
209 @end example
211 @end deffn
213 @deffn {Operador especial} do
214 La sentencia @code{do} se utiliza para realizar iteraciones. Debido a su generalidad la sentencia @code{do} se describirá en dos partes. En primer lugar se mostrará su forma más usual, análoga a la de otros lenguajes de programación (Fortran, Algol, PL/I, etc.); después se mencionarán otras formas de uso.
216 Hay tres variantes de esta sentencia que se diferencian entre sí únicamente por las condiciones de fin de bucle. Son las siguientes:
218 @itemize @bullet
219 @item
220 @code{for @var{variable}: @var{valor_inicial} step @var{incremento}
221 thru @var{límite} do @var{cuerpo}}
222 @item
223 @code{for @var{variable}: @var{valor_inicial} step @var{incremento}
224 while @var{condición} do @var{cuerpo}}
225 @item
226 @code{for @var{variable}: @var{valor_inicial} step @var{incremento}
227 unless @var{condición} do @var{cuerpo}}
228 @end itemize
230 El @var{valor_inicial}, el @var{incremento}, el @var{límite} y el @var{cuerpo} pueden ser cualquier tipo de expresión válida de Maxima. Si el incremento es igual a la unidad (1) entonces "@code{step 1}" puede omitirse.
232 La ejecución de la sentencia @code{do} se realiza asignando el valor_inicial a la variable (llamada de aquí en adelante variable-control). A continuación: (1) si la variable-control ha excedido el límite de la especificación dada por un @code{thru}, o si la condición impuesta por @code{unless} es verdadera (@code{true}), o si la condición dada por @code{while} es falsa (@code{false}) entonces la iteración @code{do} termina. (2) El cuerpo se evalúa. (3) El incremento es sumado a la variable-control. El proceso de (1) a (3) se repite hasta que la condición de fin de iteración se satisfaga. También es posible especificar varias condiciones de terminación del bucle, en cuyo caso @code{do} terminará cuando se satisfaga alguna de ellas.
234 En general la condición @code{thru} se satisfará cuando la variable-control sea mayor que el límite si el incremento es no negativo, o cuando la variable-control sea menor que el límite cuando el incremento es negativo. El incremento y el límite pueden ser expresiones no numéricas, tanto en cuanto esta desigualdad pueda quedar determinada. Sin embargo, a menos que el incremento sea un número negativo en el momento de comenzar el cómputo de @code{do}, Maxima supondrá que se evaluará a una cantidad positiva. En caso de no ser efectivamente positivo, la sentencia @code{do} puede dar un resultado inesperado.
236 Nótese que el límite, el incremento y la condición de terminación se evalúan en cada iteración del bucle. Así, si alguna de expresiones necesitan de muchos cálculos y devuelven un resultado que no va a cambiar durante toda la ejecución del cuerpo, será más eficiente dar este valor a una variable antes de comenzar la sentencia @code{do} y utilizarla luego durante su ejecución.
238 El valor que habitualmente devuelva la sentencia @code{do} será el átomo @code{done}. Sin embargo, la función @code{return} puede usarse dentro del cuerpo para salir de @code{do} de forma prematura retornando un valor determinado.
239 Nótese no obstante que un @code{return} dentro de un @code{do} que está dentro de un bloque (@code{block}) provocará una salida de @code{do} pero no de @code{block}. Repárese también en que la función @code{go} no puede usarse para salir de @code{do} e ir a algún lugar de @code{block}.
241 La variable-control es siempre local respecto de @code{do}, por lo que se puede utilizar cualquier nombre de variable sin afectar el valor de cualquier otra variable externa a @code{do} y que tenga el mismo nombre. La variable-control no tendrá asignado ningún valor una vez se haya concluido el @code{do}.
243 @example
244 (%i1) for a:-3 thru 26 step 7 do display(a)$
245 a = - 3
247 a = 4
249 a = 11
251 a = 18
253 a = 25
254 @end example
256 @example
257 (%i1) s: 0$
258 (%i2) for i: 1 while i <= 10 do s: s+i;
259 (%o2) done
260 (%i3) s;
261 (%o3) 55
262 @end example
265 Nótese que la condición @code{while i <= 10} es equivalente a @code{unless i > 10} y a @code{thru 10}.
267 @example
268 (%i1) series: 1$
269 (%i2) term: exp (sin (x))$
270 (%i3) for p: 1 unless p > 7 do
271 (term: diff (term, x)/p,
272 series: series + subst (x=0, term)*x^p)$
273 (%i4) series;
274 7 6 5 4 2
275 x x x x x
276 (%o4) -- - --- - -- - -- + -- + x + 1
277 90 240 15 8 2
278 @end example
280 lo que da ocho términos del desarrollo de Taylor de la función @code{e^sin(x)}.
282 @example
283 (%i1) poly: 0$
284 (%i2) for i: 1 thru 5 do
285 for j: i step -1 thru 1 do
286 poly: poly + i*x^j$
287 (%i3) poly;
288 5 4 3 2
289 (%o3) 5 x + 9 x + 12 x + 14 x + 15 x
290 (%i4) guess: -3.0$
291 (%i5) for i: 1 thru 10 do
292 (guess: subst (guess, x, 0.5*(x + 10/x)),
293 if abs (guess^2 - 10) < 0.00005 then return (guess));
294 (%o5) - 3.162280701754386
295 @end example
297 Este ejemplo calcula la raíz cuadrada negativa de 10 haciendo 10 iteraciones del método de Newton-Raphson. De no haberse alcanzado el criterio de convergencia el valor devuelto hubiese sido @code{done}.
299 En lugar de añadir siempre una cantidad a la variable-control a veces se puede querer que cambie en cada iteración siguiendo algún otro criterio. En tal caso se puede hacer uso de @code{next @var{expresión}} en lugar de @code{step @var{incremento}}. Esto hará que a la variable-control se le asigne el resultado de evaluar la expresión en cada iteración del bucle.
301 @example
302 (%i6) for count: 2 next 3*count thru 20 do display (count)$
303 count = 2
305 count = 6
307 count = 18
308 @end example
310 En ocasiones puede interesar realizar una iteración en la que la variable-control no se utilice nunca. Se podrá entonces dar únicamente las condiciones de terminación del bucle omitiendo la inicialización y actualizando la información, tal como se hace en el siguiente ejemplo para calcular la raíz cuadrada de 5 utilizando un valor inicial alejado de la solución.
312 @example
313 (%i1) x: 1000$
314 (%i2) thru 20 do x: 0.5*(x + 5.0/x)$
315 (%i3) x;
316 (%o3) 2.23606797749979
317 (%i4) sqrt(5), numer;
318 (%o4) 2.23606797749979
319 @end example
321 Si así se quiere, incluso es posible omitir las condiciones de terminación completamente y escribir únicamente @code{do @var{body}}, lo que provocará entrar en un bucle infinito. En tal caso, debería usarse la función @code{return} a fin de terminar con la ejecución de @code{do}.
323 @example
324 (%i1) newton (f, x):= ([y, df, dfx], df: diff (f ('x), 'x),
325 do (y: ev(df), x: x - f(x)/y,
326 if abs (f (x)) < 5e-6 then return (x)))$
327 (%i2) sqr (x) := x^2 - 5.0$
328 (%i3) newton (sqr, 1000);
329 (%o3) 2.236068027062195
330 @end example
332 (En este ejemplo, cuando se ejecuta @code{return} obliga a que sea @code{x} el valor devuelto por @code{do}. Al salirse del bloque, @code{x} es también el valor que devuelve @code{block} por ser @code{do} la última sentencia del bloque.)
334 Hay todavía otra forma de @code{do} en Maxima. Su sintaxis es:
336 @example
337 for @var{variable} in @var{lista} @var{test_de_parada} do @var{cuerpo}
338 @end example
340 Los elementos de @var{list} son cualesquiera expresiones que se irán asignando sucesivamente a la variable en cada repetición del cuerpo. El test de parada @var{end_tests} (que es opcional) puede usarse para terminar la ejecución de @code{do}; de otro modo las iteraciones se pararán cuando la lista se haya agotado o cuando se ejecute un @code{return} dentro del cuerpo. (De hecho, la lista puede ser cualquier expresión no atómica, de la cual se irán extrayendo de forma sucesiva sus diferentes partes.)
342 @example
343 (%i1) for f in [log, rho, atan] do ldisp(f(1))$
344 (%t1) 0
345 (%t2) rho(1)
346 %pi
347 (%t3) ---
348 4
349 (%i4) ev(%t3,numer);
350 (%o4) 0.78539816
351 @end example
353 @end deffn
357 @deffn {Función} errcatch (@var{expr_1}, ..., @var{expr_n})
358 Evalúa las expresiones @var{expr_1}, ..., @var{expr_n} una a una y devuelve @code{[@var{expr_n}]} (una lista) en caso de que no ocurra ningún error. En caso de aparecer algún error durante el cálculo de alguno de los argumentos, @code{errcatch} evita que el error se propague y devuelve la lista vacía @code{[]} sin evaluar más argumentos.
360 La función @code{errcatch} es útil en ficheros @code{batch} donde se sospeche que pueda aparecer algún error, el cual provocaría la terminación de la ejecución del @code{batch} de no ser previamente detectado.
362 @end deffn
364 @deffn {Función} error (@var{expr_1}, ..., @var{expr_n})
365 @deffnx {Variable del sistema} error
366 Calcula y devuelve @var{expr_1}, ..., @var{expr_n}, enviando posteriormente una seãl de error a Maxima o al @code{errcatch} más cercano.
368 A la variable @code{error} se le asigna una lista con la descripción del error. El primer elemento de @code{error} es una cadena de formato, la cual une todas las cadenas de los argumentos @var{expr_1}, ..., @var{expr_n}, siendo los demás elementos de la lista los valores de los argumentos que no son cadenas.
370 La llamada a @code{errormsg()} formatea e imprime @code{error}. Se reimprime así el mensaje de error más reciente.
372 @end deffn
376 @defvr {Variable opcional} error_size
377 Valor por defecto: 10
379 La variable @code{error_size} modifica los mensajes de error de acuerdo con el tamaño de las expresiones que aparecen en él. Si el tamaño de una expresión (tal como lo determina la función Lisp @code{ERROR-SIZE})
380 es mayor que @code{error_size}, la expresión se reemplaza en el mensaje por un símbolo, asignándole a éste una expresión. Los símbolos se toman de la lista @code{error_syms}.
382 En caso contrario, si la expresión es menor que @code{error_size}, la expresión se muestra en el propio mensaje.
384 Véanse también @code{error} y @code{error_syms}.
386 Ejemplo:
387 @c OUTPUT GENERATED BY THE FOLLOWING
388 @c U: (C^D^E + B + A)/(cos(X-1) + 1)$
389 @c error_size: 20$
390 @c error ("Example expression is", U);
391 @c errexp1;
392 @c error_size: 30$
393 @c error ("Example expression is", U);
395 El tamaño de @code{U}, tal como lo determina @code{ERROR-SIZE}, es 24.
397 @example
398 (%i1) U: (C^D^E + B + A)/(cos(X-1) + 1)$
400 (%i2) error_size: 20$
402 (%i3) error ("Example expression is", U);
404 Example expression is errexp1
405 -- an error. Quitting. To debug this try debugmode(true);
406 (%i4) errexp1;
407 E
408 D
409 C + B + A
410 (%o4) --------------
411 cos(X - 1) + 1
412 (%i5) error_size: 30$
414 (%i6) error ("Example expression is", U);
416 E
417 D
418 C + B + A
419 Example expression is --------------
420 cos(X - 1) + 1
421 -- an error. Quitting. To debug this try debugmode(true);
422 @end example
424 @end defvr
428 @defvr {Variable opcional} error_syms
429 Valor por defecto: @code{[errexp1, errexp2, errexp3]}
431 En los mensajes de error, las expresiones mayores que @code{error_size} son reemplazadas por símbolos a los cuales se les asignas estas expresiones. Los símbolos se toman de la lista @code{error_syms}. La primera expresión que resulte ser demasiado larga se reemplaza por @code{error_syms[1]}, la segunda por @code{error_syms[2]} y así sucesivamente.
433 Si hay más expresiones largas que elementos en @code{error_syms}, los símbolos se construyen automáticamente, siendo el @var{n}-ésimo símbolo equivalente a @code{concat ('errexp, @var{n})}.
435 Véanse también @code{error} y @code{error_size}.
437 @end defvr
441 @deffn {Función} errormsg ()
443 Reimprime el mensaje de error más reciente. La variable @code{error} guarda el mensaje y @code{errormsg} lo formatea e imprime.
445 @end deffn
449 @defvr {Variable opcional} errormsg
450 Valor por defecto: @code{true}
452 Cuando @code{errormsg} vale @code{false} se suprimen los contenidos
453 de los mensajes de error.
455 La variable @code{errormsg} no se puede asignar a un valor local dentro
456 de un bloque. El valor global de @code{errormsg} está siempre presente.
458 Ejemplos:
460 @c ===beg===
461 @c errormsg;
462 @c sin(a,b);
463 @c errormsg:false;
464 @c sin(a,b);
465 @c ===end===
466 @example
467 (%i1) errormsg;
468 (%o1) true
469 (%i2) sin(a,b);
470 Wrong number of arguments to sin
471 -- an error. To debug this try: debugmode(true);
472 (%i3) errormsg:false;
473 (%o3) false
474 (%i4) sin(a,b);
476 -- an error. To debug this try: debugmode(true);
477 @end example
479 La variable @code{errormsg} no se puede asignar a un valor local dentro
480 de un bloque.
482 @c ===beg===
483 @c f(bool):=block([errormsg:bool], print ("value of errormsg is",errormsg))$
484 @c errormsg:true;
485 @c f(false);
486 @c errormsg:false;
487 @c f(true);
488 @c ===end===
489 @example
490 (%i1) f(bool):=block([errormsg:bool],
491 print ("value of errormsg is",errormsg))$
492 (%i2) errormsg:true;
493 (%o2) true
494 (%i3) f(false);
495 value of errormsg is true
496 (%o3) true
497 (%i4) errormsg:false;
498 (%o4) false
499 (%i5) f(true);
500 value of errormsg is false
501 (%o5) false
502 @end example
503 @end defvr
507 @deffn {Operador especial} for
508 Utilizado en las iteraciones. Véase @code{do} para una descripción de las técnicas de iteración en Maxima.
510 @end deffn
512 @deffn {Función} go (@var{etiqueta})
513 Se utiliza dentro de un bloque (@code{block}) para transferir el control a la sentencia del bloque que esté etiquetada con el argumento de @code{go}. Una sentencia queda etiquetada cuando está precedida por un argumento de tipo átomo como cualquier otra sentencia de @code{block}. Por ejemplo:
515 @example
516 block ([x], x:1, tururu, x+1, ..., go(tururu), ...)
517 @end example
519 El argumento de @code{go} debe ser el nombre de una etiqueta que aparezca en el mismo bloque (@code{block}). No se puede utilizar @code{go} para transferir el control a un bloque que no sea aquel que contenga la sentencia @code{go}.
521 @end deffn
523 @deffn {Operador especial} if
524 Evaluación condicionada. Se reconocen varias formas de expresiones @code{if}.
526 La expresión @code{if @var{cond_1} then @var{expr_1} else @var{expr_0}}
527 devuelve @var{expr_1} si @var{cond_1} vale @code{true},
528 en caso contrario la respuesta es @code{expr_0}.
530 La expresión @code{if @var{cond_1} then @var{expr_1} elseif @var{cond_2}
531 then @var{expr_2} elseif ... else @var{expr_0}}
532 devuelve @var{expr_k} si @var{cond_k} vale @code{true} y todas las
533 condiciones anteriores toman el valor @code{false}.
534 Si ninguna de las condiciones vale @code{true}, la respuesta es @code{expr_0}.
536 La falta de un @code{else} final se interpreta como un @code{else false};
537 esto es, la expresión @code{if @var{cond_1} then @var{expr_1}}
538 equivale a @code{if @var{cond_1} then @var{expr_1} else false},
539 y @code{if @var{cond_1} then @var{expr_1} elseif ... elseif @var{cond_n} then @var{expr_n}}
540 equivale a su vez a
541 @code{if @var{cond_1} then @var{expr_1} elseif ... elseif @var{cond_n} then @var{expr_n} else false}.
543 Las alternativas @var{expr_0}, ..., @var{expr_n} pueden ser expresiones
544 válidas de Maxima, incluidas expresiones @code{if} anidadas.
545 Las alternativas ni se simplifican ni se evalúan, a menos que su
546 condición asociada valga @code{true}.
548 Las condiciones @var{cond_1}, ..., @var{cond_n} deben ser expresiones
549 capaces de dar como resultado @code{true} o @code{false} al ser
550 evaluadas. Si en un momento dado una condición no da como resultado
551 un valor de verdad (@code{true} o @code{false}), el comportamiento de @code{if} se controla
552 con la variable global @code{prederror}. Si @code{prederror} vale @code{true},
553 se considera un error que la condición evaluada no dé como resultado
554 un valor de verdad; en caso contrario, las condiciones que no
555 den como resultado un valor de verdad se aceptan, dándose el
556 resultado como una expresión condicional.
558 Las condiciones pueden contener operadores lógicos y relacionales,
559 así como otros elementos, tal como se indica a continuación:
562 @example
563 Operación Símbolo Tipo
565 menor que < operador relacional infijo
566 menor o igual que <= operador relacional infijo
567 igualdad (sintáctica) = operador relacional infijo
568 negación de = # operador relacional infijo
569 igualdad (por valor) equal operador relacional infijo
570 negación de equal notequal operador relacional infijo
571 mayor o igual que >= operador relacional infijo
572 mayor que > operador relacional infijo
573 y and operador lógico infijo
574 o or operador lógico infijo
575 no not operador lógico prefijo
576 @end example
578 @end deffn
580 @deffn {Función} map (@var{f}, @var{expr_1}, ..., @var{expr_n})
581 Devuelve una expresión cuyo operador principal es el mismo
582 que aparece en las expresiones @var{expr_1}, ..., @var{expr_n}
583 pero cuyas subpartes son los resultados de aplicar @var{f}
584 a cada una de las subpartes de las expresiones; @var{f} puede ser
585 tanto el nombre de una función de @math{n} argumentos como
586 una expresión @code{lambda} de @math{n} argumentos.
588 Uno de los usos que tiene @code{map} es la de aplicar (o mapear)
589 una función (por ejemplo, @code{partfrac}) sobre cada término
590 de una expresión extensa en la que normalmente no se
591 podría utilizar la función debido a insuficiencias
592 en el espacio de almacenamiento durante el curso de un cálculo.
594 @example
595 (%i1) map(f,x+a*y+b*z);
596 (%o1) f(b z) + f(a y) + f(x)
597 (%i2) map(lambda([u],partfrac(u,x)),x+1/(x^3+4*x^2+5*x+2));
598 1 1 1
599 (%o2) ----- - ----- + -------- + x
600 x + 2 x + 1 2
601 (x + 1)
602 (%i3) map(ratsimp, x/(x^2+x)+(y^2+y)/y);
603 1
604 (%o3) y + ----- + 1
605 x + 1
606 (%i4) map("=",[a,b],[-0.5,3]);
607 (%o4) [a = - 0.5, b = 3]
608 @end example
610 Véase también @code{maperror} .
611 @end deffn
613 @deffn {Función} mapatom (@var{expr})
614 Devuelve @code{true} si y sólo @var{expr} es tratado por las rutinas de mapeo como un átomo.
615 @end deffn
617 @defvr {Variable opcional} maperror
618 Valor por defecto: @code{true}
620 Cuando @code{maperror} toma el valor @code{false},
621 hace que todas las funciones de mapeo, como por ejemplo
623 @example
624 map (f, @var{expr_1}, @var{expr_2}, ...)
625 @end example
627 (1) paren cuando hayan terminado de procesar la @var{expr_i} más corta,
628 a menos que todas ellas sean del mismo tamaño y (2) apliquen @code{f}
629 a @code{[expr_1, expr_2, ...]} si es el caso que las @code{expr_i}
630 no son todas del mismo tipo de objeto.
632 Cuando @code{maperror} toma el valor @code{true} entonces se emite un mensaje de error cuando se presenta cualquiera de los dos casos anteriores.
634 @end defvr
638 @defvr {Variable opcional} mapprint
639 Valor por defecto: @code{true}
641 Si @code{mapprint} vale @code{true}, se producirán ciertos mensajes
642 por parte de las funciones @code{map}, @code{mapl} y @code{fullmap}
643 en determinadas situaciones, como cuando @code{map} hace uso de
644 @code{apply}.
646 Si @code{mapprint} vale @code{false}, no se emitirán tales mensajes.
647 @end defvr
651 @deffn {Función} maplist (@var{f}, @var{expr_1}, ..., @var{expr_n})
652 Devuelve una lista con las aplicaciones de @var{f} a las partes de las expresiones @var{expr_1}, ..., @var{expr_n}; @var{f} es el nombre de una función ou una expresión lambda.
654 La función @code{maplist} difiere de @code{map (@var{f}, @var{expr_1}, ..., @var{expr_n})}, la cual devuelve una expresión con el mismo operador principal que tenga @var{expr_i}, excepto en simplificaciones y en el caso en el que @code{map} hace un @code{apply}.
656 @end deffn
658 @defvr {Variable opcional} prederror
659 Valor por defecto: @code{false}
661 Cuando @code{prederror} toma el valor @code{true}, se emite un mensaje de error siempre que el predicado de una sentencia @code{if} o de una función @code{is} no se pueda evaluar ni a verdadero (@code{true}) ni a falso (@code{false}).
663 Si toma el valor @code{false}, se devuelve bajo las mismas circunstancias anteriores el valor @code{unknown}. El modo @code{prederror: false} no está soportado en el código traducido; sin embargo, @code{maybe} está soportado en código traducido.
665 Véanse también @code{is} y @code{maybe}.
667 @end defvr
669 @deffn {Función} return (valor)
670 Puede utilizarse para salir de un bloque, devolviendo su argumento.
671 Véase @code{block} para más información.
673 @end deffn
675 @deffn {Función} scanmap (@var{f}, @var{expr})
676 @deffnx {Función} scanmap (@var{f}, @var{expr}, bottomup)
677 Aplica recursivamente @var{f} sobre @var{expr}, de arriba hacia abajo. Esto es más útil cuando se busca una factorización completa, por ejemplo:
679 @example
680 (%i1) exp:(a^2+2*a+1)*y + x^2$
681 (%i2) scanmap(factor,exp);
682 2 2
683 (%o2) (a + 1) y + x
684 @end example
686 Nótese que cómo @code{scanmap} aplica la función dada @code{factor} a las subexpresiones que forman a @var{expr}; si se presenta otra forma de @var{expr} a @code{scanmap} entonces el resultado puede ser diferente. Así, @code{%o2} no se restaura cuando @code{scanmap} se aplica a la forma expandida de exp:
688 @example
689 (%i3) scanmap(factor,expand(exp));
690 2 2
691 (%o3) a y + 2 a y + y + x
692 @end example
694 Aquí hay otro ejemplo de la forma en que @code{scanmap} aplica recursivamente una función dada a todas las subexpresiones, incluyendo exponentes:
696 @example
697 (%i4) expr : u*v^(a*x+b) + c$
698 (%i5) scanmap('f, expr);
699 f(f(f(a) f(x)) + f(b))
700 (%o5) f(f(f(u) f(f(v) )) + f(c))
701 @end example
703 @code{scanmap (@var{f}, @var{expr}, bottomup)} aplica @var{f} a @var{expr} de abajo hacia arriba. Por ejemplo, para @code{f} no definida,
705 @example
706 scanmap(f,a*x+b) ->
707 f(a*x+b) -> f(f(a*x)+f(b)) -> f(f(f(a)*f(x))+f(b))
708 scanmap(f,a*x+b,bottomup) -> f(a)*f(x)+f(b)
709 -> f(f(a)*f(x))+f(b) ->
710 f(f(f(a)*f(x))+f(b))
711 @end example
713 En este caso se obtiene la misma respuesta por cualquiera de los dos métodos.
715 @end deffn
717 @deffn {Función} throw (@var{expr})
718 Evalúa @var{expr} y devuelve el valor del @code{catch} más reciente. La función @code{throw} se utiliza junto con @code{catch} como un mecanismo de retorno no local.
720 @end deffn
723 @deffn {Operador especial} while
724 @deffnx {Operador especial} unless
726 Véase @code{do}.
728 @end deffn
731 @deffn {Función} outermap (@var{f}, @var{a_1}, ..., @var{a_n})
732 Aplica la función @var{f} a cada uno de los elementos del producto vectorial @var{a_1} por @var{a_2} ... por @var{a_n}.
734 El argumento @var{f} debe ser el nombre de una función de @math{n} argumentos,
735 o una expresión lambda de @math{n} argumentos.
736 Cada uno de los argumentos @var{a_k} puede ser una lista, una lista anidada,
737 una matriz o cualquier otro tipo de expresión.
739 El valor devuelto por @code{outermap} es una estructura anidada. Si @var{x} es la
740 respuesta dada por @code{outermap}, entonces tiene la misma estructura que la primera lista,
741 lista anidada o matriz, @code{@var{x}[i_1]...[i_m]} tiene la misma estructura que la
742 segunda lista, lista anidada o matriz, @code{@var{x}[i_1]...[i_m][j_1]...[j_n]} tiene
743 la misma estructura que la tercera lista, lista anidada o matriz, y así
744 sucesivamente, siendo @var{m}, @var{n}, ... los números índice
745 necesarios para acceder a los elementos de cada argumento: uno para las listas,
746 dos para las matrices y uno o más para las listas anidadas.
747 Aquellos argumentos que no sean listas ni matrices no tienen efecto alguno sobre
748 la estructura del valor retornado.
750 Nótese que el efecto producido por @code{outermap} es diferente del que
751 se obtiene al aplicar @var{f} a cada uno de los elementos del producto
752 devuelto por @code{cartesian_product}. La función @code{outermap}
753 mantiene la estructura de los argumentos en la respuesta, miemtras que
754 @code{cartesian_product} no lo hace.
756 La función @code{outermap} evalúa sus argumentos.
758 Véanse también @code{map}, @code{maplist} y @code{apply}.
760 Ejemplos:
762 Ejemplos elementales de uso de @code{outermap}.
763 Con el fin de mostrar con mayor claridad las combinaciones del argumento,
764 se mantiene sin definir @code{F}.
767 @c ===beg===
768 @c outermap (F, [a, b, c], [1, 2, 3]);
769 @c outermap (F, matrix ([a, b], [c, d]), matrix ([1, 2], [3, 4]));
770 @c outermap (F, [a, b], x, matrix ([1, 2], [3, 4]));
771 @c outermap (F, [a, b], matrix ([1, 2]), matrix ([x], [y]));
772 @c outermap ("+", [a, b, c], [1, 2, 3]);
773 @c ===end===
774 @example
775 (%i1) outermap (F, [a, b, c], [1, 2, 3]);
776 (%o1) [[F(a, 1), F(a, 2), F(a, 3)], [F(b, 1), F(b, 2), F(b, 3)],
777 [F(c, 1), F(c, 2), F(c, 3)]]
778 (%i2) outermap (F, matrix ([a, b], [c, d]), matrix ([1, 2], [3, 4]));
779 [ [ F(a, 1) F(a, 2) ] [ F(b, 1) F(b, 2) ] ]
780 [ [ ] [ ] ]
781 [ [ F(a, 3) F(a, 4) ] [ F(b, 3) F(b, 4) ] ]
782 (%o2) [ ]
783 [ [ F(c, 1) F(c, 2) ] [ F(d, 1) F(d, 2) ] ]
784 [ [ ] [ ] ]
785 [ [ F(c, 3) F(c, 4) ] [ F(d, 3) F(d, 4) ] ]
786 (%i3) outermap (F, [a, b], x, matrix ([1, 2], [3, 4]));
787 [ F(a, x, 1) F(a, x, 2) ] [ F(b, x, 1) F(b, x, 2) ]
788 (%o3) [[ ], [ ]]
789 [ F(a, x, 3) F(a, x, 4) ] [ F(b, x, 3) F(b, x, 4) ]
790 (%i4) outermap (F, [a, b], matrix ([1, 2]), matrix ([x], [y]));
791 [ [ F(a, 1, x) ] [ F(a, 2, x) ] ]
792 (%o4) [[ [ ] [ ] ],
793 [ [ F(a, 1, y) ] [ F(a, 2, y) ] ]
794 [ [ F(b, 1, x) ] [ F(b, 2, x) ] ]
795 [ [ ] [ ] ]]
796 [ [ F(b, 1, y) ] [ F(b, 2, y) ] ]
797 (%i5) outermap ("+", [a, b, c], [1, 2, 3]);
798 (%o5) [[a + 1, a + 2, a + 3], [b + 1, b + 2, b + 3],
799 [c + 1, c + 2, c + 3]]
800 @end example
802 El siguiente ejemplo permite hacer un análisis más profundo del valor
803 retornado por @code{outermap}.
804 Los tres primeros argumentos son una matriz, una lista y otra matriz, en este
805 orden. El valor devuelto es una matriz, cuyos elementos son listas y
806 cada elemento de cada una de estas listas es a su vez una matriz.
808 @c ===beg===
809 @c arg_1 : matrix ([a, b], [c, d]);
810 @c arg_2 : [11, 22];
811 @c arg_3 : matrix ([xx, yy]);
812 @c xx_0 : outermap (lambda ([x, y, z], x / y + z), arg_1,
813 @c arg_2, arg_3);
814 @c xx_1 : xx_0 [1][1];
815 @c xx_2 : xx_0 [1][1] [1];
816 @c xx_3 : xx_0 [1][1] [1] [1][1];
817 @c [op (arg_1), op (arg_2), op (arg_3)];
818 @c [op (xx_0), op (xx_1), op (xx_2)];
819 @c ===end===
820 @example
821 (%i1) arg_1 : matrix ([a, b], [c, d]);
822 [ a b ]
823 (%o1) [ ]
824 [ c d ]
825 (%i2) arg_2 : [11, 22];
826 (%o2) [11, 22]
827 (%i3) arg_3 : matrix ([xx, yy]);
828 (%o3) [ xx yy ]
829 (%i4) xx_0 : outermap(lambda([x, y, z], x / y + z), arg_1,
830 arg_2, arg_3);
831 [ [ a a ] [ a a ] ]
832 [ [[ xx + -- yy + -- ], [ xx + -- yy + -- ]] ]
833 [ [ 11 11 ] [ 22 22 ] ]
834 (%o4) Col 1 = [ ]
835 [ [ c c ] [ c c ] ]
836 [ [[ xx + -- yy + -- ], [ xx + -- yy + -- ]] ]
837 [ [ 11 11 ] [ 22 22 ] ]
838 [ [ b b ] [ b b ] ]
839 [ [[ xx + -- yy + -- ], [ xx + -- yy + -- ]] ]
840 [ [ 11 11 ] [ 22 22 ] ]
841 Col 2 = [ ]
842 [ [ d d ] [ d d ] ]
843 [ [[ xx + -- yy + -- ], [ xx + -- yy + -- ]] ]
844 [ [ 11 11 ] [ 22 22 ] ]
845 (%i5) xx_1 : xx_0 [1][1];
846 [ a a ] [ a a ]
847 (%o5) [[ xx + -- yy + -- ], [ xx + -- yy + -- ]]
848 [ 11 11 ] [ 22 22 ]
849 (%i6) xx_2 : xx_0 [1][1] [1];
850 [ a a ]
851 (%o6) [ xx + -- yy + -- ]
852 [ 11 11 ]
853 (%i7) xx_3 : xx_0 [1][1] [1] [1][1];
854 a
855 (%o7) xx + --
856 11
857 (%i8) [op (arg_1), op (arg_2), op (arg_3)];
858 (%o8) [matrix, [, matrix]
859 (%i9) [op (xx_0), op (xx_1), op (xx_2)];
860 (%o9) [matrix, [, matrix]
861 @end example
863 La función @code{outermap} mantiene la estructura de los argumentos en su respuesta,
864 mientras que @code{cartesian_product} no lo hace.
866 @c ===beg===
867 @c outermap (F, [a, b, c], [1, 2, 3]);
868 @c setify (flatten (%));
869 @c map (lambda ([L], apply (F, L)), cartesian_product ({a, b, c}, {1, 2, 3}));
870 @c is (equal (%, %th (2)));
871 @c ===end===
872 @example
873 (%i1) outermap (F, [a, b, c], [1, 2, 3]);
874 (%o1) [[F(a, 1), F(a, 2), F(a, 3)], [F(b, 1), F(b, 2), F(b, 3)],
875 [F(c, 1), F(c, 2), F(c, 3)]]
876 (%i2) setify (flatten (%));
877 (%o2) @{F(a, 1), F(a, 2), F(a, 3), F(b, 1), F(b, 2), F(b, 3),
878 F(c, 1), F(c, 2), F(c, 3)@}
879 (%i3) map (lambda ([L], apply (F, L)), cartesian_product (@{a, b, c@}, @{1, 2, 3@}));
880 (%o3) @{F(a, 1), F(a, 2), F(a, 3), F(b, 1), F(b, 2), F(b, 3),
881 F(c, 1), F(c, 2), F(c, 3)@}
882 (%i4) is (equal (%, %th (2)));
883 (%o4) true
884 @end example
886 @end deffn