n-arios
=======

Un operador de tipo nary(n-ario, en Maxima nary) es usado para denotar una función cuyo número de argumentos es arbitrario; los argumentos se separa por el símbolo del operador, como en A+B o A+B+C. La función nary("x") es una extensión de la función syntax para declarar a x como un operador n-ario. Las funciones pueden ser declaradas para ser nary. Si se hace declare(J,nary);, se esta diciendo al simplificador que haga la reducción de j(j(a,b),j(c,d)) a j(a, b, c, d).

Véase también syntax.

no-fijos
========

Los operadores de tipo nofix (no-fijos, en Maxima nofix) son usados para denotar funciones que no reciben argumentos. La mera presencia de tal operador en un comando causará que la correspondiente función sea evaluada. Por ejemplo, cuando se escribe "exit;" para salir de una interrupción de Maxima, "exit" se está comportando de forma similar a un operador no-fijo (nofix). La función nofix("x") es una extensión de la función syntax la cual declara a x como un operador nofix.

Véase también syntax.

postfijos
=========

Un operador de tipo postfix (postfijo), al contrario de los de tipo prefix, denota funciones de un solo argumento, pero en este caso el argumento precede inmediatamente la ocurrencia del operador en la cadena de entrada, como en 3!. La función postfix("x") es una extensión de la función syntax para declarar a x como un operador postfix.

Véase también syntax.

prefijos
========

Un operador de tipo prefix (prefijo, en Maxima prefix) indica una función de un (1) argumento, dicho argumento viene inmediatamente después de una ocurrencia del operador. La función prefix("x") es una extensión de la función syntax para declarar a x como un operador de prefix.

Véase también syntax.

