[ < ] | [ > ] | [ << ] | [ Up ] | [ >> ] | [Top] | [Contents] | [Index] | [ ? ] |
5.1 n-arios | ||
5.2 no-fijos | ||
5.3 postfijos | ||
5.4 prefijos | ||
5.5 Operadores aritméticos | ||
5.6 Operadores relacionales | ||
5.7 Operadores generales |
[ < ] | [ > ] | [ << ] | [ Up ] | [ >> ] | [Top] | [Contents] | [Index] | [ ? ] |
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
.
[ < ] | [ > ] | [ << ] | [ Up ] | [ >> ] | [Top] | [Contents] | [Index] | [ ? ] |
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
.
[ < ] | [ > ] | [ << ] | [ Up ] | [ >> ] | [Top] | [Contents] | [Index] | [ ? ] |
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
.
[ < ] | [ > ] | [ << ] | [ Up ] | [ >> ] | [Top] | [Contents] | [Index] | [ ? ] |
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
.
[ < ] | [ > ] | [ << ] | [ Up ] | [ >> ] | [Top] | [Contents] | [Index] | [ ? ] |
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 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
[ < ] | [ > ] | [ << ] | [ Up ] | [ >> ] | [Top] | [Contents] | [Index] | [ ? ] |
[ < ] | [ > ] | [ << ] | [ Up ] | [ >> ] | [Top] | [Contents] | [Index] | [ ? ] |
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
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
factlim
.
(%i1) factlim : 10; (%o1) 10 (%i2) [0!, (7/2)!, 4.77!, 8!, 20!]; 105 sqrt(%pi) (%o2) [1, -------------, 81.44668037931199, 40320, 20!] 16
%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]
(%i1) kill (foo); (%o1) done (%i2) foo!; (%o2) foo!
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]
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)
.
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
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 de asignación.
Cuando el miembro de la izquierda es un átomo o variable subindicada,
:
evalúa la expresión de la derecha (pero no la izquierda) y asigna ese
valor a la variable del lado izquierdo.
Cuando en el lado izquierdo hay un elemento subindicado correspondiente a una lista, matriz, array declarado de Maxima o array de Lisp, la expresión de la derecha se asigna a ese elemento. El subíndice debe hacer referencia a un elemento ya existente, ya que los objetos anteriores no pueden ampliarse nombrando elementos no existentes.
Cuando en el lado izquierdo hay un elemento subindicado correspondiente a un array no declarado de Maxima, la expresión de la derecha se asigna a ese elemento en caso de que ya exista, o a un nuevo elemento, si éste todavía no existe.
Cuando el miembro de la izquierda es una lista de átomos y/o variables subindicadas, el miembro derecho debe evaluar también a una lista, cuyos elementos serán asignados en paralelo a las variables de la lista de la izquierda.
Véanse también kill
y remvalue
, que deshacen las asociaciones
hechas por el operador :
.
Ejemplos:
Asignación a un símbolo.
(%i1) a; (%o1) a (%i2) a : 123; (%o2) 123 (%i3) a; (%o3) 123
Asignación a un elemento de una lista.
(%i1) b : [1, 2, 3]; (%o1) [1, 2, 3] (%i2) b[3] : 456; (%o2) 456 (%i3) b; (%o3) [1, 2, 456]
La asignación crea un array no declarado.
(%i1) c[99] : 789; (%o1) 789 (%i2) c[99]; (%o2) 789 (%i3) c; (%o3) c (%i4) arrayinfo (c); (%o4) [hashed, 1, [99]] (%i5) listarray (c); (%o5) [789]
Asignación múltiple.
(%i1) [a, b, c] : [45, 67, 89]; (%o1) [45, 67, 89] (%i2) a; (%o2) 45 (%i3) b; (%o3) 67 (%i4) c; (%o4) 89
La asignación múltiple se hace en paralelo. Los valores
de a
y b
se intercambian en este ejemplo.
(%i1) [a, b] : [33, 55]; (%o1) [33, 55] (%i2) [a, b] : [b, a]; (%o2) [55, 33] (%i3) a; (%o3) 55 (%i4) b; (%o4) 33
Operador de asignación.
El operador ::
es similar a :
, excepto que ::
evalúa ambos miembros, tanto el derecho como el izquierdo.
Ejemplos:
(%i1) x : 'foo; (%o1) foo (%i2) x :: 123; (%o2) 123 (%i3) foo; (%o3) 123 (%i4) x : '[a, b, c]; (%o4) [a, b, c] (%i5) x :: [11, 22, 33]; (%o5) [11, 22, 33] (%i6) a; (%o6) 11 (%i7) b; (%o7) 22 (%i8) c; (%o8) 33
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
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 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 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 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 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.
Devuelve el valor absoluto de expr. Si la expresión es compleja, retorna el módulo de expr.
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)
.
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, ... .
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.
Devuelve el valor absoluto complejo (módulo complejo) de expr.
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
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]
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
.
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.
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.
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
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
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
El operador eval
realiza una evaluación extra de una expresión expr.
Véase ev
.
Devuelve true
si expr es un entero par y false
en cualquier otro caso.
Es un sinónimo de entier (x)
.
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)
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]]
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
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
Devuelve la "raíz cuadrada entera" del valor absoluto de x, el cual debe ser un entero.
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.
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.
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)
.
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)
.
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
.
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
Devuelve true
si expr es un entero impar y false
en caso contrario.
El operador pred
realiza una evaluación extra de un predicado (expresión cuya evaluación debe dar true
o false
). Véase ev
.
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.
Establece s como estado del generador de números aleatorios.
La función set_random_state
devuelve done
en todo caso.
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
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 ("+", %);
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).
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)
.
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]]
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
.
Valor por defecto: true
Si sqrtdispflag
vale false
, hará que sqrt
se muestre con el exponente 1/2.
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)
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]
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.
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)
.
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
.
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
.
Devuelve true
si expr es una variable subindicada, como a[i]
.
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
.
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
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.
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)
Analiza si la expresión expr de variable v equivale a cero, devolviendo true
, false
o
dontknow
.
La función zeroequiv
tiene estas restricciones:
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 Robert Dodier on diciembre, 22 2007 using texi2html 1.76.