@c English version 2011-07-25
@menu
* Lisp y Maxima::
* Recolector de basura::
* Introducción a la programación::  
* Funciones y variables para la programación::  
@end menu

@node Lisp y Maxima, Recolector de basura, Programación, Programación
@section Lisp y Maxima

Maxima fue escrito en Lisp, y es muy fácil tener acceso a funciones y variables Lisp desde Maxima y viceversa. 
Los símbolos Lisp y los símblos Maxima están claramente diferenciados por medio de una convención de nombres. 
Un símblo Lisp el cual comienza con un signo pesos @code{$} corresponde a un símbolo Maxima sin el signo pesos. 
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.
Por ejemplo, el símbolo Maxima @code{foo} corresponde a el símbolo Lisp @code{$FOO}, 
mientras que el símbolo Maxima @code{?foo} corresponde a el símbolo Lisp @code{FOO}, 
tenga en cuenta que @code{?foo} esta escrito sin espacio entre @code{?} y @code{foo}; 
de otra manera se estaría invocando a @code{describe ("foo")}. 

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. 
Por ejemplo, el identificador Lisp @code{*foo-bar*} se debe escribir @code{?\*foo\-bar\*} en Maxima. 

Se puede ejecutar código Lisp desde una sesión de Maxima. 
Una línea Lisp (que contenga una o más formas) puede ser ejecutada
por medio de un comando especial @code{:lisp}. Por ejemplo, 

@example
(%i1) :lisp (foo $x $y)
@end example

@noindent
se llama a la función Lisp @code{foo} con variables Maxima @code{x} y
@code{y} como argumentos. 
La instrucción @code{:lisp} puede aparecer en el prompt interactivo
o en un archivo que sea procesado por @code{batch} o @code{demo}, pero no
en un archivo que sea procesado por @code{load}, @code{batchload}, @code{translate_file} o @code{compile_file}. 

La función @code{to_lisp()} abre una sesión interactiva con el interprete Lisp. 
Escribiendo @code{(to-maxima)} se cierra la sesión con Lisp y se retorna a Maxima. 

@c I DON'T EVEN WANT TO MENTION USING CTRL-C TO OPEN A LISP SESSION.
@c (1) IT TAKES EXTRA SET UP TO GET STARTED NAMELY :lisp (setq *debugger-hook* nil)
@c (2) IT GETS SCREWED UP EASILY -- TYPE SOMETHING WRONG AND YOU CAN'T GET BACK TO MAXIMA
@c (3) IT DOESN'T OFFER FUNCTIONALITY NOT PRESENT IN THE to_lisp() SESSION

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 
@code{$}. 

Maxima distingue entre letras minúsculas y mayúsculas en identificadores. 
Existen algunas reglas que gobiernan la traducción de nombres entre Lisp y Maxima. 

@enumerate
@item
Un identificador Lisp que no se encuentra encerrado en barras verticales
corresponde a un identificador Maxima en minúscula. 
Que el idenficador Lisp esté en mayúscula, minúscula o una combinación
de ambas, no afecta en nada. 
Por ejemplo, los identificadores Lisp @code{$foo}, @code{$FOO}, y @code{$Foo},
todos corresponden al identificador Maxima @code{foo}. Esto es así
porque @code{$foo}, @code{$FOO} y  @code{$Foo} se convierten por defecto al
símbolo @code{$FOO} de Lisp.

@item
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. 
Esto es, de mayúsculas cambia a minúsculas y de minúsculas cambia a mayúsculas. 
E.g., el identificador Lisp @code{|$FOO|} y @code{|$foo|}
corresponden los identificadores Maxima @code{foo} y @code{FOO}, respectivamente. 
@item
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. 
E.g., el identificador Lisp @code{|$Foo|} corresponde a el identificador Maxima @code{Foo}. 
@end enumerate

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}.   

