Comentarios
===========

En Maxima, un comentario es cualquier texto encerrado entre las marcas /* y */.

El analizador sintáctico de Maxima trata los comentarios como espacios en blanco a efectos de encontrar tokens en el flujo de entrada. Una entrada tal como a/* foo */b contiene dos tokens, a y b, no un único token ab. En cualquier otro contexto, los comentarios son ignorados por Maxima; no se almacenan ni sus contenidos ni sus localizaciones.

Los comentarios pueden anidarse hasta una profundidad arbitraria. Las marcas  /* y */ deben emparejarse y debe haber igual número de ambos.

Ejemplos:

     (%i1) /* aa is a variable of interest */  aa : 1234;
     (%o1)                         1234
     (%i2) /* Value of bb depends on aa */  bb : aa^2;
     (%o2)                        1522756
     (%i3) /* User-defined infix operator */  infix ("b");
     (%o3)                           b
     (%i4) /* Parses same as a b c, not abc */  a/* foo */b/* bar */c;
     (%o4)                         a b c
     (%i5) /* Comments /* can be nested /* to any depth */ */ */  1 + xyz;
     (%o5)                        xyz + 1

Archivos
========

Un archivo no es más que una área de un cierto dispositivo de almacenamiento que contiene datos o texto. Los archivos se agrupan en los discos en "directorios", que son listas de archivos. Instrucciones que operan con archivos son: save, load, loadfile, stringout, batch, demo, writefile, closefile y appendfile.

