Manual de Maxima

1
Manual de Maxima
Maxima es un sistema de calculo simbolico escrito en Lisp.
Maxima desciende del sistema Macsyma, desarrollado en el MIT (Massachusetts Institute
of Technology) entre los a nos 1968 y 1982 como parte del proyecto MAC. El MIT paso una
copia del codigo fuente al DOE (Department of Energy) en 1982, en una version conocida
como DOE-Macsyma. Una de estas copias fue mantenida por el Profesor William F. Schelter
de la Universidad de Texas desde el a no 1982 hasta su fallecimiento en 2001. En 1998
Schelter haba obtenido del Departamento de Energa permiso para distribuir el codigo
fuente de DOE-Macsyma bajo licencia GNU-GPL, iniciando en el a no 2000 el proyecto
Maxima en SourceForge con el n de mantener y seguir desarrollando DOE-Macsyma,
ahora con el nombre de Maxima.
Notas de la traduccion espa nola.
La primera traduccion al espa nol del manual de Maxima se debio a
Juan Pablo Romero Bernal y colaboradores del proyecto GLUD-CLog
([Link] del Grupo Linux Universidad Distrital
(Colombia). Parte de la version actual se debe a ellos. Actualmente este documento
lo mantiene Mario Rodrguez Riotorto ([Link] para comentarios,
sugerencias y colaboraciones, contactar en la direccion de correo electronico:
mario ARROBA edu PUNTO xunta PUNTO es
2 Manual de Maxima
Captulo 1: Introduccion a Maxima 3
1 Introducci on a Maxima
Se puede iniciar Maxima con el comando "maxima". Maxima desplegara alguna infor-
macion importante acerca de la version que se esta usando y un prompt. Cada comando
que vaya a ser ejecutado por Maxima debe terminar con un punto y coma. Para nalizar
una sesion en Maxima se emplea el comando "quit();". A continuacion se presenta un breve
ejemplo de sesion:
[wfs@chromium]$ maxima
Maxima 5.9.1 [Link]
Using Lisp CMU Common Lisp 19a
Distributed under the GNU Public License. See the file COPYING.
Dedicated to the memory of William Schelter.
This is a development version of Maxima. The function bug_report()
provides bug reporting information.
(%i1) factor(10!);
8 4 2
(%o1) 2 3 5 7
(%i2) expand ((x + y)^6);
6 5 2 4 3 3 4 2 5 6
(%o2) y + 6 x y + 15 x y + 20 x y + 15 x y + 6 x y + x
(%i3) factor (x^6 - 1);
2 2
(%o3) (x - 1) (x + 1) (x - x + 1) (x + x + 1)
(%i4) quit();
[wfs@chromium]$
Maxima puede buscar en las paginas info. Para ello puede usar el comando describe
que mostrara todos los comandos y variables asociadas con la cadena o argumento de este
comando. Opcionalmente puede mostrar la documentacion respectiva. El signo de cierre
de interrogacion ? es una abreviacion del comando describe:
(%i1) ? integ
0: ([Link])Introduction to Elliptic Functions and Integrals.
1: Definitions for Elliptic Integrals.
2: Integration.
3: Introduction to Integration.
4: Definitions for Integration.
5: askinteger :Definitions for Simplification.
6: integerp :Definitions for Miscellaneous Options.
7: integrate :Definitions for Integration.
8: integrate_use_rootsof :Definitions for Integration.
9: integration_constant_counter :Definitions for Integration.
Enter space-separated numbers, all or none: 6 5
Info from file /usr/local/info/[Link]:
- Function: integerp (<expr>)
Returns true if <expr> is an integer, otherwise false.
4 Manual de Maxima
- Function: askinteger (expr, integer)
- Function: askinteger (expr)
- Function: askinteger (expr, even)
- Function: askinteger (expr, odd)
askinteger (expr, integer) attempts to determine from the
assume database whether expr is an integer. askinteger will
ask the user if it cannot tell otherwise, and attempt to install
the information in the database if possible. askinteger (expr)
is equivalent to askinteger (expr, integer).
askinteger (expr, even) and askinteger (expr, odd) likewise
attempt to determine if expr is an even integer or odd integer,
respectively.
(%o1) false
Para usar un resultado de forma posterior, usted puede asignar dicho resultado a una
variable o referirse a el por medio de la etiqueta asociada (%i* o %o*). Adicionalmente
puede usar % para referirse al ultimo resultado obtenido.
(%i1) u: expand ((x + y)^6);
6 5 2 4 3 3 4 2 5 6
(%o1) y + 6 x y + 15 x y + 20 x y + 15 x y + 6 x y + x
(%i2) diff (u, x);
5 4 2 3 3 2 4 5
(%o2) 6 y + 30 x y + 60 x y + 60 x y + 30 x y + 6 x
(%i3) factor (%o2);
5
(%o3) 6 (y + x)
Maxima manipula sin ning un problema n umeros complejos y constantes numericas:
(%i1) cos(%pi);
(%o1) - 1
(%i2) exp(%i*%pi);
(%o2) - 1
Maxima puede hacer derivadas e integrales:
(%i1) u: expand ((x + y)^6);
6 5 2 4 3 3 4 2 5 6
(%o1) y + 6 x y + 15 x y + 20 x y + 15 x y + 6 x y + x
(%i2) diff (%, x);
5 4 2 3 3 2 4 5
(%o2) 6 y + 30 x y + 60 x y + 60 x y + 30 x y + 6 x
(%i3) integrate (1/(1 + x^3), x);
2 x - 1
2 atan(-------)
log(x - x + 1) sqrt(3) log(x + 1)
(%o3) - --------------- + ------------- + ----------
6 sqrt(3) 3
Maxima puede resolver sistemas de ecuaciones lineales y c ubicas:
(%i1) linsolve ([3*x + 4*y = 7, 2*x + a*y = 13], [x, y]);
Captulo 1: Introduccion a Maxima 5
7 a - 52 25
(%o1) [x = --------, y = -------]
3 a - 8 3 a - 8
(%i2) solve (x^3 - 3*x^2 + 5*x = 15, x);
(%o2) [x = - sqrt(5) %i, x = sqrt(5) %i, x = 3]
Maxima puede resolver sistemas de ecuaciones no lineales. Tenga en cuenta que si usted
no desea que el resultado sea impreso, puede nalizar el comando con $ en vez de ;.
(%i1) eq_1: x^2 + 3*x*y + y^2 = 0$
(%i2) eq_2: 3*x + y = 1$
(%i3) solve ([eq_1, eq_2]);
3 sqrt(5) + 7 sqrt(5) + 3
(%o3) [[y = - -------------, x = -----------],
2 2
3 sqrt(5) - 7 sqrt(5) - 3
[y = -------------, x = - -----------]]
2 2
Bajo un sistema X window, (es decir que poseea interfaz graca), Maxima puede generar
gracas de una o mas funciones:
(%i1) eq_1: x^2 + 3*x*y + y^2 = 0$
(%i2) eq_2: 3*x + y = 1$
(%i3) solve ([eq_1, eq_2]);
3 sqrt(5) + 7 sqrt(5) + 3
(%o3) [[y = - -------------, x = -----------],
2 2
3 sqrt(5) - 7 sqrt(5) - 3
[y = -------------, x = - -----------]]
2 2
(%i4) kill(labels);
(%o0) done
(%i1) plot2d (sin(x)/x, [x, -20, 20]);
(%o1)
(%i2) plot2d ([atan(x), erf(x), tanh(x)], [x, -5, 5]);
(%o2)
(%i3) plot3d (sin(sqrt(x^2 + y^2))/sqrt(x^2 + y^2), [x, -12, 12], [y, -12, 12]);
(%o3)
6 Manual de Maxima
Captulo 2: Reporte y Deteccion de Bugs 7
2 Reporte y Detecci on de Bugs
2.1 Introducci on a la detecci on de Bugs y su reporte
Como todos los grandes programas, Maxima contiene tanto bugs conocidos como de-
sconocidos. Este captulo describe las facilidades internas para ejecutar la suite de evalu-
acion de Maxima (Maxima test suite) ademas de reportar nuevos bugs.
2.2 Deniciones para la detecci on de Bugs y su reporte::
Funcion run testsuite ()
Funcion run testsuite (boolean)
Funcion run testsuite (boolean, boolean)
Funcion run testsuite (boolean, boolean, list)
Ejecuta la suite de evaluacion de Maxima. Los tests que producen las respuestas
deseadas son considerados como pruebas superadas, como los tests que no producen
las respuestas deseadas, son marcados como bugs conocidos.
run_testsuite () muestra solo los test que no pasaron la prueba.
run_testsuite (true) muestra los tests que son marcados como bugs conocidos,
ademas de fallos.
run_testsuite (true, true) muestra todos los tests.
Si se incluye el tercer argumento opcional, se ejecutara una parte de los tests. Los
tests a ejecutar se especican formando una lista con los nombres de los mismos. La
lista completa de tests esta en testsuite_files.
run_testsuite cambia el entorno de Maxima. Tpicamente un script de test ejecuta
kill para establecer un entorno conocido (llamese uno sin funciones ni variables
denidas por el usuario) y entonces dene una serie de funciones y variables apropiadas
para el test.
run_testsuite retorna done.
Variable opcional testsuite les
testsuite_files es el conjunto de tests a ejecutar por run_testsuite. Se trata de
una lista con los nombres de los cheros que contienen los tests a ejecutar. Si se sabe
que alguno de los tests de un chero falla, entonces en lugar de listar el nombre del
chero, se utiliza una lista que contiene el nombre del chero y los n umeros de los
tests que fallan.
Por ejemplo, esta es una parte de los tests por defecto:
["rtest13s", ["rtest14", 57, 63]]
Con esto se especica que el conjunto de tests esta formado por los cheros "rtest13s"
y "rtest14", pero que "rtest14" contiene dos tests que se sabe que causan fallos, el 57
y el 63.
8 Manual de Maxima
Funcion bug report ()
Imprime las versiones de Maxima y de Lisp y proporciona un enlace a la pagina web
de reporte de bugs del proyecto Maxima. La informacion respecto a las versiones es
la misma que reporta la funcion build_info.
Cuando un bug es reportado, es de gran ayuda que se copie la informacion relacionada
con la version de Maxima y de Lisp usada, dentro del reporte de bug.
bug_report retorna una cadena vaca "".
Funcion build info ()
Imprime un resumen de los parametros que se usaron para construir la version de
Maxima que se esta usando.
build_info retorna una cadena vaca "".
Captulo 3: Ayuda 9
3 Ayuda
3.1 Introducci on a la Ayuda
El comando de ayuda mas util es describe, el cual es invocado por el signo de cierre
de interrogacion ? a traves del prompt interactivo. ? foo (con espacio entre ? y foo) es
equivalente a describe ("foo"), donde foo es el nombre o parte del nombre de alguna
funcion o tema; entonces describe encontrara todos los documentos que contengan la
cadena foo en sus ttulos y los desplegara como opciones. Si hay mas de una opcion,
Maxima preguntara al usuario para que seleccione las opciones que desee consultar.
(%i1) ? integ
0: ([Link])Introduction to Elliptic Functions and Integrals.
1: Definitions for Elliptic Integrals.
2: Integration.
3: Introduction to Integration.
4: Definitions for Integration.
5: askinteger :Definitions for Simplification.
6: integerp :Definitions for Miscellaneous Options.
7: integrate :Definitions for Integration.
8: integrate_use_rootsof :Definitions for Integration.
9: integration_constant_counter :Definitions for Integration.
Enter space-separated numbers, all or none: 7 8
Info from file /use/local/maxima/doc/info/[Link]:
- Function: integrate (expr, var)
- Function: integrate (expr, var, a, b)
Attempts to symbolically compute the integral of expr with
respect to var. integrate (expr, var) is an indefinite
integral, while integrate (expr, var, a, b) is a definite
integral, [...]
En este ejemplo las opciones 7 y 8 fueron seleccionadas. Todas o ninguna de las opciones
pueden ser seleccionadas escribiendo all o none, las cuales pueden ser abrevidas por a o n,
respectivamente.
3.2 Lisp y Maxima
Maxima fue escrito en Lisp, y es muy facil tener acceso a funciones y variables Lisp desde
Maxima y viceversa. Los smbolos Lisp y los smblos Maxima estan claramente diferenciados
por medio de una convencion de nombres. Un smblo Lisp el cual comienza con un signo
pesos $ corresponde a un smbolo Maxima sin el signo pesos. Un smbolo Maxima el cual
comienza con un signo de cierre de interrogacion ? corresponde a un smbolo Lisp sin dicho
signo. Por ejemplo, el smbolo Maxima foo corresponde a el smbolo Lisp $foo, mientras
que el smbolo Maxima ?foo corresponde a el smbolo Lisp foo, tenga en cuenta que ?foo
esta escrito sin espacio entre ? y foo; de otra manera se estara invocando a describe
("foo").
10 Manual de Maxima
El guion -, asterisco *, u otros caracteres especiales en s

imbolos Lisp deben ser escritos

mediante un backslash \ si aparecen en codigo Maxima. Por ejemplo, el identicador Lisp
*foo-bar* se debe escribir ?\*foo\-bar\* en Maxima.
Se puede ejecutar codigo Lisp desde una sesion de Maxima. Una lnea Lisp (que contenga
una o mas formas) puede ser ejecutada por medio de un comando especial :lisp. Por
ejemplo,
(%i1) :lisp (foo $x $y)
se llama a la funcion Lisp foo con variables Maxima x y y como argumentos. La instruccion
:lisp puede aparecer en el prompt interactivo o en un archivo que sea procesado por batch
o demo, pero no en un archivo que sea procesado por load, batchload, translate_file o
compile_file.
La funcion to_lisp() abre una sesion interactiva con el interprete Lisp. Escribiendo
(to-maxima) se cierra la sesion con Lisp y se retorna a Maxima.
Las funciones y variables Lisp las cuales esten para ser visibles en Maxima como funciones
y variables con nombres oridinarios (sin una puntuacion especial), deben tener nombres tipo
Lisp que comiencen con el signo pesos $.
Maxima es case-sensitive, distingue entre letras min usculas y may usculas en identi-
cadores, mientras que Lisp no. Existen algunas reglas que gobiernan la traduccion de
nombres entre Lisp y Maxima.
1. Un identicador Lisp que no se encuentra encerrado en barras verticales corresponde
a un identicador Maxima in min uscula. Que el idencador Lisp este en may uscula,
min uscula o una combinacion de las dos, no afecta en nada. E.g., los identicadores
Lisp $foo, $FOO, y $Foo, todos corresponden al identicador Maxima foo.
2. Unn identicador Lisp el cual se encuentre todo en may uscula o todo en min uscula
y encerrado entre barras verticales corresponde a un identicador Maxima con el caso
contrario. Esto es, de may usculas cambia a min usculas y de min usculas cambia a
may usculas. E.g., el identicador Lisp |$FOO| y |$foo| corresponden los identi-
cadores Maxima foo y FOO, respectivamente.
3. Un identicador Lisp el cual esta escrito mezclando letras may usculas y min usculas y se
encuentra entre barras verticales corresponde a un identicador Maxima con la misma
escritura. E.g., el identicador Lisp |$Foo| corresponde a el identicador Maxima Foo.
La macro Lisp #$ permite el uso de expresiones Maxima dentro de codigo Lisp. #$expr$
extiende a una expresion Lisp equivalente a la expresion Maxima expr.
(msetq $foo #$[x, y]$)
Esto tiene el mismo efecto que:
(%i1) foo: [x, y];
La funcion Lisp displa imprime una expresion en formato Maxima.
(%i1) :lisp #$[x, y, z]$
((MLIST SIMP) $X $Y $Z)
(%i1) :lisp (displa ((MLIST SIMP) $X $Y $Z))
[x, y, z]
NIL
Las funciones denidas en Maxima no son funciones Lisp ordinarias. La funcion Lisp
mfuncall llama a una funcion Maxima. Por ejemplo:
Captulo 3: Ayuda 11
(%i1) foo(x,y) := x*y$
(%i2) :lisp (mfuncall $foo a b)
((MTIMES SIMP) A B)
Algunas funciones Lisp son compartidas en el paquete Maxima, las cuales se listan a
continuacion:
complement, continue, //, float, functionp, array, exp, listen, signum, atan, asin,
acos, asinh, acosh, atanh, tanh, cosh, sinh, tan, break, y gcd.
3.3 Recolector de Basura
La computacion simbolica tiende a crear una buena cantidad de basura, y un manejo
efectivo de esto puede ser crucial para el termino exitoso de algunos programas.
Bajo GCL (GNU Common Lisp), en los sistemas UNIX donde la llamada al sistema
mprotect esta disponible (incluyendo SUN OS 4.0 y algunas variantes de BSD) un recolector
de basura estraticado esta disponibe. Estos lmites de coleccion para memoria virtual, han
sido escritos recientemente. Mire la documentacion de GCL bajo ALLOCATE y GBC. En
el nivel lisp haga (setq si::*notify-gbc* t) eso le ayudara a determinar cuales areas necesitan
mas espacio.
3.4 Documentaci on
El manual en lnea del usuario de Maxima puede ser visto en diferentes formas. Desde el
prompt interactivo de Maxima, el manual de usuario es visto como texto plano por medio
del comando ? (i.e., la funcion describe). El manual de usuario tambien puede ser visto
como hipertexto tipo info por medio del programa info y como una pagina web a traves
de cualquier navegador.
El comando example muestra ejemplos para muchas funciones Maxima. Por ejemplo:
(%i1) example (integrate);
produce:
(%i2) test(f):=block([u],u:integrate(f,x),ratsimp(f-diff(u,x)))
(%o2) test(f) := block([u], u : integrate(f, x),
ratsimp(f - diff(u, x)))
(%i3) test(sin(x))
(%o3) 0
(%i4) test(1/(x+1))
(%o4) 0
(%i5) test(1/(x^2+1))
(%o5) 0
y salidas adicionales.
3.5 Deniciones para la Ayuda
Funcion demo (archivo)
Evalua las expresiones Maxima contenidas en archivo y muestra los resultados. demo
hace pausas despues de evaluar cada expresion y continua despues de que el usuario
12 Manual de Maxima
ingrese un retorno de carro. (Si se ejecuta en Xmaxima, demo puede que necesite un
punto y coma ; a continuacion del retorno de carro.)
demo busca la lista de directorios file_search_demo para encontrar archivo. Si el
archivo tiene el sujo dem, el sujo puede ser omitido. Ver tambien file_search.
demo evalua su argumento. demo retorna el nombre del archivo demostracion.
Ejemplo:
(%i1) demo ("disol");
batching /home/wfs/maxima/share/simplification/[Link]
At the _ prompt, type ; followed by enter to get next demo
(%i2) load(disol)
_
(%i3) exp1 : a (e (g + f) + b (d + c))
(%o3) a (e (g + f) + b (d + c))
_
(%i4) disolate(exp1, a, b, e)
(%t4) d + c
(%t5) g + f
(%o5) a (%t5 e + %t4 b)
_
(%i5) demo ("rncomb");
batching /home/wfs/maxima/share/simplification/[Link]
At the _ prompt, type ; followed by enter to get next demo
(%i6) load(rncomb)
_
z x
(%i7) exp1 : ----- + ---------
y + x 2 (y + x)
z x
(%o7) ----- + ---------
y + x 2 (y + x)
_
(%i8) combine(exp1)
z x
(%o8) ----- + ---------
y + x 2 (y + x)
_
(%i9) rncombine(%)
2 z + x
Captulo 3: Ayuda 13
(%o9) ---------
2 (y + x)
_
d c b a
(%i10) exp2 : - + - + - + -
3 3 2 2
d c b a
(%o10) - + - + - + -
3 3 2 2
_
(%i11) combine(exp2)
2 d + 2 c + 3 (b + a)
(%o11) ---------------------
6
_
(%i12) rncombine(exp2)
2 d + 2 c + 3 b + 3 a
(%o12) ---------------------
6
_
(%i13)
Funcion describe (cadena)
Encuentra todos los documentos los cuales contengan cadena es sus ttulos y los
despliega como opciones. Si hay mas de una opcion, Maxima preguntara al usuario
para que seleccione las opciones que desee consultar. En el prompt interactivo, ? foo
(con espacio entre ? y foo) es equivalente a describe ("foo").
describe ("") produce una lista de todos los temas documentados en el manual en
lnea.
describe no evalua su argumento. describe siempre retorna false.
Ejemplo:
(%i1) ? integ
0: ([Link])Introduction to Elliptic Functions and Integrals.
1: Definitions for Elliptic Integrals.
2: Integration.
3: Introduction to Integration.
4: Definitions for Integration.
5: askinteger :Definitions for Simplification.
6: integerp :Definitions for Miscellaneous Options.
7: integrate :Definitions for Integration.
8: integrate_use_rootsof :Definitions for Integration.
9: integration_constant_counter :Definitions for Integration.
Enter space-separated numbers, all or none: 7 8
14 Manual de Maxima
Info from file /use/local/maxima/doc/info/[Link]:
- Function: integrate (expr, var)
- Function: integrate (expr, var, a, b)
Attempts to symbolically compute the integral of expr with
respect to var. integrate (expr, var) is an indefinite
integral, while integrate (expr, var, a, b) is a definite
integral, [...]
En este ejemplo las opciones 7 y 8 fueron seleccionadas. Todas o ninguna de las
opciones pueden ser seleccionadas escribiendo all o none, las cuales pueden ser abre-
vidas por a o n, respectivamente.
Funcion example (tema)
Funcion example ()
example (tema) mostrara algunos ejemplos de tema, el cual es un smbolo (no una
cadena). La mayora de los temas son nombres de funciones. example () retorna la
lista de todos los temas conocidos.
El nombre del archivo que contiene los ejemplos esta dado por la variable global
manual_demo, cuyo valor por defecto es "[Link]".
example no evalua su argumento. example retorna done a menos que haya un error
o que no haya argumento, en cuyo caso example retornara la lista de todos los temas
conocidos.
Ejemplos:
(%i1) example (append);
(%i2) append([x+y,0,-3.2],[2.5E+20,x])
(%o2) [y + x, 0, - 3.2, 2.5E+20, x]
(%o2) done
(%i3) example (coeff);
(%i4) coeff(b+tan(x)+2*a*tan(x) = 3+5*tan(x),tan(x))
(%o4) 2 a + 1 = 5
(%i5) coeff(1+x*%e^x+y,x,0)
(%o5) y + 1
(%o5) done
Captulo 4: Lnea de Comandos 15
4 Lnea de Comandos
4.1 Introducci on a la Lnea de Comandos
Operador ""
El operador comilla sencilla evita la evaluacion.
Aplicado a un smbolo, la comilla sencilla evita la evaluacion del smbolo.
Aplicado a la llamada de una funcion, la comilla sencilla evita la evaluacion de la
funcion llamada, aunque los argumentos de la funcion son evaluados (siempre y cuando
la evaluacion no se evite de otra manera). El resultado es una forma de nombre de la
funcion llamada.
Aplicado a una expresion con parentesis, la comilla simple evita la evaluacion de
todos los smbolos y llamadas a funciones que hayan en la expresion. E.g., (f(x))
signica que no se evalua la expresion f(x). f(x) (con la comilla simple aplicada
a f en cambio de a f(x)) signica el retorno de la forma de nombre de f aplicada a
[x].
La comilla simple no evita la simplicacion.
Cuando el interruptor global noundisp es true, los nombres se muestran con una
comilla simple. Este interruptor siempre tiene como valor true cuando se muestran
deniciones de funciones.
Ver tambien los operadores comilla-comilla y nouns.
Ejemplos:
Aplicado a un smbolo, la comilla sencilla evita la evaluacion del smbolo.
(%i1) aa: 1024;
(%o1) 1024
(%i2) aa^2;
(%o2) 1048576
(%i3) aa^2;
2
(%o3) aa
(%i4) %;
(%o4) 1048576
Aplicado a la llamada de una funcion, la comilla sencilla evita la evaluacion de la
funcion llamada, aunque los argumentos de la funcion son evaluados (siempre y cuando
la evaluacion no se evite de otra manera). El resultado es una forma de nombre de la
funcion llamada.
(%i1) x0: 5;
(%o1) 5
(%i2) x1: 7;
(%o2) 7
(%i3) integrate (x^2, x, x0, x1);
218
(%o3) ---
3
16 Manual de Maxima
(%i4) integrate (x^2, x, x0, x1);
7
/
[ 2
(%o4) I x dx
]
/
5
(%i5) %, nouns;
218
(%o5) ---
3
Aplicado a una expresion con parentesis, la comilla simple evita la evaluacion de todos
los smbolos y llamadas a funciones que hayan en la expresion.
(%i1) aa: 1024;
(%o1) 1024
(%i2) bb: 19;
(%o2) 19
(%i3) sqrt(aa) + bb;
(%o3) 51
(%i4) (sqrt(aa) + bb);
(%o4) bb + sqrt(aa)
(%i5) %;
(%o5) 51
La comilla sencilla no evita la simplicacion.
(%i1) sin (17 * %pi) + cos (17 * %pi);
(%o1) - 1
(%i2) (sin (17 * %pi) + cos (17 * %pi));
(%o2) - 1
Operador ""
El operador (doble comilla simple) causa que una evaluacion extra tenga lugar.
E.g., %i4 reevaluara la lnea de entrada %i4. (f(x)) signica evaluar la expresion
f(x) en tiempo extra. f(x) (con la doble comilla simple aplicada a f en vez de a
f(x)) signica el retorno de la forma verbal de f aplicada a [x].
4.2 Deniciones para la Lnea de Comandos
Funcion alias (new name 1, old name 1, ..., new name n, old name n)
provee un nombre alternativo para una (bien sea denida por el usuario o por el
sistema) funcion, variable, arreglo, etc. Cualquier n umero par de argumentos puede
ser usado.
Variable opcional debugmode
Valor por defecto: false
Cuando en Maxima ocurre un error, Maxima inicializara el depurador si debugmode
tiene el valor true. El usuario puede ingresar comandos para examinar la pila de
Captulo 4: Lnea de Comandos 17
llamadas, los puntos de interrupcion; en pocas palabras ir a traves del codigo de
Maxima. Vea debugging para una lista de los comandos del depurador.
Habilitando debugmode no se capturaran los errores tipo Lisp.
Funcion ev (expr, arg 1, ..., arg n)
Evalua la expresion expr en el entorno especicado por los argumentos arg 1, ...,
arg n. Los argumentos son interruptores (Variables Booleanas), variables de asig-
nacion, ecuaciones y funciones. ev retorna el resultado (otra expresion) de la evalu-
acion.
La evaluacion se realiza por etapas, como sigue:
1. Primero se congura el entorno de acuerdo a los argumentos los cuales pueden
ser algunos o todos de la siguiente lista:
simp causa que expr sea simplicada sin importar el valor de la variable
interruptor simp la cual inhibe la simplicacion cuando su valor es false.
noeval suprime la fase de evaluacion de ev (Vea el paso (4) mas adelante).
Esto es muy util en conjuncion con otras variables interruptor y causan en
expr que sea resimplicada sin ser reevaluada.
nouns causa que la evaluacion de las formas de nombre (tpicamente fun-
ciones sin evaluar tales como integrate or diff) en expr.
expand causa expansion.
expand (m, n) causa expansion, asignando los valores de maxposex y
maxnegex a m y n, respectivamente.
detout causa que cualesquiera matrices inversas computadas en expr conser-
ven su determinante fuera de la inversa en vez de que divida a cada elemento.
diif causa que todas las diferenciaciones indicadas en expr sean llevadas a
cabo.
derivlist (x, y, z, ...) causa que solo las diferenciaciones con respecto
a las variables indicadas se lleven a cabo.
float causa que los n umeros racionales no-enteros sean convertidos a
n umeros de tipo otante.
numer causa que algunas funciones matematicas (incluyendo potenciacion)
con argumentos numericos sean evaluados como punto otante. Esto causa
que las variables en expr las cuales hayan sido declaradas como variables
numericas sean reemplazadas por sus respectivos valores. Esto tambien con-
gura la variable interruptor float a true.
pred causa que los predicados (expresiones las cuales se evaluan a true o
false) sean evaluados.
eval causa que una post-evaluacion extra de expr ocurra. (Vea el paso (5)
mas adelante).
A, donde A es un atomo declarado como una variable de tipo interruptor,
(Vea evflag) causa que A tenga como valor true durante la evaluacion de
expr.
18 Manual de Maxima
V: expresion (o alternativamente V=expresion) causa que V tenga el valor
de expresion durante la evaluacion de expr. Notese que si V es una opcion
Maxima, entonces expresion se usa como su valor durante la evaluacion de
expr. Si mas de un argumento de ev es de este tipo entonces el vnculo se
hace en paralelo. Si V es una expresion no atomica entonces se hace una
sustitucion mas que un vnculo.
F donde F, un nombre de funcion, ha sido declarado para ser una funcion de
evaluacion (Vea evfun) causa que F sea aplicada a expr.
Cualquier otro nombre de funcion (e.g., sum) causa la evaluacion de las
ocurrencias de esos nombres en expr como si ellos fueran verbos.
En adicion de que una funcion ocurra en expr (digamos F(x)) puede ser
denida localmente para el proposito de esta evaluacion de expr pasando
F(x) := expresion como un argumento a ev.
Si un atomo no mencionado anteriormente o una variable o expresion con
subndices fueran pasadas como un argumento, esta es evaluada y si el re-
sultado es una ecuacion o una asignacion entonces el vnculo o sustitucion se
llevara a cabo. Si el resultado es una lista entonces los miembros de la lista
tratados como si ellos fueran argumentos adicionales pasados a ev. Esto
permite que una lista de argumentos sea pasada (e.g., [X=1, Y=A**2]) o
una lista de nombres de ecuaciones (e.g., [%t1, %t2] donde %t1 y %t2 son
ecuaciones) tal como lo que es retornado por solve.
Los argumentos de ev pueden ser pasados en cualquier orden con excepcion de la
sustitucion de ecuaciones las cuales son manipuladas en secuencia, de izquierda a
derecha y las funciones de evaluacion las cuales son compuestas, e.g., ev (expr,
ratsimp, realpart) es manipulada como realpart (ratsimp (expr)).
Los interruptores simp, numer, float y pred pueden tambien ser congurados
localmente en una sentencia block, o globalmente en Maxima para que su efecto
permanezca hasta que sean reconguradas.
Si expr es una Expresion Racional Canonica (CRE, por sus siglas en ingles),
entonces la expresion retornada por ev es tambien de tipo CRE, siempre que los
interruptores numer y float no sean true.
2. Durante el paso (1), se fabrica una lista de las variables que no contienen
subndices que aparecen en el lado izquierdo de las ecuaciones en los argumentos
o en el valor de algunos argumentos si el valor es una ecuacion. Las variables
(variables que contienen subndices las cuales no tienen asociado un arreglo
de funciones como tambien las variables que no contienen subndices) en la
expresion expr son reemplazadas por sus valores globales, excepto por aquellos
que aparezcan en esa lista. Usualmente, expr es solo una etiqueta o un % (como
en %i2 en el ejemplo de mas abajo) as que este paso simplemente recupera la
expresion a la que hace referencia la etiqueta y as ev puede trabajarla.
3. Si algunas sustituciones son indicadas por los argumentos, ellas seran llevadas a
cabo ahora.
4. La expresion resultante es tambien reevaluada (a menos que uno de los argu-
mentos fuese noeval) y simplicada de acuerdo a los argumentos. Notese que
cualquier llamada a una funcion en expr sera llevada a cabo despues de que
Captulo 4: Lnea de Comandos 19
las variables sean evaluadas en ella y que ev(F(x)) pueda comportarse como
F(ev(x)).
5. Si uno de los argumentos fuese eval, los pasos (3) y (4) se repiten.
Ejemplos
(%i1) sin(x) + cos(y) + (w+1)^2 + diff (sin(w), w);
d 2
(%o1) cos(y) + sin(x) + -- (sin(w)) + (w + 1)
dw
(%i2) ev (%, sin, expand, diff, x=2, y=1);
2
(%o2) cos(w) + w + 2 w + cos(1) + 1.909297426825682
Una sintaxis alternativa de alto nivel ha sido proveida para ev, por medio de la cual
uno puede escribir solamente sus argumentos, sin el comando ev(). Esto es, una
forma sencilla de escritura:
expr, arg 1, ..., arg n
Esto no es permitido como parte de otra expresion , e.g., en funciones, sentencias
block, etc.
Notese el proceso de vnculo en paralelo en el siguiente ejemplo:
(%i3) programmode: false;
(%o3) false
(%i4) x+y, x: a+y, y: 2;
(%o4) y + a + 2
(%i5) 2*x - 3*y = 3$
(%i6) -3*x + 2*y = -4$
(%i7) solve ([%o5, %o6]);
Solucion
1
(%t7) y = - -
5
6
(%t8) x = -
5
(%o8) [[%t7, %t8]]
(%i8) %o6, %o8;
(%o8) - 4 = - 4
(%i9) x + 1/x > gamma (1/2);
1
(%o9) x + - > sqrt(%pi)
x
(%i10) %, numer, x=1/2;
(%o10) 2.5 > 1.772453850905516
(%i11) %, pred;
(%o11) true
20 Manual de Maxima
Propiedad evag
Algunos interruptores booleanos tienen la propiedad evflag. ev trata de forma es-
pecial tales interruptores. Un interruptor con la propiedad evflag sera puesto a
true durante la ejecucion de ev si este es mencionado en la llamada a ev. Por ejem-
plo, demoivre y ratfac son puestos a true durante la llamada a ev (%, demoivre,
ratfac).
Los interruptores que tienen la propiedad evflag son:
algebraic, cauchysum, demoivre, dotscrules, %emode, %enumer, exponentialize,
exptisolate, factorflag, float, halfangles, infeval, isolate_wrt_times,
keepfloat, letrat, listarith, logabs, logarc, logexpand, lognegint, lognumer,
m1pbranch, numer_pbranch, programmode, radexpand, ratalgdenom, ratfac,
ratmx, ratsimpexpons, simp, simpsum, sumexpand, y trigexpand.
La instruccion :lisp (putprop |$foo| t evflag) da la propiedad evflag a la
variable foo, as que foo es puesta a true durante la llamada a ev (%, foo). De
forma equivalente, ev ($, foo:true) tiene el mismo efecto.
Propiedad evfun
Algunas funciones tienen la propiedad evfun. ev trata tales funciones de forma
especial. Una funcion con la propiedad evfun sera aplicada durante la ejecucion de
ev si esta es mencion