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 $ 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 ? corresponde a un símbolo Lisp sin dicho signo. Por ejemplo, el símbolo Maxima foo corresponde a el símbolo Lisp $foo, mientras que el símbolo Maxima ?foo corresponde a el símbolo Lisp foo, tenga en cuenta que ?foo esta escrito sin espacio entre ? y foo; de otra manera se estaría invocando a describe ("foo").

El guión -, asterisco *, u otros carácteres especiales en símbolos Lisp deben ser escritos mediante un backslash \ si aparecen en código Maxima. Por ejemplo, el identificador Lisp *foo-bar* se debe escribir ?\*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 :lisp. Por ejemplo,

     (%i1) :lisp (foo $x $y)

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

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

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

Maxima es case-sensitive, distingue entre letras minúsculas y mayúsculas en identificadores, mientras que Lisp no. Existen algunas reglas que gobiernan la traducción de nombres entre Lisp y Maxima.

 1. 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 $foo, $FOO, y $Foo, todos corresponden al identificador Maxima foo.

 2. 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 |$FOO| y |$foo| corresponden los identificadores Maxima foo y FOO, respectivamente.

 3. 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 |$Foo| corresponde a el identificador Maxima Foo.

La macro Lisp #$ permite el uso de expresiones Maxima dentro de código Lisp. #$EXPR$ extiende a una expresión Lisp equivalente a la expresión Maxima EXPR.

     (msetq $foo #$[x, y]$)

Esto tiene el mismo efecto que:

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

La función Lisp displa imprime una expresión en formato Maxima.

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

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

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

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

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

Recolector de basura
====================

La computación simbólica tiende a crear una buena cantidad de basura, y un manejo efectivo de esto puede ser crucial para el término exitoso de algunos programas.

Bajo GCL (GNU Common Lisp), en los sistemas UNIX donde la llamada al  sistema mprotect esta disponible (incluyendo SUN OS 4.0 y algunas variantes de BSD) un recolector de basura estratificado está disponible. Estos límites de colección para memoria virtual, han sido escritos recientemente. Mire la documentación de GCL bajo ALLOCATE y GBC.  En el nivel lisp haga (setq si::*notify-gbc* t) eso le ayudará a determinar cuales áreas necesitan más espacio.

Documentación
=============

El manual en línea del usuario de Maxima puede ser visto en diferentes formas. Desde el prompt interactivo de Maxima, el manual de usuario es visto como texto plano por medio del comando  ? (i.e., la función describe). El manual de usuario también puede ser visto como hipertexto tipo info por medio del programa info y como una página web a través de cualquier navegador.

El comando example muestra ejemplos para muchas funciones Maxima. Por ejemplo:

     (%i1) example (integrate);

produce:

     (%i2) test(f):=block([u],u:integrate(f,x),ratsimp(f-diff(u,x)))
     (%o2) test(f) := block([u], u : integrate(f, x),

                                              ratsimp(f - diff(u, x)))
     (%i3) test(sin(x))
     (%o3)                           0
     (%i4) test(1/(x+1))
     (%o4)                           0
     (%i5) test(1/(x^2+1))
     (%o5)                           0

y salidas adicionales.

Funciones y variables para la ayuda
===================================

 -- Función: demo (ARCHIVO)
     Evalua las expresiones Maxima contenidas en ARCHIVO y muestra los resultados. demo hace pausas después de evaluar  cada expresión y continua después de que el usuario ingrese un retorno de carro. (Si se ejecuta en Xmaxima, demo puede que necesite un punto y coma ; a continuación del retorno de carro.)

     demo busca la lista de directorios file_search_demo para encontrar archivo. Si el archivo tiene el sufijo dem, el sufijo puede ser omitido. Ver también file_search.

     demo evalua su argumento. demo retorna el nombre del archivo demostración.

     Ejemplo:

          (%i1) demo ("disol");

          batching /home/wfs/maxima/share/simplification/disol.dem
           At the _ prompt, type ';' followed by enter to get next demo
          (%i2)                      load(disol)

          _
          (%i3)           exp1 : a (e (g + f) + b (d + c))
          (%o3)               a (e (g + f) + b (d + c))

          _
          (%i4)                disolate(exp1, a, b, e)
          (%t4)                         d + c

          (%t5)                         g + f

          (%o5)                   a (%t5 e + %t4 b)

          _
          (%i5) demo ("rncomb");

          batching /home/wfs/maxima/share/simplification/rncomb.dem
           At the _ prompt, type ';' followed by enter to get next demo
          (%i6)                     load(rncomb)

          _
                                       z         x
          (%i7)               exp1 : ----- + ---------
                                     y + x   2 (y + x)
                                    z         x
          (%o7)                   ----- + ---------
                                  y + x   2 (y + x)

          _
          (%i8)                     combine(exp1)
                                    z         x
          (%o8)                   ----- + ---------
                                  y + x   2 (y + x)

          _
          (%i9)                     rncombine(%)
                                       2 z + x
          (%o9)                       ---------
                                      2 (y + x)

          _
                                       d   c   b   a
          (%i10)                exp2 : - + - + - + -
                                       3   3   2   2
                                    d   c   b   a
          (%o10)                    - + - + - + -
                                    3   3   2   2

          _
          (%i11)                    combine(exp2)
                                2 d + 2 c + 3 (b + a)
          (%o11)                ---------------------
                                          6

          _
          (%i12)                   rncombine(exp2)
                                2 d + 2 c + 3 b + 3 a
          (%o12)                ---------------------
                                          6

          _
          (%i13)

 -- Función: describe (STRING)
 -- Función: describe (STRING, exact)
 -- Función: describe (STRING, inexact)
     La sentencia describe(STRING) equivale a describe(STRING, exact).

     La sentencia describe(STRING, exact) encuentra el elemento, si existe, cuyo título coincide exactamente con STRING (ignorando la diferencia entre mayúsculas y minúsculas).

     La sentencia describe(STRING, inexact) encuentra todos los elementos documentados que contengan STRING en sus títulos.

     Si hay más de una opción, Maxima preguntará al usuario para que seleccione las opciones que desee consultar.

     La sentencia ? foo (con espacio entre ? y foo) equivale a  describe("foo", exact), mientras que ?? foo equivale a describe("foo", inexact).

     describe ("", inexact) produce una lista de todos los temas documentados en el manual en línea.

     describe no evalúa su argumento. La función describe devuelve true si encuentra la documentación solicitada y false en caso contrario.

     Véase también Documentación.

     Ejemplo:

          (%i1) ?? integ
           0: Functions and Variables for Elliptic Integrals
           1: Functions and Variables for Integration
           2: Introduction to Elliptic Functions and Integrals
           3: Introduction to Integration
           4: askinteger  (Functions and Variables for Simplification)
           5: integerp  (Functions and Variables for Miscellaneous Options)
           6: integer_partitions  (Functions and Variables for Sets)
           7: integrate  (Functions and Variables for Integration)
           8: integrate_use_rootsof  (Functions and Variables for
              Integration)
           9: integration_constant_counter  (Functions and Variables for
              Integration)
           10: nonnegintegerp  (Functions and Variables for linearalgebra)
          Enter space-separated numbers, `all' or `none': 7 8

           -- Function: integrate (<expr>, <x>)
           -- Function: integrate (<expr>, <x>, <a>, <b>)
               Attempts to symbolically compute the integral of <expr> with
               respect to <x>.  `integrate (<expr>, <x>)' is an indefinite
               integral, while `integrate (<expr>, <x>, <a>, <b>)' is a
               definite integral, [...]

           -- Option variable: integrate_use_rootsof
               Default value: `false'

               When `integrate_use_rootsof' is `true' and the denominator of
               a rational function cannot be factored, `integrate' returns
               the integral in a form which is a sum over the roots (not yet
               known) of the denominator.
               [...]

     En este ejemplo fueron seleccionadas las opciones 7 y 8 (la salida ha sido recortada, tal como indica [...]). Todas o ninguna de las opciones pueden ser seleccionadas escribiendo all o none, las cuales pueden ser abreviadas por a o n, respectivamente.

 -- Función: example (TEMA)
 -- Función: example ()
     example (TEMA) mostrará algunos ejemplos de TEMA, el cual es un símbolo (no una cadena). La mayoría de los temas son nombres de funciones. example () retorna la lista de todos los temas conocidos.

     El nombre del archivo que contiene los ejemplos esta dado por la variable global manual_demo, cuyo valor por defecto es "manual.demo".

     example no evalua su argumento. example retorna done a menos que haya un error o que no haya argumento, en cuyo caso example devolverá la lista de todos los temas conocidos.

     Ejemplos:

          (%i1) example (append);
          (%i2) append([x+y,0,-3.2],[2.5E+20,x])
          (%o2)             [y + x, 0, - 3.2, 2.5E+20, x]
          (%o2)                         done
          (%i3) example (coeff);
          (%i4) coeff(b+tan(x)+2*a*tan(x) = 3+5*tan(x),tan(x))
          (%o4)                      2 a + 1 = 5
          (%i5) coeff(1+x*%e^x+y,x,0)
          (%o5)                         y + 1
          (%o5)                         done