Operadores aritméticos
======================

 -- Operador: +
 -- Operador: -
 -- Operador: *
 -- Operador: /
 -- Operador: ^

     Los símbolos + * / y ^ representan la suma, resta, multiplicación, división y exponenciación, respectivamente. Los nombres de estos operadores son "+" "*" "//" y "^", que pueden aparecer allá donde se requiera el nombre de una función u operador.

     Los símbolos + y - representan el positivo y negativo unario, siendo los nombres de estos operadores "+" y "-", respectivamente.

     En Maxima, la resta a - b se representa como la suma a + (- b). Expresiones tales como a + (- b) se muestran como restas. Maxima reconoce "-" tan solo como el operador de negación unaria, no como el nombre del operador de resta binaria.

     La división a / b se representa en maxima como la multiplicación a * b^(- 1). Expresiones tales como a * b^(- 1) se muestran como divisiones. Maxima reconoce "//" como el nombre del operador de división.

     La suma y la multiplicación son operadores conmutativos n-arios. La división y la exponenciación son operadores no conmutativos binarios.

     Maxima ordena los operandos de los operadores conmutativos para formar lo que se conoce como representación canónica. A efectos de almacenamiento interno, la ordenación viene determinada por orderlessp. A efectos de presentación de las expresiones, la ordenación de la suma la determina ordergreatp, y en el caso de la multiplicación, la ordenación coincide con la del almacenamiento interno.

     Los cálculos aritméticos se realizan con números literales (enteros, racionales, decimales ordinarios y decimales grandes). Excepto en el caso de la exponenciación, todas las operaciones aritméticas con números dan lugar a resultados en forma de números. La exponenciación da como resultado un número si alguno de los operandos es decimal ordinario o grande (bigfloat), o si el resultado es un entero o racional; en caso contrario, la exponenciación puede expresarse como una raíz cuadrada (sqrt), como otra potencia, o simplemente no sufre cambios.

     Se produce contagio de los decimales en coma flotante en los cálculos aritméticos: si algún operando es un número decimal grande (bigfloat), el resultado será también un número decimal grande; no habiendo decimales grandes, pero sí ordinarios, el resultado srá también un decimal ordinario; de no haber operandos decimales, el resultado será un número racional o entero.

     Los cálculos aritméticos son simplificaciones, no evaluaciones, por lo que se realizan en expresiones comentadas.

     Las operaciones aritméticas se aplican elemento a elemento en el caso de las listas cuando la variable global listarith vale true; pero en el caso de las matrices, siempre se aplican elemento a elemento. Cuando un operando es una lista o matriz y otro operando lo es de otro tipo cualquiera, éste se combina con cada uno de los elementos de la lista o matriz.

     Ejemplos:

     La suma y la multiplicación son operadores conmutativos n-arios. Maxima ordena los operandos para formar lo que se conoce como representación canónica. Los nombres de estos operadores son "+" y "-".

          (%i1) c + g + d + a + b + e + f;
          (%o1)               g + f + e + d + c + b + a
          (%i2) [op (%), args (%)];
          (%o2)              [+, [g, f, e, d, c, b, a]]
          (%i3) c * g * d * a * b * e * f;
          (%o3)                     a b c d e f g
          (%i4) [op (%), args (%)];
          (%o4)              [*, [a, b, c, d, e, f, g]]
          (%i5) apply ("+", [a, 8, x, 2, 9, x, x, a]);
          (%o5)                    3 x + 2 a + 19
          (%i6) apply ("*", [a, 8, x, 2, 9, x, x, a]);
                                           2  3
          (%o6)                       144 a  x

     La división y la exponenciación son operadores no conmutativos binarios. Los nombres de estos operadores son "//" y "^".

          (%i1) [a / b, a ^ b];
                                        a   b
          (%o1)                        [-, a ]
                                        b
          (%i2) [map (op, %), map (args, %)];
          (%o2)              [[//, ^], [[a, b], [a, b]]]
          (%i3) [apply ("//", [a, b]), apply ("^", [a, b])];
                                        a   b
          (%o3)                        [-, a ]
                                        b

     La resta y la división se representan internamente en términos de la suma y multiplicación, respectivamente.

          (%i1) [inpart (a - b, 0), inpart (a - b, 1), inpart (a - b, 2)];
          (%o1)                      [+, a, - b]
          (%i2) [inpart (a / b, 0), inpart (a / b, 1), inpart (a / b, 2)];
                                             1
          (%o2)                       [*, a, -]
                                             b

     Los cálculos se realizan con números literales. Se produce el contagio de los números decimales.

          (%i1) 17 + b - (1/2)*29 + 11^(2/4);
                                                 5
          (%o1)                   b + sqrt(11) + -
                                                 2
          (%i2) [17 + 29, 17 + 29.0, 17 + 29b0];
          (%o2)                   [46, 46.0, 4.6b1]

     Los cálculos aritméticos son una simplificación, no una evaluación.

          (%i1) simp : false;
          (%o1)                         false
          (%i2) '(17 + 29*11/7 - 5^3);
                                        29 11    3
          (%o2)                    17 + ----- - 5
                                          7
          (%i3) simp : true;
          (%o3)                         true
          (%i4) '(17 + 29*11/7 - 5^3);
                                          437
          (%o4)                         - ---
                                           7

     Los cálculos aritméticos se realizan elemento a elemento en las listas (según sea el valor de listarith) y matrices.

          (%i1) matrix ([a, x], [h, u]) - matrix ([1, 2], [3, 4]);
                                  [ a - 1  x - 2 ]
          (%o1)                   [              ]
                                  [ h - 3  u - 4 ]
          (%i2) 5 * matrix ([a, x], [h, u]);
                                    [ 5 a  5 x ]
          (%o2)                     [          ]
                                    [ 5 h  5 u ]
          (%i3) listarith : false;
          (%o3)                         false
          (%i4) [a, c, m, t] / [1, 7, 2, 9];
                                    [a, c, m, t]
          (%o4)                     ------------
                                    [1, 7, 2, 9]
          (%i5) [a, c, m, t] ^ x;
                                                x
          (%o5)                     [a, c, m, t]
          (%i6) listarith : true;
          (%o6)                         true
          (%i7) [a, c, m, t] / [1, 7, 2, 9];
                                        c  m  t
          (%o7)                     [a, -, -, -]
                                        7  2  9
          (%i8) [a, c, m, t] ^ x;
                                    x   x   x   x
          (%o8)                   [a , c , m , t ]

 -- Operador: **

     Operador de exponenciación. Maxima identifica ** con el operador ^ en la entrada de expresiones, pero se representa como ^ en las salidas no formateadas (display2d=false), o colocando un superíndice en la salida formateada (display2d=true).

     La función fortran representa el operador de exponenciación con **, tanto si se ha introducido como ** o como ^.

     Ejemplos:

          (%i1) is (a**b = a^b);
          (%o1)                         true
          (%i2) x**y + x^z;
                                        z    y
          (%o2)                        x  + x
          (%i3) string (x**y + x^z);
          (%o3)                        x^z+x^y
          (%i4) fortran (x**y + x^z);
                x**z+x**y
          (%o4)                         done

Operadores relacionales
=======================

 -- Operator: <
 -- Operator: <=
 -- Operator: >=
 -- Operator: >

Operadores generales
====================

 -- Operator: ^^

     Operador de exponenciación no conmutativa. Se trata del operador de exponenciación correspondiente a la multiplicación no conmutativa ., del mismo modo que el operador de exponenciación ordinario ^ se corresponde con la multiplicación conmutativa *.

     La exponenciación no conmutativa se representa como ^^ en las salidas no formateadas (display2d=false), o colocando un superíndice entre ángulos (< >) en la salida formateada (display2d=true).

     Ejemplos:

          (%i1) a . a . b . b . b + a * a * a * b * b;
                                  3  2    <2>    <3>
          (%o1)                  a  b  + a    . b
          (%i2) string (a . a . b . b . b + a * a * a * b * b);
          (%o2)                  a^3*b^2+a^^2 . b^^3

 -- Operador: !
     El operador factorial. Para cualquier número complejo x (incluyendo enteros, racionales  y números reales) excepto para enteros negativos, x! se define como gamma(x+1).

     Para un entero x, x! simplifica el producto de los enteros desde 1 hasta x. 0! simplifica a 1. Para a un número de punto flotante x, x! calcula al valor de gamma(x+1). Para x igual a n/2 donde n es un entero impar, x! simplifica a un factor racional por sqrt(%pi) (donde gamma(1/2)) es igual a sqrt(%pi)). Si x es cualquier otra cosa, x! no se simplifica.

     Las variables factlim, minfactorial y  factcomb controlan la simplificación de expresiones que contienen factoriales.

     Las funciones gamma, bffac y cbffac son variaciones de la función gamma. makegamma substituye a gamma para factoriales y funciones relacionadas.

     Funciones relacionadas: binomial

       * El factorial de un entero, semi-entero o de punto flotante es simplificado a menos que el operando sea mayor que factlim.

               (%i1) factlim : 10;
               (%o1)                          10
               (%i2) [0!, (7/2)!, 4.77!, 8!, 20!];
                           105 sqrt(%pi)
               (%o2)   [1, -------------, 81.44668037931199, 40320, 20!]
                                16

       * El factorial de un número complejo, constante  conocida (por ejemplo %e) o una expresión general no es simplificado.

          Sin embargo puede ser posible simplificar el factorial después de evaluar el operando.

               (%i1) [(%i + 1)!, %pi!, %e!, (cos(1) + sin(1))!];
               (%o1)      [(%i + 1)!, %pi!, %e!, (sin(1) + cos(1))!]
               (%i2) ev (%, numer, %enumer);
               (%o2) [(%i + 1)!, 7.188082728976037, 4.260820476357,
                                                              1.227580202486819]

       * El factorial de un símbolo no se simplifica.

               (%i1) kill (foo);
               (%o1)                         done
               (%i2) foo!;
               (%o2)                         foo!

       * Los factoriales son simplificados, no evaluados. Así x! puede ser reemplazado en una expresión precedida por el operador comilla.

               (%i1) '([0!, (7/2)!, 4.77!, 8!, 20!]);
                         105 sqrt(%pi)
               (%o1) [1, -------------, 81.44668037931199, 40320,
                              16
                                                            2432902008176640000]

 -- Operador: !!
     El operador doble factorial.

     Para un número entero, de punto flotante o racional n, n!! se evaluará como el producto de n (n-2) (n-4) (n-6) ... (n - 2 (k-1)) donde k es igual a entier(n/2), que es, el mayor entero menor o igual a n/2. Note que esta definición no coincide con otras definciones publicadas para argumentos, los cuales no son enteros.

     Para un entero par (o impar) n, n! se evalua el producto de todos los enteros pares (o impares) consecutivos desde 2 (o 1) por n inclusive.

     Para un argumento n el cual no es un número entero, punto flotante o racional, n!! produce una forma de nombre genfact (n, n/2, 2).

 -- Operador: #
     Representa la negación de la igualdad sintáctica =.

     Nótese que debido a las reglas de evaluación de expresiones de tipo predicado (en concreto debido a que not EXPR obliga a la evaluación previa de EXPR), not A = B equivale a is(A # B), pero no a A # B.

     Ejemplos:

          (%i1) a = b;
          (%o1)                         a = b
          (%i2) is (a = b);
          (%o2)                         false
          (%i3) a # b;
          (%o3)                         a # b
          (%i4) not a = b;
          (%o4)                         true
          (%i5) is (a # b);
          (%o5)                         true
          (%i6) is (not a = b);
          (%o6)                         true

 -- Operador: .
     El operador punto, para multiplicación de matrices (no-conmutativo). Cuando "." se usa de esta forma, se dejarán espacios a ambos lados de éste, como en A . B. Así se evita que se confunda con el punto decimal de los números.

     Véanse: dot, dot0nscsimp, dot0simp, dot1simp, dotassoc, dotconstrules, dotdistrib, dotexptsimp, dotident y dotscrules.

 -- Operador: :
     El operador de asignación. Por ejemplo, A:3 se asigna a la variable A el valor de 3.

 -- Operador: ::
     Operador de asignación. :: asigna el valor de una expresión en su derecha a el valor de la cantidad en su izquierda, la cual debe evaluarse a una variable de tipo atómica o una variable subindicada.

 -- Operador: ::=
     El operador de definición de macros ::= define una función (llamada macro por razones históricas) que no evalúa sus argumentos, siendo la expresión que retorna (llamada "macroexpansión") evaluada dentro del contexto desde el cual se ha invocado la macro. En cualquier otro sentido, una función macro es igual que una función ordinaria.

     macroexpand devuelve la expresión que a su vez fue devuelta por una macro (sin evaluar la expresión); macroexpand (foo (x)) seguida de ''% es equivalente a foo (x) si foo es una función macro.

     ::= coloca el nombre de la nueva función macro en la lista global macros. Por otro lado, las funciones kill, remove y remfunction borran las definiciones de las funciones macro y eliminan sus nombres de la lista macros.

     Las funciones fundef y dispfun devuelven la definición de una función macro y le asignan una etiqueta, respectivamente.

     Las funciones macro normalmente contienen expresiones buildq y splice para construir una expresión, que luego será evaluada.

     Ejemplos:

     Una función macro no evalúa sus argumentos, por lo que el mensaje (1) muestra y - z, no el valor de y - z. La macroexpansión (es decir, la expresión no evaluada '(print ("(2) x is equal to", x))) se evalúa en el contexto desde el cual se produjo la llamada a la macro, imprimiendo el mensaje (2).

          (%i1) x: %pi;
          (%o1)                          %pi
          (%i2) y: 1234;
          (%o2)                         1234
          (%i3) z: 1729 * w;
          (%o3)                        1729 w
          (%i4) printq1 (x) ::=
                   block (print ("(1) x is equal to", x),
                   '(print ("(2) x is equal to", x)));
          (%o4) printq1(x) ::= block(print("(1) x is equal to", x),
                                          '(print("(2) x is equal to", x)))
          (%i5) printq1 (y - z);
          (1) x is equal to y - z
          (2) x is equal to %pi
          (%o5)                          %pi

     Una función ordinaria evalúa sus argumentos, por lo que el mensaje (1) muestra el valor de y - z. El valor de retorno no se evalúa, por lo que el mensaje (2) no se imprime hasta la evaluación explícita ''%.

          (%i1) x: %pi;
          (%o1)                          %pi
          (%i2) y: 1234;
          (%o2)                         1234
          (%i3) z: 1729 * w;
          (%o3)                        1729 w
          (%i4) printe1 (x) :=
                   block (print ("(1) x is equal to", x),
                         '(print ("(2) x is equal to", x)));
          (%o4) printe1(x) := block(print("(1) x is equal to", x),
                                          '(print("(2) x is equal to", x)))
          (%i5) printe1 (y - z);
          (1) x is equal to 1234 - 1729 w
          (%o5)              print((2) x is equal to, x)
          (%i6) ''%;
          (2) x is equal to %pi
          (%o6)                          %pi

     macroexpand devuelve la macroexpansión; macroexpand (foo (x)) seguida de ''% es equivalente a foo (x) si foo es una función macro.

          (%i1) x: %pi;
          (%o1)                          %pi
          (%i2) y: 1234;
          (%o2)                         1234
          (%i3) z: 1729 * w;
          (%o3)                        1729 w
          (%i4) g (x) ::= buildq ([x], print ("x is equal to", x));
          (%o4)    g(x) ::= buildq([x], print("x is equal to", x))
          (%i5) macroexpand (g (y - z));
          (%o5)              print(x is equal to, y - z)
          (%i6) ''%;
          x is equal to 1234 - 1729 w
          (%o6)                     1234 - 1729 w
          (%i7) g (y - z);
          x is equal to 1234 - 1729 w
          (%o7)                     1234 - 1729 w

 -- Operador: :=

     El operador de definición de funciones. La expresión F(X_1, ..., X_N) := EXPR define una función de nombre F con argumentos X_1, ..., X_N y cuerpo EXPR. El operador := no evalúa el cuerpo de la función (a menos que se indique lo contrario mediante el operador comilla-comilla ''). La función así definida puede ser una función ordinaria de Maxima (con argumentos encerrados entre paréntesis) o una función array (con argumentos encerrados entre corchetes).

     Cuando el último o único argumento X_N es una lista de un solo elemento, la función definida por := acepta un número variable de argumentos. Los valores de los argumentos se asignan uno a uno a los argumentos formales X_1, ..., X_(N - 1), y cualesquiera otros valores de argumentos, si existen, se asignan a X_N en forma de lista.

     Todas las definiciones de funciones aparecen en el mismo espacio de nombres; definiendo una función f dentro de otra función g no limita el alcance de f a g.

     Si un argumento formal X_K es un símbolo afectado por el operador comilla (expresión nominal), la función definida por := no evalúa el correspondiente valor de argumento. En cualquier otro caso, los argumentos que se pasan son evaluados.

     Véanse también define y ::=.

     Ejemplos:

     := no evalúa el cuerpo de la función (a menos que se indique lo contrario mediante el operador comilla-comilla '').

          (%i1) expr : cos(y) - sin(x);
          (%o1)                    cos(y) - sin(x)
          (%i2) F1 (x, y) := expr;
          (%o2)                   F1(x, y) := expr
          (%i3) F1 (a, b);
          (%o3)                    cos(y) - sin(x)
          (%i4) F2 (x, y) := ''expr;
          (%o4)              F2(x, y) := cos(y) - sin(x)
          (%i5) F2 (a, b);
          (%o5)                    cos(b) - sin(a)

     La función así definida puede ser una función ordinaria de Maxima o una función array.

          (%i1) G1 (x, y) := x.y - y.x;
          (%o1)               G1(x, y) := x . y - y . x
          (%i2) G2 [x, y] := x.y - y.x;
          (%o2)                G2     := x . y - y . x
                                 x, y

     Cuando el último o único argumento X_N es una lista de un solo elemento, la función definida por := acepta un número variable de argumentos.

          (%i1) H ([L]) := apply ("+", L);
          (%o1)                H([L]) := apply("+", L)
          (%i2) H (a, b, c);
          (%o2)                       c + b + a

 -- Operador: =
     Operador de ecuación.

     La expresión A = B representa una ecuación sin evaluar, la cual puede verificarse o no. Las ecuaciones sin evaluar pueden aparecer como argumentos de solve, algsys y de algunas otras funciones.

     La función is evalúa el operador = a un resultado booleano; is(A = B) asigna un valor de verdad a A = B, siendo true si A y B son idénticos, lo cual acontece si ambos A y B son átomos idénticos, o si no siendo átomos, sus operadores y argumentos respectivos son idénticos; en caso contrario, is(A = B) devuelve el valor  false. Nunca se devuelve el valor unknown. Cuando is(A = B) toma el valor true, se dice que A y B son sintácticamente iguales, no expresiones equivalentes, para las cuales is(equal(A, B)) devuelve true. Las expresiones pueden ser equivalentes, pero no sintácticamente iguales.

     La negación de = se representa por #. Como en el caso de =, la expresión A # B no está evaluada; sin embargo, is(A # B) evalúa A # B a true o false.

     Además de is, hay otros operadores que evalúan = y # a true o false; a saber, if, and, or y not.

     Nótese que debido a las reglas de evaluación de expresiones de tipo predicado (en concreto debido a que not EXPR obliga a la evaluación previa de EXPR), not A = B equivale a is(A # B), pero no a A # B.

     Las funciones rhs y lhs devuelven los miembros derecho e izquierdo, respectivamente, de una ecuación o inecuación.

     Véanse también equal y notequal.

     Ejemplos:

     La expresión A = B representa una ecuación sin evaluar, la cual puede verificarse o no.

          (%i1) eq_1 : a * x - 5 * y = 17;
          (%o1)                    a x - 5 y = 17
          (%i2) eq_2 : b * x + 3 * y = 29;
          (%o2)                    3 y + b x = 29
          (%i3) solve ([eq_1, eq_2], [x, y]);
                                  196         29 a - 17 b
          (%o3)          [[x = ---------, y = -----------]]
                               5 b + 3 a       5 b + 3 a
          (%i4) subst (%, [eq_1, eq_2]);
                   196 a     5 (29 a - 17 b)
          (%o4) [--------- - --------------- = 17,
                 5 b + 3 a      5 b + 3 a
                                            196 b     3 (29 a - 17 b)
                                          --------- + --------------- = 29]
                                          5 b + 3 a      5 b + 3 a
          (%i5) ratsimp (%);
          (%o5)                  [17 = 17, 29 = 29]

     is(A = B) evalúa A = B a true si A y B son sintácticamente iguales (es decir, idénticas). Las expresiones pueden ser equivalentes, pero no sintácticamente iguales.

          (%i1) a : (x + 1) * (x - 1);
          (%o1)                    (x - 1) (x + 1)
          (%i2) b : x^2 - 1;
                                        2
          (%o2)                        x  - 1
          (%i3) [is (a = b), is (a # b)];
          (%o3)                     [false, true]
          (%i4) [is (equal (a, b)), is (notequal (a, b))];
          (%o4)                     [true, false]

     Algunos operadores evalúan = y # a true o false.

          (%i1) if expand ((x + y)^2) = x^2 + 2 * x * y + y^2
                  then FOO else BAR;
          (%o1)                          FOO
          (%i2) eq_3 : 2 * x = 3 * x;
          (%o2)                       2 x = 3 x
          (%i3) eq_4 : exp (2) = %e^2;
                                        2     2
          (%o3)                       %e  = %e
          (%i4) [eq_3 and eq_4, eq_3 or eq_4, not eq_3];
          (%o4)                  [false, true, true]

     Debido a que not EXPR obliga a la evaluación previa de EXPR, not A = B equivale a is(A # B).

          (%i1) [2 * x # 3 * x, not (2 * x = 3 * x)];
          (%o1)                   [2 x # 3 x, true]
          (%i2) is (2 * x # 3 * x);
          (%o2)                         true

 -- Operador: and
     Operador de conjunción lógica. El operador and es un operador infijo n-ario; sus operandos son expresiones booleanas y su resultado es un valor lógico.

     El operador and impone la evaluación (igual que is) de uno o más operandos, y puede forzar la evaluación de todos los operandos.

     Los operandos se evalúan en el orden en el que aparecen; sólo evalúa tantos operandos como sean necesarios para determinar el resultado. Si algún operando vale false, el resultado es false y ya no se evalúan más operandos.

     La variable global prederror controla el comportamiento de and cuando la evaluación de un operando no da como resultado true o false; and imprime un mensaje de error cuando prederror vale true. Cuando los operandos devuelven un valor diferente a true o false al ser evaluados, el resultado es una expresión booleana.

     El operador and no es conmutativo: a and b puede no ser igual a b and a debido al tratamiento de operandos indeterminados.

 -- Operador: or
     Operador de disyunción lógica. El operador or es un operador infijo n-ario; sus operandos son expresiones booleanas y su resultado es un valor lógico.

     El operador or impone la evaluación (igual que is) de uno o más operandos, y puede forzar la evaluación de todos los operandos.

     Los operandos se evalúan en el orden en el que aparecen; or sólo evalúa tantos operandos como sean necesarios para determinar el resultado. Si un operando vale true, el resultado es true y ya no se evalúan más operandos.

     La variable global prederror controla el comportamiento de or cuando la evaluación de un operando no da como resultado true o false; or imprime un mensaje de error cuando prederror vale true. Cuando los operandos devuelven un valor diferente a true o false al ser evaluados, el resultado es una expresión booleana.

     El operador or no es conmutativo: a or b puede no ser igual a b or a debido al tratamiento de operandos indeterminados.

 -- Operador: not
     Operador de negación lógica. El operador not es un operador prefijo; su operando es una expresión booleana y su resultado es un valor lógico.

     El operador not impone la evaluación (igual que is) de su operando.

     La variable global prederror controla el comportamiento de not cuando la evaluación de su operando no da como resultado true o false; not imprime un mensaje de error cuando prederror vale true. Cuando los operandos devuelven un valor diferente a true o false al ser evaluados, el resultado es una expresión booleana.

 -- Función: abs (EXPR)
     Devuelve el valor absoluto de EXPR. Si la expresión es compleja, retorna el módulo de EXPR.

 -- Clave: additive
     Si declare(f,additive) ha sido ejecutado, entonces:

     (1) Si f es univariado, cada vez que el simplificador encuentre f aplicada a una suma, f será distribuida bajo esta suma. Por ejemplo, f(x+y) se simplificará a f(x)+f(y).

     (2) Si f es una función de 2 o más argumentos, aditivamente es definida como aditiva en el primer argumento de f, como en el caso de sum o integrate. Por ejemplo, f(h(x)+g(x),x) se simplificará a f(h(x),x)+f(g(x),x). Esta simplificación no ocurre cuando f se aplica a expresiones de la forma sum(x[i],i,lower-limit,upper-limit).

 -- Clave: allbut
     Opera con los comandos part (como part, inpart, substpart, substinpart, dpart y lpart). Por ejemplo:

          (%i1) expr : e + d + c + b + a;
          (%o1)                   e + d + c + b + a
          (%i2) part (expr, [2, 5]);
          (%o2)                         d + a

     mientras que:

          (%i1) expr : e + d + c + b + a;
          (%o1)                   e + d + c + b + a
          (%i2) part (expr, allbut (2, 5));
          (%o2)                       e + c + b

     La función kill también reconoce a allbut.

          (%i1) [aa : 11, bb : 22, cc : 33, dd : 44, ee : 55];
          (%o1)                 [11, 22, 33, 44, 55]
          (%i2) kill (allbut (cc, dd));
          (%o0)                         done
          (%i1) [aa, bb, cc, dd];
          (%o1)                   [aa, bb, 33, 44]

     La sentencia kill(allbut(A_1, A_2, ...)) tiene el mismo efecto que kill(all), excepto que no elimina los símbolos A_1, A_2, ... .

 -- Declaración: antisymmetric
     Si declare(h,antisymmetric) es ejecutado, esto dice al simplificador que h es antisimétrico. E.g. h(x,z,y) será simplificado a -h(x,y,z). Que es, el producto de (-1)^n por el resultado dado por symmetric o commutative, donde n es el número de intercambios necesarios de dos argumentos para convertirle a esta forma.

 -- Función: cabs (EXPR)
     Devuelve el valor absoluto complejo (módulo complejo) de EXPR.

 -- Función: ceiling (X)

     Si X es un número real, devuelve el menor entero mayor o igual que X.

     Si X es una expresión constante (por ejemplo, 10 * %pi), ceiling evalúa X haciendo uso de números grandes en coma flotante (big floats), aplicando a continuación ceiling al número decimal obtenido. Puesto que ceiling hace evaluaciones en coma flotante, es posible, pero improbable, que esta función devuelva un valor erróneo para entradas constantes. Para evitar estos errores, la evaluación en punto flotante se lleva a cabo utilizando tres valores para fpprec.

     Para argumentos no constantes, ceiling intenta devolver un valor simplificado. Aquí se presentan algunos ejemplos sobre las simplificaciones que ceiling es capaz de hacer:

          (%i1) ceiling (ceiling (x));
          (%o1)                      ceiling(x)
          (%i2) ceiling (floor (x));
          (%o2)                       floor(x)
          (%i3) declare (n, integer)$
          (%i4) [ceiling (n), ceiling (abs (n)), ceiling (max (n, 6))];
          (%o4)                [n, abs(n), max(n, 6)]
          (%i5) assume (x > 0, x < 1)$
          (%i6) ceiling (x);
          (%o6)                           1
          (%i7) tex (ceiling (a));
          $$\left \lceil a \right \rceil$$
          (%o7)                                false

     La función ceiling no se extiende automáticamente a los elementos de listas y matrices. Por último, para todos los argumentos que tengan una forma compleja, ceiling devuelve una forma nominal.

     Si el rango de una función es subconjunto de los números enteros, entonces puede ser declarada como integervalued. Tanto ceiling como floor son funciones que hacen uso de esta información; por ejemplo:

          (%i1) declare (f, integervalued)$
          (%i2) floor (f(x));
          (%o2)                         f(x)
          (%i3) ceiling (f(x) - 1);
          (%o3)                       f(x) - 1

 -- Función: charfun (P)

     Devuelve 0 cuando el predicado P toma el valor false, y devuelve 1 cuando vale true.  Si el predicado toma un valor diferente de true y false (desconocido), entonces devuelve una forma nominal.

     Ejemplos:

          (%i1) charfun(x<1);
          (%o1) charfun(x<1)
          (%i2) subst(x=-1,%);
          (%o2) 1
          (%i3) e : charfun('"and"(-1 < x, x < 1))$
          (%i4) [subst(x=-1,e), subst(x=0,e), subst(x=1,e)];
          (%o4) [0,1,0]

 -- Declaración: commutative
     Si declare(h,commutative) es ejecutado, le dice al simplificador que h es una función conmutaiva. Por ejemplo, h(x,z,y) se simplificará a h(x,y,z). Esto es lo mismo que symmetric.

 -- Función: compare (X, Y)

     Devuelve un operador de comparación OP (<, <=, >, >=, = o #) de manera que is (X OP Y) tome el valor true; cuando tanto X como Y dependan de %i y X # Y, devuelve notcomparable; cuando no exista tal operador o Maxima sea incapaz de determinarlo, devolverá unknown.

     Ejemplos:

          (%i1) compare(1,2);
          (%o1) <
          (%i2) compare(1,x);
          (%o2) unknown
          (%i3) compare(%i,%i);
          (%o3) =
          (%i4) compare(%i,%i+1);
          (%o4) notcomparable
          (%i5) compare(1/x,0);
          (%o5) #
          (%i6) compare(x,abs(x));
          (%o6) <=

     La función compare no intenta determinar si los dominios reales de sus argumentos son conjuntos no vacíos; así,

          (%i1) compare(acos(x^2+1), acos(x^2+1) + 1);
          (%o1) <

     Aquí, el dominio real de acos (x^2 + 1) es el conjunto vacío.

 -- Función: entier (X)
     Devuelve el mayor entero menor o igual a X, siendo X numérico. La función  fix (como en fixnum) es un sinónimo, de modo que fix(X) hace justamente lo mismo.

 -- Función: equal (A, B)
     Representa la equivalencia, esto es, la igualdad de los valores.

     Por sí misma, equal no evalúa ni simplifica. La función is intenta evaluar equal a un resultado booleano. La instrucción is(equal(A, B)) devuelve true (o false) si y sólo si A y B son iguales (o no iguales) para todos los posibles valores de sus variables, tal como lo determina ratsimp(A - B); si ratsimp devuelve 0, las dos expresiones se consideran equivalentes. Dos expresiones pueden ser equivalentes  sin ser sintácticamente iguales (es decir, idénticas).

     Si is no consigue reducir equal a true o false, el resultado está controlado por la variable global prederror. Si prederror vale true, is emite un mensaje de error; en caso contrario, is devuelve unknown.

     Además de is, otros operadores evalúan equal y notequal a  true o false; a saber, if, and, or y not.

     La negación de equal es notequal.

     Ejemplos:

     Por sí misma, equal no evalúa ni simplifica.

          (%i1) equal (x^2 - 1, (x + 1) * (x - 1));
                                  2
          (%o1)            equal(x  - 1, (x - 1) (x + 1))
          (%i2) equal (x, x + 1);
          (%o2)                    equal(x, x + 1)
          (%i3) equal (x, y);
          (%o3)                      equal(x, y)

     La función is intenta evaluar equal a un resultado booleano. La instrucción is(equal(A, B)) devuelve true si ratsimp(A - B) devuelve 0. Dos expresiones pueden ser equivalentes  sin ser sintácticamente iguales (es decir, idénticas).

          (%i1) ratsimp (x^2 - 1 - (x + 1) * (x - 1));
          (%o1)                           0
          (%i2) is (equal (x^2 - 1, (x + 1) * (x - 1)));
          (%o2)                         true
          (%i3) is (x^2 - 1 = (x + 1) * (x - 1));
          (%o3)                         false
          (%i4) ratsimp (x - (x + 1));
          (%o4)                          - 1
          (%i5) is (equal (x, x + 1));
          (%o5)                         false
          (%i6) is (x = x + 1);
          (%o6)                         false
          (%i7) ratsimp (x - y);
          (%o7)                         x - y
          (%i8) is (equal (x, y));
          (%o8)                        unknown
          (%i9) is (x = y);
          (%o9)                         false

     Si is no consigue reducir equal a true o false, el resultado está controlado por la variable global prederror.

          (%i1) [aa : x^2 + 2*x + 1, bb : x^2 - 2*x - 1];
                              2             2
          (%o1)             [x  + 2 x + 1, x  - 2 x - 1]
          (%i2) ratsimp (aa - bb);
          (%o2)                        4 x + 2
          (%i3) prederror : true;
          (%o3)                         true
          (%i4) is (equal (aa, bb));
          Maxima was unable to evaluate the predicate:
                 2             2
          equal(x  + 2 x + 1, x  - 2 x - 1)
           -- an error.  Quitting.  To debug this try debugmode(true);
          (%i5) prederror : false;
          (%o5)                         false
          (%i6) is (equal (aa, bb));
          (%o6)                        unknown

     Otros operadores evalúan equal y notequal a  true o false.

          (%i1) if equal (y, y - 1) then FOO else BAR;
          (%o1)                          BAR
          (%i2) eq_1 : equal (x, x + 1);
          (%o2)                    equal(x, x + 1)
          (%i3) eq_2 : equal (y^2 + 2*y + 1, (y + 1)^2);
                                   2                   2
          (%o3)             equal(y  + 2 y + 1, (y + 1) )
          (%i4) [eq_1 and eq_2, eq_1 or eq_2, not eq_1];
          (%o4)                  [false, true, true]

     Debido a que not EXPR obliga a la evaluación previa de EXPR, not equal(A, B) equivale a is(notequal(A, B)).

          (%i1) [notequal (2*z, 2*z - 1), not equal (2*z, 2*z - 1)];
          (%o1)            [notequal(2 z, 2 z - 1), true]
          (%i2) is (notequal (2*z, 2*z - 1));
          (%o2)                         true

 -- Función: floor (X)

     Si X es un número real, devuelve el mayor entero menor o igual que X.

     Si X es una expresión constante (por ejemplo, 10 * %pi), floor evalúa X haciendo uso de números grandes en coma flotante (big floats), aplicando a continuación floor al número decimal obtenido. Puesto que floor hace evaluaciones en coma flotante, es posible, pero improbable, que esta función devuelva un valor erróneo para entradas constantes. Para evitar estos errores, la evaluación en punto flotante se lleva a cabo utilizando tres valores para fpprec.

     Para argumentos no constantes, floor intenta devolver un valor simplificado. Aquí se presentan algunos ejemplos sobre las simplificaciones que floor es capaz de hacer:

          (%i1) floor (ceiling (x));
          (%o1)                      ceiling(x)
          (%i2) floor (floor (x));
          (%o2)                       floor(x)
          (%i3) declare (n, integer)$
          (%i4) [floor (n), floor (abs (n)), floor (min (n, 6))];
          (%o4)                [n, abs(n), min(n, 6)]
          (%i5) assume (x > 0, x < 1)$
          (%i6) floor (x);
          (%o6)                           0
          (%i7) tex (floor (a));
          $$\left \lfloor a \right \rfloor$$
          (%o7)                         false

     La función floor no se extiende automáticamente a los elementos de listas y matrices. Por último, para todos los argumentos que tengan una forma compleja, floor devuelve una forma nominal.

     Si el rango de una función es subconjunto de los números enteros, entonces puede ser declarada como integervalued. Tanto ceiling como floor son funciones que hacen uso de esta información; por ejemplo:

          (%i1) declare (f, integervalued)$
          (%i2) floor (f(x));
          (%o2)                         f(x)
          (%i3) ceiling (f(x) - 1);
          (%o3)                       f(x) - 1

 -- Función: notequal (A, B)
     Representa la negación de equal (A, B).

     Ejemplos:

          (%i1) equal (a, b);
          (%o1)                      equal(a, b)
          (%i2) maybe (equal (a, b));
          (%o2)                        unknown
          (%i3) notequal (a, b);
          (%o3)                    notequal(a, b)
          (%i4) not equal (a, b);
          (%o4)                    notequal(a, b)
          (%i5) maybe (notequal (a, b));
          (%o5)                        unknown
          (%i6) assume (a > b);
          (%o6)                        [a > b]
          (%i7) equal (a, b);
          (%o7)                      equal(a, b)
          (%i8) maybe (equal (a, b));
          (%o8)                         false
          (%i9) notequal (a, b);
          (%o9)                    notequal(a, b)
          (%i10) maybe (notequal (a, b));
          (%o10)                        true

 -- Operador: eval
     El operador eval realiza una evaluación extra de una expresión EXPR. Véase ev.

 -- Función: evenp (EXPR)
     Devuelve true si EXPR es un entero par y false en cualquier otro caso.

 -- Función: fix (X)
     Es un sinónimo de  entier (X).

 -- Función: fullmap (F, EXPR_1, ...)
     Similar a map, pero conservará el mapeado descendente de todas las subexpresiones hasta que los operadores principales ya no sean los mismos.

     La función fullmap es utilizada por el simplificador de Maxima en algunas transformaciones matriciales, por lo que Maxima generará en algunas ocasiones mensajes de error relacionados con fullmap aunque el usuario no haya invocado explícitamente esta función.

          (%i1) a + b * c;
          (%o1)                        b c + a
          (%i2) fullmap (g, %);
          (%o2)                   g(b) g(c) + g(a)
          (%i3) map (g, %th(2));
          (%o3)                     g(b c) + g(a)

 -- Función: fullmapl (F, LIST_1, ...)
     Similar a fullmap, pero fullmapl sólo hace mapeo sobre listas y matrices.

          (%i1) fullmapl ("+", [3, [4, 5]], [[a, 1], [0, -1.5]]);
          (%o1)                [[a + 3, 4], [4, 3.5]]

 -- Función: is (EXPR)
     Intenta determinar si el predicado EXPR  se puede deducir de los hechos almacenados en la base de datos gestionada por assume.

     Si el predicado se reduce a true o false, is devuelve true o false, respectivamente. En otro caso, el valor devuelto está controlado por la variable global prederror. Si prederror vale true, is emite un mensaje de error; en caso contrario, is devuelve unknown.

     La instrucción ev(EXPR, pred) (que puede escribirse como EXPR, pred en el modo interactivo) equivale a is(EXPR).

     Véanse también assume, facts y maybe.

     Ejemplos:

     is evalúa los predicados,

          (%i1) %pi > %e;
          (%o1)                       %pi > %e
          (%i2) is (%pi > %e);
          (%o2)                         true

     is intenta evaluar predicados a partir del conocimiento almacenado en la base de datos de assume.

          (%i1) assume (a > b);
          (%o1)                        [a > b]
          (%i2) assume (b > c);
          (%o2)                        [b > c]
          (%i3) is (a < b);
          (%o3)                         false
          (%i4) is (a > c);
          (%o4)                         true
          (%i5) is (equal (a, c));
          (%o5)                         false

     Si is no puede evaluar el valor lógico del predicado a partir de la base de datos gestionada por assume, la variable global  prederror controla el comportamiento de is.

          (%i1) assume (a > b);
          (%o1)                        [a > b]
          (%i2) prederror: true$
          (%i3) is (a > 0);
          Maxima was unable to evaluate the predicate:
          a > 0
           -- an error.  Quitting.  To debug this try debugmode(true);
          (%i4) prederror: false$
          (%i5) is (a > 0);
          (%o5)                        unknown

 -- Función: maybe (EXPR)
     Intenta determinar si el predicado EXPR  se puede deducir de los hechos almacenados en la base de datos gestionada por assume.

     Si el predicado se reduce a true o false, maybe devuelve true o false, respectivamente. En otro caso, maybe devuelve unknown.

     La función maybe es funcionalmente equivalente a is con prederror: false, pero el resultado se calcula sin asignar valor alguno a prederror.

     Véanse también assume, facts y is.

     Ejemplos:

          (%i1) maybe (x > 0);
          (%o1)                        unknown
          (%i2) assume (x > 1);
          (%o2)                        [x > 1]
          (%i3) maybe (x > 0);
          (%o3)                         true

 -- Función: isqrt (X)
     Devuelve la "raíz cuadrada entera" del valor absoluto de X, el cual debe ser un entero.

 -- Función: lmax (L)

     Si L es una lista o conjunto, devuelve apply ('max, args (L)).  Si L no es una lista o conjunto, envía un mensaje de error.

 -- Función: lmin (L)

     Si L es una lista o conjunto, devuelve apply ('min, args (L)).  Si L no es una lista o conjunto, envía un mensaje de error.

 -- Función: max (X_1, ..., X_N)
     Devuelve un valor simplificado de la mayor de las expresiones desde X_1 hasta X_N. Si get (trylevel, maxmin) es 2 o más, max aplica la simplificación max (e, -e) --> |e|.  Si get (trylevel, maxmin) es 3 o más, MAX intenta eliminar las expresiones que estén entre otros dos de los argumentos dados; por ejemplo, max (x, 2*x, 3*x) --> max (x, 3*x). Para asignar el valor 2 a trylevel se puede hacer put (trylevel, 2, maxmin).

 -- Función: min (X_1, ..., X_N)
     Devuelve un valor simplificado de la menor de las expresiones desde X_1 hasta X_N. Si get (trylevel, maxmin) es 2 o más, min aplica la simplificación min (e, -e) --> |e|.  Si get (trylevel, maxmin) es 3 o más, MIN intenta eliminar las expresiones que estén entre otros dos de los argumentos dados; por ejemplo, min (x, 2*x, 3*x) --> min (x, 3*x). Para asignar el valor 2 a trylevel se puede hacer put (trylevel, 2, maxmin).

 -- Función: polymod (P)
 -- Función: polymod (P, M)
     Convierte el polinomio P a una representación modular respecto del módulo actual, que es el valor almacenado en la variable modulus.

     La llamada polymod (P, M) especifica un módulo M para ser utilizado en lugar de valor almacenado en modulus.

     Véase modulus.

 -- Función: mod (X, Y)

     Si X e Y son números reales e Y es distinto de cero, devuelve X - Y * floor(X / Y). Para todos los reales X, se tiene mod (X, 0) = X. Para información sobre la definición de  mod (X, 0) = X, véase la sección 3.4 de "Concrete Mathematics", by Graham, Knuth, and Patashnik. La función mod (X, 1) es de diente de sierra con periodo unidad y con mod (1, 1) = 0 y mod (0, 1) = 0.

     Para encontrar el argumento principal (un número del intervalo (-%pi, %pi]) de un número complejo, hágase uso de la función X |-> %pi - mod (%pi - X, 2*%pi), donde X es un argumento.

     Si X e Y son expresiones constantes (por ejemplo, 10 * %pi), mod utiliza el mismo esquema de evaluación basado en números grandes en coma flotante (big floats) que floor y ceiling. También es posible, pero improbable, que mod pueda retornar un valor erróneo en tales casos.

     Para argumentos no numéricos X o Y, mod aplica algunas reglas de simplificación:

          (%i1) mod (x, 0);
          (%o1)                           x
          (%i2) mod (a*x, a*y);
          (%o2)                      a mod(x, y)
          (%i3) mod (0, x);
          (%o3)                           0

 -- Función: oddp (EXPR)
     Devuelve true si EXPR es un entero impar y false en caso contrario.

 -- Operador: pred
     El operador pred realiza una evaluación extra de un predicado (expresión cuya evaluación debe dar true o false). Véase ev.

 -- Función: make_random_state (N)
 -- Función: make_random_state (S)
 -- Función: make_random_state (true)
 -- Función: make_random_state (false)

     Un objeto de estado aleatorio representa el estado del generador de números aleatorios. El estado consiste en 627 cadenas binarias de 32 bits.

     La llamada make_random_state (N) devuelve un nuevo objeto de estado aleatorio creado a partir de una semilla entera igual a N módulo 2^32. El argumento N puede ser negativo.

     La llamada make_random_state (S) devuelve una copia del estado aleatorio S.

     La llamada make_random_state (true) devuelve un nuevo objeto de estado aleatorio, cuya semilla se genera a partir de la hora actual del reloj del sistema como semilla.

     La llamada make_random_state (false) devuelve una copia del estado actual del generador de números aleatorios.

 -- Función: set_random_state (S)
     Establece S como estado del generador de números aleatorios.

     La función set_random_state devuelve done en todo caso.

 -- Función: random (X)
     Devuelve un número seudoaleatorio. Si X es un entero, random (X) devuelve un entero entre 0 y X - 1, ambos inclusive. Si X es un decimal en punto flotante, random (X) devuelve un decimal no negativo en punto flotante menor que X. La función random emite un mensaje de error si X no es ni entero ni de punto flotante, o si X no es positivo.

     Las funciones make_random_state y set_random_state permiten controlar el estado del generador de números aleatorios.

     El generador de números aleatorios de Maxima implementa el algoritmo de Mersenne twister MT 19937.

     Ejemplos:

          (%i1) s1: make_random_state (654321)$
          (%i2) set_random_state (s1);
          (%o2)                         done
          (%i3) random (1000);
          (%o3)                          768
          (%i4) random (9573684);
          (%o4)                        7657880
          (%i5) random (2^75);
          (%o5)                11804491615036831636390
          (%i6) s2: make_random_state (false)$
          (%i7) random (1.0);
          (%o7)                   .2310127244107132
          (%i8) random (10.0);
          (%o8)                   4.394553645870825
          (%i9) random (100.0);
          (%o9)                   32.28666704056853
          (%i10) set_random_state (s2);
          (%o10)                        done
          (%i11) random (1.0);
          (%o11)                  .2310127244107132
          (%i12) random (10.0);
          (%o12)                  4.394553645870825
          (%i13) random (100.0);
          (%o13)                  32.28666704056853

 -- Función: rationalize (EXPR)
     Convierte todos los números en coma flotante de doble precisión y grandes (big float) presentes en una expresión EXPR de Maxima a sus formas racionales exactas equivalentes. Si el usuario no está familiarizado con la representación binaria de números en coma flotante, le puede extrañar que rationalize (0.1) no sea igual que 1/10.  Este comportamiento no es único de Maxima, ya que el número 1/10 en su forma binaria es periódico y no exacto.

          (%i1) rationalize (0.5);
                                          1
          (%o1)                           -
                                          2
          (%i2) rationalize (0.1);
                                         1
          (%o2)                          --
                                         10
          (%i3) fpprec : 5$
          (%i4) rationalize (0.1b0);
                                       209715
          (%o4)                        -------
                                       2097152
          (%i5) fpprec : 20$
          (%i6) rationalize (0.1b0);
                               236118324143482260685
          (%o6)                ----------------------
                               2361183241434822606848
          (%i7) rationalize (sin (0.1*x + 5.6));
                                        x    28
          (%o7)                     sin(-- + --)
                                        10   5

     Ejemplo de uso:

          (%i1) unitfrac(r) := block([uf : [], q],
              if not(ratnump(r)) then
                error("The input to 'unitfrac' must be a rational number"),
              while r # 0 do (
                  uf : cons(q : 1/ceiling(1/r), uf),
                  r : r - q),
              reverse(uf));
          (%o1) unitfrac(r) := block([uf : [], q],
          if not ratnump(r) then
            error("The input to 'unitfrac' must be a rational number"),
                                               1
          while r # 0 do (uf : cons(q : ----------, uf), r : r - q),
                                                   1
                                           ceiling(-)
                                                   r
          reverse(uf))
                                      1  1  1
          (%o2)                      [-, -, --]
                                      2  3  15
          (%i3) unitfrac (9/10);
                                         9
          (%o3)                          --
                                         10
          (%i4) apply ("+", %);
                                            1
          (%o4)                       [- 1, --]
                                            10
          (%i5) unitfrac (-9/10);
                                          9
          (%o5)                         - --
                                          10
          (%i6) apply ("+", %);
                                  1  1  1  1    1
          (%o6)                  [-, -, -, --, ----]
                                  2  3  8  69  6808
          (%i7) unitfrac (36/37);
                                         36
          (%o7)                          --
                                         37
          (%i8) apply ("+", %);

 -- Función: sign (EXPR)
     Intenta determinar el signo de EXPR en base a los hechos almacenados en la base de datos. Devuelve una de las siguientes respuestas: pos (positivo), neg (negativo), zero (cero), pz (positivo o cero), nz (negativo o cero), pn (positivo o negativo), o pnz (positivo, negativo o cero, lo que significa que el signo es desconocido).

 -- Función: signum (X)
     Para X numérico, devuelve 0 si X es 0, en caso contrario devuelve -1 o +1, según que X sea menor o mayor que 0, respectivamente.

     Si X no es numérico, entonces se devuelve una forma simplificada equivalente. Por ejemplo, signum(-x) devuelve -signum(x).

 -- Función: sort (L, P)
 -- Función: sort (L)
     Ordena la lista L de acuerdo con el predicado P de dos argumentos, de tal manera que P (L[k], L[k + 1]) es true (verdadero) para cualesquiera dos elementos sucesivos. El predicado se puede especificar como nombre de una función o de un operador infijo binario, o como una expresión lambda. Si se especifica con el nombre de un operador, este nombre debe encerrarse con "comillas dobles".

     La lista ordenada se devuelve como un objeto nuevo, de manera que el argumento L no se ve alterado. A fin de construir el valor de retorno, sort hace una copia previa de los elementos de L.

     Si el predicado P no ordena totalmente los elementos de L, entonces sort puede seguir ejecutándose hasta el final sin emitir errores, pero el resultado no es predecible. La función muestra un mensaje de error en caso de que el predicado devuelva algo diferente de true o false.

     La llamada sort (L) equivale a sort (L, orderlessp); esto es, el orden por defecto es el ascendente, tal como queda definido por orderlessp. Todos los átomos y expresiones de Maxima son comparables para orderlessp, aunque existen ejemplos aislados de expresiones para las cuales orderlessp deja de ser transitivo; se trata de un fallo de Maxima.

     Ejemplos:

          (%i1) sort ([11, -17, 29b0, 7.55, 3, -5/2, b + a, 9 * c, 19 - 3 * x]);
                         5
          (%o1) [- 17, - -, 3, 7.55, 11, 2.9b1, b + a, 9 c, 19 - 3 x]
                         2
          (%i2) sort ([11, -17, 29b0, 7.55, 3, -5/2, b + a, 9 * c, 19 - 3 * x],
                    ordergreatp);
                                                             5
          (%o2) [19 - 3 x, 9 c, b + a, 2.9b1, 11, 7.55, 3, - -, - 17]
                                                             2
          (%i3) sort ([%pi, 3, 4, %e, %gamma]);
          (%o3)                [3, 4, %e, %gamma, %pi]
          (%i4) sort ([%pi, 3, 4, %e, %gamma], "<");
          (%o4)                [%gamma, %e, 3, %pi, 4]
          (%i5) my_list : [[aa, hh, uu], [ee, cc], [zz, xx, mm, cc], [%pi, %e]];
          (%o5) [[aa, hh, uu], [ee, cc], [zz, xx, mm, cc], [%pi, %e]]
          (%i6) sort (my_list);
          (%o6) [[%pi, %e], [aa, hh, uu], [ee, cc], [zz, xx, mm, cc]]
          (%i7) sort (my_list, lambda ([a, b],
                                       orderlessp (reverse (a), reverse (b))));
          (%o7) [[%pi, %e], [ee, cc], [zz, xx, mm, cc], [aa, hh, uu]]

 -- Función: sqrt (X)
     Raíz cuadrada de X. Se representa internamente por X^(1/2).  Véase también rootscontract.

     Si la variable radexpand vale true hará que las raíces n-ésimas de los factores de un producto que sean potencias de n sean extraídas del radical; por ejemplo, sqrt(16*x^2) se convertirá en 4*x sólo si radexpand vale true.

 -- Variable opcional: sqrtdispflag
     Valor por defecto: true

     Si sqrtdispflag vale false, hará que sqrt se muestre con el exponente 1/2.

 -- Función: sublis (LIST, EXPR)
     Realiza sustituciones  múltiples en paralelo en una expresión.

     La variable sublis_apply_lambda controla la simplificación después de sublis.

     Ejemplo:

          (%i1) sublis ([a=b, b=a], sin(a) + cos(b));
          (%o1)                    sin(b) + cos(a)

 -- Función: sublist (LIST, P)
     Devuelve la lista de elementos de LIST para los cuales el predicado p retorna true.

     Ejemplo:

          (%i1) L: [1, 2, 3, 4, 5, 6];
          (%o1)                  [1, 2, 3, 4, 5, 6]
          (%i2) sublist (L, evenp);
          (%o2)                       [2, 4, 6]

 -- Variable opcional: sublis_apply_lambda
     Valor por defecto: true

     Controla si los lambda sustituidos son aplicados en la simplificación después de invocar a sublis, o si se tiene que hacer un ev para hacerlo. Si sublis_apply_lambda vale true, significa que se ejecute la aplicación.

 -- Función: subst (A, B, C)
     Sustituye A por B en C. El argumento  B debe ser un átomo o una subexpresión completa de C.  Por ejemplo, x+y+z es una subexpresión completa de  2*(x+y+z)/w mientras que x+y no lo es. Cuando B no cumple esta característica, se puede utilizar en algunos casos substpart o ratsubst (ver más abajo).  Alternativamente, si B no es de la forma e/f entonces se puede usar subst (a*f, e, c), pero si B es de la forma e^(1/f) se debe usar subst (a^f, e, c).  La instrucción subst también reconoce x^y en x^-y, de manera que  subst (a, sqrt(x), 1/sqrt(x)) da 1/a. Los argumentos A y B también pueden ser operadores de una expresión acotados por comillas dobles " o nombres de funciones.  Si se quiere sustituir la variable independiente en expresiones con derivadas se debe utilizar la función at (ver más abajo).

     La función subst es sinónimo de substitute.

     La llamada subst (EQ_1, EXPR) o subst ([EQ_1, ..., EQ_K], EXPR) están permitidas.  Las EQ_I son ecuaciones que indican las sustituciones a realizar. Para cada ecuación, el miembro derecho será sustituida por la expresión del miembro izquierdo en EXPR.

     Si la variable exptsubst vale true se permiten ciertas sustituciones de exponentes; por ejemplo, sustituir y por %e^x en %e^(a*x).

     Si opsubst vale false, subst no intentará sustituir un operador de una expresión. Por ejemplo, (opsubst: false, subst (x^2, r, r+r[0])) trabajará sin problemas.

     Ejemplos:

          (%i1) subst (a, x+y, x + (x+y)^2 + y);
                                              2
          (%o1)                      y + x + a
          (%i2) subst (-%i, %i, a + b*%i);
          (%o2)                       a - %i b

     Para más ejemplos, ejecútese example (subst).

 -- Función: substinpart (X, EXPR, N_1, ..., N_K)
     Es similar a substpart, pero substinpart trabaja con la representación interna de EXPR.

          (%i1) x . 'diff (f(x), x, 2);
                                        2
                                       d
          (%o1)                   x . (--- (f(x)))
                                         2
                                       dx
          (%i2) substinpart (d^2, %, 2);
                                            2
          (%o2)                        x . d
          (%i3) substinpart (f1, f[1](x + 1), 0);
          (%o3)                       f1(x + 1)

     Si el último argumento de la función part es una lista de índices, entonces se toman varias subexpresiones, cada una de las cuales en correspondencia con un índice de la lista. Así,

          (%i1) part (x+y+z, [1, 3]);
          (%o1)                         z + x

     piece guarda el valor de la última expresión seleccionada cada vez que se utiliza la función part. Esta asignación se se hace durante la ejecución de la función, con lo que puede ser referenciada en la propia función tal como se muestra más abajo. Si partswitch vale true entonces se devuelve end cuando la parte seleccionada de una expresión no existe, en caso contrario se muestra un mensaje de error.

          (%i1) expr: 27*y^3 + 54*x*y^2 + 36*x^2*y + y + 8*x^3 + x + 1;
                        3         2       2            3
          (%o1)     27 y  + 54 x y  + 36 x  y + y + 8 x  + x + 1
          (%i2) part (expr, 2, [1, 3]);
                                            2
          (%o2)                         54 y
          (%i3) sqrt (piece/54);
          (%o3)                        abs(y)
          (%i4) substpart (factor (piece), expr, [1, 2, 3, 5]);
                                         3
          (%o4)               (3 y + 2 x)  + y + x + 1
          (%i5) expr: 1/x + y/x - 1/z;
                                       1   y   1
          (%o5)                      - - + - + -
                                       z   x   x
          (%i6) substpart (xthru (piece), expr, [2, 3]);
                                      y + 1   1
          (%o6)                       ----- - -
                                        x     z

     Además, darle a la opción inflag el valor true y llamar a part o a substpart es lo mismo que llamar a inpart o a substinpart.

 -- Función: substpart (X, EXPR, N_1, ..., N_K)
     Sustituye X por la subexpresión determinada por el resto de argumentos, según el esquema de part.  Devuelve el nuevo valor de EXPR. El argumento  X puede ser un operador a ser sustituido por un operador de EXPR. En algunos casos X necesita estar acotado por comillas dobles ", como en substpart ("+", a*b, 0) para que retorne b + a.

          (%i1) 1/(x^2 + 2);
                                         1
          (%o1)                        ------
                                        2
                                       x  + 2
          (%i2) substpart (3/2, %, 2, 1, 2);
                                         1
          (%o2)                       --------
                                       3/2
                                      x    + 2
          (%i3) a*x + f (b, y);
          (%o3)                     a x + f(b, y)
          (%i4) substpart ("+", %, 1, 0);
          (%o4)                    x + f(b, y) + a

     Además, darle a la opción inflag el valor true y llamar a part o a substpart es lo mismo que llamar a inpart o a substinpart.

 -- Función: subvarp (EXPR)
     Devuelve true si EXPR es una variable subindicada, como a[i].

 -- Función: symbolp (EXPR)
     Devuelve true si EXPR es un símbolo y false en caso contrario. La llamada symbolp(x) equivale al predicado atom(x) and not numberp(x).

     Véase también Identifiers.

 -- Función: unorder ()
     Desactiva las asociaciones creadas por la última utilización de los comandos de ordenación ordergreat y orderless, los cuales no pueden ser utilizados más de una vez sin invocar a unorder. Véase también ordergreat y orderless.

          (%i1) unorder();
          (%o1)                          []
          (%i2) b*x + a^2;
                                             2
          (%o2)                       b x + a
          (%i3) ordergreat (a);
          (%o3)                         done
          (%i4) b*x + a^2;
           %th(1) - %th(3);
                                       2
          (%o4)                       a  + b x
          (%i5) unorder();
                                        2    2
          (%o5)                        a  - a

 -- Función: vectorpotential (GIVENCURL)
     Devuelve el vector potencial de un vector rotacional en el sistema de coordenadas actual. potentialzeroloc tiene un rol similar al de potential, pero el orden del miembro izquierdo de las ecuaciones debe ser una permutación cíclica de las coordenadas.

 -- Función: xthru (EXPR)
     Combina todos los términos de EXPR (la cual debe ser una suma) sobre un común denominador sin expandir productos ni sumas elevadas a exponentes al modo que lo hace ratsimp. La función xthru cancela factores comunes en el numerador y denominador de expresiones racionales, pero sólo si los factores son explícitos.

     En ocasiones puede ser útil el uso de xthru antes de la llamada a ratsimp a fin de cancelar factores explícitos del máximo común divisor del numerador y denominador y así simplificar la expresión a la que se va a aplicar ratsimp.

          (%i1) ((x+2)^20 - 2*y)/(x+y)^20 + (x+y)^(-19) - x/(x+y)^20;
           xthru (%);
                                          20
                           1       (x + 2)   - 2 y       x
          (%o1)        --------- + --------------- - ---------
                              19             20             20
                       (y + x)        (y + x)        (y + x)

 -- Función: zeroequiv (EXPR, V)
     Analiza si la expresión EXPR de variable V equivale a cero, devolviendo true, false o dontknow.

     La función zeroequiv tiene estas restricciones:

      1. No utilizar funciones que Maxima no sepa derivar y evaluar.

      2. Si la expresión tiene polos en la recta real, pueden aparecer errores en el resultado, aunque es poco probable.

      3. Si la expresión contiene funciones que no son soluciones de ecuaciones diferenciales ordinarias de primer orden (como las funciones de Bessel) pueden presentarse resultados incorrectos.

      4. El algoritmo utiliza evaluaciones en puntos aleatoriamente seleccionados. Esto conlleva un riesgo,aunque el algoritmo intenta minimizar el error.

     Por ejemplo, zeroequiv (sin(2*x) - 2*sin(x)*cos(x), x) devuelve true y zeroequiv (%e^x + x, x) devuelve false. Por otro lado zeroequiv (log(a*b) - log(a) - log(b), a) devuelve dontknow debido a la presencia del parámetro b.