@example
(msetq $foo #$[x, y]$)
@end example

@noindent
Esto tiene el mismo efecto que: 

@example
(%i1) foo: [x, y];
@end example

@noindent
La función Lisp @code{displa} imprime una expresión en formato Maxima.

@example
(%i1) :lisp #$[x, y, z]$ 
((MLIST SIMP) $X $Y $Z)
(%i1) :lisp (displa '((MLIST SIMP) $X $Y $Z))
[x, y, z]
NIL
@end example

Las funciones definidas en Maxima no son funciones Lisp ordinarias. 
La función Lisp @code{mfuncall} llama a una función Maxima. 
Por ejemplo: 

@example
(%i1) foo(x,y) := x*y$
(%i2) :lisp (mfuncall '$foo 'a 'b)
((MTIMES SIMP) A B)
@end example

Algunas funciones Lisp son compartidas en el paquete Maxima, las cuales se listan a continuación: 

@code{complement},
@code{continue},
@code{//},
@code{float},
@code{functionp},
@code{array},
@code{exp},
@code{listen},
@code{signum},
@code{atan},
@code{asin},
@code{acos},
@code{asinh},
@code{acosh},
@code{atanh},
@code{tanh},
@code{cosh},
@code{sinh},
@code{tan},
@code{break},
y @code{gcd}.






@node Recolector de basura, Introducción a la programación, Lisp y Maxima, Programación
@section Recolector de basura

La computación simbólica tiende a crear una buena cantidad de basura
(resultados temporales que ya no serán utilizados),
y un manejo efectivo de esto puede ser crucial para el término exitoso de
algunos programas. 

Bajo GCL (GNU Common Lisp), en aquellos sistemas UNIX donde la llamada al sistema
mprotect está disponible (incluyendo SUN OS 4.0 y algunas variantes de BSD)
se dispone de un recolector de basura estratificado. Véase la documentación
de GCL para ALLOCATE y GBC. A nivel Lisp, ejecutando (setq si::*notify-gbc* t) 
pemitirá determinar qué áreas necesitan más espacio.

En cuanto al resto de Lisps bajo los que funciona Maxima, se remite
al lector a la documentación correspondiente para controlar la
recolección de basura.






@node Introducción a la programación, Funciones y variables para la programación, Recolector de basura, Programación
@section Introducción a la programación

Maxima dispone de los bucles @code{do} para hacer iteraciones, así como estructuras más primitivas del estilo de @code{go}.


@node Funciones y variables para la programación,  , Introducción a la programación, Programación
@section Funciones y variables para la programación

@deffn {Función} backtrace ()
@deffnx {Función} backtrace (@var{n})
Devuelve la pila de llamadas, esto es, la lista de funciones que han llamado a la función actualmente activa.

La llamada a @code{backtrace()} devuelve la pila completa de llamadas.

Ejemplos:

@example
(%i1) h(x) := g(x/7)$
(%i2) g(x) := f(x-11)$
(%i3) f(x) := e(x^2)$
(%i4) e(x) := (backtrace(), 2*x + 13)$
(%i5) h(10);
#0: e(x=4489/49)
#1: f(x=-67/7)
#2: g(x=10/7)
#3: h(x=10)
                              9615
(%o5)                         ----
                               49
@end example

La llamada @code{backtrace (@var{n})} devuelve las @var{n} funciones más recientes, incluyendo a la función actualmente activa.

Ejemplos:

@example
(%i1) h(x) := (backtrace(1), g(x/7))$
(%i2) g(x) := (backtrace(1), f(x-11))$
(%i3) f(x) := (backtrace(1), e(x^2))$
(%i4) e(x) := (backtrace(1), 2*x + 13)$
(%i5) h(10);
#0: h(x=10)
#0: g(x=10/7)
#0: f(x=-67/7)
#0: e(x=4489/49)
                              9615
(%o5)                         ----
                               49
@end example

@end deffn

@deffn {Operador especial} do
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.

Hay tres variantes de esta sentencia que se diferencian entre sí únicamente por las condiciones de fin de bucle. Son las siguientes:

@itemize @bullet
@item
@code{for @var{variable}: @var{valor_inicial} step @var{incremento}
      thru @var{límite} do @var{cuerpo}}
@item
@code{for @var{variable}: @var{valor_inicial} step @var{incremento}
      while @var{condición} do @var{cuerpo}}
@item
@code{for @var{variable}: @var{valor_inicial} step @var{incremento}
      unless @var{condición} do @var{cuerpo}}
@end itemize

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.

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.

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.

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.

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.
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}.

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}.

@example
(%i1) for a:-3 thru 26 step 7 do display(a)$
                             a = - 3

                              a = 4

                             a = 11

                             a = 18

                             a = 25
@end example

@example
(%i1) s: 0$
(%i2) for i: 1 while i <= 10 do s: s+i;
(%o2)                         done
(%i3) s;
(%o3)                          55
@end example


Nótese que la condición @code{while i <= 10} es equivalente a @code{unless i > 10} y a @code{thru 10}.

@example
(%i1) series: 1$
(%i2) term: exp (sin (x))$
(%i3) for p: 1 unless p > 7 do
          (term: diff (term, x)/p, 
           series: series + subst (x=0, term)*x^p)$
(%i4) series;
                  7    6     5    4    2
                 x    x     x    x    x
(%o4)            -- - --- - -- - -- + -- + x + 1
                 90   240   15   8    2
@end example

lo que da ocho términos del desarrollo de Taylor de la función @code{e^sin(x)}.

@example
(%i1) poly: 0$
(%i2) for i: 1 thru 5 do
          for j: i step -1 thru 1 do
              poly: poly + i*x^j$
(%i3) poly;
                  5      4       3       2
(%o3)          5 x  + 9 x  + 12 x  + 14 x  + 15 x
(%i4) guess: -3.0$
(%i5) for i: 1 thru 10 do
          (guess: subst (guess, x, 0.5*(x + 10/x)),
           if abs (guess^2 - 10) < 0.00005 then return (guess));
(%o5)                  - 3.162280701754386
@end example

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}.

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.

@example
(%i6) for count: 2 next 3*count thru 20 do display (count)$
                            count = 2

                            count = 6

                           count = 18
@end example

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.

@example
(%i1) x: 1000$
(%i2) thru 20 do x: 0.5*(x + 5.0/x)$
(%i3) x;
(%o3)                   2.23606797749979
(%i4) sqrt(5), numer;
(%o4)                   2.23606797749979
@end example

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}.

