[ < ] [ > ]   [ << ] [ Up ] [ >> ]         [Top] [Contents] [Index] [ ? ]

5. Operadores


[ < ] [ > ]   [ << ] [ Up ] [ >> ]         [Top] [Contents] [Index] [ ? ]

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

Funciones relacionadas: syntax.


[ < ] [ > ]   [ << ] [ Up ] [ >> ]         [Top] [Contents] [Index] [ ? ]

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

Funciones relacionadas syntax.


[ < ] [ > ]   [ << ] [ Up ] [ >> ]         [Top] [Contents] [Index] [ ? ]

5.3 operadores

Véase operadores.


[ < ] [ > ]   [ << ] [ Up ] [ >> ]         [Top] [Contents] [Index] [ ? ]

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

Funciones relacionadas: syntax.


[ < ] [ > ]   [ << ] [ Up ] [ >> ]         [Top] [Contents] [Index] [ ? ]

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

Funciones relacionadas: syntax.


[ < ] [ > ]   [ << ] [ Up ] [ >> ]         [Top] [Contents] [Index] [ ? ]

5.6 Definiciones para Operadores

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 la función gamma. makegamma substituye a gamma para factoriales y funciones relacionadas.

Funciones relacionadas: binomial

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

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 no será equivalente a a # b en algunos casos.

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
operator: ":="

El operador de definición de funciones. Por ejemplo, f(x):=sin(x) define una función f.

Operador: "="

Denota una ecuación para Maxima. El patrón de emparejamiento en Maxima denota una relación total que se sostiene entre dos expresiones si y sólo si las expresiones son sintácticamente idénticas.

La negación de = se representa por #. 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 no será equivalente a a # b en algunos casos.

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; and sólo evalúa tantos operandos como sean necesarios para determinar el resultado. Si un 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. En caso contrario, and devuelve unknown.

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. En caso contrario, and devuelve unknown.

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. En caso contrario, not devuelve unknown.

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 declate(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 aplia 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$
(%i2) part (expr, [2, 5]);
(%o2)                         d + a

mientras que:

 
(%i3) part (expr, allbut (2, 5));
(%o3)                       e + c + b

También trabaja con el comando kill,

 
kill (allbut (name_1, ..., name_k))

lo cual hará un kill(all) excepto a aquellos nombres especificados a kill, en este caso. Nota: name_i representa un nombre de función tal como u, f, foo o g, no una lista como functions.

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

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 (expr_1, expr_2)

Utilizado junto con is, devuelve true (o false) si y sólo si expr_1 y expr_2 son iguales (o no) para todos los posibles valores de sus variables (tal como los calcula ratsimp). Así, is (equal ((x + 1)^2, x^2 + 2*x + 1)) devuelve true, mientras que si x no tiene valor asignado, is ((x + 1)^2 = x^2 + 2*x + 1) devuelve false. Nótese también que is(rat(0)=0) da false pero is (equal (rat(0), 0)) da true.

Si algún cálculo no se puede hacer, is (equal (a, b)) devuelve una expresión simplificada y equivalente, mientras que is (a=b) siempre devuelve true o false.

Todas las variables presentes en expr_1 y expr_2 se suponen números reales.

La negación de equal es notequal. 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), notequal no será equivalente a not equal en algunos casos.

La llamada ev (expr, pred) equivale a is (expr).

 
(%i1) is (x^2 >= 2*x - 1);
(%o1)                         true
(%i2) assume (a > 1);
(%o2)                        [a > 1]
(%i3) is (log (log (a+1) + 1) > 0 and a^2 + 1 > 2*a);
(%o3)                         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)$
(%i3) [floor(n), floor(abs(n)), floor(min(n,6))];
(%o4) [n,abs(n),min(n,6)]
(%i4) assume(x > 0, x < 1)$
(%i5) floor(x);
(%o5) 0
(%i6) tex(floor(a);
    $$\left \lfloor a \right \rfloor$$

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 (expr_1, expr_2)

Representa la negación de equal (expr_1, expr_2).

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), notequal no será equivalente a not equal en algunos casos.

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);
`macsyma' was unable to evaluate the predicate:
equal(a, b)
 -- an error.  Quitting.  To debug this try debugmode(true);
(%i5) maybe (notequal (a, b));
(%o5)                        unknown
(%i6) maybe (not equal (a, b));
(%o6)                        unknown
(%i7) assume (a > b);
(%o7)                        [a > b]
(%i8) equal (a, b);
(%o8)                      equal(a, b)
(%i9) maybe (equal (a, b));
(%o9)                         false
(%i10) notequal (a, b);
(%o10)                   notequal(a, b)
(%i11) not equal (a, b);
(%o11)                        true
(%i12) maybe (notequal (a, b));
(%o12)                        true
(%i13) maybe (not equal (a, b));
(%o13)                        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$
(%i2) fullmap (g, %);
(%o2)                   g(b) g(c) + g(a)
(%i3) map (g, %th(2));
(%o3)                     g(b c) + g(a)
Function: 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 false, is devuelve unknown si el predicado no se puede reducir a un valor de verdad lógica, retornando un mensaje de error si prederror vale true.

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

Ejemplos:

is hace evaluación de predicados.

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

is evalúa predicados a partir de 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);
`macsyma' 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 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);
(%o1) 1/2
(%i2) rationalize(0.1);
(%o2) 3602879701896397/36028797018963968
(%i3) fpprec : 5$
(%i4) rationalize(0.1b0);
(%o4) 209715/2097152
(%i5) fpprec : 20$
(%i6) rationalize(0.1b0);
(%o6) 236118324143482260685/2361183241434822606848
(%i7) rationalize(sin(0.1 * x + 5.6));
(%o7) sin((3602879701896397*x)/36028797018963968+3152519739159347/562949953421312)

Ejemplo de uso:

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

(%i2) unitfrac(9/10);
(%o2) [1/2,1/3,1/15]
(%i3) apply("+",%);
(%o3) 9/10
(%i4) unitfrac(-9/10);
(%o4) [-1,1/10]
(%i5) apply("+",%);
(%o5) -9/10
(%i6) unitfrac(36/37);
(%o6) [1/2,1/3,1/8,1/69,1/6808]
(%i7) apply("+",%);
(%o7) 36/37   
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 (list, p)
Función: sort (list)

Ordena list de acuerdo con el predicado p de dos argumentos, como "<" o orderlessp.

La llamada sort (list) ordena list de acuerdo con la ordenación preestablecida en Maxima.

El argumento list puede contener elementos numéricos o no numéricos o de de ambos tipos.

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 se 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]$
(%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;
                             2
(%o4)                       a  + b x
(%i5) %th(1) - %th(3);
                              2    2
(%o5)                        a  - a
(%i6) unorder();
(%o6)                          [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;
                                20
                 1       (x + 2)   - 2 y       x
(%o1)        --------- + --------------- - ---------
                    19             20             20
             (y + x)        (y + x)        (y + x)
(%i2) xthru (%);
                                 20
                          (x + 2)   - y
(%o2)                     -------------
                                   20
                            (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.


[ << ] [ >> ]           [Top] [Contents] [Index] [ ? ]

This document was generated by root on octubre, 3 2006 using texi2html 1.76.