Funciones y variables para lectura y escritura
==============================================

 -- Variable del sistema: __

     __ es la expresión de entrada que está siendo actualmente evaluada. Esto es, mientras se está evaluando una expresión de entrada, __ es igual a EXPR.

     A __ se le asigna la expresión de entrada antes de que ésta sea simplificada o evaluada. Sin embargo, el valor de __ es simplificado, pero no evaluado, cuando su valor es mostrado en el terminal.

     La variable __ es reconocida por  batch y por load. Cuando un fichero es procesado por batch, la variable __ tiene el mismo significado que en el modo interactivo. Cuando un fichero es procesado por load, a la variable __ se le asigna la última expresión introducida, bien desde el modo interactivo, bien en un fichero por lotes; en ningún caso se le asigna a __ una expresión de entrada del fichero que está siendo procesado. En particular, si load (FILENAME) es ejecutado desde el modo interactivo, entonces __ almacena la expresión load (FILENAME) mientras el fichero está siendo procesado.

     Véanse también _ y %.

     Ejemplos:

          (%i1) print ("I was called as", __);
          I was called as print(I was called as, __)
          (%o1)              print(I was called as, __)
          (%i2) foo (__);
          (%o2)                     foo(foo(__))
          (%i3) g (x) := (print ("Current input expression =", __), 0);
          (%o3) g(x) := (print("Current input expression =", __), 0)
          (%i4) [aa : 1, bb : 2, cc : 3];
          (%o4)                       [1, 2, 3]
          (%i5) (aa + bb + cc)/(dd + ee + g(x));
                                      cc + bb + aa
          Current input expression = --------------
                                     g(x) + ee + dd
                                          6
          (%o5)                        -------
                                       ee + dd

 -- Variable del sistema: _

     El símbolo _ representa la última expresión de entrada (esto es, %i1, %i2, %i3, ...).

     Al símbolo _ se le asigna la expresión de entrada antes de que ésta sea simplificada o evaluada. Sin embargo, el valor de _ se simplifica (pero no se evalúa) cuando se muestra en el terminal.

     La variable _ es reconocida por  batch y por load. Cuando un fichero es procesado por batch, la variable _ tiene el mismo significado que en el modo interactivo. Cuando un fichero es procesado por load, a la variable _ se le asigna la última expresión introducida, bien desde el modo interactivo, bien en un fichero por lotes; en ningún caso se le asigna a _ una expresión de entrada del fichero que está siendo procesado.

     Véanse también __ y %.

     Ejemplos:

          (%i1) 13 + 29;
          (%o1)                          42
          (%i2) :lisp $_
          ((MPLUS) 13 29)
          (%i2) _;
          (%o2)                          42
          (%i3) sin (%pi/2);
          (%o3)                           1
          (%i4) :lisp $_
          ((%SIN) ((MQUOTIENT) $%PI 2))
          (%i4) _;
          (%o4)                           1
          (%i5) a: 13$
          (%i6) b: 29$
          (%i7) a + b;
          (%o7)                          42
          (%i8) :lisp $_
          ((MPLUS) $A $B)
          (%i8) _;
          (%o8)                         b + a
          (%i9) a + b;
          (%o9)                          42
          (%i10) ev (_);
          (%o10)                         42

 -- Variable del sistema: %

     El símbolo % representa la expresión de salida (esto es, %o1, %o2, %o3, ...) más reciente calculada por Maxima, independientemente de que la haya mostrado o no.

     La variable % es reconocida por  batch y por load. Cuando un fichero es procesado por batch, la variable % tiene el mismo significado que en el modo interactivo. Cuando un fichero es procesado por load, a la variable % se le asigna la última expresión introducida, bien desde el modo interactivo, bien en un fichero por lotes; en ningún caso se le asigna a % una expresión de entrada del fichero que está siendo procesado.

     Véanse también _, %% y %th.

 -- Variable del sistema: %%

     En una sentencia compuesta, como block, lambda o (S_1, ..., S_N), %% es el valor de la sentencia previa. Por ejemplo,

          block (integrate (x^5, x), ev (%%, x=2) - ev (%%, x=1));
          block ([prev], prev: integrate (x^5, x),
                         ev (prev, x=2) - ev (prev, x=1));

     devuelven el mismo resultado  21/2.

     Una sentencia compuesta puede contener otras sentencias compuestas. Independientemente de que una sentencia sea simple o compuesta, %% es el valor de la sentencia previa. Por ejemplo,

          block (block (a^n, %%*42), %%/6)

     devuelve 7*a^n.

     Dentro de una sentencia compuesta, el valor de %% puede inspeccionarse en un punto de interrupción que se abra ejecutando la función break. Por ejemplo, en el punto de interrupción abierto por

          block (a: 42, break ())$

     introduciendo %%; se obtiene 42.

     En la primera sentencia de una sentencia compuesta, o fuera de una sentencia compuesta, %% no está definido.

     La variable %% es reconocida por  batch y por load. Cuando un fichero es procesado por batch, la variable %% tiene el mismo significado que en el modo interactivo.

     Véase también %.

 -- Variable opcional: %edispflag
     Valor por defecto: false

     Si %edispflag vale true, Maxima muestra %e elevado a un exponente negativo como un cociente. Por ejemplo, %e^-x se muestra como 1/%e^x.

 -- Función: %th (I)

     Es el valor de la expresión de la I-ésima salida anterior. Esto es, si la siguiente expresión a calcular es la salida N-ésima, %th (M) es la salida  (N - M)-ésima.

     La función %th es útil en archivos tipo batch o para hacer referencia a un grupo de expresiones de salida. Por ejemplo,

          block (s: 0, for i:1 thru 10 do s: s + %th (i))$

     asigna a s la suma de las diez últimas expresiones de salida.

     La variable %th es reconocida por  batch y por load. Cuando un fichero es procesado por batch, la variable %th tiene el mismo significado que en el modo interactivo. Cuando un fichero es procesado por load, a la variable %th se le asigna la última expresión introducida, bien desde el modo interactivo, bien en un fichero por lotes; en ningún caso se le asigna a %th una expresión de entrada del fichero que está siendo procesado.

     Véase también %.

 -- Símbolo especial: ?

     Como prefijo de una función o nombre de variable, ? significa que el nombre es de Lisp, no de Maxima. Por ejemplo, ?round representa la función de Lisp ROUND. Véase Lisp y Maxima para más información.

     La notación ? word (un símbolo de interrogación seguido de una palabra y separados por un espacio) equivale a describe ("word"). El símbolo de interrogación debe escribirse al comienzo de la línea de entrada; en caso contrario no se reconoce como una solicitud de documentación.

 -- Símbolo especial: ??

     La notación ?? palabra (?? seguido de un espacio y una palabra) equivale a describe("palabra", inexact). El símbolo de interrogación debe escribirse al comienzo de la línea de entrada; en caso contrario no se reconoce como una solicitud de documentación.

 -- Variable opcional: absboxchar
     Valor por defecto: !

     La variable absboxchar es el carácter utilizado para representar el valor absoluto de una expresión que ocupa más de una línea de altura.

 -- Variable opcional: file_output_append
     Valor por defecto: false

     La variable file_output_append controla si las funciones de escritura de ficheros añaden información o sustituyen el fichero de salida. Cuando file_output_append toma el valor true, estas funciones amplían el contenido de sus ficheros de salida; en otro caso, sustituyen el fichero anterior de igual nombre por otro con el nuevo contenido.

     Las funciones save, stringout y with_stdout se ven afectadas por el valor que tome la variable file_output_append. Otras funciones que también escriben en ficheros de salida no tienen en cuenta este valor; en concreto, las funciones para la representación de gráficos y las de traducción siempre sustituyen el fichero anterior por uno nuevo de igual nombre, mientras que las funciones tex y appendfile siempre añaden información al fichero de salida sin eliminar la información anterior.

 -- Función: appendfile (FILENAME)
     Añade información de la consola a FILENAME, de igual manera que lo hace writefile, pero con la salvedad de que si el archivo ya existe la información queda añadida al final de su contenido.

     La función closefile cierra los archivos abiertos por appendfile o writefile.

 -- Función: batch (FILENAME)
     Lee expresiones de Maxima desde FILENAME y las evalúa. La función batch busca FILENAME en la lista file_search_maxima. Véase file_search.

     El contenido de FILENAME debe ser una secuencia de expresiones de Maxima, cada una de las cuales termina en ; o $. La variable especial % y la función %th se refieren a resultados previos dentro del archivo. El archivo puede incluir construcciones del tipo :lisp. Espacios, tabulaciones y saltos de línea en el archivo se ignoran. Un archivo de entrada válido puede crearse con un editor de texto o con la función stringout.

     La función batch lee las expresiones del archivo FILENAME, muestra las entradas en la consola, realiza los cálculos solicitados y muestra las expresiones de los resultados. A las expresiones de entrada se les asignan etiquetas, así como a las de salida. La función batch evalúa todas las expresiones de entrada del archivo a menos que se produzca un error. Si se le solicita información al usuario (con asksign o askinteger, por ejemplo) batch se detiene para leer la nueva información para luego continuar.

     Es posible detener  batch tecleando control-C desde la consola. El efecto de control-C depende del entorno Lisp instalado.

     La función batch tiene diversas aplicaciones, tales como servir de almacén de líneas de instrucciones, suministrar demostraciones libres de errores o ayudar a organizar el trabajo del usuario en la resolución de problemas complejos.

     La función batch evalúa su argumento.

     Véanse también  load, batchload y demo.

 -- Función: batchload (FILENAME)
     Lee expresiones de Maxima desde FILENAME y las evalúa sin mostrar las entradas ni las salidas y sin asignarles etiquetas. Sin embargo, las salidas producidas por  print o describe sí se muestran.

     La variable especial % y la función %th se refieren a resultados previos del intérprete interactivo, no a los del propio archivo. El archivo no puede incluir construcciones del tipo :lisp.

     La función batchload devuelve la ruta de FILENAME en formato de cadena.

     La función batchload evalúa sus argumentos.

     Véanse también batch y load.

 -- Función: closefile ()
     La función closefile cierra los archivos abiertos por appendfile o writefile.

 -- Función: concat (ARG_1, ARG_2, ...)
     Concatena sus argumentos, que deben ser todos átomos. El valor devuelto es un símbolo si el primer argumento es a su vez un símbolo, o una cadena de Maxima en caso contrario.

     La función concat evalúa sus argumentos. El apátrofo  ' evita la evaluación.

          (%i1) y: 7$
          (%i2) z: 88$
          (%i3) concat (y, z/2);
          (%o3)                          744
          (%i4) concat ('y, z/2);
          (%o4)                          y44

     A un símbolo construido por concat se le puede asignar un valor y ser utilizado posteriormente en expresiones. La asignación con el operador :: evalúa su expresión izquierda.

          (%i5) a: concat ('y, z/2);
          (%o5)                          y44
          (%i6) a:: 123;
          (%o6)                          123
          (%i7) y44;
          (%o7)                          123
          (%i8) b^a;
                                         y44
          (%o8)                         b
          (%i9) %, numer;
                                         123
          (%o9)                         b

     Nótese que aunque concat (1, 2) parezca un número, se trata de una cadena de Maxima.

          (%i10) concat (1, 2) + 3;
          (%o10)                       12 + 3

 -- Función: sconcat (ARG_1, ARG_2, ...)

     Concatena sus argumentos para producir una cadena. Al contrario que concat, sus argumentos no necesitan ser átomos.

     El resultado es una cadena de Lisp.

          (%i1) sconcat ("xx[", 3, "]:", expand ((x+y)^3));
          (%o1)               xx[3]:y^3+3*x*y^2+3*x^2*y+x^3

 -- Función: disp (EXPR_1, EXPR_2, ...)
     Es como display pero sólo se muestran los valores de los argumentos, no las ecuaciones. Es útil para argumentos complicados que no tienen nombre o en situaciones en las que solamente es de interés el valor del argumento pero no su nombre.

 -- Función: dispcon (TENSOR_1, TENSOR_2, ...)
 -- Función: dispcon (all)
     Muestra las propiedades contractivas de sus argumentos tal como fueron asignadas por defcon. La llamada dispcon (all) muestra todas propiedades contractivas que fueron definidas.

 -- Función: display (EXPR_1, EXPR_2, ...)
     Muestra las ecuaciones cuyos miembros izquierdos son EXPR_I sin evaluar y cuyos miembros derechos son los valores de las expresiones. Esta función es útil en los bloques y en las sentencias for para mostrar resultados intermedios.  Los argumentos de display suelen ser átomos, variables subindicadas o llamadas a funciones. Véase también disp.

          (%i1) display(B[1,2]);
                                                2
                                   B     = X - X
                                    1, 2
          (%o1)                            done

 -- Variable opcional: display2d
     Valor por defecto: true

     Si display2d vale false, la salida por consola es una cadena unidimensional, en lugar de una expresión bidimensional.

 -- Variable opcional: display_format_internal
     Valor por defecto: false

     Si display_format_internal vale true, las expresiones se muestran sin ser transformadas de manera que oculten su representación matemática interna. Se representa lo que la función inpart devolvería, en oposición a part.

     Ejemplos:

          User     part       inpart
          a-b;      A - B     A + (- 1) B

                     A            - 1
          a/b;       -         A B
                     B
                                 1/2
          sqrt(x);   sqrt(X)    X

                    4 X        4
          X*4/3;    ---        - X
                     3         3

 -- Función: dispterms (EXPR)
     Muestra EXPR en partes, una debajo de la otra. Esto es, primero se muestra el operador de EXPR, luego cada término si se trata de una suma, o cada factor si es un producto, o si no se muestra separadamente la parte de una expresión más general. Es útil si EXPR es demasiado grande para representarla de otra forma.  Por ejemplo, si P1, P2, ...  son expresiones muy grandes, entonces el programa de representación puede superar el espacio de almacenamiento tratando de mostrar P1 + P2 + ... todo junto.  Sin embargo, dispterms (P1 + P2 + ...) muestra P1, debajo  P2, etc.  Cuando una expresión exponencial es demasiado ancha para ser representada como A^B, si no se utiliza dispterms, entonces aparecerá como expt (A, B) (o como ncexpt (A, B), en lugar de A^^B).

 -- Variable opcional: error_size
     Valor por defecto: 10

     La variable 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 ERROR-SIZE) es mayor que 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 error_syms.

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

     Véanse también error y error_syms.

     Ejemplo:

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

          (%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);

 -- Variable opcional: error_syms
     Valor por defecto: [errexp1, errexp2, errexp3]

     En los mensajes de error, las expresiones mayores que error_size son reemplazadas por símbolos a los cuales se les asignas estas expresiones.  Los símbolos se toman de la lista error_syms. La primera expresión que resulte ser demasiado larga se reemplaza por error_syms[1], la segunda por error_syms[2] y así sucesivamente.

     Si hay más expresiones largas que elementos en error_syms, los símbolos se construyen automáticamente, siendo el N-ésimo símbolo equivalente a concat ('errexp, N).

     Véanse también error y error_size.

 -- Función: expt (A, B)
     Si una expresión exponencial es demasiado ancha para ser mostrada como A^B aparecerá como expt (A, B) (o como ncexpt (A, B) en lugar de A^^B).

     Las funciones expt y ncexpt no se reconocen en una entrada.

 -- Variable opcional: exptdispflag
     Valor por defecto: true

     Si exptdispflag vale true, Maxima muestra las expresiones con exponentes negativos como cocientes; por ejemplo, X^(-1) se muestra como 1/X.

 -- Función: filename_merge (PATH, FILENAME)
     Construye una ruta modificada a partir de PATH y FILENAME. Si la componente final de PATH es de la forma ###.SOMETHING, la componente se reemplaza con FILENAME.SOMETHING. En otro caso, la componente final se reemplaza simplemente por FILENAME.

 -- Función: file_search (FILENAME)
 -- Función: file_search (FILENAME, PATHLIST)

     La función file_search busca el archivo FILENAME y devuelve su ruta como una cadena; si no lo encuentra,  file_search devuelve false. La llamada file_search (FILENAME) busca en los directorios de búsqueda por defecto, que son los especificados por las variables file_search_maxima, file_search_lisp y file_search_demo.

     La función file_search analiza primero si el nombre del argumento existe antes de hacerlo coincidir con los comodines de los patrones de búsqueda de archivos. Véase file_search_maxima para más información sobre patrones de búsqueda de archivos.

     El argumento FILENAME puede ser una ruta con nombre de archivo, o simplemente el nombre del archivo, o, si el directorio de búsqueda de archivo incluye un patrón de búsqueda, es suficiente con el nombre de archivo sin extensión. Por ejemplo,

          file_search ("/home/wfs/special/zeta.mac");
          file_search ("zeta.mac");
          file_search ("zeta");

     todos buscan el mismo archivo, dando por hecho que el archivo existe y que /home/wfs/special/###.mac está en file_search_maxima.

     La llamada file_search (FILENAME, PATHLIST) busca solamente en los directorios especificados por PATHLIST, que es una lista de cadenas. El argumento PATHLIST ignora los directorios de búsqueda por defecto, de manera que si se da la lista de rutas, file_search busca solamente en ellas y no en los directorios por defecto. Incluso si hay un único directorio en PATHLIST, debe ser suministrado como una lista de un único elemento.

     El usuario puede modificar los directorios de búsqueda por defecto; véase para ello See file_search_maxima.

     La función file_search es llamada por load con los directorios de búsqueda file_search_maxima y file_search_lisp.

 -- Variable opcional: file_search_maxima
 -- Variable opcional: file_search_lisp
 -- Variable opcional: file_search_demo
     Estas variables especifican listas de directorios en los que deben buscar la funciones  load, demo y algunas otras. Los valores por defecto de estas variables nombran directorios de la instalación de Maxima.

     El usuario puede modificar estas variables, bien reemplazando los valores por defecto, bien añadiendo nuevos directorios. Por ejemplo,

          file_search_maxima: ["/usr/local/foo/###.mac",
              "/usr/local/bar/###.mac"]$

     reemplaza el valor por defecto de file_search_maxima, mintras que

          file_search_maxima: append (file_search_maxima,
              ["/usr/local/foo/###.mac", "/usr/local/bar/###.mac"])$

     añade dos directorios más. Puede ser conveniente colocar una expresión como esta en el archivo maxima-init.mac, de manera que la ruta de búsqueda de ficheros se asigne automáticamente cada vez que arranca Maxima.

     Se pueden especificar varias extensiones de archivos y rutas con comodines especiales. La cadena ### representa el nombre del archivo buscado y una lista separada de comas y encerrada entre llaves,  {foo,bar,baz} representa múltiples cadenas. Por ejemplo, suponiendo que se busca el nombre neumann,

          "/home/{wfs,gcj}/###.{lisp,mac}"

     se interpreta como /home/wfs/neumann.lisp, /home/gcj/neumann.lisp, /home/wfs/neumann.mac y /home/gcj/neumann.mac.

 -- Función: file_type (FILENAME)
     Devuelve una descripción del contenido de FILENAME basada en la extensión, sin intentar abrir el archivo para inspeccionar su contenido.

     El valor que la función retorna puede ser cualquiera de los siguientes: object, lisp o maxima. Si la extensión comienza por m o d, file_type devuelve maxima. Si la extensión comienza por l, file_type devuelve lisp. En cualquier otro caso, file_type devuelve object.

 -- Función: grind (EXPR)
 -- Variable opcional: grind
     La función grind imprime EXPR en la consola en un formato admisible como entrada para Maxima. La función grind devuelve siempre done.

     Cuando EXPR es el nombre de una función o macro, grind muestra la definición de la función o de la macro en lugar de sólo su nombre.

     Véase también string, que devuelve una cadena en lugar de imprimir la salida. La función grind intenta imprimir la expresión de forma que sea lago más sencilla de leer que la salida de string.

     Cuando la variable grind vale true, la salida de string y stringout tienen el mismo formato que la de grind; en caso contrario no se formatea la salida de esas funciones. El valor por defecto de la variable grind es false.

     La variable grind también se puede utilizar como  argumento en playback. Si grind está presente, playback imprime las expresiones de entrada en el mismo formato que lo hace la función grind; en caso contrario no se formatean la expresiones de entrada.

     La función grind evalúa sus argumentos.

     Ejemplos:

          (%i1) aa + 1729;
          (%o1)                       aa + 1729
          (%i2) grind (%);
          aa+1729$
          (%o2)                         done
          (%i3) [aa, 1729, aa + 1729];
          (%o3)                 [aa, 1729, aa + 1729]
          (%i4) grind (%);
          [aa,1729,aa+1729]$
          (%o4)                         done
          (%i5) matrix ([aa, 17], [29, bb]);
                                     [ aa  17 ]
          (%o5)                      [        ]
                                     [ 29  bb ]
          (%i6) grind (%);
          matrix([aa,17],[29,bb])$
          (%o6)                         done
          (%i7) set (aa, 17, 29, bb);
          (%o7)                   {17, 29, aa, bb}
          (%i8) grind (%);
          {17,29,aa,bb}$
          (%o8)                         done
          (%i9) exp (aa / (bb + 17)^29);
                                          aa
                                      -----------
                                               29
                                      (bb + 17)
          (%o9)                     %e
          (%i10) grind (%);
          %e^(aa/(bb+17)^29)$
          (%o10)                        done
          (%i11) expr: expand ((aa + bb)^10);
                   10           9        2   8         3   7         4   6
          (%o11) bb   + 10 aa bb  + 45 aa  bb  + 120 aa  bb  + 210 aa  bb
                   5   5         6   4         7   3        8   2
           + 252 aa  bb  + 210 aa  bb  + 120 aa  bb  + 45 aa  bb
                  9        10
           + 10 aa  bb + aa
          (%i12) grind (expr);
          bb^10+10*aa*bb^9+45*aa^2*bb^8+120*aa^3*bb^7+210*aa^4*bb^6
               +252*aa^5*bb^5+210*aa^6*bb^4+120*aa^7*bb^3+45*aa^8*bb^2
               +10*aa^9*bb+aa^10$
          (%o12)                        done
          (%i13) string (expr);
          (%o13) bb^10+10*aa*bb^9+45*aa^2*bb^8+120*aa^3*bb^7+210*aa^4*bb^6\
          +252*aa^5*bb^5+210*aa^6*bb^4+120*aa^7*bb^3+45*aa^8*bb^2+10*aa^9*\
          bb+aa^10
          (%i14) cholesky (A):= block ([n : length (A), L : copymatrix (A),
            p : makelist (0, i, 1, length (A))], for i thru n do
            for j : i thru n do
            (x : L[i, j], x : x - sum (L[j, k] * L[i, k], k, 1, i - 1),
            if i = j then p[i] : 1 / sqrt(x) else L[j, i] : x * p[i]),
            for i thru n do L[i, i] : 1 / p[i],
            for i thru n do for j : i + 1 thru n do L[i, j] : 0, L)$
          (%i15) grind (cholesky);
          cholesky(A):=block(
                   [n:length(A),L:copymatrix(A),
                    p:makelist(0,i,1,length(A))],
                   for i thru n do
                       (for j from i thru n do
                            (x:L[i,j],x:x-sum(L[j,k]*L[i,k],k,1,i-1),
                             if i = j then p[i]:1/sqrt(x)
                                 else L[j,i]:x*p[i])),
                   for i thru n do L[i,i]:1/p[i],
                   for i thru n do (for j from i+1 thru n do L[i,j]:0),L)$
          (%o15)                        done
          (%i16) string (fundef (cholesky));
          (%o16) cholesky(A):=block([n:length(A),L:copymatrix(A),p:makelis\
          t(0,i,1,length(A))],for i thru n do (for j from i thru n do (x:L\
          [i,j],x:x-sum(L[j,k]*L[i,k],k,1,i-1),if i = j then p[i]:1/sqrt(x\
          ) else L[j,i]:x*p[i])),for i thru n do L[i,i]:1/p[i],for i thru \
          n do (for j from i+1 thru n do L[i,j]:0),L)

 -- Variable opcional: ibase
     Valor por defecto: 10

     Los enteros que se escriban en Maxima se interpretan como dados en base ibase.

     A la variable ibase se le puede asignar cualquier entero entre 2 y 35 (decimal), ambos inclusive. Si ibase es mayor que 10, las cifras serán los números decimales entre 0 y 9, más las letras mayúsculas A, B, C, ..., sgún sea necesario. Las cifras en base 35, la mayor base que acepta Maxima, son los dígitos de 0 a 9 y las letras de A a Y.

     Véase también obase.

 -- Variable opcional: inchar
     Valor por defecto: %i

     La variable inchar es el prefijo de las etiquetas de las expresiones introducidas por el usuario. Maxima crea automáticamente una etiqueta para cada expresión de entrada concatenando inchar y linenum; a inchar se le puede asignar cualquier símbolo o cadena, no necesariamente un caracácter sencillo.

          (%i1) inchar: "input";
          (%o1)                                input
          (input1) expand ((a+b)^3);
                                      3        2      2      3
          (%o1)                      b  + 3 a b  + 3 a  b + a
          (input2)

     Véase también labels.

 -- Función: ldisp (EXPR_1, ..., EXPR_N)
     Muestra las expresiones EXPR_1, ..., EXPR_N en la consola con el formato de salida; ldisp asigna una etiqueta a cada argumento y devuelve la lista de etiquetas.

     Véase también disp.

          (%i1) e: (a+b)^3;
                                             3
          (%o1)                       (b + a)
          (%i2) f: expand (e);
                               3        2      2      3
          (%o2)               b  + 3 a b  + 3 a  b + a
          (%i3) ldisp (e, f);
                                             3
          (%t3)                       (b + a)

                               3        2      2      3
          (%t4)               b  + 3 a b  + 3 a  b + a

          (%o4)                      [%t3, %t4]
          (%i4) %t3;
                                             3
          (%o4)                       (b + a)
          (%i5) %t4;
                               3        2      2      3
          (%o5)               b  + 3 a b  + 3 a  b + a

 -- Función: ldisplay (EXPR_1, ..., EXPR_N)
     Muestra las expresiones EXPR_1, ..., EXPR_N en la consola con el formato de salida. Cad expresión se muestra como una ecuación de la forma lhs = rhs en la que lhs es uno de los argumentos de ldisplay y rhs su valor. Normalmente, cada argumento será el nombre de una variable. La función ldisp asigna una etiqueta a cada ecuación y devuelve la lista de etiquetas.

     Véase también display.

          (%i1) e: (a+b)^3;
                                             3
          (%o1)                       (b + a)
          (%i2) f: expand (e);
                               3        2      2      3
          (%o2)               b  + 3 a b  + 3 a  b + a
          (%i3) ldisplay (e, f);
                                               3
          (%t3)                     e = (b + a)

                                 3        2      2      3
          (%t4)             f = b  + 3 a b  + 3 a  b + a

          (%o4)                      [%t3, %t4]
          (%i4) %t3;
                                               3
          (%o4)                     e = (b + a)
          (%i5) %t4;
                                 3        2      2      3
          (%o5)             f = b  + 3 a b  + 3 a  b + a

 -- Variable opcional: linechar
     Valor por defecto: %t

     La variable linechar es el prefijo de las etiquetas que genera Maxima para expresiones intermedias. Cuando sea necesario, Maxima creará una etiqueta para cada expresión intermedia concatenando linechar y linenum. A linechar se le puede asignar cualquier cadena o símbolo, no necesariamente un carácter simple.

     Las expresiones intermedias pueden ser mostradas o no. Véanse también programmode y labels.

 -- Variable opcional: linel
     Valor por defecto: 79

     La variable linel es la anchura (medida en número de caracteres) de la consola que se le da a Maxima para que muestre las expresiones. A linel se le puede asignar cualquier valor, pero si éste es muy pequeño o grande resultará de poca utilidad. El texto que impriman las funciones internas de Maxima, como los mensajes de error y las salidas de la función describe, no se ve afectado por el valor de linel.

 -- Variable opcional: lispdisp
     Valor por defecto: false

     Si lispdisp vale true, los símbolos de Lisp se muestran precedidos del carácter de interrogación ?. En caso contrario, los símbolos de Lisp se muestran sin esta marca.

     Ejemplos:

          (%i1) lispdisp: false$
          (%i2) ?foo + ?bar;
          (%o2)                       foo + bar
          (%i3) lispdisp: true$
          (%i4) ?foo + ?bar;
          (%o4)                      ?foo + ?bar

 -- Función: load (FILENAME)
     Evalúa las expresiones del archivo FILENAME, trayendo variables, funciones y otros objetos a Maxima. Una asignación hecha previamente a una variable en Maxima será destruida por otra asignación que se le haga en FILENAME. Para encontrar el fichero, load llama a file_search con file_search_maxima y file_search_lisp como directorios de búsqueda. Si la llamada a load funciona correctamente, devuelve el nombre del fichero; en caso contrario, load muestra un mensaje de error.

     La función load trabaja indistintamente con código Lisp y Maxima. Los ficheros creados con save, translate_file y compile_file, que crea código Lisp, y stringout, que crea código Maxima, todos ellos pueden ser procesados por load. La función load llama a loadfile para cargar archivos en Lisp y a  batchload para cargar archivos en Maxima.

     La función load no reconoce las construcciones de tipo :lisp en ficheros de Maxima. Además, mientras se está procesando FILENAME, las variables globales _, __, % y %th mantienen los valores que tenían cuando se realizó la llamada a load.

     Véanse también loadfile, batch, batchload y demo; loadfile procesa archivos en Lisp; batch, batchload y demo procesan archivos en Maxima.

     Véase file_search para más detalles sobre el mecanismo de búsqueda de archivos.

     La función load evalúa sus argumentos.

 -- Función: loadfile (FILENAME)
     Evalúa las expresiones Lisp del archivo FILENAME. La función loadfile no llama a file_search, de manera que filename debe incluir la extensión del archivo y su ruta completa.

     La función loadfile puede procesar ficheros creados por  save, translate_file y compile_file. Puede ser más conveniente utilizar load en lugar de loadfile.

 -- Variable opcional: loadprint
     Valor por defecto: true

     La variable loadprint indica si mostrar un mensaje cuando se carga un archivo.

       * Si loadprint vale true, se muestra siempre un mensaje.

       * Si loadprint vale 'loadfile, muestra un mensaje sólo si el archivo es cargado con la función loadfile.

       * Si loadprint vale 'autoload, muestra un mensaje sólo cuandi un archivo se carga automáticamente. Véase  setup_autoload.

       * Si loadprint vale false, nunca mostrará mensajes.

 -- Variable opcional: obase
     Valor por defecto: 10

     La variable obase es la base de los enteros mostrados por Maxima; se le puede asignar cualquier entero entre 2 y 35 (decimal), ambos inclusive. Si obase es mayor que 10, las cifras serán los números decimales entre 0 y 9, más las letras mayúsculas A, B, C, ..., sgún sea necesario. Las cifras en base 35, la mayor base que acepta Maxima, son los dígitos de 0 a 9 y las letras de A a Y.

     Véase también ibase.

 -- Variable opcional: outchar
     Valor por defecto: %o

     La variable outchar es el prefijo de las etiquetas de las expresiones calculadas por Maxima. Maxima crea automáticamente una etiqueta para cada expresión calculada concatenando outchar y linenum; a outchar se le puede asignar cualquier símbolo o cadena, no necesariamente un caracácter sencillo.

          (%i1) outchar: "output";
          (output1)                           output
          (%i2) expand ((a+b)^3);
                                      3        2      2      3
          (output2)                  b  + 3 a b  + 3 a  b + a
          (%i3)

     Véase también labels.

 -- Variable opcional: packagefile
     Valor por defecto: false

     Los desarrolladores de paquetes que utilizan  save o translate para crear paquetes (ficheros) que van a ser utilizados por terceros pueden hacer packagefile: true para evitar que se añada información a la listas de información de Maxima (por ejemplo, values, functions) excepto allí donde sea necesario cuando el archivo sea cargado en memoria.

 -- Variable opcional: pfeformat
     Valor por defecto: false

     Si pfeformat vale true, una fracción de enteros será mostrada con el carácter de barra inclinada / entre ellos.

          (%i1) pfeformat: false$
          (%i2) 2^16/7^3;
                                        65536
          (%o2)                         -----
                                         343
          (%i3) (a+b)/8;
                                        b + a
          (%o3)                         -----
                                          8
          (%i4) pfeformat: true$
          (%i5) 2^16/7^3;
          (%o5)                       65536/343
          (%i6) (a+b)/8;
          (%o6)                      1/8 (b + a)

 -- Función: print (EXPR_1, ..., EXPR_N)
     Evalúa y muestra las expresiones  EXPR_1, ..., EXPR_N secuencialmente de izquierda a derecha, comenzando la impresión por el borde izquierdo de la consola.

     El valor devuelto por print es el valor de su último argumento. La función print no genera etiquetas para las expresiones intermedias.

     Véanse también display, disp, ldisplay y ldisp, que muestran una expresión por línea, mientras que print trata de mostrar dos o más expresiones por línea.

     Para mostrar el contenido de un archivo véase printfile.

          (%i1) r: print ("(a+b)^3 is", expand ((a+b)^3), "log (a^10/b) is",
                radcan (log (a^10/b)))$
                      3        2      2      3
          (a+b)^3 is b  + 3 a b  + 3 a  b + a  log (a^10/b) is

                                                        10 log(a) - log(b)
          (%i2) r;
          (%o2)                  10 log(a) - log(b)
          (%i3) disp ("(a+b)^3 is", expand ((a+b)^3), "log (a^10/b) is",
                radcan (log (a^10/b)))$
                                     (a+b)^3 is

                               3        2      2      3
                              b  + 3 a b  + 3 a  b + a

                                   log (a^10/b) is

                                 10 log(a) - log(b)

 -- Función: read (EXPR_1, ..., EXPR_N)
     Imprime EXPR_1, ..., EXPR_N y a continuación lee una expresión desde la consola y devuelve la expresión evaluada. La expresión termina con un punto y coma ; o con el símbolo de dólar $.

     Véase también readonly.

          (%i1) foo: 42$
          (%i2) foo: read ("foo vale", foo, " -- nuevo valor.")$
          foo vale 42  -- nuevo valor.
          (a+b)^3;
          (%i3) foo;
                                               3
          (%o3)                         (b + a)

 -- Función: readonly (EXPR_1, ..., EXPR_N)
     Imprime EXPR_1, ..., EXPR_N y a continuación lee una expresión desde la consola y devuelve la expresión sin evaluar. La expresión termina con un punto y coma ; o con el símbolo de dólar $.

          (%i1) aa: 7$
          (%i2) foo: readonly ("Introducir expresion:");
          Introducir expresion:
          2^aa;
                                            aa
          (%o2)                            2
          (%i3) foo: read ("Introducir expresion:");
          Introducir expresion:
          2^aa;
          (%o3)                            128

     Véase también read.

 -- Función: reveal (EXPR, NIVEL)
     Reemplaza partes de EXPR al NIVEL especificado y las sutituye por descripciones cortas.

       * Las sumas y restas se reemplazan por sum(N), siendo N el número de términos de la suma.

       * Los productos se reemplazan por product(N), siendo N el número de factores del producto.

       * Las potencias se reemplazan por expt.

       * Los cocientes se reemplazan por quotient.

       * El símbolo negativo se reemplaza por negterm.

     Si el entero  DEPTH es mayor o igual que la profundidad máxima de EXPR, reveal (EXPR, DEPTH) devuelve EXPR sin modificar.

     La función reveal evalúa sus argumentos y devuelve la expresión con las modificaciones solicitadas.

     Ejemplo:

          (%i1) e: expand ((a - b)^2)/expand ((exp(a) + exp(b))^2);
                                    2            2
                                   b  - 2 a b + a
          (%o1)               -------------------------
                                  b + a     2 b     2 a
                              2 %e      + %e    + %e
          (%i2) reveal (e, 1);
          (%o2)                       quotient
          (%i3) reveal (e, 2);
                                       sum(3)
          (%o3)                        ------
                                       sum(3)
          (%i4) reveal (e, 3);
                               expt + negterm + expt
          (%o4)               ------------------------
                              product(2) + expt + expt
          (%i5) reveal (e, 4);
                                 2                 2
                                b  - product(3) + a
          (%o5)         ------------------------------------
                                   product(2)     product(2)
                        2 expt + %e           + %e
          (%i6) reveal (e, 5);
                                   2            2
                                  b  - 2 a b + a
          (%o6)              --------------------------
                                 sum(2)     2 b     2 a
                             2 %e       + %e    + %e
          (%i7) reveal (e, 6);
                                    2            2
                                   b  - 2 a b + a
          (%o7)               -------------------------
                                  b + a     2 b     2 a
                              2 %e      + %e    + %e

 -- Variable opcional: rmxchar
     Valor por defecto: ]

     La variable rmxchar es el carácter que se dibuja al lado derecho de una matriz.

     Véase también lmxchar.

 -- Función: save (FILENAME, NAME_1, NAME_2, NAME_3, ...)
 -- Función: save (FILENAME, values, functions, labels, ...)
 -- Función: save (FILENAME, [M, N])
 -- Función: save (FILENAME, NAME_1=EXPR_1, ...)
 -- Función: save (FILENAME, all)
 -- Función: save (FILENAME, NAME_1=EXPR_1, NAME_2=EXPR_2, ...)

     Alamacena los valores actuales de NAME_1, NAME_2, NAME_3, ..., en el archivo FILENAME. Los argumentos son nombres de variables, funciones u otros objetos. Si un nombre no tiene un valor o una función asociado a él, entonces se ignora.

     La función save devuelve FILENAME.

     La función save almacena datos en forma de expresiones Lisp. Los datos almacenados por save pueden recuperarse con load (FILENAME). El resultado de ejecutar  save cuando FILENAME ya existe depende del soporte Lisp implementado; el archivo puede ser sobreescrito o que save envíe un mesaje de error.

     La llamada save (FILENAME, values, functions, labels, ...) almacena los elementos cuyos nombres son values, functions, labels, etc. Los nombres pueden ser cualesquiera de los especificados por la variable infolists; values incluye todas las variables definidas por el usuario.

     La llamada save (FILENAME, [M, N]) almacena los valores de las etiquetas de entrada y salida desde M hasta N. Nótese que M y N deben ser números. Las etiquetas de entrada y salida también se pueden almacenar una a una, por ejemplo, save ("foo.1", %i42, %o42). La llamada save (FILENAME, labels) almacena todas las etiquetas de entrada y salida. Cuando las etiquetas almacenadas en el archivo sean posteriormente recuperadas, se sobreescribirán las activas en ese momento.

     La llamada save (FILENAME, NAME_1=EXPR_1, NAME_2=EXPR_2, ...) almacena los valores de EXPR_1, EXPR_2, ..., con los nombres NAME_1, NAME_2, .... Es útil hacer este tipo de llamada para con etiquetas de entrada y salida, por ejemplo, save ("foo.1", aa=%o88). El miembro derecho de la igualdad puede ser cualquier expresión, que será evaluada. Esta llamada a la función save no incorpora nuevos nombres a la sesión actual de Maxima, simplemente los almacena en el archivo FILENAME.

     Todas estas formas de llamar a la función save se pueden combinar a voluntad. Por ejemplo, save (FILENAME, aa, bb, cc=42, functions, [11, 17]).

     La llamada save (FILENAME, all) almacena el estado actual de Maxima, lo que incluye todas las variables definidas por el usuario, funciones, arreglos, etc., así como algunos objetos definidos automáticamente. Los elementos almacenados incluyen variables del sistema, como file_search_maxima o showtime, si han sido modificadas por el usuario. Véase myoptions.

     save evalúa FILENAME pero no el resto de argumentos.

 -- Variable opcional: savedef
     Valor por defecto: true

     Si savedef vale 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 dispfun y que la función pueda ser editada.

     Si savedef vale false, los nombres de las funciones traducidas se eliminan de la lista functions.

 -- Función: show (EXPR)
     Muestra expr con sus objetos indexados que tengan índices covariantes como subíndices y los contravariantes como superíndices.  Los índices derivados se muestran como subíndices, separados por una coma de los covariantes.

 -- Función: showratvars (EXPR)
     Devuelve una lista de las variables de expresiones canónicas racionales (CRE) en la expresión expr.

     Véase también ratvars.

 -- Variable opcional: stardisp
     Valor por defecto: false

     Si stardisp vale true, la multiplicación se muestra con un asterisco * entre los operandos.

 -- Función: string (EXPR)
     Convierte expr a la notación lineal de Maxima, tal como si fuese tecleada.

     El valor que retorna la función string es una cadena, por lo que no puede ser utilizada en los cálculos.

 -- Variable opcional: stringdisp
     Valor por defecto: false

     Si stringdisp vale true, las cadenas alfanuméricas se muestran encerradas entre comillas dobles. En caso contrario, no se nuestran las comillas.

     La variable stringdisp vale siempre true cuando se muestra la definición de una función.

     Ejemplos:

          (%i1) stringdisp: false$
          (%i2) "This is an example string.";
          (%o2)              This is an example string.
          (%i3) foo () :=
                print ("This is a string in a function definition.");
          (%o3) foo() :=
                        print("This is a string in a function definition.")
          (%i4) stringdisp: true$
          (%i5) "This is an example string.";
          (%o5)             "This is an example string."

 -- Función: stringout (FILENAME, EXPR_1, EXPR_2, EXPR_3, ...)
 -- Función: stringout (FILENAME, [M, N])
 -- Función: stringout (FILENAME, input)
 -- Función: stringout (FILENAME, functions)
 -- Función: stringout (FILENAME, values)

     La función stringout escribe expresiones en un archivo de la misma forma en que se escribirían como expresiones de entrada. El archivo puede ser utilizado entonces como entrada a las funciones batch o demo, y puede ser editado para cualquier otro propósito.

     La forma general de stringout escribe los valores de una o más expresiones en el archivo de salida. Nótese que si una expresión es una variable, solamente se escribirá el valor de la variable y no el nombre de ésta. Como caso especial, y muy útil en algunas ocasiones, las expresiones pueden ser etiquetas de entrada (%i1, %i2, %i3, ...) o de salida (%o1, %o2, %o3, ...).

     Si grind vale true, stringout formatea la salida utilizando grind. En caso contrario, se utilizará el formato string. Véanse grind y string.

     La forma especial stringout (FILENAME, [M, N]) escribe los valores de las etiquetas de entrada desde la m hasta la n, ambas inclusive.

     La forma especial stringout (FILENAME, input) escribe todas las etiquetas de entrada en el archivo.

     La forma especial stringout (FILENAME, functions) escribe todas las funciones definidas por el usuario, contenidas en la lista global functions, en el archivo.

     La forma especial stringout (FILENAME, values) escribe todas las variables asignadas por el usuario, contenidas en la lista global values, en el archivo. Cada variable se escribe como una sentencia de asignación, con el nombre de la variable seguida de dos puntos y a continuación su valor. Nótese que la forma general de stringout no escribe las variables como sentencias de asignación.

 -- Función: tex (EXPR)
 -- Función: tex (LABEL)
 -- Función: tex (EXPR, FILENAME)
 -- Función: tex (LABEL, FILENAME)

     Devuelve la expresión en un formato apropiado para para ser incorporado a un documento basado en TeX. El resultado que se obtiene es un fragmento de código que puede incluirse en un documento mayor, pero que no puede ser procesado aisladamente.

     La instrucción tex (EXPR) imprime en la consola la representación en TeX de EXPR.

     La instrucción tex (LABEL) imprime en la consola la representación en TeX de la expresión a la que hace referencia la etiqueta LABEL, asignándole a su vez una etiqueta de ecuación que será mostrada al lado izquierdo de la misma. La etiqueta de la expresión en TeX es la misma que la de Maxima.

     La instrucción tex (EXPR, FILENAME) añade la representación TeX de EXPR al fichero FILENAME.

     La instrucción tex (LABEL, FILENAME) añade la representación TeX de la expresión a la que hace referencia la etiqueta  LABEL, junto con una etiqueta, al fichero FILENAME.

     La función tex evalúa su primer argumento tras comprobar si se trata de una etiqueta. La doble comilla simple '' fuerza la evaluación del argumento, anulando la comprobación sobre la etiqueta.

     Véase también texput.

     Ejemplos:

          (%i1) integrate (1/(1+x^3), x);
                                              2 x - 1
                            2            atan(-------)
                       log(x  - x + 1)        sqrt(3)    log(x + 1)
          (%o1)      - --------------- + ------------- + ----------
                              6             sqrt(3)          3
          (%i2) tex (%o1);
          $$-{{\log \left(x^2-x+1\right)}\over{6}}+{{\arctan \left({{2\,x-1
           }\over{\sqrt{3}}}\right)}\over{\sqrt{3}}}+{{\log \left(x+1\right)
           }\over{3}}\leqno{\tt (\%o1)}$$
          (%o2)                          (\%o1)
          (%i3) tex (integrate (sin(x), x));
          $$-\cos x$$
          (%o3)                           false
          (%i4) tex (%o1, "foo.tex");
          (%o4)                          (\%o1)

 -- Función: texput (A, S)
 -- Función: texput (A, S, OPERATOR_TYPE)
 -- Función: texput (A, [S_1, S_2], matchfix)
 -- Función: texput (A, [S_1, S_2, S_3], matchfix)

     Establece el formato en TeX del átomo A, el cual puede ser un símbolo o el nombre de un operador.

     La instrucción texput (A, S) hace que la función tex introduzca S en la salida TeX en el lugar de A.

     La instrucción texput (A, S, OPERATOR_TYPE), en la que OPERATOR_TYPE es prefix, infix o postfix, nary o nofix,hace que la función tex introduzca S en la salida TeX en el lugar de A, colocándolo en el lugar correcto.

     La instrucción texput (A, [S_1, S_2], matchfix) hace que la función tex introduzca S_1 y S_2 en la salida TeX a los lados de los argumentos de A. Si son más de uno, los argumentos se separan por comas.

     La instrucción texput (A, [S_1, S_2, S_3], matchfix) hace que la función tex introduzca S_1 y S_2 en la salida TeX a los lados de los argumentos de A, con S_3 separando los argumentos.

     Ejemplos:

     Asigna código TeX para una variable.

          (%i1) texput (me,"\\mu_e");
          (%o1)                         \mu_e
          (%i2) tex (me);
          $$\mu_e$$
          (%o2)                         false

     Asigna código TeX para una función ordinaria (no para un operador).

          (%i1) texput (lcm, "\\mathrm{lcm}");
          (%o1)                     \mathrm{lcm}
          (%i2) tex (lcm (a, b));
          $$\mathrm{lcm}\left(a , b\right)$$
          (%o2)                         false

     Asigna código TeX para un operador prefijo.

          (%i1) prefix ("grad");
          (%o1)                         grad
          (%i2) texput ("grad", " \\nabla ", prefix);
          (%o2)                        \nabla
          (%i3) tex (grad f);
          $$ \nabla f$$
          (%o3)                         false

     Asigna código TeX para un operador infijo.

          (%i1) infix ("~");
          (%o1)                           ~
          (%i2) texput ("~", " \\times ", infix);
          (%o2)                        \times
          (%i3) tex (a ~ b);
          $$a \times b$$
          (%o3)                         false

     Asigna código TeX para un operador postfijo..

          (%i1) postfix ("##");
          (%o1)                          ##
          (%i2) texput ("##", "!!", postfix);
          (%o2)                          !!
          (%i3) tex (x ##);
          $$x!!$$
          (%o3)                         false

     Asigna código TeX para un operador n-ario.

          (%i1) nary ("@@");
          (%o1)                          @@
          (%i2) texput ("@@", " \\circ ", nary);
          (%o2)                         \circ
          (%i3) tex (a @@ b @@ c @@ d);
          $$a \circ b \circ c \circ d$$
          (%o3)                         false

     Asigna código TeX para un operador "no-fijo".

          (%i1) nofix ("foo");
          (%o1)                          foo
          (%i2) texput ("foo", "\\mathsc{foo}", nofix);
          (%o2)                     \mathsc{foo}
          (%i3) tex (foo);
          $$\mathsc{foo}$$
          (%o3)                         false

     Asigna código TeX para un operador "bi-fijo" (matchfix).

          (%i1) matchfix ("<<", ">>");
          (%o1)                          <<
          (%i2) texput ("<<", [" \\langle ", " \\rangle "], matchfix);
          (%o2)                [ \langle ,  \rangle ]
          (%i3) tex (<<a>>);
          $$ \langle a \rangle $$
          (%o3)                         false
          (%i4) tex (<<a, b>>);
          $$ \langle a , b \rangle $$
          (%o4)                         false
          (%i5) texput ("<<", [" \\langle ", " \\rangle ", " \\, | \\,"],
                matchfix);
          (%o5)           [ \langle ,  \rangle ,  \, | \,]
          (%i6) tex (<<a>>);
          $$ \langle a \rangle $$
          (%o6)                         false
          (%i7) tex (<<a, b>>);
          $$ \langle a \, | \,b \rangle $$
          (%o7)                         false

 -- Función: system (COMMAND)
     Ejecuta la instrucción COMMAND como un proceso independiente de Maxima. La instrucción se le pasa a la consola del sistema para su ejecución. La función system no está soportada por todos los sistemas operativos, pero suele estarlo en todos los entornos  Unix y similares.

     Suponiendo que _hist.out es una lista de frecuencias que se quieren representar en un diagrama de barras utilizando el programa xgraph,

          (%i1) (with_stdout("_hist.out",
                     for i:1 thru length(hist) do (
                       print(i,hist[i]))),
                 system("xgraph -bar -brw .7 -nl < _hist.out"));

     A fin de hacer el diagrama y eliminar el archivo temporal posteriormente, hágase:

          system("(xgraph -bar -brw .7 -nl < _hist.out;  rm -f _hist.out)&")

 -- Variable opcional: ttyoff
     Valor por defecto: false

     Si ttyoff vale true, no se muestran las expresiones resultantes, pero éstas se calculan de todos modos y se les asignan etiquetas. Véase labels.

     El texto que escriban las funciones internas de Maxima, tales como los mensajes de error y las salidas de describe, no se ven afectadas por ttyoff.

 -- Macro: with_stdout (FILENAME, EXPR_1, EXPR_2, EXPR_3, ...)
     Abre el archivo FILENAME y a continuación evalúa EXPR_1, EXPR_2, EXPR_3, .... Los valores de los argumentos no se almacenan FILENAME, pero cualquier resultado a imprimir por print, display, disp o grind, va a parar al archivo FILENAME en lugar de a la consola.

     La macro with_stdout devuelve el valor de su último argumento.

     Véase también writefile.

          (%i1) with_stdout ("tmp.out", for i:5 thru 10 do print (i, "! yields", i!))$
          (%i2) printfile ("tmp.out")$
          5 ! yields 120
          6 ! yields 720
          7 ! yields 5040
          8 ! yields 40320
          9 ! yields 362880
          10 ! yields 3628800

 -- Función: writefile (FILENAME)
     Comienza escribiendo una transcripción de la sesión de Maxima en el archivo FILENAME. Cualquier interacción entre Maxima y el usuario se almacena también en este archivo, tal como aparece en la consola.

     Puesto que la transcripción se escribe en el formato de salida a la consola, su contenido no es interpretable por Maxima. Para hacer un archivo que contenga expresiones que puedan ser nuevamente cargadas en Maxima, véanse save y stringout; la función save almacena expresiones en formato Lisp, mientras que stringout lo hace en formato Maxima.

     El resultado de ejecutar writefile cuando el archivo FILENAME ya existe depende del entorno Lisp operativo; el contenido anterior puede ser sobreescrito o ampliado con la sesión actual. La función appendfile siempre añade la sesión al contenido actual.

     Puede ser útil ejecutar playback después de writefile para guardar las interacciones previas de la sesión. Puesto que  playback muestra solamente las variables de entrada y salida (%i1, %o1, etc.), cualquier salida generada por una sentencia de impresión desde dentro de una función no es mostrada por playback.

     La función closefile cierra los archivos abiertos por writefile o appendfile.