Manual de Maxima 5.47post

2.1 Funciones y variables para la detección e informe de fallos

Función: run_testsuite ([options]) ¶

Ejecuta el conjunto de pruebas 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 fallos conocidos.

run_testsuite admite las siguientes opciones:

display_all

Muestra todas las pruebas. Normalmente no se muestran las pruebas, a menos que produzcan fallos. (Su valor por defecto es false).

display_known_bugs

Muestra las pruebas marcadas como fallos ya conocidos. (Su valor por defecto es false).

tests

Esta es la lista de las pruebas que se deben ejecutar. Cada prueba se puede especificar, tanto mediante una cadena de texto como por un símbolo. Por defecto, todas las pruebas se ejecutan. El conjunto completo de pruebas está especificado en testsuite_files.

time

Muestra información sobre tiempos de ejecución. Si vale true, se muestran los tiempos de los ficheros de prueba. Si vale all, se muestran los tiempos de cada prueba individual si display_all vale true. El valor por defecto es false, por lo que no se muestra información temporal alguna.

Por ejemplo, run_testsuite(display_known_bugs = true, tests=[rtest5]) ejecuta la prueba rtest5 y muestra si está marcada como fallo conocido.

run_testsuite(display_all = true, tests=["rtest1", rtest1a]) ejecutará las pruebas rtest1 y rtest2, mostrando cada una de ellas.

run_testsuite cambia el entorno de Maxima. Típicamente un script de test ejecuta kill para establecer un entorno conocido (llámese uno sin funciones ni variables definidas por el usuario) y entonces define una serie de funciones y variables apropiadas para el test.

run_testsuite retorna done.

Variable opcional: testsuite_files ¶

testsuite_files es el conjunto de tests a ejecutar por run_testsuite. Se trata de una lista con los nombres de los ficheros que contienen los tests a ejecutar. Si se sabe que alguno de los tests de un fichero falla, entonces en lugar de listar el nombre del fichero, se utiliza una lista que contiene el nombre del fichero y los números de los tests que fallan.

Por ejemplo, esta es una parte de los tests por defecto:

 ["rtest13s", ["rtest14", 57, 63]]

Con esto se especifica que el conjunto de tests está formado por los ficheros "rtest13s" y "rtest14", pero que "rtest14" contiene dos tests que se sabe que causan fallos, el 57 y el 63.

Función: bug_report () ¶

Imprime las versiones de Maxima y de Lisp y proporciona un enlace a la página web sobre informe de fallos del proyecto Maxima. La información respecto a las versiones es la misma que reporta la función build_info.

Cuando se informa sobre un fallo, es de gran ayuda que se copie la información relacionada con la versión de Maxima y de Lisp usada, dentro del propio informe.

bug_report retorna una cadena vacía "".

Función: build_info () ¶

Devuelve un resumen de los parámetros con los que se ha compilado Maxima en formato de estructura defstruct. Los campos de la estructura son: version, timestamp, host, lisp_name y lisp_version. Cuando display2d toma el valor true, la estructura se muestra como una pequeña tabla.

Véase también bug_report.

Ejemplos:

(%i1) build_info ();
(%o1) 
Maxima version: "5.26.0_16_gb72c64c_dirty"
Maxima build date: "2012-01-29 12:29:04"
Host type: "i686-pc-linux-gnu"
Lisp implementation type: "CMU Common Lisp"
Lisp implementation version: "CVS release-19a 19a-release-20040728 + minimal debian patches"

(%i2) x : build_info ()$

(%i3) x@version;
(%o3)               5.26.0_16_gb72c64c_dirty

(%i4) x@timestamp;
(%o4)                  2012-01-29 12:29:04

(%i5) x@host;
(%o5)                   i686-pc-linux-gnu

(%i6) x@lisp_name;
(%o6)                    CMU Common Lisp

(%i7) x@lisp_version;
(%o7) 
    CVS release-19a 19a-release-20040728 + minimal debian patches

(%i8) x;
(%o8) 
Maxima version: "5.26.0_16_gb72c64c_dirty"
Maxima build date: "2012-01-29 12:29:04"
Host type: "i686-pc-linux-gnu"
Lisp implementation type: "CMU Common Lisp"
Lisp implementation version: "CVS release-19a 19a-release-20040728 + minimal debian patches"

3.1 Documentación

El manual en línea 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 función describe). El manual de usuario también puede ser visto como hipertexto tipo info por medio del programa info y como una página web a través 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.2 Funciones y variables para la ayuda

Función: apropos (string) ¶

Busca los símbolos de Maxima en los cuales aparezca cadena en cualquier lugar dentro de su nombre. Así, apropos (exp) devuelve una lista con todas las variables y funciones que tengan exp formando parte de sus nombres, como expand, exp y exponentialize. De esta forma, si el usuario tan solo recuerda parte del nombre de algo, puede utilizar este comando para encontrar el resto del nombre. De manera semejante, también se puede hacer apropos (tr_) para encontrar una lista de muchas de las variables relacionadas con el traductor, buena parte de las cuales comienzan con tr_.

apropos("") devuelve una lista con todos los nombres de Maxima.

En caso de no encontrar información relevante, apropos devuelve la lista vacía [].

Ejemplo:

Devuelve todos los símbolos de Maxima que contienen la subcadena "gamma" en su nombre:

(%i1) apropos("gamma");
(%o1) [%gamma, gamma, gammalim, gamma_expand, gamma_incomplete_lower, 
gamma_incomplete, gamma_incomplete_generalized, 
gamma_incomplete_regularized, Gamma, log_gamma, makegamma, 
prefer_gamma_incomplete, 
gamma_incomplete_generalized_regularized]

Función: demo (archivo) ¶

Evalua las expresiones Maxima contenidas en archivo y muestra los resultados. demo hace pausas después de evaluar cada expresión y continua después de que el usuario ingrese un retorno de carro. (Si se ejecuta en Xmaxima, demo puede que necesite un punto y coma ; a continuación del retorno de carro.)

demo busca la lista de directorios file_search_demo para encontrar archivo. Si el archivo tiene el sufijo dem, el sufijo puede ser omitido. Ver también file_search.

demo evalua su argumento. demo retorna el nombre del archivo demostración.

Ejemplo:

(%i1) demo ("disol");

batching /home/wfs/maxima/share/simplification/disol.dem
 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/rncomb.dem
 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
(%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) 

Función: describe (string) ¶

Función: describe (string, exact) ¶

Función: describe (string, inexact) ¶

La sentencia describe(string) equivale a describe(string, exact).

La sentencia describe(string, exact) encuentra el elemento, si existe, cuyo título coincide exactamente con string (ignorando la diferencia entre mayúsculas y minúsculas).

La sentencia describe(string, inexact) encuentra todos los elementos documentados que contengan string en sus títulos.

Si hay más de una opción, Maxima preguntará al usuario para que seleccione las opciones que desee consultar.

La sentencia ? foo (con espacio entre ? y foo) equivale a describe("foo", exact), mientras que ?? foo equivale a describe("foo", inexact).

describe ("", inexact) produce una lista de todos los temas documentados en el manual en línea.

describe no evalúa su argumento. La función describe devuelve true si encuentra la documentación solicitada y false en caso contrario.

Véase también Documentación.

Ejemplo:

(%i1) ?? integ
 0: Functions and Variables for Elliptic Integrals
 1: Functions and Variables for Integration
 2: Introduction to Elliptic Functions and Integrals
 3: Introduction to Integration
 4: askinteger  (Functions and Variables for Simplification)
 5: integerp  (Functions and Variables for Miscellaneous Options)
 6: integer_partitions  (Functions and Variables for Sets)
 7: integrate  (Functions and Variables for Integration)
 8: integrate_use_rootsof  (Functions and Variables for
    Integration)
 9: integration_constant_counter  (Functions and Variables for
    Integration)
 10: nonnegintegerp  (Functions and Variables for linearalgebra)