@example
(%i1) newton (f, x):= ([y, df, dfx], df: diff (f ('x), 'x),
          do (y: ev(df), x: x - f(x)/y, 
              if abs (f (x)) < 5e-6 then return (x)))$
(%i2) sqr (x) := x^2 - 5.0$
(%i3) newton (sqr, 1000);
(%o3)                   2.236068027062195
@end example

(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.)

Hay todavía otra forma de @code{do} en Maxima. Su sintaxis es:

@example
for @var{variable} in @var{lista} @var{test_de_parada} do @var{cuerpo}
@end example

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.)

@example
(%i1)  for f in [log, rho, atan] do ldisp(f(1))$
(%t1)                                  0
(%t2)                                rho(1)
                                     %pi
(%t3)                                 ---
                                      4
(%i4) ev(%t3,numer);
(%o4)                             0.78539816
@end example

@end deffn



@deffn {Función} errcatch (@var{expr_1}, ..., @var{expr_n})
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.

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.

@end deffn

@deffn {Función} error (@var{expr_1}, ..., @var{expr_n})
@deffnx {Variable del sistema} error
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. 

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.

La llamada a @code{errormsg()} formatea e imprime @code{error}. Se reimprime así el mensaje de error más reciente.

@end deffn



@defvr {Variable opcional} error_size
Valor por defecto: 10

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})
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}.

En caso contrario, si la expresión es menor que @code{error_size}, la expresión se muestra en el propio mensaje.

Véanse también @code{error} y @code{error_syms}.

