Introducción a la Línea de Comandos
===================================

 -- Operador: '
     El operador comilla simple ' evita la evaluación.

     Aplicado a un símbolo, la comilla simple evita la evaluación del símbolo.

     Aplicado a la llamada de una función, la comilla simple evita la evaluación de la función llamada, aunque los argumentos de la función son evaluados (siempre y cuando la evaluación no se evite de otra manera). El resultado es una forma de nombre de la función llamada.

     Aplicado a una expresión con paréntesis, la comilla simple evita la evaluación de todos los símbolos y llamadas a funciones que hayan en la expresión. E.g., '(f(x)) significa que no se evalua la expresión f(x). 'f(x) (con la comilla simple aplicada a f en cambio de a f(x)) significa el retorno de la forma de nombre de f aplicada a [x].

     La comilla simple no evita la simplificación.

     Cuando el interruptor global noundisp es true, los nombres se muestran con una comilla simple. Este interruptor siempre tiene como valor true cuando se muestran definiciones de funciones.

     Ver también los operadores comilla-comilla '' y nouns.

     Ejemplos:

     Aplicado a un símbolo, la comilla simple evita la evaluación del símbolo.

          (%i1) aa: 1024;
          (%o1)                         1024
          (%i2) aa^2;
          (%o2)                        1048576
          (%i3) 'aa^2;
                                           2
          (%o3)                          aa
          (%i4) ''%;
          (%o4)                        1048576

     Aplicado a la llamada de una función, la comilla simple evita la evaluación de la función llamada, aunque los argumentos de la función son evaluados (siempre y cuando la evaluación no se evite de otra manera). El resultado es una forma de nombre de la función llamada.

          (%i1) x0: 5;
          (%o1)                           5
          (%i2) x1: 7;
          (%o2)                           7
          (%i3) integrate (x^2, x, x0, x1);
                                         218
          (%o3)                          ---
                                          3
          (%i4) 'integrate (x^2, x, x0, x1);
                                       7
                                      /
                                      [   2
          (%o4)                       I  x  dx
                                      ]
                                      /
                                       5
          (%i5) %, nouns;
                                         218
          (%o5)                          ---
                                          3

     Aplicado a una expresión con paréntesis, la comilla simple evita la evaluación de todos los símbolos y llamadas a funciones que hayan en la expresión.

          (%i1) aa: 1024;
          (%o1)                         1024
          (%i2) bb: 19;
          (%o2)                          19
          (%i3) sqrt(aa) + bb;
          (%o3)                          51
          (%i4) '(sqrt(aa) + bb);
          (%o4)                     bb + sqrt(aa)
          (%i5) ''%;
          (%o5)                          51

     La comilla simple no evita la simplificación.

          (%i1) sin (17 * %pi) + cos (17 * %pi);
          (%o1)                          - 1
          (%i2) '(sin (17 * %pi) + cos (17 * %pi));
          (%o2)                          - 1

 -- Operador: "
     El operador comilla-comilla '' (dos comillas simples) modifica la evaluación en las expresiones de entrada.

     Aplicado a cualquier expresión general EXPR, las dos comillas simples hacen que el valor de EXPR sea sustituido por EXPR en la expresión de entrada.

     Aplicado al operador de una expresión, el operador comilla-comilla hace que el operador pase de ser un nombre a ser un verbo, a menos que ya sea un verbo.

     El operador comilla-comilla es aplicado por el analizador sintáctico de entrada; no se almacena como una parte de la expresión de entrada analizada. Este operador se aplica siempre tan pronto como es detectado y no puede ser comentado con una comilla simple. De esta manera, el operador comilla-comilla provoca la evaluación de una expresión cuando ésta no estaba previsto que fuese evaluada, como en la definición de funciones, expresiones lambda y expresiones comentadas con una comilla simple '.

     El operador comilla-comilla es reconocido tanto por batch como por load.

     Véanse también el operador comilla simple ' y nouns.

     Ejemplos:

     Aplicado a cualquier expresión general EXPR, las dos comillas simples hacen que el valor de EXPR sea sustituido por EXPR en la expresión de entrada.

          (%i1) expand ((a + b)^3);
                               3        2      2      3
          (%o1)               b  + 3 a b  + 3 a  b + a
          (%i2) [_, ''_];
                                   3    3        2      2      3
          (%o2)     [expand((b + a) ), b  + 3 a b  + 3 a  b + a ]
          (%i3) [%i1, ''%i1];
                                   3    3        2      2      3
          (%o3)     [expand((b + a) ), b  + 3 a b  + 3 a  b + a ]
          (%i4) [aa : cc, bb : dd, cc : 17, dd : 29];
          (%o4)                   [cc, dd, 17, 29]
          (%i5) foo_1 (x) := aa - bb * x;
          (%o5)                 foo_1(x) := aa - bb x
          (%i6) foo_1 (10);
          (%o6)                      cc - 10 dd
          (%i7) ''%;
          (%o7)                         - 273
          (%i8) ''(foo_1 (10));
          (%o8)                         - 273
          (%i9) foo_2 (x) := ''aa - ''bb * x;
          (%o9)                 foo_2(x) := cc - dd x
          (%i10) foo_2 (10);
          (%o10)                        - 273
          (%i11) [x0 : x1, x1 : x2, x2 : x3];
          (%o11)                    [x1, x2, x3]
          (%i12) x0;
          (%o12)                         x1
          (%i13) ''x0;
          (%o13)                         x2
          (%i14) '' ''x0;
          (%o14)                         x3

     Aplicado al operador de una expresión, el operador comilla-comilla hace que el operador pase de ser un nombre a ser un verbo, a menos que ya sea un verbo.

          (%i1) sin (1);
          (%o1)                        sin(1)
          (%i2) ''sin (1);
          (%o2)                    0.8414709848079
          (%i3) declare (foo, noun);
          (%o3)                         done
          (%i4) foo (x) := x - 1729;
          (%o4)                 ''foo(x) := x - 1729
          (%i5) foo (100);
          (%o5)                       foo(100)
          (%i6) ''foo (100);
          (%o6)                        - 1629

     El operador comilla-comilla es aplicado por el analizador sintáctico de entrada; no se almacena como una parte de la expresión de entrada analizada.

          (%i1) [aa : bb, cc : dd, bb : 1234, dd : 5678];
          (%o1)                 [bb, dd, 1234, 5678]
          (%i2) aa + cc;
          (%o2)                        dd + bb
          (%i3) display (_, op (_), args (_));
                                     _ = cc + aa

                                   op(cc + aa) = +

                              args(cc + aa) = [cc, aa]

          (%o3)                         done
          (%i4) ''(aa + cc);
          (%o4)                         6912
          (%i5) display (_, op (_), args (_));
                                     _ = dd + bb

                                   op(dd + bb) = +

                              args(dd + bb) = [dd, bb]

          (%o5)                         done

     El operador comilla-comilla provoca la evaluación de una expresión cuando ésta no estaba previsto que fuese evaluada, como en la definición de funciones, expresiones lambda y expresiones comentadas con una comilla simple '.

          (%i1) foo_1a (x) := ''(integrate (log (x), x));
          (%o1)               foo_1a(x) := x log(x) - x
          (%i2) foo_1b (x) := integrate (log (x), x);
          (%o2)           foo_1b(x) := integrate(log(x), x)
          (%i3) dispfun (foo_1a, foo_1b);
          (%t3)               foo_1a(x) := x log(x) - x

          (%t4)           foo_1b(x) := integrate(log(x), x)

          (%o4)                      [%t3, %t4]
          (%i4) integrate (log (x), x);
          (%o4)                     x log(x) - x
          (%i5) foo_2a (x) := ''%;
          (%o5)               foo_2a(x) := x log(x) - x
          (%i6) foo_2b (x) := %;
          (%o6)                    foo_2b(x) := %
          (%i7) dispfun (foo_2a, foo_2b);
          (%t7)               foo_2a(x) := x log(x) - x

          (%t8)                    foo_2b(x) := %

          (%o8)                      [%t7, %t8]
          (%i8) F : lambda ([u], diff (sin (u), u));
          (%o8)             lambda([u], diff(sin(u), u))
          (%i9) G : lambda ([u], ''(diff (sin (u), u)));
          (%o9)                  lambda([u], cos(u))
          (%i10) '(sum (a[k], k, 1, 3) + sum (b[k], k, 1, 3));
          (%o10)         sum(b , k, 1, 3) + sum(a , k, 1, 3)
                              k                  k
          (%i11) '(''(sum (a[k], k, 1, 3)) + ''(sum (b[k], k, 1, 3)));
          (%o11)             b  + a  + b  + a  + b  + a
                              3    3    2    2    1    1

