[ < ] | [ > ] | [ << ] | [ Up ] | [ >> ] | [Top] | [Contents] | [Index] | [ ? ] |
5.1 n-arios | ||
5.2 no-fijos | ||
5.3 operadores | ||
5.4 postfijos | ||
5.5 prefijos | ||
5.6 Definiciones para Operadores |
[ < ] | [ > ] | [ << ] | [ 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)
.
Funciones relacionadas: 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
.
Funciones relacionadas syntax
.
[ < ] | [ > ] | [ << ] | [ Up ] | [ >> ] | [Top] | [Contents] | [Index] | [ ? ] |
Véase operadores
.
[ < ] | [ > ] | [ << ] | [ 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
.
Funciones relacionadas: 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
.
Funciones relacionadas: syntax
.
[ < ] | [ > ] | [ << ] | [ Up ] | [ >> ] | [Top] | [Contents] | [Index] | [ ? ] |
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
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 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
.
El operador de asignación. Por ejemplo, A:3
se asigna a la variable A el valor de 3.
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.
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. Por ejemplo, f(x):=sin(x)
define
una función f
.
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 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 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
.
Devuelve el valor absoluto de expr. Si la expresión es compleja, retorna el módulo de expr.
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)
.
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
.
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 equal(a, b)
equivale a is(notequal(a, b))
,
pero no a notequal(a, b)
.
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)); Maxima was unable to evaluate the predicate: equal(x, y) -- an error. Quitting. To debug this try debugmode(true); (%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 (a, b) then FOO else BAR; Maxima was unable to evaluate the predicate: equal(a, b) -- an error. Quitting. To debug this try debugmode(true); (%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)
.
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 equal(a, b)
equivale a is(notequal(a, b))
,
pero no a notequal(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); Maxima 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 |
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 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 root on noviembre, 10 2006 using texi2html 1.76.