Ejemplo:
@c OUTPUT GENERATED BY THE FOLLOWING
@c U: (C^D^E + B + A)/(cos(X-1) + 1)$
@c error_size: 20$
@c error ("Example expression is", U);
@c errexp1;
@c error_size: 30$
@c error ("Example expression is", U);

El tamaño de @code{U}, tal como lo determina @code{ERROR-SIZE}, es 24.

@example
(%i1) U: (C^D^E + B + A)/(cos(X-1) + 1)$

(%i2) error_size: 20$

(%i3) error ("Example expression is", U);

Example expression is errexp1
 -- an error.  Quitting.  To debug this try debugmode(true);
(%i4) errexp1;
                            E
                           D
                          C   + B + A
(%o4)                    --------------
                         cos(X - 1) + 1
(%i5) error_size: 30$

(%i6) error ("Example expression is", U);

                         E
                        D
                       C   + B + A
Example expression is --------------
                      cos(X - 1) + 1
 -- an error.  Quitting.  To debug this try debugmode(true);
@end example

@end defvr



@defvr {Variable opcional} error_syms
Valor por defecto: @code{[errexp1, errexp2, errexp3]}

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.

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})}.

Véanse también @code{error} y @code{error_size}.

@end defvr



@deffn {Función} errormsg ()

Reimprime el mensaje de error más reciente. La variable @code{error} guarda el mensaje y @code{errormsg} lo formatea e imprime.

@end deffn



@defvr {Variable opcional} errormsg
Valor por defecto: @code{true}

Cuando @code{errormsg} vale @code{false} se suprimen los contenidos
de los mensajes de error.

La variable @code{errormsg} no se puede asignar a un valor local dentro
de un bloque. El valor global de @code{errormsg} está siempre presente.

Ejemplos:

@c ===beg===
@c errormsg;
@c sin(a,b);
@c errormsg:false;
@c sin(a,b);
@c ===end===
@example
(%i1) errormsg;
(%o1)                                true
(%i2) sin(a,b);
Wrong number of arguments to sin
 -- an error. To debug this try: debugmode(true);
(%i3) errormsg:false;
(%o3)                                false
(%i4) sin(a,b);

 -- an error. To debug this try: debugmode(true);
@end example

La variable @code{errormsg} no se puede asignar a un valor local dentro
de un bloque.

@c ===beg===
@c f(bool):=block([errormsg:bool], print ("value of errormsg is",errormsg))$
@c errormsg:true;
@c f(false);
@c errormsg:false;
@c f(true);
@c ===end===
@example
(%i1) f(bool):=block([errormsg:bool], 
                     print ("value of errormsg is",errormsg))$
(%i2) errormsg:true;
(%o2)                                true
(%i3) f(false);
value of errormsg is true 
(%o3)                                true
(%i4) errormsg:false;
(%o4)                                false
(%i5) f(true);
value of errormsg is false 
(%o5)                                false
@end example
@end defvr



@deffn {Operador especial} for
Utilizado en las iteraciones. Véase @code{do} para una descripción de las técnicas de iteración en Maxima.

@end deffn

@deffn {Función} go (@var{etiqueta})
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:

@example
block ([x], x:1, tururu, x+1, ..., go(tururu), ...)
@end example

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}.

@end deffn

@deffn {Operador especial} if
Evaluación condicionada. Se reconocen varias formas de expresiones @code{if}.

La expresión @code{if @var{cond_1} then @var{expr_1} else @var{expr_0}}
devuelve @var{expr_1} si @var{cond_1} vale @code{true},
en caso contrario la respuesta es @code{expr_0}.

La expresión @code{if @var{cond_1} then @var{expr_1} elseif @var{cond_2}
then @var{expr_2} elseif ... else @var{expr_0}}
devuelve @var{expr_k} si @var{cond_k} vale @code{true} y todas las
condiciones anteriores toman el valor @code{false}.
Si ninguna de las condiciones vale @code{true}, la respuesta es @code{expr_0}.