Enter space-separated numbers, `all' or `none': 7 8

 -- Function: integrate (<expr>, <x>)
 -- Function: integrate (<expr>, <x>, <a>, <b>)
     Attempts to symbolically compute the integral of <expr> with
     respect to <x>.  `integrate (<expr>, <x>)' is an indefinite
     integral, while `integrate (<expr>, <x>, <a>, <b>)' is a
     definite integral, [...]
     
 -- Option variable: integrate_use_rootsof
     Default value: `false'

     When `integrate_use_rootsof' is `true' and the denominator of
     a rational function cannot be factored, `integrate' returns
     the integral in a form which is a sum over the roots (not yet
     known) of the denominator.
     [...]

En este ejemplo fueron seleccionadas las opciones 7 y 8 (la salida ha sido recortada, tal como indica [...]). Todas o ninguna de las opciones pueden ser seleccionadas escribiendo all o none, las cuales pueden ser abreviadas por a o n, respectivamente.

Función: example (topic) ¶

Función: example () ¶

example (topic) muestra algunos ejemplos sobre topic, el cual debe ser un símbolo o cadena de texto. Para ver ejemplos sobre operadores como if, do o lambda el argumento debe ser necesariamente una cadena de texto, como example ("do"). La función example no distingue entre minúsculas y mayúsculas. La mayor parte de ejemplos versan sobre funciones.

La sentencia example () devuelve la lista de todos los ejemplos existentes.

El nombre del fichero que contine los ejemplos existentes se guarda en la variable global manual_demo, cuyo valor por defecto es "manual.demo".

La función example no evalúa su argumento.

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("lambda");
(%i4) lambda([x,y,z],z^2+y^2+x^2)
                                           2    2    2
(%o4)                   lambda([x, y, z], z  + y  + x )
(%i5) %(1,2,a)
                                     2
(%o5)                               a  + 5
(%i6) a+2+1
(%o6)                                a + 3
(%o6)                                done
(%i7) example("allROOTS");
(%i8) (1+2*x)^3 = 13.5*(1+x^5)
                                   3          5
(%o8)                     (2 x + 1)  = 13.5 (x  + 1)
(%i9) allroots(%)
(%o9) [x = .8296749902129361, x = - 1.015755543828121, 
x = .9659625152196369 %i - .4069597231924075, 
x = - .9659625152196369 %i - .4069597231924075, x = 1.0]
(%o9)                                done

Variable opcional: manual_demo ¶

Valor por defecto: "manual.demo"

manual_demo especifica el nombre del fichero que contiene los ejemplo para la función example.

Véase example.

4.1 Introducción a la línea de comandos

Consola

Existen distintos interfaces para Maxima, tales como wxMaxima, Xmaxima, Imaxima y la consola o terminal de texto.

La consola trabaja en modo texto, al tiempo que para introducir instrucciones con ayuda de un menú y obtener resultados en modo gráfico es necesario instalar otros interfaces.

A lo largo de este manual se utilizará la consola, la cual está disponible en cualquiera de los sistemas operativos en los que trabaja Maxima. El usuario puede introducir todas las funciones de Maxima desde la consola; en el modo texto, los resultados se devolverán normalmente en un formato ASCII bidimensional, mientras que los gráficos necesitan de un programa adicional tal como Gnuplot.

Entrada, Evaluación, Simplificación y Salida

Desde que el usuario introduce una solicitud de cálculo hasta que obtiene el resultado en la consola, se desarrolla un proceso que consta de cuatro fases:

1. Bien sea desde un teclado o desde un fichero se lee una expresión que el analizador sintáctico se encargará de transformar en una cierta representación interna. En esta primera fase, se utilizan principalmente operadores tales como "+", "/" o "do".
2. La expresión leída por el analizador sintáctico es evaluada durante la segunda fase. Las variables se substituyen por sus valores y se ejecutan funciones tales como la derivación o la integración. El resultado de esta fase es una expresión evaluada.
3. La expresión evaluada de la fase anterior se simplifica en esta tercera fase, en la que una expresión tal como a+a se reduce a 2*a, o sin(%pi/2) se simplifica a 1.
4. Tras la tercera fase se dispone de una expresión que ha sido evaluada y posteriormente simplificada. Ya en la cuarta y última fase, se prepara el resultado para ser mostrado a través de la consola.

El usuario puede tomar el control en cualquiera de las cuatro fases recién descritas. En diferentes capítulos de este manual se detallan estas posibilidades, pero en éste se describen aquellas instrucciones relacionadas con las fases primera y cuarta, relacionadas con la entrada y salida a través de la consola. Los capítulos sobre Evaluación y Simplificación tratan de las otras dos fases intermedias.

Marcas

Maxima almacena todas las entradas con la marca %i seguida de un número entero en orden creciente, así como las salidas o resultados con la marca %o también seguida de un número de orden. Además, ciertas funciones utilizan la marca intermedia %t. Otras variables del sistema almacenan el último resultado devuelto por Maxima o la última entrada efectuada por el usuario. Los siguientes símbolos indican variables y funciones para la gestión de las marcas:

   __          _        
   %           %%           %th
   inchar      linechar     outchar
   linenum     nolabels

Listas informativas

Maxima gestiona listas informativas, cuyos nombres se guardan en la variable del sistema infolists. En el presente capítulo se describen las listas labels, values y myoptions. Los siguientes símbolos indican variables y funciones relacionadas con las listas informativas y variables opcionales.

   infolists     labels        values 
   myoptions     optionset

Otras listas informativas, que se describirán en otros capítulos, son:

   functions      arrays         macros
   rules          aliases        dependencies 
   gradefs        props          let_rule_packages
   structures

Borrado y reiniciación

A fin de establecer el contexto en el que trabaje Maxima, en el que no haya variables o funciones definidas, o en el que se eliminen hipótesis, propiedades o definiciones concretas, se dispone de las siguientes funciones:

   kill     reset     reset_verbosely

Otras instrucciones

Se puede acceder a la documentación con los símbolos ? y ??. En caso de que se utilice ? a modo de prefijo de un símbolo, éste se interpretará como símbolo de Lisp. Hay instrucciones para terminar una sesión de Maxima o para cambiar a una sesión de Lisp. También es posible conocer el tiempo que ha necesitado Maxima para realizar un cálculo. Para este tipo de cuestiones, Maxima dispone de las siguientes instrucciones:

   ?            ??
   playback     prompt     showtime
   quit         to_lisp

Las funciones read und readonly imprimen texto en la consola y leen la información introducida por el usuario.

Salida por consola

Antes de mostrar un resultado, se transforma su representación interna a otra externa. Por ejemplo, la representación interna de sqrt(x) es x^(1/2), y ambos formatos pueden ser devueltos por Maxima en función del valor que guarde la variable opcional sqrtdispflag.

Los siguientes símbolos y variables opcionales controlan la salida de resultados por consola:

   %edispflag         absboxchar       display2d
   display_format_internal             exptdispflag
   expt               nexpt            ibase
   linel              lispdisp         negsumdispflag
   obase              pfeformat        powerdisp
   sqrtdispflag       stardisp         ttyoff

Con las siguientes funciones es posible formatear los resultados:

   disp               display          dispterms
   grind              ldisp            ldisplay
   print

4.2 Funciones y variables para la línea de comandos

Variable del sistema: __ ¶

__ es la expresión de entrada que está siendo actualmente evaluada. Esto es, mientras se está evaluando una expresión de entrada, __ es igual a expr.

A __ se le asigna la expresión de entrada antes de que ésta sea simplificada o evaluada. Sin embargo, el valor de __ es simplificado, pero no evaluado, cuando su valor es mostrado en el terminal.

La variable __ es reconocida por batch y por load. Cuando un fichero es procesado por batch, la variable __ tiene el mismo significado que en el modo interactivo. Cuando un fichero es procesado por load, a la variable __ se le asigna la última expresión introducida, bien desde el modo interactivo, bien en un fichero por lotes; en ningún caso se le asigna a __ una expresión de entrada del fichero que está siendo procesado. En particular, si load (filename) es ejecutado desde el modo interactivo, entonces __ almacena la expresión load (filename) mientras el fichero está siendo procesado.

Véanse también _ y %.

Ejemplos:

(%i1) print ("I was called as", __);
I was called as print(I was called as, __) 
(%o1)              print(I was called as, __)
(%i2) foo (__);
(%o2)                     foo(foo(__))
(%i3) g (x) := (print ("Current input expression =", __), 0);
(%o3) g(x) := (print("Current input expression =", __), 0)
(%i4) [aa : 1, bb : 2, cc : 3];
(%o4)                       [1, 2, 3]
(%i5) (aa + bb + cc)/(dd + ee + g(x));
                            cc + bb + aa
Current input expression = -------------- 
                           g(x) + ee + dd
                                6
(%o5)                        -------
                             ee + dd

Variable del sistema: _ ¶

El símbolo _ representa la última expresión de entrada (esto es, %i1, %i2, %i3, ...).

Al símbolo _ se le asigna la expresión de entrada antes de que ésta sea simplificada o evaluada. Sin embargo, el valor de _ se simplifica (pero no se evalúa) cuando se muestra en el terminal.

La variable _ es reconocida por batch y por load. Cuando un fichero es procesado por batch, la variable _ tiene el mismo significado que en el modo interactivo. Cuando un fichero es procesado por load, a la variable _ se le asigna la última expresión introducida, bien desde el modo interactivo, bien en un fichero por lotes; en ningún caso se le asigna a _ una expresión de entrada del fichero que está siendo procesado.

Véanse también __ y %.

Ejemplos:

(%i1) 13 + 29;
(%o1)                          42
(%i2) :lisp $_
((MPLUS) 13 29)
(%i2) _;
(%o2)                          42
(%i3) sin (%pi/2);
(%o3)                           1
(%i4) :lisp $_
((%SIN) ((MQUOTIENT) $%PI 2))
(%i4) _;
(%o4)                           1
(%i5) a: 13$
(%i6) b: 29$
(%i7) a + b;
(%o7)                          42
(%i8) :lisp $_
((MPLUS) $A $B)
(%i8) _;
(%o8)                         b + a
(%i9) a + b;
(%o9)                          42
(%i10) ev (_);
(%o10)                         42

Variable del sistema: % ¶

El símbolo % representa la expresión de salida (esto es, %o1, %o2, %o3, ...) más reciente calculada por Maxima, independientemente de que la haya mostrado o no.

La variable % es reconocida por batch y por load. Cuando un fichero es procesado por batch, la variable % tiene el mismo significado que en el modo interactivo. Cuando un fichero es procesado por load, a la variable % se le asigna la última expresión introducida, bien desde el modo interactivo, bien en un fichero por lotes; en ningún caso se le asigna a % una expresión de entrada del fichero que está siendo procesado.

Véanse también _, %% y %th.

Variable del sistema: %% ¶

En una sentencia compuesta, como block, lambda o (s_1, ..., s_n), %% es el valor de la sentencia previa.

La variable %% no está definida cuando se utiliza en la primera sentencia, o fuera de una sentencia compuesta.

%% se puede utilizar con batch y load, manteniendo en ambos casos el mismo significado que en el modo interactivo.

Véase también %

Ejemplos:

Los siguientes dos ejemplos devuelven el mismo resultado.

(%i1) block (integrate (x^5, x), ev (%%, x=2) - ev (%%, x=1));
                               21
(%o1)                          --
                               2
(%i2) block ([prev], prev: integrate (x^5, x),
               ev (prev, x=2) - ev (prev, x=1));
                               21
(%o2)                          --
                               2

Una sentencia compuesta puede contener otras sentencias compuestas. Independientemente de que una sentencia sea simple o compuesta, %% es el valor de la sentencia previa.

(%i3) block (block (a^n, %%*42), %%/6);
                                 n
(%o3)                         7 a

Dentro de una sentencia compuesta, el valor de %% puede inspeccionarse en un punto de interrupción que se abra ejecutando la función break. Por ejemplo, escribiendo %%; en el siguiente ejemplo se obtiene 42.

(%i4) block (a: 42, break ())$

Entering a Maxima break point. Type 'exit;' to resume.
_%%;
42
_

Función: %th (i) ¶

Es el valor de la expresión de la i-ésima salida anterior. Esto es, si la siguiente expresión a calcular es la salida n-ésima, %th (m) es la salida (n - m)-ésima.

%th es reconocido por batch y load, interpretándose de la misma manera que se acaba de indicar. Cuando un fichero es procesado por load, %th se refiere a los cálculos más recientes; %th no hace referencia a las expresiones de salida incluidas en el propio fichero que se está procesando.

Véanse también % y %%

Ejemplo:

%th es útil en ficheros batch para hacer referencia a grupos de resultados recién obtenidos. En este ejemplo se asigna a s la suma de los cinco resultados.

(%i1) 1;2;3;4;5;
(%o1)                           1
(%o2)                           2
(%o3)                           3
(%o4)                           4
(%o5)                           5
(%i6) block (s: 0, for i:1 thru 5 do s: s + %th(i), s);
(%o6)                          15

Símbolo especial: ? ¶

Como prefijo de una función o nombre de variable, ? significa que el nombre es de Lisp, no de Maxima. Por ejemplo, ?round representa la función de Lisp ROUND. Véase Lisp y Maxima para más información.

La notación ? word (un símbolo de interrogación seguido de una palabra y separados por un espacio) equivale a describe ("word"). El símbolo de interrogación debe escribirse al comienzo de la línea de entrada; en caso contrario no se reconoce como una solicitud de documentación.

Símbolo especial: ?? ¶

La notación ?? palabra (?? seguido de un espacio y una palabra) equivale a describe("palabra", inexact). El símbolo de interrogación debe escribirse al comienzo de la línea de entrada; en caso contrario no se reconoce como una solicitud de documentación.

Variable opcional: inchar ¶

Valor por defecto: %i

La variable inchar es el prefijo de las etiquetas de las expresiones introducidas por el usuario. Maxima crea automáticamente una etiqueta para cada expresión de entrada concatenando inchar y linenum.

A inchar se le puede asignar cualquier símbolo o cadena, no necesariamente un caracácter sencillo. Puesto que internamente Maxima solo tiene en cuenta el primer carácter del prefijo, los prefijos inchar, outchar y linechar deben comenzar con caracteres diferentes; en caso contrario, sentencias como kill(inlables) pueden dar resultados inesperados.

Véase también labels.

Ejemplo:

(%i1) inchar: "input";
(%o1)                         input
(input2) expand((a+b)^3);
                     3        2      2      3
(%o2)               b  + 3 a b  + 3 a  b + a
(input3)

Variable del sistema: infolists ¶

Valor por defecto: []

La variable infolists es una lista con los nombres de todas las listas que guardan información sobre Maxima. Estas son:

labels

Todas las etiquetas %i, %o y %t con valores asignados.

values

Todos los átomos que son variables de usuario, no opciones de Maxima creadas con : o ::.

functions

Todas las funciones de usuario creadas con := o define.

arrays

Arreglos declarados y no declarados, creados por :, :: o :=.

macros

Cualquier macro definida por el usuario.

myoptions

Todas las opciones inicializadas por el usuario, independientemente de que posteriormente hayan sido devueltas a sus valores por defecto.

rules

Reglas de patrones y simplificación definidas por el usuario, creadas con tellsimp, tellsimpafter, defmatch o defrule.

aliases

Átomos que tienen un "alias" definido por el usuario, creado por las funciones alias, ordergreat o orderless o por haber declarado el átomo como noun (nombre) con declare.

dependencies

Átomos que tienen dependencias funcionales, creados por las funciones depends o gradef.

gradefs

Funciones que tienen derivadas definidas por el usuario, creadas por la función gradef.

props

Todos los átomos que tengan cualquier propiedad que no sea de las mencionadas hasta ahora, como las establecidas por atvalue, matchdeclare, etc., así como propiedadas especificadas en la función declare.

let_rule_packages

Todos los paquetes de reglas let definidos por el usuario, junto con el paquete especial default_let_rule_package; default_let_rule_package es el nombre del paquete de reglas utilizado cuando no se use ningún otro especificado por el usuario.

Función: kill (a_1, ..., a_n) ¶

Función: kill (labels) ¶

Función: kill (inlabels, outlabels, linelabels) ¶

Función: kill (n) ¶

Función: kill ([m, n]) ¶

Función: kill (values, functions, arrays, ...) ¶

Función: kill (all) ¶

Función: kill (allbut (a_1, ..., a_n)) ¶

Elimina todas las asignaciones (valor, función, arreglo o regla) hechas a los argumentos a_1, ..., a_n. Un argumento a_k puede ser un símbolo o el elemento de un array. Si a_k es elemento de un array, kill elimina la asignación hecha a este elemento sin afectar al resto del array.

Se reconocen varios argumentos especiales. Se pueden combinar diferentes clases de argumentos, como por ejemplo, kill (inlabels, functions, allbut (foo, bar)).

La instrucción kill (labels) borra todas las asignaciones asociadas a las etiquetas de entrada, de salida e intermedias creadas hasta el momento. La instrucción kill (inlabels) elimina únicamente las asignaciones de las etiquetas de entrada que comienzan con el valor actual de inchar. Del mismo modo, kill (outlabels) elimina únicamente las asignaciones de las etiquetas de salida que comienzan con el valor actual de outchar. Finalmente, kill (linelabels) elimina únicamente las asignaciones de las etiquetas de las expresiones intermedias que comienzan con el valor actual de linechar.

La instrucción kill (n), siendo n un entero, elimina las asignaciones de las últimas n etiquetas, tanto de entrada como de salida.

La instrucción kill ([m, n]) elimina las asignaciones hechas a las etiquetas de entrada y salida desde la m hasta lan.

La instrucción kill (infolist), siendo infolist cualquier elemento de infolists (como values, functions o arrays), elimina todas las asignaciones hechas a los elementos de infolist. Véase también infolists.

La instrucción kill (all) elimina todas las asignaciones de todas las variables, pero no reinicia las variables globales a sus valores por defecto. Véase también reset.

La instrucción kill (allbut (a_1, ..., a_n)) elimina las asignaciones hechas a todas las variables, excepto a a_1, ..., a_n; la instrucción kill (allbut (infolist)) elimina todas las asignaciones, excepto las de los elementos de infolist, pudiendo ser infolist igual a values, functions, arrays, etc.

La memoria reservada para una asignación no se libera hasta que no se vacíen todos los símbolos asociados con esta asignación; por ejemplo, para liberar la memoria del valor de un símbolo es necesario eliminar tanto la asignación de la etiqueta de salida que muestra el resultado, como la del propio símbolo.

La función kill no evalua sus argumentos. El operador comilla-comilla, '', obliga a que se realice la evaluación.

La llamada kill (symbol) elimina todas las propiedades de symbol. Por el contrario, remvalue, remfunction, remarray y remrule eliminan propiedades específicas.

kill siempre devuelve done, incluso cuando alguno de sus argumentos carecía de asignación previa.

Función: labels (symbol) ¶

Variable del sistema: labels ¶

Retorna la lista de etiquetas de entrada, salida o de expresiones intermedias las cuales empiezan con symbol. Típicamente symbol es el valor de las variables inchar, outchar o linechar. El caractér de etiqueta puede ser pasado con o sin signo de porcentaje, así, por ejemplo, i y %i producen el mismo resultado.

Si ninguna etiqueta empieza con symbol, labels retorna a una lista vacía.

La función labels no evalua su argumento. El operador comilla-comilla, '', obliga a que se realice la evaluación. Por ejemplo, labels (''inchar) devuelve las etiquetas de entrada que empiezan con el caractér de etiqueta de entrada actual.

La variable labels es una lista de las etiquetas de entrada, salida y expresiones intermedias, incluyendo todas las etiquetas anteriores en el caso de que inchar, outchar o linechar hayan sido redefinidas.

Por defecto, Maxima muestra el resultado de cada expresión introducida por el usuario, asignando al resultado una etiqueta de salida. La salida (es decir el resultado) puede ser suprimida terminando la expresión de entrada con un $ (signo de dólar) en vez de un ; (punto y coma). En este caso, se crea la etiqueta de salida y se le asigna el resultado, aunque éste no se muestre; aún así, la etiqueta puede ser referenciada de la misma forma que se hace con aquéllas cuyos resultados sí son mostrados.

Véanse también: %, %% y %th.

Las etiquetas de expresiones intermedias pueden ser generadas por algunas funciones. El interruptor programmode controla si solve y algunas otras funciones generan etiquetas de expresiones intermedias en vez de retornar una lista de expresiones. Algunas otras funciones, tales como ldisplay, siempre generan etiquetas de expresiones intermedias.

Véase también: inchar, outchar, linechar y infolists.

Variable opcional: linechar ¶

Valor por defecto: %t

La variable linechar es el prefijo de las etiquetas que genera Maxima para expresiones intermedias. Cuando sea necesario, Maxima creará una etiqueta para cada expresión intermedia concatenando linechar y linenum.

A linechar se le puede asignar cualquier símbolo o cadena, no necesariamente un caracácter sencillo. Puesto que internamente Maxima solo tiene en cuenta el primer carácter del prefijo, los prefijos inchar, outchar y linechar deben comenzar con caracteres diferentes; en caso contrario, sentencias como kill(inlables) pueden dar resultados inesperados.

Las expresiones intermedias pueden ser mostradas o no. Véanse también programmode y labels.

Variable del sistema: linenum ¶

El número de la línea del par de expresiones de entrada y salida actuales.

Variable del sistema: myoptions ¶

Valor por defecto: []

myoptions es la lista de todas las opciones que nunca fueron reconfiguradas por el usuario, aunque éstas hayan sido reconfiguradas a su valor por defecto.

Variable opcional: nolabels ¶

Valor por defecto: false

Cuando nolabels vale true, las etiquetas de entrada y salida (%i y %o, respectivamente) son mostradas, pero a éstas no se les asignan los resultados; además, las etiquetas no se incorporan a la lista labels. Puesto que a las etiquetas no se les asignan resultados, el colector de basura puede recuperar la memoria ocupada por éstos.

En el caso contrario, a las etiquetas de entrada y salida se les asignan los resultados correspondientes y son añadidas a la lista labels.

Las etiquetas de expresiones intermedias (%t) no se ven afectadas por la variable nolabels; independientemente de que nolabels valga true o false, a las etiquetas de expresiones intermedias se les asignan siempre valores, además de ser añadidas a la lista labels.

Véanse también batch, batchload y labels.

Variable opcional: optionset ¶

Valor por defecto: false

Cuando optionset tiene como valor true, Maxima imprime un mensaje cada vez que una opción de Maxima es reconfigurada. Esto es muy útil si el usuario duda con frecuencia de la correctitud de alguna opción y quiere estar seguro de la variable a la que él asignó un valor fue verdaramente una variable opción (o interruptor).

Ejemplo:

(%i1) optionset:true;
assignment: assigning to option optionset
(%o1)                         true
(%i2) gamma_expand:true;
assignment: assigning to option gamma_expand
(%o2)                         true

Variable opcional: outchar ¶

Valor por defecto: %o

La variable outchar es el prefijo de las etiquetas de las expresiones calculadas por Maxima. Maxima crea automáticamente una etiqueta para cada expresión calculada concatenando outchar y linenum.

A outchar se le puede asignar cualquier símbolo o cadena, no necesariamente un caracácter sencillo. Puesto que internamente Maxima solo tiene en cuenta el primer carácter del prefijo, los prefijos inchar, outchar y linechar deben comenzar con caracteres diferentes; en caso contrario, sentencias como kill(inlables) pueden dar resultados inesperados.

Véase también labels.

Ejemplo:

(%i1) outchar: "output";
(output1)                    output
(%i2) expand((a+b)^3);
                     3        2      2      3
(output2)           b  + 3 a b  + 3 a  b + a
(%i3)

Función: playback () ¶

Función: playback (n) ¶

Función: playback ([m, n]) ¶

Función: playback ([m]) ¶

Función: playback (input) ¶

Función: playback (slow) ¶

Función: playback (time) ¶

Función: playback (grind) ¶

Muestra las entradas, salidas y expresiones intermedias sin recalcularlas. playback sólo muestra las expresiones asociadas con etiquetas; cualquier otra salida (tal como texto impreso por print o describe, o mensajes de error) no es mostrada. Véase también: labels.

playback no evalua sus argumentos. El operador comilla-comilla, '', obliga a que se realice la evaluación. playback siempre devuelve done.

playback () (sin argumentos) muestra todas las entradas, salidas y expresiones intermedias generadas hasta el momento. Una expresión de salida es mostrada incluso si ésta fue suprimida por el caracter de terminación $, cuando fue originalmente calculada.

playback (n) muestra las n expresiones más recientes. Cada entrada, salida y expresión intermedia cuenta como una.

playback ([m, n]) muestra entradas, salidas y expresiones intermedias con los números desde m hasta n, ambos inclusive.

playback ([m]) es equivalente a playback ([m, m]); esto usualmente imprime un par de expresiones de entrada y salida.

playback (input) muestra todas las expresiones de entrada generadas hasta el momento.

playback (slow) hace pausas entre expresiones y espera a que el usuario pulse la tecla enter para continuar. Esto es un comportamiento similar a demo.

playback (slow) es muy útil en conjunción con save o stringout cuando se crea un archivo secundario de almacenamiento con el objetivo de elegir cuidadosamente las expresiones realmente útiles.

playback (time) muestra el tiempo de computo por cada expresión.

playback (grind) muestra las expresiones de entrada en el mismo formato como la función grind. Las expresiones de salida no se ven afectadas por la opción grind. Vea grind. Los argumentos pueden ser combinados, por ejemplo, playback ([5, 10], grind, time, slow).

Variable opcional: prompt ¶

Valor por defecto: _

prompt es el símbolo del prompt de la función demo, del modo playback (slow) y del bucle de interrupción de Maxima (el que se invoca con break).

Función: quit () ¶

Termina una sesión de Maxima. Nótese que la función debe ser invocada como quit(); o quit()$, no como quit.

Para parar un cálculo muy demorado pulse Control-C. La acción por defecto es retornar a prompt de Maxima. Si *debugger-hook* tiene como valor nil, pulsar Control-C abrirá el depurador de Lisp. Vea también: debugging.

Función: read (expr_1, ..., expr_n) ¶

Imprime expr_1, ..., expr_n y a continuación lee una expresión desde la consola y devuelve la expresión evaluada. La expresión termina con un punto y coma ; o con el símbolo de dólar $.

Véase también readonly.

(%i1) foo: 42$ 
(%i2) foo: read ("foo vale", foo, " -- nuevo valor.")$
foo vale 42  -- nuevo valor. 
(a+b)^3;
(%i3) foo;
                                     3
(%o3)                         (b + a)

Función: readonly (expr_1, ..., expr_n) ¶

Imprime expr_1, ..., expr_n y a continuación lee una expresión desde la consola y devuelve la expresión sin evaluar. La expresión termina con un punto y coma ; o con el símbolo de dólar $.

(%i1) aa: 7$
(%i2) foo: readonly ("Introducir expresion:");
Introducir expresion: 
2^aa;
                                  aa
(%o2)                            2
(%i3) foo: read ("Introducir expresion:");
Introducir expresion: 
2^aa;
(%o3)                            128

Véase también read.

Función: reset () ¶

Reconfigura muchas variables y opciones globales y algunas otras variables a sus valores por defecto.

reset procesa las variables que se encuentran en la lista Lisp *variable-initial-values*. La macro Lisp defmvar pone las variables en ésta lista (entre otras acciones). Muchas, pero no todas, las variables y opciones globales son definidas por defmvar, y algunas variables definidas por defmvar no son ni variables ni opciones globales.

Variable opcional: showtime ¶

Valor por defecto: false

Cuando showtime tiene como valor true, el tiempo de cálculo y el tiempo de retardo se imprimen junto con la salida de cada expresión.

El tiempo de cálculo se almacena siempre, de manera que time y playback puedan mostrar el tiempo de cálculo incluso cuando showtime vale false.

Véase también timer.

Function: to_lisp () ¶

Entra en el intérprete Lisp bajo Maxima. (to-maxima) retorna de nuevo a Maxima.

Ejemplo:

Define una función y entra en el nivel Lisp. La definición se consulta en la lista de propiedades, luego se extrae la definición de la función, se factoriza y almacena el resultado en la variable $result. Esta variable se puede utilizar luego una vez se haya vuelto al nivel de Maxima.

(%i1) f(x):=x^2+x;
                                         2
(%o1)                           f(x) := x  + x
(%i2) to_lisp();
Type (to-maxima) to restart, ($quit) to quit Maxima.

MAXIMA> (symbol-plist '$f)
(MPROPS (NIL MEXPR ((LAMBDA) ((MLIST) $X) ((MPLUS) ((MEXPT) $X 2) $X))))
MAXIMA> (setq $result ($factor (caddr (mget '$f 'mexpr))))
((MTIMES SIMP FACTORED) $X ((MPLUS SIMP IRREDUCIBLE) 1 $X))
MAXIMA> (to-maxima)
Returning to Maxima
(%o2)                                true
(%i3) result;
(%o3)                              x (x + 1)

Variable del sistema: values ¶

Valor inicial: []

values es una lista de todas las variables que el usuario ha creado (no incluye las opciones de Maxima ni los interruptores). La lista comprende los símbolos a los que se ha asignado un valor mediante : o ::.

Si el valor de una variable se borra con cualquiera de las instrucciones kill, remove o remvalue, dicha variable desaparece de la lista values.

Véase functions para una lista de funciones definidas por el usuario.

Ejemplos:

Primero, values muestra los símbolos a, b y c, pero no d, pues no tiene valor asignado, ni la función de usuario f. Luego los valores de las variables se borran y values queda como una lista vacía.

(%i1) [a:99, b::a-90, c:a-b, d, f(x):= x^2];
                                                  2
(%o1)                     [99, 9, 90, d, f(x) := x ]
(%i2) values;
(%o2)                              [a, b, c]
(%i3) [kill(a), remove(b,value), remvalue(c)];
(%o3)                          [done, done, [c]]
(%i4) values;
(%o4)                                 []

4.3 Funciones y variables para la impresión

Variable opcional: %edispflag ¶

Valor por defecto: false

Si %edispflag vale true, Maxima muestra %e elevado a un exponente negativo como un cociente. Por ejemplo, %e^-x se muestra como 1/%e^x. Véase también exptdispflag.

Ejemplo:

(%i1) %e^-10;
                               - 10
(%o1)                        %e
(%i2) %edispflag:true$
(%i3) %e^-10;
                               1
(%o3)                         ----
                                10
                              %e

Variable opcional: absboxchar ¶

Valor por defecto: !

La variable absboxchar es el carácter utilizado para representar el valor absoluto de una expresión que ocupa más de una línea de altura.

Ejemplo:

(%i1) abs((x^3+1));
                            ! 3    !
(%o1)                       !x  + 1!

Función: disp (expr_1, expr_2, ...) ¶

Es como display pero sólo se muestran los valores de los argumentos, no las ecuaciones. Es útil para argumentos complicados que no tienen nombre o en situaciones en las que solamente es de interés el valor del argumento pero no su nombre.

Véanse también ldisp y print.

Ejemplos:

(%i1) b[1,2]:x-x^2$
(%i2) x:123$
(%i3) disp(x, b[1,2], sin(1.0));
                               123

                                  2
                             x - x

                        .8414709848078965

(%o3)                         done

Función: display (expr_1, expr_2, ...) ¶

Muestra las ecuaciones cuyos miembros izquierdos son expr_i sin evaluar y cuyos miembros derechos son los valores de las expresiones. Esta función es útil en los bloques y en las sentencias for para mostrar resultados intermedios. Los argumentos de display suelen ser átomos, variables subindicadas o llamadas a funciones.

Véanse también ldisplay, disp y ldisp.

Ejemplos:

(%i1) b[1,2]:x-x^2$
(%i2) x:123$
(%i3) display(x, b[1,2], sin(1.0));
                             x = 123

                                      2
                         b     = x - x
                          1, 2

                  sin(1.0) = .8414709848078965

(%o3)                         done

Variable opcional: display2d ¶

Valor por defecto: true

Si display2d vale false, la salida por consola es una cadena unidimensional, en lugar de una expresión bidimensional.

Véase también leftjust para cambiar la justificación a la izquierda o el centrado de la ecuación.

Ejemplo:

(%i1) x/(x^2+1);
                               x
(%o1)                        ------
                              2
                             x  + 1
(%i2) display2d:false$
(%i3) x/(x^2+1);
(%o3) x/(x^2+1)

Variable opcional: display_format_internal ¶

Valor por defecto: false

Si display_format_internal vale true, las expresiones se muestran sin ser transformadas de manera que oculten su representación matemática interna. Se representa lo que la función inpart devolvería, en oposición a part.

Ejemplos:

User     part       inpart
a-b;      a - b     a + (- 1) b

           a            - 1
a/b;       -         a b
           b
                       1/2
sqrt(x);   sqrt(x)    x

          4 X        4
X*4/3;    ---        - X
           3         3

Función: dispterms (expr) ¶

Muestra expr en partes, una debajo de la otra. Esto es, primero se muestra el operador de expr, luego cada término si se trata de una suma, o cada factor si es un producto, o si no se muestra separadamente la parte de una expresión más general. Es útil si expr es demasiado grande para representarla de otra forma. Por ejemplo, si P1, P2, ... son expresiones muy grandes, entonces el programa de representación puede superar el espacio de almacenamiento tratando de mostrar P1 + P2 + ... todo junto. Sin embargo, dispterms (P1 + P2 + ...) muestra P1, debajo P2, etc. Cuando una expresión exponencial es demasiado ancha para ser representada como A^B, si no se utiliza dispterms, entonces aparecerá como expt (A, B) (o como ncexpt (A, B), en lugar de A^^B).

Ejemplo:

(%i1) dispterms(2*a*sin(x)+%e^x);

+

2 a sin(x)

  x
%e

(%o1)                         done

Símbolo especial: expt (a, b) ¶

Símbolo especial: ncexpt (a, b) ¶

Si una expresión exponencial es demasiado ancha para ser mostrada como a^b aparecerá como expt (a, b) (o como ncexpt (a, b) en lugar de a^^b).

Las funciones expt y ncexpt no se reconocen en una entrada.

Variable opcional: exptdispflag ¶

Valor por defecto: true

Si exptdispflag vale true, Maxima muestra las expresiones con exponentes negativos como cocientes. Véase también %edispflag.

Ejemplo:

(%i1) exptdispflag:true;
(%o1)                         true
(%i2) 10^-x;
                                1
(%o2)                          ---
                                 x
                               10
(%i3) exptdispflag:false;
(%o3)                         false
(%i4) 10^-x;
                                - x
(%o4)                         10

Función: grind (expr) ¶

Variable opcional: grind ¶

La función grind imprime expr en la consola en un formato admisible como entrada para Maxima. La función grind devuelve siempre done.

Cuando expr es el nombre de una función o macro, grind muestra la definición de la función o de la macro en lugar de sólo su nombre.

Véase también string, que devuelve una cadena en lugar de imprimir la salida. La función grind intenta imprimir la expresión de forma que sea lago más sencilla de leer que la salida de string.

Cuando la variable grind vale true, la salida de string y stringout tienen el mismo formato que la de grind; en caso contrario no se formatea la salida de esas funciones. El valor por defecto de la variable grind es false.

La variable grind también se puede utilizar como argumento en playback. Si grind está presente, playback imprime las expresiones de entrada en el mismo formato que lo hace la función grind; en caso contrario no se formatean la expresiones de entrada.

La función grind evalúa sus argumentos.

Ejemplos:

(%i1) aa + 1729;
(%o1)                       aa + 1729
(%i2) grind (%);
aa+1729$
(%o2)                         done
(%i3) [aa, 1729, aa + 1729];
(%o3)                 [aa, 1729, aa + 1729]
(%i4) grind (%);
[aa,1729,aa+1729]$
(%o4)                         done
(%i5) matrix ([aa, 17], [29, bb]);
                           [ aa  17 ]
(%o5)                      [        ]
                           [ 29  bb ]
(%i6) grind (%);
matrix([aa,17],[29,bb])$
(%o6)                         done
(%i7) set (aa, 17, 29, bb);
(%o7)                   {17, 29, aa, bb}
(%i8) grind (%);
{17,29,aa,bb}$
(%o8)                         done
(%i9) exp (aa / (bb + 17)^29);
                                aa
                            -----------
                                     29
                            (bb + 17)
(%o9)                     %e
(%i10) grind (%);
%e^(aa/(bb+17)^29)$
(%o10)                        done
(%i11) expr: expand ((aa + bb)^10);
         10           9        2   8         3   7         4   6
(%o11) bb   + 10 aa bb  + 45 aa  bb  + 120 aa  bb  + 210 aa  bb
         5   5         6   4         7   3        8   2
 + 252 aa  bb  + 210 aa  bb  + 120 aa  bb  + 45 aa  bb
        9        10
 + 10 aa  bb + aa
(%i12) grind (expr);
bb^10+10*aa*bb^9+45*aa^2*bb^8+120*aa^3*bb^7+210*aa^4*bb^6
     +252*aa^5*bb^5+210*aa^6*bb^4+120*aa^7*bb^3+45*aa^8*bb^2
     +10*aa^9*bb+aa^10$
(%o12)                        done
(%i13) string (expr);
(%o13) bb^10+10*aa*bb^9+45*aa^2*bb^8+120*aa^3*bb^7+210*aa^4*bb^6\
+252*aa^5*bb^5+210*aa^6*bb^4+120*aa^7*bb^3+45*aa^8*bb^2+10*aa^9*\
bb+aa^10
(%i14) cholesky (A):= block ([n : length (A), L : copymatrix (A),
  p : makelist (0, i, 1, length (A))], for i thru n do
  for j : i thru n do
  (x : L[i, j], x : x - sum (L[j, k] * L[i, k], k, 1, i - 1),
  if i = j then p[i] : 1 / sqrt(x) else L[j, i] : x * p[i]),
  for i thru n do L[i, i] : 1 / p[i],
  for i thru n do for j : i + 1 thru n do L[i, j] : 0, L)$
(%i15) grind (cholesky);
cholesky(A):=block(
         [n:length(A),L:copymatrix(A),
          p:makelist(0,i,1,length(A))],
         for i thru n do
             (for j from i thru n do
                  (x:L[i,j],x:x-sum(L[j,k]*L[i,k],k,1,i-1),
                   if i = j then p[i]:1/sqrt(x)
                       else L[j,i]:x*p[i])),
         for i thru n do L[i,i]:1/p[i],
         for i thru n do (for j from i+1 thru n do L[i,j]:0),L)$
(%o15)                        done
(%i16) string (fundef (cholesky));
(%o16) cholesky(A):=block([n:length(A),L:copymatrix(A),p:makelis\
t(0,i,1,length(A))],for i thru n do (for j from i thru n do (x:L\
[i,j],x:x-sum(L[j,k]*L[i,k],k,1,i-1),if i = j then p[i]:1/sqrt(x\
) else L[j,i]:x*p[i])),for i thru n do L[i,i]:1/p[i],for i thru \
n do (for j from i+1 thru n do L[i,j]:0),L)

Variable opcional: ibase ¶

Valor por defecto: 10

ibase es la base en la que Maxima lee valores enteros.

A ibase se le puede asignar cualquier entero entre 2 y 36 (base decimal), ambos inclusive. Si ibase es mayor que 10, las cifras a utilizar serán los dígitos de 0 a 9, junto con las letras del alfabeto A, B, C, ..., tantas como sean necesarias para completar la base ibase. Las letras se interpretarán como cifras sólo cuando el primer dígito sea un valor entre 9. Es indiferente hacer uso de letras mayúsculas o minúsculas. Las cifras para la base 36, la mayor posible, son los dígitos numéricos de 0 a 9 y las letras desde la A hasta la Z.

Cualquiera que sea el valor de ibase, si un entero termina con un punto decimal, se interpretará en base 10.

Véase también obase.

Ejemplos:

ibase menor que 10.

(%i1) ibase : 2 $
(%i2) obase;
(%o2)                          10
(%i3) 1111111111111111;
(%o3)                         65535

ibase mayor que 10. Las letras se interpretan como dígitos sólo si el primer dígito es una cifra entre 0 y 9.

(%i1) ibase : 16 $
(%i2) obase;
(%o2)                          10
(%i3) 1000;
(%o3)                         4096
(%i4) abcd;
(%o4)                         abcd
(%i5) symbolp (abcd);
(%o5)                         true
(%i6) 0abcd;
(%o6)                         43981
(%i7) symbolp (0abcd);
(%o7)                         false

Independientemente del valor de ibase, si el entero termina con un punto decimal, se interpretará en base diez.

(%i1) ibase : 36 $
(%i2) obase;
(%o2)                          10
(%i3) 1234;
(%o3)                         49360
(%i4) 1234.;
(%o4)                         1234

Función: ldisp (expr_1, ..., expr_n) ¶

Muestra las expresiones expr_1, ..., expr_n en la consola con el formato de salida; ldisp asigna una etiqueta a cada argumento y devuelve la lista de etiquetas.

Véanse también disp, display y ldisplay.

(%i1) e: (a+b)^3;
                                   3
(%o1)                       (b + a)
(%i2) f: expand (e);
                     3        2      2      3
(%o2)               b  + 3 a b  + 3 a  b + a
(%i3) ldisp (e, f);
                                   3
(%t3)                       (b + a)

                     3        2      2      3
(%t4)               b  + 3 a b  + 3 a  b + a

(%o4)                      [%t3, %t4]
(%i4) %t3;
                                   3
(%o4)                       (b + a)
(%i5) %t4;
                     3        2      2      3
(%o5)               b  + 3 a b  + 3 a  b + a

Función: ldisplay (expr_1, ..., expr_n) ¶

Muestra las expresiones expr_1, ..., expr_n en la consola con el formato de salida. Cad expresión se muestra como una ecuación de la forma lhs = rhs en la que lhs es uno de los argumentos de ldisplay y rhs su valor. Normalmente, cada argumento será el nombre de una variable. La función ldisp asigna una etiqueta a cada ecuación y devuelve la lista de etiquetas.

Véanse también disp, display y ldisp.

(%i1) e: (a+b)^3;
                                   3
(%o1)                       (b + a)
(%i2) f: expand (e);
                     3        2      2      3
(%o2)               b  + 3 a b  + 3 a  b + a
(%i3) ldisplay (e, f);
                                     3
(%t3)                     e = (b + a)

                       3        2      2      3
(%t4)             f = b  + 3 a b  + 3 a  b + a

(%o4)                      [%t3, %t4]
(%i4) %t3;
                                     3
(%o4)                     e = (b + a)
(%i5) %t4;
                       3        2      2      3
(%o5)             f = b  + 3 a b  + 3 a  b + a

Variable opcional: linel ¶

Valor por defecto: 79

La variable linel es la anchura (medida en número de caracteres) de la consola que se le da a Maxima para que muestre las expresiones. A linel se le puede asignar cualquier valor, pero si éste es muy pequeño o grande resultará de poca utilidad. El texto que impriman las funciones internas de Maxima, como los mensajes de error y las salidas de la función describe, no se ve afectado por el valor de linel.

Variable opcional: lispdisp ¶

Valor por defecto: false

Si lispdisp vale true, los símbolos de Lisp se muestran precedidos del carácter de interrogación ?. En caso contrario, los símbolos de Lisp se muestran sin esta marca.

Ejemplos:

(%i1) lispdisp: false$
(%i2) ?foo + ?bar;
(%o2)                       foo + bar
(%i3) lispdisp: true$
(%i4) ?foo + ?bar;
(%o4)                      ?foo + ?bar

Variable opcional: negsumdispflag ¶

Valor por defecto: true

Si negsumdispflag vale true, x - y se muestra como x - y en lugar de - y + x. Dándole el valor false se realiza un análisis adicional para que no se representen de forma muy diferente dos expresiones similares. Una aplicación puede ser para que a + %i*b y a - %i*b se representen ambas de la misma manera.

Variable opcional: obase ¶

Valor por defecto: 10

obase es la base en la que Maxima imprime los números enteros.

A obase se le puede asignar cualquier entero entre 2 y 36 (base decimal), ambos inclusive. Si obase es mayor que 10, las cifras a utilizar serán los dígitos de 0 a 9, junto con las letras del alfabeto A, B, C, ..., tantas como sean necesarias para completar la base obase. Si el primer dígito resulta ser una letra, se le añadirá el cero como prefijo. Las cifras para la base 36, la mayor posible, son los dígitos numéricos de 0 a 9 y las letras desde la A hasta la Z.

Véase también ibase.

Ejemplos:

(%i1) obase : 2;
(%o1)                          10
(%i2) 2^8 - 1;
(%o10)                      11111111
(%i3) obase : 8;
(%o3)                          10
(%i4) 8^8 - 1;
(%o4)                       77777777
(%i5) obase : 16;
(%o5)                          10
(%i6) 16^8 - 1;
(%o6)                       0FFFFFFFF
(%i7) obase : 36;
(%o7)                          10
(%i8) 36^8 - 1;
(%o8)                       0ZZZZZZZZ

Variable opcional: pfeformat ¶

Valor por defecto: false

Si pfeformat vale true, una fracción de enteros será mostrada con el carácter de barra inclinada / entre ellos.

(%i1) pfeformat: false$
(%i2) 2^16/7^3;
                              65536
(%o2)                         -----
                               343
(%i3) (a+b)/8;
                              b + a
(%o3)                         -----
                                8
(%i4) pfeformat: true$ 
(%i5) 2^16/7^3;
(%o5)                       65536/343
(%i6) (a+b)/8;
(%o6)                      1/8 (b + a)

Variable opcional: powerdisp ¶

Valor por defecto: false

Si powerdisp vale true, se muestran las sumas con sus términos ordenados de menor a mayor potencia. Así, un polinomio se presenta como una serie de potencias truncada con el término constante al principio y el de mayor potencia al final.

Por defecto, los términos de una suma se muestran en el orden de las potencias decrecientes.

Ejemplo:

(%i1) powerdisp:true;
(%o1)                         true
(%i2) x^2+x^3+x^4;
                           2    3    4
(%o2)                     x  + x  + x
(%i3) powerdisp:false;
(%o3)                         false
(%i4) x^2+x^3+x^4;
                           4    3    2
(%o4)                     x  + x  + x

Función: print (expr_1, ..., expr_n) ¶

Evalúa y muestra las expresiones expr_1, ..., expr_n secuencialmente de izquierda a derecha, comenzando la impresión por el borde izquierdo de la consola.

El valor devuelto por print es el valor de su último argumento. La función print no genera etiquetas para las expresiones intermedias.

Véanse también display, disp, ldisplay y ldisp, que muestran una expresión por línea, mientras que print trata de mostrar dos o más expresiones por línea.

Para mostrar el contenido de un archivo véase printfile.

(%i1) r: print ("(a+b)^3 is", expand ((a+b)^3), "log (a^10/b) is",
      radcan (log (a^10/b)))$
            3        2      2      3
(a+b)^3 is b  + 3 a b  + 3 a  b + a  log (a^10/b) is 

                                              10 log(a) - log(b) 
(%i2) r;
(%o2)                  10 log(a) - log(b)
(%i3) disp ("(a+b)^3 is", expand ((a+b)^3), "log (a^10/b) is",
      radcan (log (a^10/b)))$
                           (a+b)^3 is

                     3        2      2      3
                    b  + 3 a b  + 3 a  b + a

                         log (a^10/b) is

                       10 log(a) - log(b)

Variable opcional: sqrtdispflag ¶

Valor por defecto: true

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

Variable opcional: stardisp ¶

Valor por defecto: false

Si stardisp vale true, la multiplicación se muestra con un asterisco * entre los operandos.

Variable opcional: ttyoff ¶

Valor por defecto: false

Si ttyoff vale true, no se muestran las expresiones resultantes, pero éstas se calculan de todos modos y se les asignan etiquetas. Véase labels.

El texto que escriban las funciones internas de Maxima, tales como los mensajes de error y las salidas de describe, no se ven afectadas por ttyoff.

5.1 Números

• Introducción a los números
• Funciones y variables para los números

(%i1) 1/3+5/4+3;
                               55
(%o1)                          --
                               12
(%i2) 100!;
(%o2) 9332621544394415268169923885626670049071596826438162146859\
2963895217599993229915608941463976156518286253697920827223758251\
185210916864000000000000000000000000
(%i3) 100!/101!;
                                1
(%o3)                          ---
                               101

   integerp       numberp       nonnegintegerp     
   oddp           evenp
   ratnump        rationalize

(%i1) [2.0,1f10,1,e10,1d10,1d300];
(%o1)        [2.0, 1.e+10, 1, e10, 1.e+10, 1.e+300]
(%i2) [2.0b0,1b10,1b300];
(%o2)               [2.0b0, 1.0b10, 1.0b300]

(%i1) 2.0+1/2+3;
(%o1)                                 5.5
(%i2) 2.0b0+1/2+3;
(%o2)                                5.5b0

(%i1) float([2,1/2,1/3,2.0b0]);
(%o1)          [2.0, 0.5, .3333333333333333, 2.0]
(%i2) bfloat([2,1/2,1/3,2.0b0]);
(%o2)     [2.0b0, 5.0b-1, 3.333333333333333b-1, 2.0b0]

   float        floatnump     
   bfloat       bfloatp       fpprec
   float2bf     bftorat       ratepsilon

   number_pbranch 
   m1pbranch

   realpart     imagpart      rectform     polarform
   cabs         carg          conjugate    csign

5.2 Cadenas de texto

• Introducción a las cadenas de texto
• Funciones y variables para las cadenas de texto

(%i1) s_1 : "This is a string.";
(%o1)               This is a string.
(%i2) s_2 : "Embedded \"double quotes\" and backslash \\ characters.";
(%o2) Embedded "double quotes" and backslash \ characters.
(%i3) s_3 : "Embedded line termination
in this string.";
(%o3) Embedded line termination
in this string.
(%i4) s_4 : "Ignore the \
line termination \
characters in \
this string.";
(%o4) Ignore the line termination characters in this string.
(%i5) stringdisp : false;
(%o5)                         false
(%i6) s_1;
(%o6)               This is a string.
(%i7) stringdisp : true;
(%o7)                         true
(%i8) s_1;
(%o8)              "This is a string."

5.3 Constantes

• Funciones y variables para Constantes

5.4 Listas

• Introducción a las listas
• Funciones y variables para listas

((MPLUS) $A 2)

[1, 2, 7, x+y]

((MLIST) 1  2  7  ((MPLUS)  $X $Y ))

((MLIST SIMP) 1 2 7 ((MPLUS SIMP) $X $Y))

5.5 Arrays

• Introducción a los arrays
• Funciones y variables para los arrays

(%i1) a[1,2]: 99;
(%o1)                          99
(%i2) a[x,y]: x^y;
                                y
(%o2)                          x
(%i3) listarray(a);
                                  y
(%o3)                       [99, x ]

(%i1) array(a, fixnum, 2, 2);
(%o1)                           a
(%i2) b: make_array(fixnum, 2, 2);
(%o2)              {Array:  #2A((0 0) (0 0))}

(%i3) use_fast_arrays: true;
(%o3)                         true
(%i4) array(c, 2, 2);
(%o4)    #2A((NIL NIL NIL) (NIL NIL NIL) (NIL NIL NIL))
(%i5) c;
(%o5)    #2A((NIL NIL NIL) (NIL NIL NIL) (NIL NIL NIL))
(%i6) array(c, fixnum, 2, 2);

make_array: dimensions must be integers; found [fixnum + 1, 3, 3]
 -- an error. To debug this try: debugmode(true);

   array         arrayapply     arrayinfo   
   arraymake     arrays         fillarray
   listarray     make_array     rearray
   remarray      subvar         subvarp
   use_fast_arrays

5.6 Estructuras

• Introducción a las estructuras
• Funciones y variables para las estructuras

6.1 Introducción a los operadores

Maxima reconoce los operadores aritméticos, relacionales y lógicos usuales de la matemática. Además, Maxima dispone de operadores para la asignación de valores a variables y la definición de funciones. La siguiente tabla muestra los operadores que se describen en este capítulo, en la que se incluye el nombre del operador, el rango de enlace por la izquierda lbp, el rango de enlace por la derecha rbp, el tipo de operador y un ejemplo, para finalizar, en cada caso, con su formato interno tal como es leída por el analizador sintáctico.

Operador  lbp rbp  Tipo     Ejemplo  Formato interno
                       
   +      100 134  nary     a+b      ((mplus) $A $B)
   -      100 134  prefix   -a       ((mminus) $A)
   *      120      nary     a*b      ((mtimes) $A $B)
   /      120 120  infix    a/b      ((mquotient) $A $B)
   ^      140 139  infix    a^b      ((mexpt) $A $B)
   **     140 139  infix    a**b     ((mexpt) $A $B)
   ^^     140 139  infix    a^^b     ((mncexpt) $A $B)
   .      130 129  infix    a.b      ((mnctimes) $A $B)
                                     
   <       80  80  infix    a<b      ((mlessp) $A $B)
   <=      80  80  infix    a<=b     ((mleqp) $A $B)
   >       80  80  infix    a>b      ((mqreaterp) $A $B)
   >=      80  80  infix    a>=b     ((mgeqp) $A $B)
                                     
   not         70  prefix   not a    ((mnot) $A)
   and     65      nary     a and b  ((mand) $A $B)
   or      60      nary     a or b   ((mor) $A $B)
                                     
   #       80  80  infix    a#b      ((mnotequal) $A $B)
   =       80  80  infix    a=b      ((mequal) $A $B)
                                     
   :      180  20  infix    a:b      ((msetq) $A $B)
   ::     180  20  infix    a::b     ((mset) $A $B)
   :=     180  20  infix    a:=b     ((mdefine) $A $B)
   ::=    180  20  infix    a::=b    ((mdefmacro) $A $B)

Con los rangos de enlace de los operadores se definen las reglas de prioridad de cálculo de los mismos. Así, por ejemplo, el analizador sintáctico interpreta la expresión a + b * c como a + (b * c) , pues el rango de enlace por la izquierda de la multiplicación es mayor que rango de enlace por la izquierda de la suma.

Maxima clasifica los operadores de la siguiente manera:

Prefijo (prefix)

Los operadores prefijos son unarios con un único operando que se escribe a continuación del operando. Ejemplos son - y not.

Sufijo (postfix)

Los operadores sufijos son unarios con un único operando que se escribe precediendo al operando. Un ejemplo es el factorial !.

Infijo (infix)

Los operadores infijos son operadores binarios que necesitan dos operandos, los cuales se colocan uno a cada lado del operador. Ejemplos son el operador para la exponenciación, ^, y el operador de asignación, :.

N-ario (n-ary)

Los operadores n-arios admiten un número arbitrario de operandos. Son ejemplos la multiplicación, *, y la suma, +.

Acotador (matchfix)

Los acotadores son operadores que se utilizan para establecer el comienzo y final de una lista de operandos. Los operadores [ y ] son ejemplos de acotadores, que se utilizan para definir una lista tal como [a, b, ...].

No-fijo (nofix)

Un operador no-fijo carece de operandos. Maxima no tiene operadores internos no-fijos, pero se pueden crear como cuando se escribe nofix(quit), lo que permite obviar el uso de paréntesis, y utilizar simplemente quit en lugar de quit(), para cerrar una sesión de Maxima.

En la sección dedicada a los operadores definidos por el usuario se describe cómo redefinir los operadores internos de Maxima y cómo crear otros nuevos.

El mecanismo para definir un nuevo operador es sencillo. Tan solo es necesario declarar una función como operador; la función operador puede estar definida o no.

Un ejemplo de operador definido por el usuario es el siguiente. Nótese que la llamada a función "dd" (a) equivale a dd a, de igual manera que "<-" (a, b) también equivale a a <- b. Nótese también que las funciones "dd" y "<-" no están definidas en este ejemplo.

(%i1) prefix ("dd");
(%o1)                          dd
(%i2) dd a;
(%o2)                         dd a
(%i3) "dd" (a);
(%o3)                         dd a
(%i4) infix ("<-");
(%o4)                          <-
(%i5) a <- dd b;
(%o5)                      a <- dd b
(%i6) "<-" (a, "dd" (b));
(%o6)                      a <- dd b

La tabla anterior no incluye todos los operadores definidos en Maxima, ya que también lo son ! para el factorial, for, do y while para programar bucles, o if, then y else para definir condicionales.

Las funciones remove y kill eliminan propiedades de operadores de un átomo. La llamada remove ("a", op) sólo elimina las propiedades de operador de a. La llamada kill ("a") elimina todas las propiedades de a, incluidas las propiedades de operador. Nótese que el nombre del operador debe ir entre comillas.

(%i1) infix ("##");
(%o1)                          ##
(%i2) "##" (a, b) := a^b;
                                     b
(%o2)                     a ## b := a
(%i3) 5 ## 3;
(%o3)                          125
(%i4) remove ("##", op);
(%o4)                         done
(%i5) 5 ## 3;
Incorrect syntax: # is not a prefix operator
5 ##
  ^
(%i5) "##" (5, 3);
(%o5)                          125
(%i6) infix ("##");
(%o6)                          ##
(%i7) 5 ## 3;
(%o7)                          125
(%i8) kill ("##");
(%o8)                         done
(%i9) 5 ## 3;
Incorrect syntax: # is not a prefix operator
5 ##
  ^
(%i9) "##" (5, 3);
(%o9)                       ##(5, 3)

6.2 Operadores aritméticos

Operador: + ¶

Operador: - ¶

Operador: * ¶

Operador: / ¶

Operador: ^ ¶

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

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

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

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

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

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

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

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

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

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

Ejemplos:

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

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

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

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

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

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

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

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

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

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

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

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

Operador: ** ¶

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

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

Ejemplos:

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

Operator: ^^ ¶

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

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

Ejemplos:

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

Operador: . ¶

El operador 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.

6.3 Operadores relacionales

Operator: < ¶

Operator: <= ¶

Operator: >= ¶

Operator: > ¶

Los símbolos <, <=, >= y > representan menor que, menor o igual que, mayor o igual que y mayor que, respectivamente. Los nombres de estos operadores son "<" "<=" ">=" y ">", que pueden aparecer allá donde se requiera el nombre de una función u operador.

Estos operadores relacionales son todos operadores binarios. Maxima no reconoce expresiones del estilo a < b < c.

Las expresiones relacionales devuelven valores booleanos haciendo uso de las funciones is o maybe, así como de las sentencias condicionales if, while y unless. Las expresiones relacionales no se evalúan de otra manera, aunque sus argumentos sí sean evaluados.

Cuando una expresión relacional no pueda ser evaluada a true o false, el comportamiento de is y de if estará controlado por la variable global prederror. Si prederror toma el valor true, is y if emiten un mensaje de error. Si prederror toma el valor false, is devuelve unknown y if devuelve una expresión condicional parcialmente evaluada.

maybe se comporta siempre como si prederror fuese false, al tiempo que while y unless se comportan siempre como si prederror fuese true.

Los operadores relacionales no se distribuyen sobre listas ni sobre cualesquiera otros tipos de estructuras de datos.

Véanse también =, #, equal y notequal.

Ejemplos:

Las expresiones relacionales se reducen a valores booleanos a través de ciertas funciones y sentencias condicionales.

(%i1) [x, y, z] : [123, 456, 789];
(%o1)                    [123, 456, 789]
(%i2) is (x < y);
(%o2)                         true
(%i3) maybe (y > z);
(%o3)                         false
(%i4) if x >= z then 1 else 0;
(%o4)                           0
(%i5) block ([S], S : 0, 
             for i:1 while i <= 100 do S : S + i, return (S));
(%o5)                         5050

Las expresiones relacionales no se evalúan de otra manera, aunque sus argumentos sí sean evaluados.

(%o1)                    [123, 456, 789]
(%i2) [x < y, y <= z, z >= y, y > z];
(%o2)    [123 < 456, 456 <= 789, 789 >= 456, 456 > 789]
(%i3) map (is, %);
(%o3)               [true, true, true, false]

6.4 Operadores lógicos

Operador: and ¶

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

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

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

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

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

Operador: not ¶

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

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

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

Operador: or ¶

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

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

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

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

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

6.5 Operadores para ecuaciones

Operador: # ¶

Representa la negación de la igualdad sintáctica =.

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

Ejemplos:

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

Operador: = ¶

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

6.6 Operadores de asignación

Operador: : ¶

Operador de asignación.

Cuando el miembro de la izquierda es una variable simple (no subindicada), : evalúa la expresión de la derecha 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 una variable simple.

(%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: :: ¶

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

Operador: ::= ¶

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

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

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

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

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

Ejemplos:

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

(%i1) x: %pi$

(%i2) y: 1234$

(%i3) z: 1729 * w$

(%i4) 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$

(%i2) y: 1234$

(%i3) z: 1729 * w$

(%i4) 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$

(%i2) y: 1234$

(%i3) z: 1729 * w$

(%i4) g (x) ::= buildq ([x], print ("x is equal to", x))$

(%i5) macroexpand (g (y - z));
(%o5)                     print(x is equal to, y - z)
(%i6) ''%;
x is equal to 1234 - 1729 w
(%o6)                            1234 - 1729 w
(%i7) g (y - z);
x is equal to 1234 - 1729 w
(%o7)                            1234 - 1729 w

Operador: := ¶

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

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

Todas las definiciones de funciones aparecen en el mismo espacio de nombres; definiendo una función f dentro de otra función g no limita automáticamente el alcance de f a g. No obstante, local(f) hace que la función f sea efectiva solamente dentro del bloque o empaquetado de expresiones en la que aparece local.

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

local define una función como local.

(%i1) foo (x) := 1 - x;
(%o1)                    foo(x) := 1 - x
(%i2) foo (100);
(%o2)                         - 99
(%i3) block (local (foo), foo (x) := 2 * x, foo (100));
(%o3)                          200
(%i4) foo (100);
(%o4)                         - 99

6.7 Operadores definidos por el usuario

Función: infix (op) ¶

Función: infix (op, lbp, rbp) ¶

Función: infix (op, lbp, rbp, lpos, rpos, pos) ¶

Declara op como operador infijo. Un operador infijo es una función de dos argumentos, con el nombre de la función escrito entre sus argumentos. Por ejemplo, el operador de sustracción - es un operador infijo.

infix (op) declara op como operador infijo con fuerzas de ligadura por la izquierda y por la derecha iguales a 180, que es el valor por defecto, y partes izquierda y derecha iguales a any.

infix (op, lbp, rbp) declara op como operador infijo con fuerzas de ligadura por la izquierda y por la derecha declaradas en los argumentos, siendo las partes izquierda y derecha iguales a any.

infix (op, lbp, rbp, lpos, rpos, pos) declara op como operador infijo con fuerzas de ligadura por la izquierda y por la derecha, junto con los tipos de expresiones correspondientes a lpos, rpos y pos, que son el operando de la izquierda, el de la derecha y el operador del resultado; los tipos reconocidos son: expr, clause y any, que indican expresión algebraica, expresión booleana o cualquier otra, respectivamente. Maxima puede detectar algunos errores sintácticos comparando los tipos declarados con los de la expresión actual.

La precedencia de op con respecto a otros operadores deriva de las fuerzas de ligadura de los operadores en cuestión. Si las fuerzas de ligadura a izquierda y derecha de op son ambas mayores que las fuerzas de ligadura a izquierda y derecha de otro operador, entonces op tiene preferencia sobre el otro operador. Si las fuerzas de ligadura no son ambas mayores o menores, se aplican otras relaciones más complejas.

La asociatividad de op depende de las fuerzas de ligadura. Una mayor fuerza de ligadura a la izquierda (lbp) implica que op sea evaluado antes que otros operadores a su izquierda en la expresión, mientras que mayor fuerza de ligadura a la derecha (rbp) implica que op sea evaluado antes que otros operadores a su derecha en la expresión. Así, si lbp es mayor, op es asociativo por la derecha, mientras que si rbp es mayor, op es asociativo por la izquierda.

Véase también Syntax.

Ejemplos:

Si las fuerzas de ligadura a izquierda y derecha de op son ambas mayores que las fuerzas de ligadura a izquierda y derecha de otro operador, entonces op tiene preferencia sobre el otro operador.

(%i1) :lisp (get '$+ 'lbp)
100
(%i1) :lisp (get '$+ 'rbp)
100
(%i1) infix ("##", 101, 101);
(%o1)                          ##
(%i2) "##"(a, b) := sconcat("(", a, ",", b, ")");
(%o2)       (a ## b) := sconcat("(", a, ",", b, ")")
(%i3) 1 + a ## b + 2;
(%o3)                       (a,b) + 3
(%i4) infix ("##", 99, 99);
(%o4)                          ##
(%i5) 1 + a ## b + 2;
(%o5)                       (a+1,b+2)

Mayor lbp hace a op asociativo por la derecha, mientras que mayor rbp hace a op asociativo por la izquierda.

(%i1) infix ("##", 100, 99);
(%o1)                          ##
(%i2) "##"(a, b) := sconcat("(", a, ",", b, ")")$
(%i3) foo ## bar ## baz;
(%o3)                    (foo,(bar,baz))
(%i4) infix ("##", 100, 101);
(%o4)                          ##
(%i5) foo ## bar ## baz;
(%o5)                    ((foo,bar),baz)

Maxima puede detectar algunos errores sintácticos comparando los tipos declarados con los de la expresión actual.

(%i1) infix ("##", 100, 99, expr, expr, expr);
(%o1)                          ##
(%i2) if x ## y then 1 else 0;
Incorrect syntax: Found algebraic expression where logical expression expected
if x ## y then 
             ^
(%i2) infix ("##", 100, 99, expr, expr, clause);
(%o2)                          ##
(%i3) if x ## y then 1 else 0;
(%o3)                if x ## y then 1 else 0

Función: matchfix (ldelimiter, rdelimiter) ¶

Función: matchfix (ldelimiter, rdelimiter, arg_pos, pos) ¶

Declara un operador "matchfix" con delimitadores a la izquierda y derecha, ldelimiter y rdelimiter, respectivamente. Los delimitadores son cadenas alfanuméricas.

Un operador "matchfix" es una función con un número arbitrario de argumentos, de manera que los argumentos se presentan entre los delimitadores de la izquierda y derecha. Los delimitadores pueden ser cualquier tipo de cadena, en tanto que el analizador sintáctico pueda distinguirlos de los operandos y de expresiones con operadores. En la práctica esto excluye delimitadores como %, ,, $ y ;, necesitando aislar los delimitadores con espacios en blanco. El delimitador de la derecha puede ser igual o diferente del de la izquierda.

Un delimitador de la izquierda sólo puede asociarse con un único delimitador de la derecha; dos operadores "matchfix" diferentes no pueden tener el mismo delimitador por la izquierda.

Un operador ya existente puede declararse como operador "matchfix" sin necesidad de que cambie el resto de propiedades. En particular, los operadores de Maxima tales como la suma + pueden ser declarados como "matchfix".

La llamada matchfix (ldelimiter, rdelimiter, arg_pos, pos) declara el argumento arg_pos y el resultado pos, así como los delimitadores ldelimiter y rdelimiter.

Los argumentos arg_pos y pos son tipos de funciones, reconociéndose como tales: expr, clause y any, los cuales hacen referencia a una expresión algebraica, booleana o de cualquier otro tipo, respectivamente. Maxima puede detectar ciertos errores sintácticos comparando el tipo de expresión declarado con el de la expresión actual.

La función que ejecutará una operación "matchfix" será una típica función definida por el usuario. La función de operador se define por el método habitual con := o define. Los argumentos pueden escribirse entre los delimitadores, o con el delimitador izquierdo como una cadena precedida de apóstrofo y seguidamente los argumentos entre paréntesis. La llamada dispfun (ldelimiter) muestra la definición de la función.

El único operador "matchfix" de Maxima es el constructor de listas [ ]. Los paréntesis ( ) y las comillas dobles " " actúan como operadores "matchfix", pero son tratados como operadores "matchfix" por el analizador sintáctico de Maxima.

Ejemplos:

• Los delimitadores pueden ser practicamente cualquier cadena.

(%i1) matchfix ("@@", "~");
(%o1)                          @@
(%i2) @@ a, b, c ~;
(%o2)                      @@a, b, c~
(%i3) matchfix (">>", "<<");
(%o3)                          >>
(%i4) >> a, b, c <<;
(%o4)                      >>a, b, c<<
(%i5) matchfix ("foo", "oof");
(%o5)                          foo
(%i6) foo a, b, c oof;
(%o6)                     fooa, b, coof
(%i7) >> w + foo x, y oof + z << / @@ p, q ~;
                     >>z + foox, yoof + w<<
(%o7)                ----------------------
                            @@p, q~

• Los operadores "matchfix" son funciones definidas por el usuario.

(%i1) matchfix ("!-", "-!");
(%o1)                         "!-"
(%i2) !- x, y -! := x/y - y/x;
                                    x   y
(%o2)                   !-x, y-! := - - -
                                    y   x
(%i3) define (!-x, y-!, x/y - y/x);
                                    x   y
(%o3)                   !-x, y-! := - - -
                                    y   x
(%i4) define ("!-" (x, y), x/y - y/x);
                                    x   y
(%o4)                   !-x, y-! := - - -
                                    y   x
(%i5) dispfun ("!-");
                                    x   y
(%t5)                   !-x, y-! := - - -
                                    y   x

(%o5)                         done
(%i6) !-3, 5-!;
                                16
(%o6)                         - --
                                15
(%i7) "!-" (3, 5);
                                16
(%o7)                         - --
                                15

Función: nary (op) ¶

Función: nary (op, bp, arg_pos, pos) ¶

Un operador n-ario denota una función con un número arbitrario de argumentos entre los que se intercal el símbolo del operador, como en A+B+C. La instrucción nary("x") declara x como operador n-ario. Las funciones se pueden declarar como n-arias; de modo que si se ejecuta declare(j,nary), el simplificador transforma j(j(a,b),j(c,d)) en j(a, b, c, d).

Función: nofix (op) ¶

Función: nofix (op, pos) ¶

Los operadores no-fijos se utilizan para definir funciones sin argumentos. La mera presencia de tal operador en una instrucción hará que se evalúe la función correspondiente. Por ejemplo, cuando se teclea exit; para salir de una interrupción de Maxima, exit se comporta como una función no-fija. La instrucción nofix("x") declara x como operador no-fijo.

Función: postfix (op) ¶

Función: postfix (op, lbp, lpos, pos) ¶

Los operadores sufijos son funciones de un único argumento en las que éste precede al operador, como en 3!. La instrucción postfix("x") declara x como operador sufijo.

Función: prefix (op) ¶

Función: prefix (op, rbp, rpos, pos) ¶

Los operadores prefijos son funciones de un único argumento en las que éste se coloca a continuación del operador. La instrucción prefix("x") declara x como operador prefijo.

7.1 Introducción a la evaluación

Las fases que se suceden desde que el usuario solicita un cálculo hasta que obtiene el resultado son: la propia solicitud del cálculo, la evaluación, la simplificación y la respuesta.

Toda expresión expr que se introduzca en Maxima será evaluada, de manera que los símbolos que no tengan asociado ningún valor y los números evalúan a sí mismos; en cambio, aquellos símbolos que tengan un valor asociado serán sustituídos por tales valores.

Dos ejemplos. En el primero, los símbolos y los números se evalúan a sí mismos; en el segundo ejemplo, al asignarle a la variable a el valor 2, allá donde se escriba a será sustituido por dicho valor.

(%i1) [a, b, 2, 1/2, 1.0];
                                  1
(%o1)                   [a, b, 2, -, 1.0]
                                  2
(%i2) a:2$

(%i3) [a, sin(a), a^2];
(%o3)                    [2, sin(2), 4]

Maxima distingue entre funciones en forma verbal y funciones en forma nominal. Las funciones en forma verbal son evaluadas tomando en cuenta los valores dados a sus argumentos; en cambio, las funciones nominales no son evaluadas, aunque sus argumentos tengan valores asignados. Las funciones son susceptibles de ser tratadas de ambos modos; ejemplos típicos son la función de diferenciación diff y la de integración integrate.

En el siguiente ejemplo se le asigna a la variable a cierto valor, a continuación se invoca la función diff en su forma verbal con sus argumentos tomando los valores a*x^2 y x. Seguidamente se invoca a la misma función diff en su forma nominal, lo cual se consigue mediante el operador de comilla simple ('); en este caso la función no es evaluada y devuelve una expresión simbólica en la que los argumentos sí han sido evaluados, pues la variable a es sustituida por el valor 1/2.

(%i1) a:1/2;
                                1
(%o1)                           -
                                2
(%i2) diff(a*x^2, x);
(%o2)                           x
(%i3) 'diff(a*x^2, x);

                                  2
                             d   x
(%o3)                        -- (--)
                             dx  2

Sin embargo, no todas las funciones de Maxima sustituyen sus argumentos por sus valores. La documentación para cada función informará si sus argumentos son evaluados o no.

Por ejemplo, la función properties no evalúa sus argumentos, lo cual resulta práctico para el usuario, ya que en caso contrario debería utilizar el operador de comilla simple ' a fin de poder mostrar las propiedades del símbolo a. A continuación se muestra como en el primer caso se devuelve una lista vacía, ya que no se le ha encontrado ninguna propiedad al símbolo a; una vez se le ha asignado el valor 2, la función properties nos dice que la variable guarda un valor y esto es así porque no ha sustituido el símbolo a por su valor 2. En consecuencia, la función properties muestra las propiedades de 'a.

(%i1) properties(a);
(%o1)                          []
(%i2) a:2$

(%i3) properties(a);
(%o3)                        [value]

La evaluación de símbolos, funciones y expresiones se puede controlar con los operadores de comilla simple (') y de doble comilla simple (''). La evaluación se suprime con la comilla simple y se fuerza con la doble comilla simple (que no comilla doble).

Con la función ev se evalúa una expresión dentro de un contexto determinado controlado por el valor de ciertas variables evflag y funciones de evaluación evfun.

7.2 Funciones y variables para la evaluación

Operador: ' ¶

El operador comilla simple ' evita la evaluación.

Aplicado a un símbolo, la comilla simple evita la evaluación del símbolo.

Aplicado a la llamada de una función, la comilla simple evita la evaluación de la función llamada, aunque los argumentos de la función son evaluados (siempre y cuando la evaluación no se evite de otra manera). El resultado es una forma de nombre de la función llamada.

Aplicado a una expresión con paréntesis, la comilla simple evita la evaluación de todos los símbolos y llamadas a funciones que hayan en la expresión. E.g., '(f(x)) significa que no se evalua la expresión f(x). 'f(x) (con la comilla simple aplicada a f en cambio de a f(x)) significa el retorno de la forma de nombre de f aplicada a [x].

La comilla simple no evita la simplificación.

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 definiciones de funciones.

Ver también los operadores comilla-comilla '' y nouns.

Ejemplos:

Aplicado a un símbolo, la comilla simple evita la evaluación del símbolo.

(%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 función, la comilla simple evita la evaluación de la función llamada, aunque los argumentos de la función son evaluados (siempre y cuando la evaluación no se evite de otra manera). El resultado es una forma de nombre de la función llamada.

(%i1) x0: 5;
(%o1)                           5
(%i2) x1: 7;
(%o2)                           7
(%i3) integrate (x^2, x, x0, x1);
                               218
(%o3)                          ---
                                3
(%i4) 'integrate (x^2, x, x0, x1);
                             7
                            /
                            [   2
(%o4)                       I  x  dx
                            ]
                            /
                             5
(%i5) %, nouns;
                               218
(%o5)                          ---
                                3

Aplicado a una expresión con paréntesis, la comilla simple evita la evaluación de todos los símbolos y llamadas a funciones que haya dentro en la expresión.

(%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 simple no evita la simplificación.

(%i1) sin (17 * %pi) + cos (17 * %pi);
(%o1)                          - 1
(%i2) '(sin (17 * %pi) + cos (17 * %pi));
(%o2)                          - 1

Internamente, Maxima considera que las operaciones con números decimales de coma flotante son simples simplificaciones.

(%i1) sin(1.0);
(%o1)                          .8414709848078965
(%i2) '(sin(1.0));
(%o2)                          .8414709848078965

Operador: '' ¶

El operador comilla-comilla '' (dos comillas simples) modifica la evaluación en las expresiones de entrada.

Aplicado a cualquier expresión general expr, las dos comillas simples hacen que el valor de expr sea sustituido por expr en la expresión de entrada.

Aplicado al operador de una expresión, el operador comilla-comilla hace que el operador pase de ser un nombre a ser un verbo, a menos que ya sea un verbo.

El operador comilla-comilla es aplicado por el analizador sintáctico de entrada; no se almacena como una parte de la expresión de entrada analizada. Este operador se aplica siempre tan pronto como es detectado y no puede ser comentado con una comilla simple. De esta manera, el operador comilla-comilla provoca la evaluación de una expresión cuando ésta no estaba previsto que fuese evaluada, como en la definición de funciones, expresiones lambda y expresiones comentadas con una comilla simple '.

El operador comilla-comilla es reconocido tanto por batch como por load.

Véanse también el operador comilla simple ' y nouns.

Ejemplos:

Aplicado a cualquier expresión general expr, las dos comillas simples hacen que el valor de expr sea sustituido por expr en la expresión de entrada.

(%i1) expand ((a + b)^3);
                     3        2      2      3
(%o1)               b  + 3 a b  + 3 a  b + a
(%i2) [_, ''_];
                         3    3        2      2      3
(%o2)     [expand((b + a) ), b  + 3 a b  + 3 a  b + a ]
(%i3) [%i1, ''%i1];
                         3    3        2      2      3
(%o3)     [expand((b + a) ), b  + 3 a b  + 3 a  b + a ]
(%i4) [aa : cc, bb : dd, cc : 17, dd : 29];
(%o4)                   [cc, dd, 17, 29]
(%i5) foo_1 (x) := aa - bb * x;
(%o5)                 foo_1(x) := aa - bb x
(%i6) foo_1 (10);
(%o6)                      cc - 10 dd
(%i7) ''%;
(%o7)                         - 273
(%i8) ''(foo_1 (10));
(%o8)                         - 273
(%i9) foo_2 (x) := ''aa - ''bb * x;
(%o9)                 foo_2(x) := cc - dd x
(%i10) foo_2 (10);
(%o10)                        - 273
(%i11) [x0 : x1, x1 : x2, x2 : x3];
(%o11)                    [x1, x2, x3]
(%i12) x0;
(%o12)                         x1
(%i13) ''x0;
(%o13)                         x2
(%i14) '' ''x0;
(%o14)                         x3

Aplicado al operador de una expresión, la doble comilla simple hace que el operador pase de ser nominal a verbal, a menos que ya sea un verbo.

(%i1) declare (foo, noun);
(%o1)                         done
(%i2) foo (x) := x - 1729;
(%o2)                 ''foo(x) := x - 1729
(%i3) foo (100);
(%o3)                       foo(100)
(%i4) ''foo (100);
(%o4)                        - 1629

El operador comilla-comilla es aplicado por el analizador sintáctico de entrada; no se almacena como una parte de la expresión de entrada analizada.

(%i1) [aa : bb, cc : dd, bb : 1234, dd : 5678];
(%o1)                 [bb, dd, 1234, 5678]
(%i2) aa + cc;
(%o2)                        dd + bb
(%i3) display (_, op (_), args (_));
                           _ = cc + aa

                         op(cc + aa) = +

                    args(cc + aa) = [cc, aa]

(%o3)                         done
(%i4) ''(aa + cc);
(%o4)                         6912
(%i5) display (_, op (_), args (_));
                           _ = dd + bb

                         op(dd + bb) = +

                    args(dd + bb) = [dd, bb]

(%o5)                         done

El operador comilla-comilla provoca la evaluación de una expresión cuando ésta no estaba previsto que fuese evaluada, como en la definición de funciones, expresiones lambda y expresiones comentadas con una comilla simple '.

(%i1) foo_1a (x) := ''(integrate (log (x), x));
(%o1)               foo_1a(x) := x log(x) - x
(%i2) foo_1b (x) := integrate (log (x), x);
(%o2)           foo_1b(x) := integrate(log(x), x)
(%i3) dispfun (foo_1a, foo_1b);
(%t3)               foo_1a(x) := x log(x) - x

(%t4)           foo_1b(x) := integrate(log(x), x)

(%o4)                      [%t3, %t4]
(%i5) integrate (log (x), x);
(%o5)                     x log(x) - x
(%i6) foo_2a (x) := ''%;
(%o6)               foo_2a(x) := x log(x) - x
(%i7) foo_2b (x) := %;
(%o7)                    foo_2b(x) := %
(%i8) dispfun (foo_2a, foo_2b);
(%t8)               foo_2a(x) := x log(x) - x

(%t9)                    foo_2b(x) := %

(%o9)                      [%t7, %t8]
(%i10) F : lambda ([u], diff (sin (u), u));
(%o10)             lambda([u], diff(sin(u), u))
(%i11) G : lambda ([u], ''(diff (sin (u), u)));
(%o11)                  lambda([u], cos(u))
(%i12) '(sum (a[k], k, 1, 3) + sum (b[k], k, 1, 3));
(%o12)         sum(b , k, 1, 3) + sum(a , k, 1, 3)
                    k                  k
(%i13) '(''(sum (a[k], k, 1, 3)) + ''(sum (b[k], k, 1, 3)));
(%o13)             b  + a  + b  + a  + b  + a
                    3    3    2    2    1    1

Función: ev (expr, arg_1, …, arg_n) ¶

Evalua la expresión expr en el entorno especificado por los argumentos arg_1, ..., arg_n. Los argumentos son interruptores (Variables Booleanas), variables de asignación, ecuaciones y funciones. ev retorna el resultado (otra expresión) de la evaluación.

La evaluación se realiza por etapas, como sigue:

1. Primero se configura el entorno de acuerdo a los argumentos los cuales pueden ser algunos o todos de la siguiente lista:
   • simp causa que expr sea simplificada sin importar el valor de la variable interruptor simp la cual inhibe la simplificación cuando su valor es false.
   • noeval suprime la fase de evaluación de ev (Vea el paso (4) más adelante). Esto es muy útil en conjunción con otras variables interruptor y causan en expr que sea resimplificada sin ser reevaluada.
   • nouns causa la evaluación de las formas nominales (típicamente funciones sin evaluar tales como 'integrate or 'diff) en expr.
   • expand causa expansión.
   • expand (m, n) causa expansión, asignando los valores de maxposex y maxnegex a m y n, respectivamente.
   • detout hace que cualesquiera matrices inversas calculadas en expr conserven su determinante fuera de la inversa, en vez de que divida a cada elemento.
   • diff realiza todas las diferenciaciones indicadas en expr.
   • derivlist (x, y, z, ...) realiza sólo las diferenciaciones con respecto a las variables indicadas.
   • risch hace que las integrales presentes en expr se evalúen mediante el algoritmo de Risch. Véase también risch. Cuando se utiliza el símbolo especial nouns, se aplica la rutina estándar de integración.
   • float provoca la conversión de los números racionales no-enteros a números decimales de coma flotante.
   • numer causa que algunas funciones matemáticas (incluyendo potenciación) con argumentos numéricos sean evaluados como punto flotante. Esto causa que las variables en expr las cuales hayan sido declaradas como variables numéricas sean reemplazadas por sus respectivos valores. Esto también configura la variable interruptor float a true.
   • pred provoca la evaluación de los predicados (expresiones las cuales se evaluan a true o false).
   • eval provoca una post-evaluación extra de expr (véase el paso (5) más adelante), pudiendo aparecer eval varias veces; por cada aparición de eval, la expresión es reevaluada.
   • A, donde A es un átomo declarado como una variable de tipo interruptor, (Vea evflag) causa que A tenga como valor true durante la evaluación de expr.
   • V: expresion (o alternativamente V=expresion) causa que V tenga el valor de expresion durante la evaluación de expr. Notese que si V es una opción Maxima, entonces expresion se usa como su valor durante la evaluación de expr. Si más de un argumento de ev es de este tipo entonces el vínculo se hace en paralelo. Si V es una expresión no atómica entonces se hace una sustitución más que un vínculo.
   • F donde F, un nombre de función, ha sido declarado para ser una función de evaluación (Vea evfun) causa que F sea aplicada a expr.
   • Cualquier otro nombre de función (e.g., sum) causa la evaluación de las ocurrencias de esos nombres en expr como si ellos fueran verbos.
   • En adición de que una función ocurra en expr (digamos F(x)) puede ser definida localmente para el propósito de esta evaluación de expr pasando F(x) := expresion como un argumento a ev.
   • Si un átomo no mencionado anteriormente o una variable o expresión con subíndices fueran pasadas como un argumento, esta es evaluada y si el resultado es una ecuación o una asignación entonces el vínculo o sustitución se llevará 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 excepción de la sustitución de ecuaciones las cuales son manipuladas en secuencia, de izquierda a derecha y las funciones de evaluación las cuales son compuestas, e.g., ev (expr, ratsimp, realpart) es manipulada como realpart (ratsimp (expr)).

   Los interruptores simp, numer y float pueden también ser configurados localmente en una sentencia block, o globalmente en Maxima para que su efecto permanezca hasta que sean reconfiguradas.

   Si expr es una Expresión Racional Canónica (CRE, por sus siglas en inglés), entonces la expresión retornada por ev es también 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 subíndices que aparecen en el lado izquierdo de las ecuaciones en los argumentos o en el valor de algunos argumentos si el valor es una ecuación. Las variables (variables que contienen subíndices las cuales no tienen asociado un arreglo de funciones como también las variables que no contienen subíndices) en la expresión expr son reemplazadas por sus valores globales, excepto por aquellos que aparezcan en esa lista. Usualmente, expr es sólo una etiqueta o un % (como en %i2 en el ejemplo de más abajo) así que este paso simplemente recupera la expresión a la que hace referencia la etiqueta y así ev puede trabajarla.
3. Si algunas sustituciones son indicadas por los argumentos, ellas serán llevadas a cabo ahora.
4. La expresión resultante es también reevaluada (a menos que uno de los argumentos fuese noeval) y simplificada de acuerdo a los argumentos. Notese que cualquier llamada a una función en expr será llevada a cabo después de que las variables sean evaluadas en ella y que ev(F(x)) pueda comportarse como F(ev(x)).
5. Por cada aparición de eval en los argumentos, se repetirán los pasos (3) y (4).

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 (%, numer, expand, diff, x=2, y=1);
                               2
(%o2)                cos(w) + w  + 2 w + 2.449599732693821

Una sintaxis alternativa de alto nivel ha sido desarrollada para ev por medio de la cual se pueden escribir solamente sus argumentos, sin el comando ev(); se trata de una forma de escritura simplificada:

expr, arg_1, ..., arg_n

Esta sintaxis no está permitida dentro de otras expresiones, como funciones, bloques, etc.

Nótese el proceso de vínculo 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]);
Solución

                                          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

Símbolo especial: eval ¶

Como argumento en una llamada a ev (expr), eval fuerza una evaluación extra de expr.

Véase también ev.

Ejemplo:

(%i1) [a:b,b:c,c:d,d:e];
(%o1)                            [b, c, d, e]
(%i2) a;
(%o2)                                  b
(%i3) ev(a);
(%o3)                                  c
(%i4) ev(a),eval;
(%o4)                                  e
(%i5) a,eval,eval;
(%o5)                                  e

Propiedad: evflag ¶

Cuando un símbolo x goza de la propiedad evflag, las expresiones ev(expr, x) y expr, x (en modo interactivo) equivalen a ev(expr, x = true). Esto es, a x se le asigna true al tiempo que se evalúa expr.

La expresión declare(x, evflag) dota a la variable x de la propiedad evflag.

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
   m1pbranch           numer_pbranch   programmode
   radexpand           ratalgdenom     ratfac
   ratmx               ratsimpexpons   simp
   simpproduct         simpsum         sumexpand
   trigexpand

Ejemplos:

(%i1) sin (1/2);
                                 1
(%o1)                        sin(-)
                                 2
(%i2) sin (1/2), float;
(%o2)                   0.479425538604203
(%i3) sin (1/2), float=true;
(%o3)                   0.479425538604203
(%i4) simp : false;
(%o4)                         false
(%i5) 1 + 1;
(%o5)                         1 + 1
(%i6) 1 + 1, simp;
(%o6)                           2
(%i7) simp : true;
(%o7)                         true
(%i8) sum (1/k^2, k, 1, inf);
                            inf
                            ====
                            \     1
(%o8)                        >    --
                            /      2
                            ====  k
                            k = 1
(%i9) sum (1/k^2, k, 1, inf), simpsum;
                                 2
                              %pi
(%o9)                         ----
                               6
(%i10) declare (aa, evflag);
(%o10)                        done
(%i11) if aa = true then YES else NO;
(%o11)                         NO
(%i12) if aa = true then YES else NO, aa;
(%o12)                         YES

Propiedad: evfun ¶

Cuando la función F goza de la propiedad evfun, las expresiones ev(expr, F) y expr, F (en modo interactivo) equivalen a F(ev(expr)).

Si se especifican dos o más funciones, F, G, etc., como poseedoras de la propiedad evfun, éstas se aplican en el mismo orden en el que han sido especificadas como tales.

La expresión declare(F, evfun) dota a la función F de la propiedad evfun.

Las funciones que tienen la propiedad evfun por defecto son:

   bfloat          factor       fullratsimp
   logcontract     polarform    radcan
   ratexpand       ratsimp      rectform
   rootscontract   trigexpand   trigreduce

Ejemplos:

(%i1) x^3 - 1;
                              3
(%o1)                        x  - 1
(%i2) x^3 - 1, factor;
                                2
(%o2)                 (x - 1) (x  + x + 1)
(%i3) factor (x^3 - 1);
                                2
(%o3)                 (x - 1) (x  + x + 1)
(%i4) cos(4 * x) / sin(x)^4;
                            cos(4 x)
(%o4)                       --------
                               4
                            sin (x)
(%i5) cos(4 * x) / sin(x)^4, trigexpand;
                 4           2       2         4
              sin (x) - 6 cos (x) sin (x) + cos (x)
(%o5)         -------------------------------------
                                4
                             sin (x)
(%i6) cos(4 * x) / sin(x)^4, trigexpand, ratexpand;
                           2         4
                      6 cos (x)   cos (x)
(%o6)               - --------- + ------- + 1
                          2          4
                       sin (x)    sin (x)
(%i7) ratexpand (trigexpand (cos(4 * x) / sin(x)^4));
                           2         4
                      6 cos (x)   cos (x)
(%o7)               - --------- + ------- + 1
                          2          4
                       sin (x)    sin (x)
(%i8) declare ([F, G], evfun);
(%o8)                         done
(%i9) (aa : bb, bb : cc, cc : dd);
(%o9)                          dd
(%i10) aa;
(%o10)                         bb
(%i11) aa, F;
(%o11)                        F(cc)
(%i12) F (aa);
(%o12)                        F(bb)
(%i13) F (ev (aa));
(%o13)                        F(cc)
(%i14) aa, F, G;
(%o14)                      G(F(cc))
(%i15) G (F (ev (aa)));
(%o15)                      G(F(cc))

Variable opcional: infeval ¶

Habilita el modo de "evaluación infinita". ev repetidamente evalua una expresión hasta que se pare de hacer cambios. Para prevenir que una variable, digamos X, sea evaluada sin parar en este modo, simplemente incluya X='X como argumento de ev. Esta claro que expresiones como ev (X, X=X+1, infeval) generarán un bucle infinito.

Símbolo especial: noeval ¶

El símbolo noeval evita la fase de evaluación de ev. Es útil conjuntamente con otras variables globales y para poder volver a simplificar expresiones sin tener que evaluarlas otra vez.

Símbolo especial: nouns ¶

El símbolo nouns es una evflag, lo que significa que cuando se utilice como una opción de la instrucción ev, todas las formas nominales que aparezcan en una expresión las convierte en verbales, esto es, las evalúa. Véanse también noun, nounify, verb y verbify.

Símbolo especial: pred ¶

Cuando se utiliza como argumento en una llamada a ev (expr), pred provoca que los predicados (expresiones que se reducen a true o false) se evalúen.

Véase ev.

Ejemplo:

(%i1) 1<2;
(%o1)                                1 < 2
(%i2) 1<2,pred;
(%o2)                                true

8.1 Introducción a las expresiones

Existe un cierto número de palabras reservadas que no deberían utilizarse como nombres de variables. Su uso podría causar errores sintácticos.

integrate            next           from                 diff            
in                   at             limit                sum             
for                  and            elseif               then            
else                 do             or                   if              
unless               product        while                thru            
step                                                                     

La mayoría de los objetos en Maxima son expresiones. Una secuencia de expresiones puede constituir una expresión, separándolas por comas y colocando paréntesis alrededor de ellas. Esto es similar a las expresiones con coma en C.

(%i1) x: 3$
(%i2) (x: x+1, x: x^2);
(%o2)                          16
(%i3) (if (x > 17) then 2 else 4);
(%o3)                           4
(%i4) (if (x > 17) then x: 2 else y: 4, y+x);
(%o4)                          20

Incluso los bucles en Maxima son expresiones, aunque el valor que retornan (done) no es muy útil.

(%i1) y: (x: 1, for i from 1 thru 10 do (x: x*i))$
(%i2) y;
(%o2)                         done

pero quizás se quiera incluir un tercer término en la expresión con coma para que devuelva el valor de interés.

(%i3) y: (x: 1, for i from 1 thru 10 do (x: x*i), x)$
(%i4) y;
(%o4)                        3628800

8.2 Nombres y verbos

Maxima distingue entre operadores que son "nombres" y operadores que son "verbos". Un verbo es un operador que puede ser ejecutado. Un nombre es un operador que aparece como un símbolo en una expresión pero sin ser ejecutado. Por defecto, los nombres de funciones son verbos. Un verbo puede transformarse en nombre utilizando el apóstrofo o aplicando la función nounify. Un nombre puede transformarse en verbo aplicando la función verbify. La variable nouns hace que ev evalúe los nombres presentes en una expresión.

La forma verbal se distingue mediante la precedencia del carácter dólar $ al correspondiente símbolo de Lisp. Por otro lado, la forma nominal se distingue mediante la precedencia del carácter porcentaje % al correspondiente símbolo de Lisp. Algunos nombres gozan de propiedades especiales para su representación, como 'integrate o 'derivative (devuelto por diff), pero la mayoría no. Por defecto, las formas nominal y verbal de una función son idénticas cuando se muestran en un terminal. La variable global noundisp hace que Maxima muestre los nombres precedidos del apóstrofo '.

Véanse también noun, nouns, nounify y verbify.

Ejemplos:

(%i1) foo (x) := x^2;
                                     2
(%o1)                     foo(x) := x
(%i2) foo (42);
(%o2)                         1764
(%i3) 'foo (42);
(%o3)                        foo(42)
(%i4) 'foo (42), nouns;
(%o4)                         1764
(%i5) declare (bar, noun);
(%o5)                         done
(%i6) bar (x) := x/17;
                                     x
(%o6)                    ''bar(x) := --
                                     17
(%i7) bar (52);
(%o7)                        bar(52)
(%i8) bar (52), nouns;
                               52
(%o8)                          --
                               17
(%i9) integrate (1/x, x, 1, 42);
(%o9)                        log(42)
(%i10) 'integrate (1/x, x, 1, 42);
                             42
                            /
                            [   1
(%o10)                      I   - dx
                            ]   x
                            /
                             1
(%i11) ev (%, nouns);
(%o11)                       log(42)

8.3 Identificadores

En Maxima, los identificadores pueden contener caracteres alfabéticos, números del 0 al 9 y cualquier otro carácter precedido de la barra invertida \.

Un identificador puede comenzar con un carácter numérico si éste va precedido de la barra invertida \. Los caracteres numéricos que ocupen la segunda posición o posterior no necesitan ir precedidos de la barra invertida.

Los caracteres pueden declararse como alfabéticos con la función declare. Así declarados, no necesitan ir precedidos de la barra invertida en un identificador. En principio, los caracteres alfabéticos son las letras de A a Z y a a z, junto con % y _.

Maxima distingue minúsculas y mayúsculas. Los identificadores foo, FOO y Foo son distintos. Véase Lisp y Maxima para más información.

Un identificador en Maxima es un símbolo Lisp que comienza con el símbolo dólar $. Cualquier otro símbolo de Lisp va precedido de la interrogación ? cuando aparece en Maxima. Véase Lisp y Maxima para más información.

Ejemplos:

(%i1) %an_ordinary_identifier42;
(%o1)               %an_ordinary_identifier42
(%i2) embedded\ spaces\ in\ an\ identifier;
(%o2)           embedded spaces in an identifier
(%i3) symbolp (%);
(%o3)                         true
(%i4) [foo+bar, foo\+bar];
(%o4)                 [foo + bar, foo+bar]
(%i5) [1729, \1729];
(%o5)                     [1729, 1729]
(%i6) [symbolp (foo\+bar), symbolp (\1729)];
(%o6)                     [true, true]
(%i7) [is (foo\+bar = foo+bar), is (\1729 = 1729)];
(%o7)                    [false, false]
(%i8) baz\~quux;
(%o8)                       baz~quux
(%i9) declare ("~", alphabetic);
(%o9)                         done
(%i10) baz~quux;
(%o10)                      baz~quux
(%i11) [is (foo = FOO), is (FOO = Foo), is (Foo = foo)];
(%o11)                [false, false, false]
(%i12) :lisp (defvar *my-lisp-variable* '$foo)
*MY-LISP-VARIABLE*
(%i12) ?\*my\-lisp\-variable\*;
(%o12)                         foo

8.4 Desigualdades

Maxima dispone de los operadores de desigualdad <, <=, >=, >, # y notequal. Véase if para una descripción de las expresiones condicionales.

8.5 Funciones y variables para expresiones

Función: alias (new_name_1, old_name_1, ..., new_name_n, old_name_n) ¶

provee un nombre alternativo para una (bien sea definida por el usuario o por el sistema) función, variable, arreglo, etc. Cualquier número par de argumentos puede ser usado.

Variable del sistema: aliases ¶

Valor por defecto: []

La variable aliases es la lista de átomos que tienen un "alias" definido por el usuario (establecido mediante las funciones alias, ordergreat o orderless o declarando el átomo como un noun (nombre) con declare.

Clave: allbut ¶

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

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

mientras que:

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

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

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

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

Función: args (expr) ¶

Devuelve la lista de argumentos de expr, que puede ser cualquier tipo de expresión a excepción de un átomo. Tan solo se muestran los argumentos del operador principal; subexpresiones de expr aparecen como elementos o subexpresiones de elementos de la lista de argumentos.

El orden de los miembros de la lista puede depender de la variable global inflag.

La llamada args (expr) es equivalente a substpart ("[", expr, 0).

Véanse también substpart y op.

Función: atom (expr) ¶

Devuelve true si expr es un átomo (número, nombre o cadena alfanumérica) y false en caso contario. Así, atom(5) devolverá true, mientras que atom(a[1]) y atom(sin(x)) darán como resultado false (dando por hecho que tanto a[1] como x no tienen valores asignados).

Función: box (expr) ¶

Función: box (expr, a) ¶

Devuelve expr encerrada en una caja. El valor devuelto es una expresión con box como operador y expr como argumento. Se dibujará una caja cuando display2d valga true.

La llamada box (expr, a) encierra expr en una caja etiquetada con el símbolo a. La etiqueta se recorta si es más larga que el ancho de la caja.

La función box evalúa su argumento. Sin embargo, la expresión encerrada no se evalúa, siendo excluída de los cálculos.

La variable boxchar guarda el carácter a utilizar para dibujar la caja en las funciones box, dpart y lpart.

Ejemplos:

(%i1) box (a^2 + b^2);
                            """""""""
                            " 2    2"
(%o1)                       "b  + a "
                            """""""""
(%i2) a : 1234;
(%o2)                         1234
(%i3) b : c - d;
(%o3)                         c - d
(%i4) box (a^2 + b^2);
                      """"""""""""""""""""
                      "       2          "
(%o4)                 "(c - d)  + 1522756"
                      """"""""""""""""""""
(%i5) box (a^2 + b^2, term_1);
                      term_1""""""""""""""
                      "       2          "
(%o5)                 "(c - d)  + 1522756"
                      """"""""""""""""""""
(%i6) 1729 - box (1729);
                                 """"""
(%o6)                     1729 - "1729"
                                 """"""
(%i7) boxchar: "-";
(%o7)                           -
(%i8) box (sin(x) + cos(y));
                        -----------------
(%o8)                   -cos(y) + sin(x)-
                        -----------------

Variable opcional: boxchar ¶

Valor por defecto: "

La variable boxchar guarda el carácter a utilizar para dibujar la caja en las funciones box, dpart y lpart.

Todas las cajas en una expresión se dibujan con el valor actual de boxchar, carácter que no se almacena con las expresión encerrada.

Función: collapse (expr) ¶

Colapsa expr haciendo que todas las subexpresiones que sean iguales compartan las mismas celdas, ahorrando espacio. collapse es una subrutina utilizada por la instrucción optimize. El uso de collapse puede ser útil después de cargar un fichero creado con save. Se pueden colapsar varias expresiones de forma conjunta utilizando collapse ([expr_1, ..., expr_n]). También se pueden colapsar los elementos del array A haciendo collapse (listarray ('A)).

Función: disolate (expr, x_1, ..., x_n) ¶

Es similar a isolate (expr, x), excepto que permite al usuario aislar más de una variable simultáneamente. Puede ser útil para hacer un cambio de variables en integrales múltiples en las que tales variables dependan de de dos o más variables de integración. Esta función se carga automáticamente desde simplification/disol.mac. Se dispone de una demostyración en demo("disol")$.

Función: dispform (expr) ¶

Function: dispform (expr, all) ¶

dispform(expr) devuelve la representación externa de expr respecto del operador del nivel superior. dispform(expr, all) devuelve la representación externa respecto de todos los operadores que haya en expr.

Véase también part, inpart y inflag.

Ejemplos:

La representación interna de - x es "menos uno multiplicado por x", mientras que la representación externa es "menos x".

(%i1) - x;
(%o1)                          - x
(%i2) ?format (true, "~S~%", %);
((MTIMES SIMP) -1 $X)
(%o2)                         false
(%i3) dispform (- x);
(%o3)                          - x
(%i4) ?format (true, "~S~%", %);
((MMINUS SIMP) $X)
(%o4)                         false

La representación interna de sqrt(x) es "x elevado a 1/2", mientras que su representación externa es "raíz de x".

(%i1) sqrt (x);
(%o1)                        sqrt(x)
(%i2) ?format (true, "~S~%", %);
((MEXPT SIMP) $X ((RAT SIMP) 1 2))
(%o2)                         false
(%i3) dispform (sqrt (x));
(%o3)                        sqrt(x)
(%i4) ?format (true, "~S~%", %);
((%SQRT SIMP) $X)
(%o4)                         false

Utilización del argumento opcional all.

(%i1) expr : sin (sqrt (x));
(%o1)                     sin(sqrt(x))
(%i2) freeof (sqrt, expr);
(%o2)                         true
(%i3) freeof (sqrt, dispform (expr));
(%o3)                         true
(%i4) freeof (sqrt, dispform (expr, all));
(%o4)                         false

Función: dpart (expr, n_1, ..., n_k) ¶

Selecciona la misma expresión que part, pero en lugar de devolver esa expresión como su valor, devuelve la expresión completa con la subexpresión seleccionada dentro de una caja. La caja es parte de la expresión.

(%i1) dpart (x+y/z^2, 1, 2, 1);
                             y
(%o1)                       ---- + x
                               2
                            """
                            "z"
                            """

Variable opcional: exptisolate ¶

Valor por defecto: false

Véase isolate.

Variable opcional: exptsubst ¶

Valor por defecto: false

Si exptsubst vale true permite la sustitución y por %e^x en %e^(a x).

Función: freeof (x_1, ..., x_n, expr) ¶

freeof (x_1, expr) devuelve true si ninguna subexpresión de expr coincide con x_1, o si x_1 aparece como variable muda en expr, o si x_1 no es ni una forma nominal ni verbal de cualesquiera operadores presentes en expr, devolviendo false en otro caso.

La llamada freeof (x_1, ..., x_n, expr) equivale a freeof (x_1, expr) and ... and freeof (x_n, expr).

Los argumentos x_1, ..., x_n pueden seer nombres de funciones y variables, nombres subindicados, operadores (encerrados entre comillas dobles) o expresiones generales.

La función freeof evalúa sus argumentos.

Una variable es una variable muda en una expresión si no tiene valor asignado fuera de la expresión. Variable mudas reconocidas por freeof son el índice de una suma o producto, la variable límite en limit, la variable de integración en la versión de integral definida de integrate, la variable original en laplace, variables formales en expresiones at y los argumentos de las expresiones lambda.

La versión indefinida de integrate no está libre de su variable de integración.

Ejemplos:

Los argumentos son nombres de funciones, variables, nombres subindicados, operaores y expresiones. La llamada freeof (a, b, expr) equivale a freeof (a, expr) and freeof (b, expr).

(%i1) expr: z^3 * cos (a[1]) * b^(c+d);
                                 d + c  3
(%o1)                   cos(a ) b      z
                             1
(%i2) freeof (z, expr);
(%o2)                         false
(%i3) freeof (cos, expr);
(%o3)                         false
(%i4) freeof (a[1], expr);
(%o4)                         false
(%i5) freeof (cos (a[1]), expr);
(%o5)                         false
(%i6) freeof (b^(c+d), expr);
(%o6)                         false
(%i7) freeof ("^", expr);
(%o7)                         false
(%i8) freeof (w, sin, a[2], sin (a[2]), b*(c+d), expr);
(%o8)                         true

freeof evalúa sus argumentos.

(%i1) expr: (a+b)^5$
(%i2) c: a$
(%i3) freeof (c, expr);
(%o3)                         false

freeof no considera funciones equivalentes. La simplificación puede dar una expresión equivalente pero diferente.

(%i1) expr: (a+b)^5$
(%i2) expand (expr);
          5        4       2  3       3  2      4      5
(%o2)    b  + 5 a b  + 10 a  b  + 10 a  b  + 5 a  b + a
(%i3) freeof (a+b, %);
(%o3)                         true
(%i4) freeof (a+b, expr);
(%o4)                         false
(%i5) exp (x);
                                 x
(%o5)                          %e
(%i6) freeof (exp, exp (x));
(%o6)                         true

Un sumatorio o integral definida está libre de su variable muda. Una integral indefinida de integrate no está libre de su variable de integración.

(%i1) freeof (i, 'sum (f(i), i, 0, n));
(%o1)                         true
(%i2) freeof (x, 'integrate (x^2, x, 0, 1));
(%o2)                         true
(%i3) freeof (x, 'integrate (x^2, x));
(%o3)                         false

Variable opcional: inflag ¶

Valor por defecto: false

Si inflag vale true, las funciones para la extracción de partes inspeccionan la forma interna de expr.

Nótese que el simplificador reordena expresiones. Así, first (x + y) devuelve x si inflag vale true y y si inflag vale false. (first (y + x) devuelve el mismo resultado.)

Además, dándole a inflag el valor true y llamando a part o a substpart es lo mismo que llamar a inpart o a substinpart.

Las funciones que se ven afectadas por el valor de inflag son: part, substpart, first, rest, last, length, la construcción for ... in, map, fullmap, maplist, reveal y pickapart.

Función: inpart (expr, n_1, ..., n_k) ¶

Similar a part, pero trabaja con la representación interna de la expresión, siendo más rápida. Se debe tener cuidado con el orden de subexpresiones en sumas y productos, pues el orden de las variables en la forma interna es normalmente diferente al que se muestra por el terminal, y cuando se trata con el signo menos unario, resta y división, pues estos operadores desaparecen de la expresión. Las llamadas part (x+y, 0) o inpart (x+y, 0) devuelven +, siendo necesario encerrar el operador entre comillas dobles cuando se haga referencia aél. Por ejemplo, ... if inpart (%o9,0) = "+" then ....

Ejemplos:

(%i1) x + y + w*z;
(%o1)                      w z + y + x
(%i2) inpart (%, 3, 2);
(%o2)                           z
(%i3) part (%th (2), 1, 2);
(%o3)                           z
(%i4) 'limit (f(x)^g(x+1), x, 0, minus);
                                  g(x + 1)
(%o4)                 limit   f(x)
                      x -> 0-
(%i5) inpart (%, 1, 2);
(%o5)                       g(x + 1)

Función: isolate (expr, x) ¶

Devuelve expr con subexpresiones que son sumas y que no contienen variables reemplazadas por etiquetas de expresiones intermedias (tales etiquetas son símbolos atómicos como %t1, %t2, ...). Esta función es de utilidad para evitar la expansión innecesaria de subexpresiones que no contienen la variable de interés. Puesto que las etiquetas intermedias toman el valor de subexpresiones pueden ser todas sustituidas evaluando la expresión en la que aparecen.

Si la variable exptisolate, cuyo valor por defecto es false, vale true hará que isolate busque exponentes de átomos (como %e) que contengan la variable.

Si isolate_wrt_times vale true, entonces isolate también aislará respecto de los productos. Véase isolate_wrt_times.

Para ejemplos, ejecútese example (isolate).

Variable opcional: isolate_wrt_times ¶

Valor por defecto: false

Si isolate_wrt_times vale true, entonces isolate también aislará respecto de los productos. Compárese el comportamiento de isolate al cambiar el valor de esta variable global en el siguiente ejemplo,

(%i1) isolate_wrt_times: true$
(%i2) isolate (expand ((a+b+c)^2), c);

(%t2)                          2 a


(%t3)                          2 b


                          2            2
(%t4)                    b  + 2 a b + a

                     2
(%o4)               c  + %t3 c + %t2 c + %t4
(%i4) isolate_wrt_times: false$
(%i5) isolate (expand ((a+b+c)^2), c);
                     2
(%o5)               c  + 2 b c + 2 a c + %t4

Variable opcional: listconstvars ¶

Valor por defecto: false

Si listconstvars vale true, hará que listofvars incluya %e, %pi, %i y cualquier otra variable que sea declarada constante de las que aparezcan en el argumento de listofvars. Estas constantes se omiten por defecto.

Variable opcional: listdummyvars ¶

Valor por defecto: true

Si listdummyvars vale false, las "variables mudas" de la expresión no serán incluídas en la lista devuelta por listofvars. (La definición de "variables mudas" se encuentra en la descripción de freeof. "Variables mudas" son objetos matemáticos como el índice de un sumatorio o producto, una variable límite o la variable de una integración definida.) Ejemplo:

(%i1) listdummyvars: true$
(%i2) listofvars ('sum(f(i), i, 0, n));
(%o2)                        [i, n]
(%i3) listdummyvars: false$
(%i4) listofvars ('sum(f(i), i, 0, n));
(%o4)                          [n]

Función: listofvars (expr) ¶

Devuelve una lista con las variables presentes en expr.

Si la variable listconstvars vale true entonces listofvars incluirá %e, %pi, %i y cualquier otra variable declarada constante de las que aparezcan en expr. Estas constantes se omiten por defecto.

Véase también la variable opcional listdummyvars para excluir o incluir variables ficticias en la lista de variables.

Ejemplo:

(%i1) listofvars (f (x[1]+y) / g^(2+a));
(%o1)                     [g, a, x , y]
                                  1

Función: lfreeof (list, expr) ¶

Para cada miembro m de list, realiza la llamada freeof (m, expr). Devuelve false si alguna de estas llamadas a freeof retornó false, y true en caso contrario.

Función: lpart (label, expr, n_1, ..., n_k) ¶

Similar a dpart pero utiliza una caja etiquetada. Una caja etiquetada es similar a la que produce dpart, pero con un nombre en la línea superior.

Propiedad: mainvar ¶

Se pueden declarar variables de tipo mainvar. El orden de los átomos es: números < constantes (como %e o %pi) < escalares < otras variables < "mainvars". Por ejemplo, compárese expand ((X+Y)^4) con (declare (x, mainvar), expand ((x+y)^4)). (Nota: Se debe tener cuidado si se quiere hacer uso de esta declaración. Por ejemplo, si se resta una expresión en la que x ha sido declarada como mainvar de otra en la que x no es mainvar, puede ser necesario volver a simplificar, ev (expr, simp), a fin de obtener cancelaciones. Además, si se guarda una expresión en la que x es mainvar, quizás sea necesario guardar también x.)

Propiedad: noun ¶

El símbolo noun es una de las opciones de la instrucción declare. Hace que una función se declare como "nombre", lo que significa que no se evaluará automáticamente.

Variable opcional: noundisp ¶

Valor por defecto: false

Si noundisp vale true, los nombres se muestran precedidos de un apóstrofo. Siempre debe valer true cuando se quiera representar la definición de funciones.

Función: nounify (f) ¶

Devuelve la forma nominal de la función cuyo nombre es f. Puede ser útil cuando se quiera hacer referencia al nombre de una función sin que ésta se ejecute. Nótese que algunas funciones verbales devolverán su forma nominal si no pueden ser evaluadas para ciertos argumentos. Esta es también la expresión que se obtiene cuando la llamada a una función va precedida por del apóstrofo.

Función: nterms (expr) ¶

Devuelve el número de términos que expr llegaría a tener si fuese completamente expandida y no hubiesen cancelaciones ni combinaciones de términos semejantes. Nótese que expresiones como sin (expr), sqrt (expr), exp (expr), etc. cuentan como un sólo término, independientemente de cuántos términos tenga a su vez expr en caso de tratarse de una suma.

Función: op (expr) ¶

Devuelve el operador principal de la expresión expr. La llamada op (expr) equivale a part (expr, 0).

La función op devuelve una cadena si el operador principal es un operador prefijo, infijo (binario o n-ario), postfijo, "bi-fijo" o "no-fijo" ("bi-fijo" se refiere a un par de símbolos que encierran su o sus argumentos, y "no-fijo" es un operador que no necesita argumentos). Si expr es la expresión de una función subindicada, op devuelve la función subindicada; en cuyo caso el valor devuelto no es un átomo. En otro caso, expr es la expresión de una función array u ordinaria, y entonces op devuelve un símbolo.

La función op observa el valor de la variable global inflag.

La función op evalúa sus argumentos.

Véase también args.

Ejemplos:

(%i1) stringdisp: true$
(%i2) op (a * b * c);
(%o2)                          "*"
(%i3) op (a * b + c);
(%o3)                          "+"
(%i4) op ('sin (a + b));
(%o4)                          sin
(%i5) op (a!);
(%o5)                          "!"
(%i6) op (-a);
(%o6)                          "-"
(%i7) op ([a, b, c]);
(%o7)                          "["
(%i8) op ('(if a > b then c else d));
(%o8)                         "if"
(%i9) op ('foo (a));
(%o9)                          foo
(%i10) prefix (foo);
(%o10)                        "foo"
(%i11) op (foo a);
(%o11)                        "foo"
(%i12) op (F [x, y] (a, b, c));
(%o12)                        F
                               x, y
(%i13) op (G [u, v, w]);
(%o13)                          G

Función: operatorp (expr, op) ¶

Función: operatorp (expr, [op_1, ..., op_n]) ¶

La llamada operatorp (expr, op) devuelve true si op es igual al operador de expr.

La llamada operatorp (expr, [op_1, ..., op_n]) devuelve true si algún elemento op_1, ..., op_n es igual al operador de expr.

Variable opcional: opsubst ¶

Valor por defecto: true

Si opsubst vale false, subst no sustituye el operdor de una expresión, de manera que (opsubst: false, subst (x^2, r, r+r[0])) trabajará correctamente.

Función: optimize (expr) ¶

Devuelve una expresión que produce el mismo valor y efectos secundarios que expr, pero de forma más eficiente al evitar recalcular subexpresiones comunes. La función optimize también tiene el efecto secundario de colapsar su argumento de manera que se compartan todas sus subexpresiones comunes. Hágase example (optimize) para ver ejemplos.

Variable opcional: optimprefix ¶

Valor por defecto: %

La variable optimprefix es el prefijo utilizado para los símbolos generados por la instrucción optimize.

Función: ordergreat (v_1, ..., v_n) ¶

Función: orderless (v_1, ..., v_n) ¶

ordergreat cambia el orden canónico de las expresiones de Maxima, de manera que v_1 prevalece sobre v_2, que prevalece sobre ..., que prevalece sobre v_n, que prevalece sobre cualquier otro símbolo no presente en la lista de argumentos.

orderless cambia el orden canónico de las expresiones de Maxima, de manera que v_1 precede a v_2, que precede a ..., que precede a v_n, que precede a cualquier otra variable no presente en la lista de argumentos.

El orden impuesto por ordergreat y orderless se destruye con unorder. ordergreat y orderless sólo se pueden llamar una vez, a menos que se invoque a unorder. La última llamada a ordergreat y orderless es la que se mantiene activa.

Véase también ordergreatp.

Función: ordergreatp (expr_1, expr_2) ¶

Función: orderlessp (expr_1, expr_2) ¶

ordergreatp devuelve true si expr_1 prevalece sobre expr_2 en el orden canónico de las expresiones de Maxima, o false en caso contrario.

orderlessp devuelve true si expr_1 precede a expr_2 en el orden canónico de las expresiones de Maxima, o false en caso contrario.

Todos los átomos y expresiones de Maxima son comparables bajo ordergreatp y orderlessp, aunque existen ejemplos aislados de expresiones para los que estos predicados no son transitivos.

La ordenación canónica de átomos (símbolos, números literales y cadenas) es la siguiente: (enteros y decimales en coma flotante) preceden a (números decimales grandes o bigfloats), que preceden a (constantes declaradas), que preceden a (cadenas), que preceden a (escalares declarados), que preceden a (primer argumento de orderless), que precede a ..., que precede a (último argumento de orderless), que precede a (otros símbolos), que preceden a (último argumento de ordergreat), que precede a ..., que precede a (primer argumento de ordergreat), que precede a (variables principales declaradas).

Para las expresiones no atómicas, la ordenación canónica se deriva de la ordenación de átomos. Para los operadores nativos +, * y ^, los criterios de ordenación no son sencillos de resumir. Para otros operadores nativos, y todas las demás funciones y operadores, las expresiones se ordenan por sus argumentos (empezando por el primero), después por el nombre del operador o función. En caso de expresiones con subíndices, el símbolo subindicado se considera operador y el subíndice un argumento del mismo.

El orden canónico de expresiones se modifica mediante las funciones ordergreat y orderless, así como por las declaraciones mainvar, constant y scalar.

Véase también sort.

Ejemplos:

Ordenación de símbolos comunes y constantes. Nótese que %pi no se ordena en función de su valor numérico.

(%i1) stringdisp : true;
(%o1)                         true
(%i2) sort ([%pi, 3b0, 3.0, x, X, "foo", 3, a, 4, "bar", 4.0, 4b0]);
(%o2) [3, 3.0, 4, 4.0, 3.0b0, 4.0b0, %pi, "bar", "foo", a, x, X]

Efecto producido por las funciones ordergreat y orderless.

(%i1) sort ([M, H, K, T, E, W, G, A, P, J, S]);
(%o1)           [A, E, G, H, J, K, M, P, S, T, W]
(%i2) ordergreat (S, J);
(%o2)                         done
(%i3) orderless (M, H);
(%o3)                         done
(%i4) sort ([M, H, K, T, E, W, G, A, P, J, S]);
(%o4)           [M, H, A, E, G, K, P, T, W, J, S]

Efecto producido por las declaraciones mainvar, constant y scalar.

(%i1) sort ([aa, foo, bar, bb, baz, quux, cc, dd, A1, B1, C1]);
(%o1)   [aa, bar, baz, bb, cc, dd, foo, quux, A1, B1, C1]
(%i2) declare (aa, mainvar);
(%o2)                         done
(%i3) declare ([baz, quux], constant);
(%o3)                         done
(%i4) declare ([A1, B1], scalar);
(%o4)                         done
(%i5) sort ([aa, foo, bar, bb, baz, quux, cc, dd, A1, B1, C1]);
(%o5)   [baz, quux, A1, B1, bar, bb, cc, dd, foo, C1, aa]

Ordenación de expresiones no atómicas.

(%i1) sort ([1, 2, n, f(1), f(2), f(2, 1), g(1), g(1, 2), g(n), f(n, 1)]);
(%o1) [1, 2, f(1), g(1), g(1, 2), f(2), f(2, 1), n, g(n), 
                                                         f(n, 1)]
(%i2) sort ([foo(1), X[1], X[k], foo(k), 1, k]);
(%o2)            [1, foo(1), X , k, foo(k), X ]
                              1              k

Función: part (expr, n_1, ..., n_k) ¶

Devuelve partes de la forma mostrada de expr. Obtiene la parte de expr que se especifica por los índices n_1, ..., n_k. Primero se obtiene la parte n_1 de expr, después la parte n_2 del resultado anterior, y así sucesivamente. El resultado que se obtiene es la parte n_k de ... la parte n_2 de la parte n_1 de expr. Si no se especifican índices, devuelve expr.

La función part se puede utilizar para obtener un elemento de una lista, una fila de una matriz, etc.

Si el último argumento de la función part es una lista de índices, entonces se toman varias subexpresiones, cada una de las cuales correspondiente a un índice de la lista. Así, part (x + y + z, [1, 3]) devuelve z+x.

La variable piece guarda la última expresión seleccionada con la función part. Se actualiza durante la ejecución de la función, por lo que puede ser referenciada en la misma función.

Si partswitch vale true entonces de devuelve end cuando no exista la parte seleccionada de una expresión, si vale false se mostrará un mensaje de error.

Véanse también inpart, substpart, substinpart, dpart y lpart.

Ejemplos:

(%i1) part(z+2*y+a,2);
(%o1)                                 2 y
(%i2) part(z+2*y+a,[1,3]);
(%o2)                                z + a
(%i3) part(z+2*y+a,2,1);
(%o3)                                  2

La instrucción example (part) muestra más ejemplos.

Función: partition (expr, x) ¶

Devuelve una lista con dos expresiones, que son: (1) los factores de expr si es un producto, los términos de expr si es una suma, o los elementos de expr, si es una lista, que no contengan a x, (2) los factores, términos o lista que contengan a x.

(%i1) partition (2*a*x*f(x), x);
(%o1)                     [2 a, x f(x)]
(%i2) partition (a+b, x);
(%o2)                      [b + a, 0]
(%i3) partition ([a, b, f(a), c], a); 
(%o3)                  [[b, c], [a, f(a)]]