Funciones y variables para la Línea de Comandos
===============================================

 -- Función: alias (NEW_NAME_1, OLD_NAME_1, ..., NEW_NAME_N, OLD_NAME_N)
     provee un nombre alternativo para una (bien sea definida por el usuario o por el sistema) función, variable, arreglo, etc. Cualquier número par de argumentos puede ser usado.

 -- Variable opcional: debugmode
     Valor por defecto: false

     Cuando en Maxima ocurre un error, Maxima inicializará el depurador si debugmode tiene el valor true. El usuario puede ingresar comandos para examinar la pila de llamadas, los puntos de interrupción; en pocas palabras ir a través del código de Maxima. Vea debugging para una lista de los comandos del depurador.

     Habilitando debugmode no se capturarán los errores tipo Lisp.

 -- Función: ev (EXPR, ARG_1, ..., ARG_N)
     Evalua la expresión EXPR en el entorno especificado por los argumentos ARG_1, ..., ARG_N. Los argumentos son interruptores (Variables Booleanas), variables de asignación, ecuaciones y funciones. ev retorna el resultado (otra expresión) de la evaluación.

     La evaluación se realiza por etapas, como sigue:

      1. Primero se configura el entorno de acuerdo a los argumentos los cuales pueden ser algunos o todos de la siguiente lista:

            * simp causa que EXPR sea simplificada sin importar el valor de la variable interruptor simp la cual inhibe la simplificación cuando su valor es false.

            * noeval suprime la fase de evaluación de ev (Vea el paso (4) más adelante). Esto es muy útil en conjunción con otras variables interruptor y causan en EXPR que sea resimplificada sin ser reevaluada.

            * nouns causa la evaluación de las formas nominales (típicamente funciones sin evaluar tales como 'integrate or 'diff) en expr.

            * expand causa expansión.

            * expand (M, N) causa expansión, asignando los valores de maxposex y maxnegex a M y N, respectivamente.

            * detout hace que cualesquiera matrices inversas calculadas en EXPR conserven su determinante fuera de la inversa, en vez de que divida a cada elemento.

            * diff realiza todas las diferenciaciones indicadas en EXPR.

            * derivlist (X, Y, Z, ...) realiza sólo las diferenciaciones con respecto a las variables indicadas.

            * float provoca la conversión de los números racionales no-enteros a números decimales de coma flotante.

            * numer causa que algunas funciones matemáticas (incluyendo potenciación) con argumentos numéricos sean evaluados como punto flotante. Esto causa que las variables en EXPR las cuales hayan sido declaradas como variables numéricas sean reemplazadas por sus respectivos valores. Esto también configura la variable interruptor float a true.

            * pred provoca la evaluación de los predicados (expresiones las cuales se evaluan a true o false).

            * eval provoca una post-evaluación extra de EXPR (véase el paso (5) más adelante), pudiendo aparecer eval varias veces; por cada aparición de eval, la expresión es reevaluada.

            * A, donde A es un átomo declarado como una variable de tipo interruptor, (Vea evflag) causa que A tenga como valor true durante la evaluación de EXPR.

            * V: expresion (o alternativamente V=expresion) causa que V tenga el valor de expresion durante la evaluación de EXPR. Notese que si V es una opción Maxima, entonces expresion se usa como su valor durante la evaluación de EXPR. Si más de un argumento de ev es de este tipo entonces el vínculo se hace en paralelo. Si V es una expresión no atómica entonces se hace una sustitución más que un vínculo.

            * F donde F, un nombre de función, ha sido declarado para ser una función de evaluación (Vea evfun) causa que F sea aplicada a EXPR.

            * Cualquier otro nombre de función (e.g., sum) causa la evaluación de las ocurrencias de esos nombres en expr como si ellos fueran verbos.

            * En adición de que una función ocurra en EXPR (digamos F(x)) puede ser definida localmente para el propósito de esta evaluación de EXPR pasando F(x) := expresion como un argumento a ev.

            * Si un átomo no mencionado anteriormente o una variable o expresión con subíndices fueran pasadas como un argumento, esta es evaluada y si el resultado es una ecuación o una asignación entonces el vínculo o sustitución se llevará a cabo. Si el resultado es una lista entonces los miembros de la lista tratados como si ellos fueran argumentos adicionales pasados a ev. Esto permite que una lista de argumentos sea pasada (e.g., [X=1, Y=A**2]) o una lista de nombres de ecuaciones (e.g., [%t1, %t2] donde %t1 y %t2 son ecuaciones) tal como lo que es retornado por solve.

          Los argumentos de ev pueden ser pasados en cualquier orden con excepción de la sustitución de ecuaciones las cuales son manipuladas en secuencia, de izquierda a derecha y las funciones de evaluación las cuales son compuestas, e.g., ev (EXPR, ratsimp, realpart) es manipulada como realpart (ratsimp (EXPR)).

          Los interruptores simp, numer, float y pred pueden también ser configurados localmente en una sentencia block, o globalmente en Maxima para que su efecto permanezca hasta que sean reconfiguradas.

          Si EXPR es una Expresión Racional Canónica (CRE, por sus siglas en inglés), entonces la expresión retornada por ev es también de tipo CRE, siempre que los interruptores numer y float no sean true.

      2. Durante el paso (1), se fabrica una lista de las variables que no contienen subíndices que aparecen en el lado izquierdo de las ecuaciones en los argumentos o en el valor de algunos argumentos si el valor es una ecuación. Las variables (variables que contienen subíndices las cuales no tienen asociado un arreglo de funciones como también las variables que no contienen subíndices) en la expresión EXPR son reemplazadas por sus valores globales, excepto por aquellos que aparezcan en esa lista. Usualmente, EXPR es sólo una etiqueta o un % (como en %i2 en el ejemplo de más abajo) así que este paso simplemente recupera la expresión a la que hace referencia la etiqueta y así ev puede trabajarla.

      3. Si algunas sustituciones son indicadas por los argumentos, ellas serán llevadas a cabo ahora.

      4. La expresión resultante es también reevaluada (a menos que uno de los argumentos fuese noeval) y simplificada de acuerdo a los argumentos. Notese que cualquier llamada a una función en EXPR será llevada a cabo después de que las variables sean evaluadas en ella y que ev(F(x)) pueda comportarse como F(ev(x)).

      5. Por cada aparición de eval en los argumentos, se repetirán los pasos (3) y (4).

     Ejemplos

          (%i1) sin(x) + cos(y) + (w+1)^2 + 'diff (sin(w), w);
                                               d                    2
          (%o1)              cos(y) + sin(x) + -- (sin(w)) + (w + 1)
                                               dw
          (%i2) ev (%, sin, expand, diff, x=2, y=1);
                                    2
          (%o2)           cos(w) + w  + 2 w + cos(1) + 1.909297426825682

     Una sintaxis alternativa de alto nivel ha sido proveida para ev, por medio de la cual uno puede escribir solamente sus argumentos, sin el comando ev(). Esto es, una forma sencilla de escritura:

          EXPR, ARG_1, ..., ARG_N

     Esto no es permitido como parte de otra expresión , e.g., en funciones, sentencias block, etc.

     Nótese el proceso de vínculo en paralelo en el siguiente ejemplo:

          (%i3) programmode: false;
          (%o3)                                false
          (%i4) x+y, x: a+y, y: 2;
          (%o4)                              y + a + 2
          (%i5) 2*x - 3*y = 3$
          (%i6) -3*x + 2*y = -4$
          (%i7) solve ([%o5, %o6]);
          Solución

                                                    1
          (%t7)                               y = - -
                                                    5

                                                   6
          (%t8)                                x = -
                                                   5
          (%o8)                            [[%t7, %t8]]
          (%i8) %o6, %o8;
          (%o8)                              - 4 = - 4
          (%i9) x + 1/x > gamma (1/2);
                                             1
          (%o9)                          x + - > sqrt(%pi)
                                             x
          (%i10) %, numer, x=1/2;
          (%o10)                      2.5 > 1.772453850905516
          (%i11) %, pred;
          (%o11)                               true

 -- Propiedad: evflag
     Cuando un símbolo X goza de la propiedad evflag, las expresiones ev(EXPR, X) y EXPR, X (en modo interactivo) equivalen a ev(EXPR, X = true). Esto es, a X se le asigna true al tiempo que se evalúa EXPR.

     La expresión declare(X, evflag) dota a la variable X de la propiedad evflag.

     Los interruptores que tienen la propiedad evflag son:

     algebraic, cauchysum, demoivre, dotscrules, %emode, %enumer, exponentialize, exptisolate, factorflag, float, halfangles, infeval, isolate_wrt_times, keepfloat, letrat, listarith, logabs, logarc, logexpand, lognegint, lognumer, m1pbranch, numer_pbranch, programmode, radexpand, ratalgdenom, ratfac, ratmx, ratsimpexpons, simp, simpsum, sumexpand, y trigexpand.

     Ejemplos:

          (%i1) sin (1/2);
                                           1
          (%o1)                        sin(-)
                                           2
          (%i2) sin (1/2), float;
          (%o2)                   0.479425538604203
          (%i3) sin (1/2), float=true;
          (%o3)                   0.479425538604203
          (%i4) simp : false;
          (%o4)                         false
          (%i5) 1 + 1;
          (%o5)                         1 + 1
          (%i6) 1 + 1, simp;
          (%o6)                           2
          (%i7) simp : true;
          (%o7)                         true
          (%i8) sum (1/k^2, k, 1, inf);
                                      inf
                                      ====
                                      \     1
          (%o8)                        >    --
                                      /      2
                                      ====  k
                                      k = 1
          (%i9) sum (1/k^2, k, 1, inf), simpsum;
                                           2
                                        %pi
          (%o9)                         ----
                                         6
          (%i10) declare (aa, evflag);
          (%o10)                        done
          (%i11) if aa = true then YES else NO;
          (%o11)                         NO
          (%i12) if aa = true then YES else NO, aa;
          (%o12)                         YES

 -- Propiedad: evfun
     Cuando la función F goza de la propiedad evfun, las expresiones ev(EXPR, F) y EXPR, F (en modo interactivo) equivalen a F(ev(EXPR)).

     Si se especifican dos o más funciones, F, G, etc., como poseedoras de la propiedad evfun, éstas se aplican en el mismo orden en el que han sido especificadas como tales.

     La expresión declare(F, evfun) dota a la función  F de la propiedad evfun.

     Las funciones que tienen la propiedad evfun por defecto son:

     bfloat, factor, fullratsimp, logcontract, polarform, radcan, ratexpand, ratsimp, rectform, rootscontract, trigexpand, y trigreduce.

     Ejemplos:

          (%i1) x^3 - 1;
                                        3
          (%o1)                        x  - 1
          (%i2) x^3 - 1, factor;
                                          2
          (%o2)                 (x - 1) (x  + x + 1)
          (%i3) factor (x^3 - 1);
                                          2
          (%o3)                 (x - 1) (x  + x + 1)
          (%i4) cos(4 * x) / sin(x)^4;
                                      cos(4 x)
          (%o4)                       --------
                                         4
                                      sin (x)
          (%i5) cos(4 * x) / sin(x)^4, trigexpand;
                           4           2       2         4
                        sin (x) - 6 cos (x) sin (x) + cos (x)
          (%o5)         -------------------------------------
                                          4
                                       sin (x)
          (%i6) cos(4 * x) / sin(x)^4, trigexpand, ratexpand;
                                     2         4
                                6 cos (x)   cos (x)
          (%o6)               - --------- + ------- + 1
                                    2          4
                                 sin (x)    sin (x)
          (%i7) ratexpand (trigexpand (cos(4 * x) / sin(x)^4));
                                     2         4
                                6 cos (x)   cos (x)
          (%o7)               - --------- + ------- + 1
                                    2          4
                                 sin (x)    sin (x)
          (%i8) declare ([F, G], evfun);
          (%o8)                         done
          (%i9) (aa : bb, bb : cc, cc : dd);
          (%o9)                          dd
          (%i10) aa;
          (%o10)                         bb
          (%i11) aa, F;
          (%o11)                        F(cc)
          (%i12) F (aa);
          (%o12)                        F(bb)
          (%i13) F (ev (aa));
          (%o13)                        F(cc)
          (%i14) aa, F, G;
          (%o14)                      G(F(cc))
          (%i15) G (F (ev (aa)));
          (%o15)                      G(F(cc))

 -- Variable opcional: infeval
     Habilita el modo de "evaluación infinita". ev repetidamente evalua una expresión hasta que se interrumpa la acción. Para prevenir que una variable, digamos X, sea evaluada sin parar en este modo, simplemente incluya X='X como argumento de ev. Esta claro que expresiones como: ev (X, X=X+1, infeval) generarán un bucle infinito.

 -- Función: kill (A_1, ..., A_N)
 -- Función: kill (labels)
 -- Función: kill (inlabels, outlabels, linelabels)
 -- Función: kill (N)
 -- Función: kill ([M, N])
 -- Función: kill (values, functions, arrays, ...)
 -- Función: kill (all)
 -- Función: kill (allbut (A_1, ..., A_N))
     Elimina todas las asignaciones (valor, función, arreglo o regla) hechas a los argumentos A_1, ..., A_N. Un argumento A_K puede ser un símbolo o el elemento de un array. Si A_K es elemento de un array, kill elimina la asignación hecha a este elemento sin afectar al resto del array.

     Se reconocen varios argumentos especiales. Se pueden combinar diferentes clases de argumentos, como por ejemplo, kill (inlabels, functions, allbut (foo, bar)).

     La instrucción kill (labels) borra todas las asignaciones asociadas a las etiquetas de entrada, de salida e intermedias creadas hasta el momento. La instrucción kill (inlabels) elimina únicamente las asignaciones de las etiquetas de entrada que comienzan con el valor actual de inchar. Del mismo modo, kill (outlabels) elimina únicamente las asignaciones de las etiquetas de salida que comienzan con el valor actual de outchar. Finalmente, kill (linelabels) elimina únicamente las asignaciones de las etiquetas de las expresiones intermedias que comienzan con el valor actual de linechar.

     La instrucción kill (N), siendo N un entero, elimina las asignaciones de las últimas N etiquetas, tanto de entrada como de salida.

     La instrucción kill ([M, N]) elimina las asignaciones hechas a las etiquetas de entrada y salida desde la M hasta laN.

     La instrucción kill (INFOLIST), siendo INFOLIST cualquier elemento de infolists (como values, functions o arrays), elimina todas las asignaciones hechas a los elementos de INFOLIST. Véase también infolists.

     La instrucción kill (all) elimina todas las asignaciones de todas las variables, pero no reinicia las variables globales a sus valores por defecto. Véase también reset.

     La instrucción kill (allbut (A_1, ..., A_N)) elimina las asignaciones hechas a todas las variables, excepto a A_1, ..., A_N; la instrucción kill (allbut (INFOLIST)) elimina todas las asignaciones, excepto las de los elementos de INFOLIST, pudiendo ser INFOLIST igual a values, functions, arrays, etc.

     La memoria reservada para una asignación no se libera hasta que no se vacíen todos los símbolos asociados con esta asignación; por ejemplo, para liberar la memoria del valor de un símbolo es necesario eliminar tanto la asignación de la etiqueta de salida que muestra el resultado, como la del propio símbolo.

     La función kill no evalua sus argumentos. El operador comilla-comilla, '', obliga a que se realice la evaluación.

     La llamada kill (SYMBOL) elimina todas las propiedades de SYMBOL. Por el contrario, remvalue, remfunction, remarray y remrule eliminan propiedades específicas.

     kill siempre devuelve done, incluso cuando alguno de sus argumentos carecía de asignación previa.

 -- Función: labels (SYMBOL)
 -- Variable del sistema: labels
     Retorna la lista de etiquetas de entrada, salida o de expresiones intermedias las cuales empiezan con SYMBOL. Típicamente SYMBOL es el valor de las variables inchar, outchar o linechar. El caractér de etiqueta puede ser pasado con o sin signo de porcentaje, así, por ejemplo, i y %i producen el mismo resultado.

     Si ninguna etiqueta empieza con SYMBOL, labels retorna a una lista vacía.

     La función labels no evalua su argumento. El operador comilla-comilla, '', obliga a que se realice la evaluación. Por ejemplo, labels (''inchar) devuelve las etiquetas de entrada que empiezan con el caractér de etiqueta de entrada actual.

     La variable labels es una lista de las etiquetas de entrada, salida y expresiones intermedias, incluyendo todas las etiquetas anteriores en el caso de que inchar, outchar o linechar hayan sido redefinidas.

     Por defecto, Maxima muestra el resultado de cada expresión introducida por el usuario, asignando al resultado una etiqueta de salida. La salida (es decir el resultado) puede ser suprimida terminando la expresión de entrada con un $ (signo de dólar) en vez de un ; (punto y coma). En este caso, se crea la etiqueta de salida y se le asigna el resultado, aunque éste no se muestre; aún así, la etiqueta puede ser referenciada de la misma forma que se hace con aquéllas cuyos resultados sí son mostrados.

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

     Las etiquetas de expresiones intermedias pueden ser generadas por algunas funciones. El interruptor programmode controla si solve y algunas otras funciones generan etiquetas de expresiones intermedias en vez de retornar una lista de expresiones. Algunas otras funciones, tales como ldisplay, siempre generan etiquetas de expresiones intermedias.

     Véase también: inchar, outchar, linechar y infolists.

 -- Variable del sistema: linenum
     El número de la línea del par de expresiones de entrada y salida actuales.

 -- Variable del sistema: myoptions
     Valor por defecto: []

     myoptions es la lista de todas las opciones que nunca fueron reconfiguradas por el usuario, aunque éstas hayan sido reconfiguradas a su valor por defecto.

 -- Variable opcional: nolabels
     Valor por defecto: false

     Cuando nolabels vale true, las etiquetas de entrada y salida (%i y %o, respectivamente) son mostradas, pero a éstas no se les asignan los resultados; además, las etiquetas no se incorporan a la lista labels. Puesto que a las etiquetas no se les asignan resultados, el colector de basura puede recuperar la memoria ocupada por éstos.

     En el caso contrario, a las etiquetas de entrada y salida se les asignan los resultados correspondientes y son añadidas a la lista labels.

     Las etiquetas de expresiones intermedias (%t) no se ven afectadas por la variable nolabels; independientemente de que nolabels valga true o false, a las etiquetas de expresiones intermedias se les asignan siempre valores, además de ser añadidas a la lista labels.

     Véanse también batch, batchload y labels.

 -- Variable opcional: optionset
     Valor por defecto: false

     Cuando optionset tiene como valor true, Maxima imprime un mensaje cada vez que una opción de Maxima es reconfigurada. Esto es muy útil si el usuario duda con frecuencia de la correctitud de alguna opción y quiere estar seguro de la variable a la que él asignó un valor fue verdaramente una variable opción (o interruptor).

 -- Función: playback ()
 -- Función: playback (N)
 -- Función: playback ([M, N])
 -- Función: playback ([M])
 -- Función: playback (input)
 -- Función: playback (slow)
 -- Función: playback (time)
 -- Función: playback (grind)
     Muestra las entradas, salidas y expresiones intermedias sin recalcularlas. playback sólo muestra las expresiones asociadas con etiquetas; cualquier otra salida (tal como texto impreso por print o describe, o mensajes de error) no es mostrada. Véase también: labels.

     playback no evalua sus argumentos. El operador comilla-comilla, '', obliga a que se realice la evaluación. playback siempre devuelve done.

     playback () (sin argumentos) muestra todas las entradas, salidas y expresiones intermedias generadas hasta el momento. Una expresión de salida es mostrada incluso si ésta fue suprimida por el caracter de terminación $, cuando fue originalmente calculada.

     playback (N)  muestra las N expresiones más recientes. Cada entrada, salida y expresión intermedia cuenta como una.

     playback ([M, N]) muestra entradas, salidas y expresiones intermedias con los números desde M hasta N, ambos inclusive.

     playback ([M]) es equivalente a playback ([M, M]); esto usualmente imprime un par de expresiones de entrada y salida.

     playback (input) muestra todas las expresiones de entrada generadas hasta el momento.

     playback (slow) hace pausas entre expresiones y espera a que el usuario pulse la tecla enter para continuar. Esto es un comportamiento similar a demo.

     playback (slow) es muy útil en conjunción con save o stringout cuando se crea un archivo secundario de almacenamiento con el objetivo de elegir cuidadosamente las expresiones realmente útiles.

     playback (time) muestra el tiempo de computo por cada expresión.

     playback (grind) muestra las expresiones de entrada en el mismo formato como la función grind. Las expresiones de salida no se ven afectadas por la opción grind. Vea grind. Los argumentos pueden ser combinados, por ejemplo, playback ([5, 10], grind, time, slow).

 -- Función: printprops (A, I)
 -- Función: printprops ([A_1, ..., A_N], I)
 -- Función: printprops (all, I)
     Muestra la propiedad con el indicador I asociado con el átomo A. A puede ser también una lista de átomos o el átomo all en cuyo caso todos los átomos a los cuales se les haya dado esa propiedad serán usados. Por ejemplo, printprops ([f, g], atvalue). printprops es para propiedades que no pueden ser mostradas de otra manera, i.e. para atvalue, atomgrad, gradef, y matchdeclare.

 -- Variable opcional: prompt
     Valor por defecto: _

     prompt es el símbolo del prompt de la función demo, del modo playback (slow) y del bucle de interrupción de Maxima (el que se invoca con break).

 -- Función: quit ()
     Termina una sesión de Maxima. Nótese que la función debe ser invocada como quit(); o quit()$, no como quit.

     Para parar un cálculo muy demorado pulse Control-C. La acción por defecto es retornar a prompt de Maxima. Si *debugger-hook* tiene como valor nil, pulsar Control-C abrirá el depurador de Lisp. Vea también: debugging.

 -- Función: remfunction (F_1, ..., F_N)
 -- Función: remfunction (all)
     Desliga las definiciones de función de sus símbolos F_1, ..., F_N. Los argumentos pueden ser nombres de funciones ordinarias (creadas con := o define) o de funciones macro (creadas con ::=).

     La instrucción remfunction (all) desliga todas las definiciones de funciones.

     La función remfunction no evalúa sus argumentos.

     La función remfunction devuelve una lista con los símbolos para los que la definición de función fue desligada. Devuelve false en el lugar de cualquier símbolo para el que no hay función definida.

 -- Función: reset ()
     Reconfigura muchas variables y opciones globales y algunas otras variables a sus valores por defecto.

     reset procesa las variables que se encuentran en la lista Lisp *variable-initial-values*. La macro Lisp defmvar pone las variables en ésta lista (entre otras acciones). Muchas, pero no todas, las variables y opciones globales son definidas por defmvar, y algunas variables definidas por defmvar no son ni variables ni opciones globales.

 -- Variable opcional: showtime
     Valor por defecto: false

     Cuando showtime tiene como valor true, el tiempo de cálculo y el tiempo de retardo se imprimen junto con la salida de cada expresión.

     El tiempo de cálculo se almacena siempre, de manera que time y playback puedan mostrar el tiempo de cálculo incluso cuando showtime vale false.

     Véase también timer.

 -- Función: sstatus (FEATURE, PACKAGE)
     Configura el estado de FEATURE en PACKAGE. Después de que sstatus (FEATURE, PACKAGE) es ejecutado status (FEATURE, PACKAGE) retorna true. Esto puede ser muy útil para escritores de paquetes, con el objetivo de conservar las pistas de que caracterísiticas han cargado estos.

 -- Function: to_lisp ()
     Entra en el intérprete Lisp bajo Maxima. (to-maxima) retorna de nuevo a Maxima.

 -- Variable del sistema: values
     Valor inicial: []

     values es una lista de todas las variables que el usuario ha creado (no constituye las opciones Maxima ni los interruptores). La lista comprende los símbolos : , ::, o :=.