La falta de un @code{else} final se interpreta como un @code{else false};
esto es, la expresión @code{if @var{cond_1} then @var{expr_1}}
equivale a @code{if @var{cond_1} then @var{expr_1} else false},
y @code{if @var{cond_1} then @var{expr_1} elseif ... elseif @var{cond_n} then @var{expr_n}}
equivale a su vez a
@code{if @var{cond_1} then @var{expr_1} elseif ... elseif @var{cond_n} then @var{expr_n} else false}.

Las alternativas @var{expr_0}, ..., @var{expr_n} pueden ser expresiones
válidas de Maxima, incluidas expresiones @code{if} anidadas.
Las alternativas ni se simplifican ni se evalúan, a menos que su
condición asociada valga @code{true}.

Las condiciones @var{cond_1}, ..., @var{cond_n} deben ser expresiones 
capaces de dar como resultado @code{true} o @code{false} al ser
evaluadas. Si en un momento dado una condición no da como resultado 
un valor de verdad (@code{true} o @code{false}), el comportamiento de @code{if} se controla
con la variable global @code{prederror}. Si @code{prederror} vale @code{true},
se considera un error que la condición evaluada no dé como resultado
un valor de verdad; en caso contrario, las condiciones que no
den como resultado un valor de verdad se aceptan, dándose el
resultado como una expresión condicional.

Las condiciones pueden contener operadores lógicos y relacionales, 
así como otros elementos, tal como se indica a continuación:


@example
Operación               Símbolo     Tipo
 
menor que               <           operador relacional infijo
menor o igual que       <=          operador relacional infijo
igualdad (sintáctica)   =           operador relacional infijo
negación de =           #           operador relacional infijo
igualdad (por valor)    equal       operador relacional infijo
negación de equal       notequal    operador relacional infijo
mayor o igual que       >=          operador relacional infijo
mayor que               >           operador relacional infijo
y                       and         operador lógico infijo
o                       or          operador lógico infijo
no                      not         operador lógico prefijo
@end example

@end deffn

@deffn {Función} map (@var{f}, @var{expr_1}, ..., @var{expr_n})
Devuelve una expresión cuyo operador principal es el mismo 
que aparece en las expresiones @var{expr_1}, ..., @var{expr_n} 
pero cuyas subpartes son los resultados de aplicar @var{f} 
a cada una de las subpartes de las expresiones;  @var{f} puede ser 
tanto el nombre de una función de @math{n} argumentos como
una expresión @code{lambda} de @math{n} argumentos.

Uno de los usos que tiene @code{map} es la de aplicar (o mapear)
una función (por ejemplo, @code{partfrac}) sobre cada término
de una expresión extensa en la que normalmente no se 
podría utilizar la función debido a insuficiencias 
en el espacio de almacenamiento durante el curso de un cálculo.

@example
(%i1) map(f,x+a*y+b*z);
(%o1)                        f(b z) + f(a y) + f(x)
(%i2) map(lambda([u],partfrac(u,x)),x+1/(x^3+4*x^2+5*x+2));
                           1       1        1
(%o2)                     ----- - ----- + -------- + x
                         x + 2   x + 1          2
                                         (x + 1)
(%i3) map(ratsimp, x/(x^2+x)+(y^2+y)/y);
                                      1
(%o3)                            y + ----- + 1
                                    x + 1
(%i4) map("=",[a,b],[-0.5,3]);
(%o4)                          [a = - 0.5, b = 3]
@end example

Véase también @code{maperror} .
@end deffn

@deffn {Función} mapatom (@var{expr})
Devuelve @code{true} si y sólo @var{expr} es tratado por las rutinas de mapeo como un átomo.
@end deffn

@defvr {Variable opcional} maperror
Valor por defecto: @code{true}

Cuando @code{maperror} toma el valor @code{false}, 
hace que todas las funciones de mapeo, como por ejemplo

@example
map (f, @var{expr_1}, @var{expr_2}, ...)
@end example

(1) paren cuando hayan terminado de procesar la @var{expr_i} más corta,
a menos que todas ellas sean del mismo tamaño y (2) apliquen  @code{f}
a @code{[expr_1, expr_2, ...]} si es el caso que las @code{expr_i}
no son todas del mismo tipo de objeto.

Cuando @code{maperror} toma el valor @code{true} entonces se emite un mensaje de error cuando se presenta cualquiera de los dos casos anteriores.

@end defvr



@defvr {Variable opcional} mapprint
Valor por defecto: @code{true}

Si @code{mapprint} vale @code{true}, se producirán ciertos mensajes
por parte de las funciones @code{map}, @code{mapl} y @code{fullmap}
en determinadas situaciones, como cuando @code{map} hace uso de
@code{apply}.

Si @code{mapprint} vale @code{false}, no se emitirán tales mensajes.
@end defvr



@deffn {Función} maplist (@var{f}, @var{expr_1}, ..., @var{expr_n})
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.

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}.

@end deffn

@defvr {Variable opcional} prederror
Valor por defecto: @code{false}

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}).

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.

Véanse también @code{is} y @code{maybe}.

@end defvr

@deffn {Función} return (valor)
Puede utilizarse para salir de un bloque, devolviendo su argumento.
Véase @code{block} para más información.

@end deffn

@deffn {Función} scanmap (@var{f}, @var{expr})
@deffnx {Función} scanmap (@var{f}, @var{expr}, bottomup)
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:

@example
(%i1) exp:(a^2+2*a+1)*y + x^2$
(%i2) scanmap(factor,exp);
                                    2      2
(%o2)                         (a + 1)  y + x
@end example

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:

@example
(%i3) scanmap(factor,expand(exp));
                           2                  2
(%o3)                      a  y + 2 a y + y + x
@end example

Aquí hay otro ejemplo de la forma en que @code{scanmap} aplica recursivamente una función dada a todas las subexpresiones, incluyendo exponentes:

@example
(%i4) expr : u*v^(a*x+b) + c$
(%i5) scanmap('f, expr);
                    f(f(f(a) f(x)) + f(b))
(%o5) f(f(f(u) f(f(v)                      )) + f(c))
@end example

@code{scanmap (@var{f}, @var{expr}, bottomup)} aplica @var{f} a @var{expr} de abajo hacia arriba. Por ejemplo, para @code{f} no definida,

@example
scanmap(f,a*x+b) ->
   f(a*x+b) -> f(f(a*x)+f(b)) -> f(f(f(a)*f(x))+f(b))
scanmap(f,a*x+b,bottomup) -> f(a)*f(x)+f(b)
    -> f(f(a)*f(x))+f(b) ->
     f(f(f(a)*f(x))+f(b))
@end example

En este caso se obtiene la misma respuesta por cualquiera de los dos métodos.

@end deffn

@deffn {Función} throw (@var{expr})
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.

@end deffn


@deffn {Operador especial} while
@deffnx {Operador especial} unless

Véase @code{do}.

@end deffn


@deffn {Función} outermap (@var{f}, @var{a_1}, ..., @var{a_n})
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}.

El argumento @var{f} debe ser el nombre de una función de @math{n} argumentos,
o una expresión lambda de @math{n} argumentos.
Cada uno de los argumentos @var{a_k} puede ser una lista, una lista anidada, 
una matriz o cualquier otro tipo de expresión.

El valor devuelto por @code{outermap} es una estructura anidada. Si @var{x} es la
respuesta dada por @code{outermap}, entonces tiene la misma estructura que la primera lista,
lista anidada o matriz, @code{@var{x}[i_1]...[i_m]} tiene la misma estructura que la
segunda lista, lista anidada o matriz, @code{@var{x}[i_1]...[i_m][j_1]...[j_n]} tiene 
la misma estructura que la tercera lista, lista anidada o matriz, y así
sucesivamente, siendo @var{m}, @var{n}, ... los números índice
necesarios para acceder a los elementos de cada argumento: uno para las listas,
dos para las matrices y uno o más para las listas anidadas. 
Aquellos argumentos que no sean listas ni matrices no tienen efecto alguno sobre
la estructura del valor retornado.

Nótese que el efecto producido por @code{outermap} es diferente del que
se obtiene al aplicar @var{f} a cada uno de los elementos del producto
devuelto por @code{cartesian_product}. La función @code{outermap}
mantiene la estructura de los argumentos en la respuesta, miemtras que
@code{cartesian_product} no lo hace.

La función @code{outermap} evalúa sus argumentos.

Véanse también @code{map}, @code{maplist} y @code{apply}.

Ejemplos:

Ejemplos elementales de uso de @code{outermap}.
Con el fin de mostrar con mayor claridad las combinaciones del argumento,
se mantiene sin definir @code{F}.


@c ===beg===
@c outermap (F, [a, b, c], [1, 2, 3]);
@c outermap (F, matrix ([a, b], [c, d]), matrix ([1, 2], [3, 4]));
@c outermap (F, [a, b], x, matrix ([1, 2], [3, 4]));
@c outermap (F, [a, b], matrix ([1, 2]), matrix ([x], [y]));
@c outermap ("+", [a, b, c], [1, 2, 3]);
@c ===end===
@example
(%i1) outermap (F, [a, b, c], [1, 2, 3]);
(%o1) [[F(a, 1), F(a, 2), F(a, 3)], [F(b, 1), F(b, 2), F(b, 3)], 
                                     [F(c, 1), F(c, 2), F(c, 3)]]
(%i2) outermap (F, matrix ([a, b], [c, d]), matrix ([1, 2], [3, 4]));
         [ [ F(a, 1)  F(a, 2) ]  [ F(b, 1)  F(b, 2) ] ]
         [ [                  ]  [                  ] ]
         [ [ F(a, 3)  F(a, 4) ]  [ F(b, 3)  F(b, 4) ] ]
(%o2)    [                                            ]
         [ [ F(c, 1)  F(c, 2) ]  [ F(d, 1)  F(d, 2) ] ]
         [ [                  ]  [                  ] ]
         [ [ F(c, 3)  F(c, 4) ]  [ F(d, 3)  F(d, 4) ] ]
(%i3) outermap (F, [a, b], x, matrix ([1, 2], [3, 4]));
       [ F(a, x, 1)  F(a, x, 2) ]  [ F(b, x, 1)  F(b, x, 2) ]
(%o3) [[                        ], [                        ]]
       [ F(a, x, 3)  F(a, x, 4) ]  [ F(b, x, 3)  F(b, x, 4) ]
(%i4) outermap (F, [a, b], matrix ([1, 2]), matrix ([x], [y]));
       [ [ F(a, 1, x) ]  [ F(a, 2, x) ] ]
(%o4) [[ [            ]  [            ] ], 
       [ [ F(a, 1, y) ]  [ F(a, 2, y) ] ]
                              [ [ F(b, 1, x) ]  [ F(b, 2, x) ] ]
                              [ [            ]  [            ] ]]
                              [ [ F(b, 1, y) ]  [ F(b, 2, y) ] ]
(%i5) outermap ("+", [a, b, c], [1, 2, 3]);
(%o5) [[a + 1, a + 2, a + 3], [b + 1, b + 2, b + 3], 
                                           [c + 1, c + 2, c + 3]]
@end example

El siguiente ejemplo permite hacer un análisis más profundo del valor
retornado por @code{outermap}.
Los tres primeros argumentos son una matriz, una lista y otra matriz, en este
orden. El valor devuelto es una matriz, cuyos elementos son listas y
cada elemento de cada una de estas listas es a su vez una matriz.

@c ===beg===
@c arg_1 :  matrix ([a, b], [c, d]);
@c arg_2 : [11, 22];
@c arg_3 : matrix ([xx, yy]);
@c xx_0 : outermap (lambda ([x, y, z], x / y + z), arg_1, 
@c                                                    arg_2, arg_3);
@c xx_1 : xx_0 [1][1];
@c xx_2 : xx_0 [1][1] [1];
@c xx_3 : xx_0 [1][1] [1] [1][1];
@c [op (arg_1), op (arg_2), op (arg_3)];
@c [op (xx_0), op (xx_1), op (xx_2)];
@c ===end===
@example
(%i1) arg_1 :  matrix ([a, b], [c, d]);
                            [ a  b ]
(%o1)                       [      ]
                            [ c  d ]
(%i2) arg_2 : [11, 22];
(%o2)                       [11, 22]
(%i3) arg_3 : matrix ([xx, yy]);
(%o3)                      [ xx  yy ]
(%i4) xx_0 : outermap(lambda([x, y, z], x / y + z), arg_1,
                                                   arg_2, arg_3);
               [  [      a        a  ]  [      a        a  ]  ]
               [ [[ xx + --  yy + -- ], [ xx + --  yy + -- ]] ]
               [  [      11       11 ]  [      22       22 ]  ]
(%o4)  Col 1 = [                                              ]
               [  [      c        c  ]  [      c        c  ]  ]
               [ [[ xx + --  yy + -- ], [ xx + --  yy + -- ]] ]
               [  [      11       11 ]  [      22       22 ]  ]
                 [  [      b        b  ]  [      b        b  ]  ]
                 [ [[ xx + --  yy + -- ], [ xx + --  yy + -- ]] ]
                 [  [      11       11 ]  [      22       22 ]  ]
         Col 2 = [                                              ]
                 [  [      d        d  ]  [      d        d  ]  ]
                 [ [[ xx + --  yy + -- ], [ xx + --  yy + -- ]] ]
                 [  [      11       11 ]  [      22       22 ]  ]
(%i5) xx_1 : xx_0 [1][1];
           [      a        a  ]  [      a        a  ]
(%o5)     [[ xx + --  yy + -- ], [ xx + --  yy + -- ]]
           [      11       11 ]  [      22       22 ]
(%i6) xx_2 : xx_0 [1][1] [1];
                      [      a        a  ]
(%o6)                 [ xx + --  yy + -- ]
                      [      11       11 ]
(%i7) xx_3 : xx_0 [1][1] [1] [1][1];
                                  a
(%o7)                        xx + --
                                  11
(%i8) [op (arg_1), op (arg_2), op (arg_3)];
(%o8)                  [matrix, [, matrix]
(%i9) [op (xx_0), op (xx_1), op (xx_2)];
(%o9)                  [matrix, [, matrix]
@end example

La función @code{outermap} mantiene la estructura de los argumentos en su respuesta,
mientras que @code{cartesian_product} no lo hace.

@c ===beg===
@c outermap (F, [a, b, c], [1, 2, 3]);
@c setify (flatten (%));
@c map (lambda ([L], apply (F, L)), cartesian_product ({a, b, c}, {1, 2, 3}));
@c is (equal (%, %th (2)));
@c ===end===
@example
(%i1) outermap (F, [a, b, c], [1, 2, 3]);
(%o1) [[F(a, 1), F(a, 2), F(a, 3)], [F(b, 1), F(b, 2), F(b, 3)], 
                                     [F(c, 1), F(c, 2), F(c, 3)]]
(%i2) setify (flatten (%));
(%o2) @{F(a, 1), F(a, 2), F(a, 3), F(b, 1), F(b, 2), F(b, 3), 
                                       F(c, 1), F(c, 2), F(c, 3)@}
(%i3) map (lambda ([L], apply (F, L)), cartesian_product (@{a, b, c@}, @{1, 2, 3@}));
(%o3) @{F(a, 1), F(a, 2), F(a, 3), F(b, 1), F(b, 2), F(b, 3), 
                                       F(c, 1), F(c, 2), F(c, 3)@}
(%i4) is (equal (%, %th (2)));
(%o4)                         true
@end example

@end deffn



