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

8. Expresiones


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

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

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

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)

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

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

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

8.4 Desigualdades

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


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

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)]]
Variable opcional: partswitch

Valor por defecto: false

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.

Función: pickapart (expr, n)

Asigna etiquetas de expresiones intermedias a subexpresiones de expr al nivel de profundidad n, que es un entero. A las subexpresiones a un nivel de profundidad mayor o menor no se les asignan etiquetas. La función pickapart devuelve una expresión en términos de expresiones intermedias equivalente a la expresión original expr.

Véanse también part, dpart, lpart, inpart y reveal.

Ejemplos:

(%i1) expr: (a+b)/2 + sin (x^2)/3 - log (1 + sqrt(x+1));
                                          2
                                     sin(x )   b + a
(%o1)       - log(sqrt(x + 1) + 1) + ------- + -----
                                        3        2
(%i2) pickapart (expr, 0);

                                          2
                                     sin(x )   b + a
(%t2)       - log(sqrt(x + 1) + 1) + ------- + -----
                                        3        2

(%o2)                          %t2
(%i3) pickapart (expr, 1);

(%t3)                - log(sqrt(x + 1) + 1)


                                  2
                             sin(x )
(%t4)                        -------
                                3


                              b + a
(%t5)                         -----
                                2

(%o5)                    %t5 + %t4 + %t3
(%i5) pickapart (expr, 2);

(%t6)                 log(sqrt(x + 1) + 1)


                                  2
(%t7)                        sin(x )


(%t8)                         b + a

                         %t8   %t7
(%o8)                    --- + --- - %t6
                          2     3
(%i8) pickapart (expr, 3);

(%t9)                    sqrt(x + 1) + 1


                                2
(%t10)                         x

                  b + a              sin(%t10)
(%o10)            ----- - log(%t9) + ---------
                    2                    3
(%i10) pickapart (expr, 4);

(%t11)                     sqrt(x + 1)

                      2
                 sin(x )   b + a
(%o11)           ------- + ----- - log(%t11 + 1)
                    3        2
(%i11) pickapart (expr, 5);

(%t12)                        x + 1

                   2
              sin(x )   b + a
(%o12)        ------- + ----- - log(sqrt(%t12) + 1)
                 3        2
(%i12) pickapart (expr, 6);
                  2
             sin(x )   b + a
(%o12)       ------- + ----- - log(sqrt(x + 1) + 1)
                3        2
Variable del sistema: piece

Guarda la última expresión seleccionada por las funciones part.

Función: psubst (list, expr)
Función: psubst (a, b, expr)

psubst(a, b, expr) es simliar a subst. Véase subst.

A diferencia de subst, la función psubst hace sustituciones en paralelo si su primer argumento es una lista de ecuaciones.

Véase también sublis para hacer sustituciones en paralelo.

Ejemplo:

El primer ejemplo muestra la sustitución en paralelo con psubst. El segundo ejemplo muestra el resultado de la función subst, que realiza la sustitución en serie.

(%i4) psubst ([a^2=b, b=a], sin(a^2) + sin(b));
(%o4)                           sin(b) + sin(a)
(%i5) subst ([a^2=b, b=a], sin(a^2) + sin(b));
(%o5)                              2 sin(a)
Función: rembox (expr, unlabelled)
Función: rembox (expr, label)
Función: rembox (expr)

Elimina cajas de expr.

La llamada rembox (expr, unlabelled) elimina todas las cajas no etiquetadas de expr.

La llamada rembox (expr, label) sólo elimina las cajas etiquetadas con label.

La llamada rembox (expr) elimina todas las caajs, independientemente de que estén etiquetadas o no.

Las cajas son dibujadas por las funciones box, dpart y lpart.

Ejemplos:

(%i1) expr: (a*d - b*c)/h^2 + sin(%pi*x);
                                  a d - b c
(%o1)                sin(%pi x) + ---------
                                      2
                                     h
(%i2) dpart (dpart (expr, 1, 1), 2, 2);
                        """""""    a d - b c
(%o2)               sin("%pi x") + ---------
                        """""""      """"
                                     " 2"
                                     "h "
                                     """"
(%i3) expr2: lpart (BAR, lpart (FOO, %, 1), 2);
                  FOO"""""""""""   BAR""""""""
                  "    """"""" "   "a d - b c"
(%o3)             "sin("%pi x")" + "---------"
                  "    """"""" "   "  """"   "
                  """"""""""""""   "  " 2"   "
                                   "  "h "   "
                                   "  """"   "
                                   """""""""""
(%i4) rembox (expr2, unlabelled);
                                  BAR""""""""
                   FOO"""""""""   "a d - b c"
(%o4)              "sin(%pi x)" + "---------"
                   """"""""""""   "    2    "
                                  "   h     "
                                  """""""""""
(%i5) rembox (expr2, FOO);
                                  BAR""""""""
                       """""""    "a d - b c"
(%o5)              sin("%pi x") + "---------"
                       """""""    "  """"   "
                                  "  " 2"   "
                                  "  "h "   "
                                  "  """"   "
                                  """""""""""
(%i6) rembox (expr2, BAR);
                   FOO"""""""""""
                   "    """"""" "   a d - b c
(%o6)              "sin("%pi x")" + ---------
                   "    """"""" "     """"
                   """"""""""""""     " 2"
                                      "h "
                                      """"
(%i7) rembox (expr2);
                                  a d - b c
(%o7)                sin(%pi x) + ---------
                                      2
                                     h
Función: reveal (expr, nivel)

Reemplaza partes de expr al nivel especificado y las sutituye por descripciones cortas.

Si el entero depth es mayor o igual que la profundidad máxima de expr, reveal (expr, depth) devuelve expr sin modificar.

La función reveal evalúa sus argumentos y devuelve la expresión con las modificaciones solicitadas.

Ejemplo:

(%i1) e: expand ((a - b)^2)/expand ((exp(a) + exp(b))^2);
                          2            2
                         b  - 2 a b + a
(%o1)               -------------------------
                        b + a     2 b     2 a
                    2 %e      + %e    + %e
(%i2) reveal (e, 1);
(%o2)                       Quotient
(%i3) reveal (e, 2);
                             Sum(3)
(%o3)                        ------
                             Sum(3)
(%i4) reveal (e, 3);
                     Expt + Negterm + Expt
(%o4)               ------------------------
                    Product(2) + Expt + Expt
(%i5) reveal (e, 4);
                       2                 2
                      b  - Product(3) + a
(%o5)         ------------------------------------
                         Product(2)     Product(2)
              2 Expt + %e           + %e
(%i6) reveal (e, 5);
                         2            2
                        b  - 2 a b + a
(%o6)              --------------------------
                       Sum(2)     2 b     2 a
                   2 %e       + %e    + %e
(%i7) reveal (e, 6);
                          2            2
                         b  - 2 a b + a
(%o7)               -------------------------
                        b + a     2 b     2 a
                    2 %e      + %e    + %e
Función: sublis (list, expr)

Hace sustituciones múltiples en paralelo dentro de las expresiones. list es una lista de ecuaciones, cuyos miembros izquierdos deben ser átomos.

La variable sublis_apply_lambda controla la simplificación después de sublis.

Véase también psubst para hacer sustituciones en paralelo.

Ejemplo:

(%i1) sublis ([a=b, b=a], sin(a) + cos(b));
(%o1)                    sin(b) + cos(a)
Variable opcional: sublis_apply_lambda

Valor por defecto: true

Controla si los lambda sustituidos son aplicados en la simplificación después de invocar a sublis, o si se tiene que hacer un ev para hacerlo. Si sublis_apply_lambda vale true, significa que se ejecute la aplicación.

Variable opcional: subnumsimp

Valor por defecto: false

Si vale true, las funciones subst y psubst puede sustituir una variable subindicada f[x] por un número simplemente utilizando el símbolo f.

Véase también subst.

(%i1) subst(100,g,g[x]+2);

subst: cannot substitute 100 for operator g in expression g
                                                           x
 -- an error. To debug this try: debugmode(true);

(%i2) subst(100,g,g[x]+2),subnumsimp:true;
(%o2)                          102
Función: subst (a, b, c)

Sustituye a por b en c. El argumento b debe ser un átomo o una subexpresión completa de c. Por ejemplo, x+y+z es una subexpresión completa de 2*(x+y+z)/w mientras que x+y no lo es. Cuando b no cumple esta característica, se puede utilizar en algunos casos substpart o ratsubst (ver más abajo). Alternativamente, si b no es de la forma e/f entonces se puede usar subst (a*f, e, c), pero si b es de la forma e^(1/f) se debe usar subst (a^f, e, c). La instrucción subst también reconoce x^y en x^-y, de manera que subst (a, sqrt(x), 1/sqrt(x)) da 1/a. Los argumentos a y b también pueden ser operadores de una expresión acotados por comillas dobles " o nombres de funciones. Si se quiere sustituir la variable independiente en expresiones con derivadas se debe utilizar la función at (ver más abajo).

La función subst es sinónimo de substitute.

La llamada subst (eq_1, expr) o subst ([eq_1, ..., eq_k], expr) están permitidas. Las eq_i son ecuaciones que indican las sustituciones a realizar. Para cada ecuación, el miembro izquierdo será sustituido por la expresión del miembro derecho en expr. Las ecuaciones se sustituyen secuencialmente de izquierda a derecha en expr. Véanse las funciones sublis y psubst para sustituciones en paralelo.

Si la variable exptsubst vale true se permiten ciertas sustituciones de exponentes; por ejemplo, sustituir y por %e^x en %e^(a*x).

Si opsubst vale false, subst no intentará sustituir un operador de una expresión. Por ejemplo, (opsubst: false, subst (x^2, r, r+r[0])) trabajará sin problemas.

Ejemplos:

(%i1) subst (a, x+y, x + (x+y)^2 + y);
                                    2
(%o1)                      y + x + a
(%i2) subst (-%i, %i, a + b*%i);
(%o2)                       a - %i b

La sustitución se hace secuencialmente según una lista de ecuaciones. Compárese con la sustitución en paralelo.

(%i3) subst([a=b, b=c], a+b);
(%o3)                                 2 c
(%i4) sublis([a=b, b=c], a+b);
(%o4)                                c + b

Para más ejemplos, ejecútese example (subst).

Función: substinpart (x, expr, n_1, …, n_k)

Es similar a substinpart, pero trabaja con la representación interna de expr.

Ejemplos:

(%i1) x . 'diff (f(x), x, 2);
                              2
                             d
(%o1)                   x . (--- (f(x)))
                               2
                             dx
(%i2) substinpart (d^2, %, 2);
                                  2
(%o2)                        x . d
(%i3) substinpart (f1, f[1](x + 1), 0);
(%o3)                       f1(x + 1)

Si el último argumento pasado a la función part es una lista de índices, se obtendrá la lista de subexpresiones correspondientes a cada uno de los índices.

(%i1) part (x + y + z, [1, 3]);
(%o1)                         z + x

La variable piece guarda el valor de la última expresión seleccionada al utilizar las funciones part. El valor es asignado durante la ejecución de la función y puede ser utilizada tal como se muestra más abajo. Si a partswitch se le asigna el valor true entonces se devolverá end cuando no existe la parte solicitada; con otro valor devuelve un mensaje de error.

(%i1) expr: 27*y^3 + 54*x*y^2 + 36*x^2*y + y + 8*x^3 + x + 1;
              3         2       2            3
(%o1)     27 y  + 54 x y  + 36 x  y + y + 8 x  + x + 1
(%i2) part (expr, 2, [1, 3]);
                                  2
(%o2)                         54 y
(%i3) sqrt (piece/54);
(%o3)                        abs(y)
(%i4) substpart (factor (piece), expr, [1, 2, 3, 5]);
                               3
(%o4)               (3 y + 2 x)  + y + x + 1
(%i5) expr: 1/x + y/x - 1/z;
                             1   y   1
(%o5)                      - - + - + -
                             z   x   x
(%i6) substpart (xthru (piece), expr, [2, 3]);
                            y + 1   1
(%o6)                       ----- - -
                              x     z

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

Función: substpart (x, expr, n_1, …, n_k)

Sustituye por x la subexpresión que se obtiene de aplicar el resto de argumentos a la función part, devolviendo el nuevo valor de expr. x puede ser un operador que sustituya otro operador de expr. En ciertos casos, x necesita estar entrecomillado por comillas dobles ("); por ejemplo, de substpart ("+", a*b, 0) se obtiene b + a.

Ejemplo:

(%i1) 1/(x^2 + 2);
                               1
(%o1)                        ------
                              2
                             x  + 2
(%i2) substpart (3/2, %, 2, 1, 2);
                               1
(%o2)                       --------
                             3/2
                            x    + 2
(%i3) a*x + f(b, y);
(%o3)                     a x + f(b, y)
(%i4) substpart ("+", %, 1, 0);
(%o4)                    x + f(b, y) + a

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

Función: symbolp (expr)

Devuelve true si expr es un símbolo y false en caso contrario. La llamada symbolp(x) equivale al predicado atom(x) and not numberp(x).

Véase también Identifiers.

Función: unorder ()

Desactiva las asociaciones creadas por la última utilización de los comandos de ordenación ordergreat y orderless, los cuales no pueden ser utilizados más de una vez sin invocar a unorder.

unorder no sustituye en expresiones los símbolos originales por los alias introducidos por ordergreat y orderless. Es por ello que tras la ejecuciĆ³n de unorder los alias aparecen en expresiones anteriores.

Véase también ordergreat y orderless.

Ejemplos:

ordergreat(a) introduce un alias para el símbolo a, razón por la cual la diferencia de %o2 y %o4 no se anula. unorder no restablece el símbolo a y el alias aparece en el resultado %o7.

(%i1) 
(%o1)                          []
(%i2) b*x+a^2;
                                   2
(%o2)                       b x + a
(%i3) ordergreat(a);
(%o3)                         done
(%i4) b*x+a^2;
                             2
(%o4)                       a  + b x
(%i5) %th(1)-%th(3);
                              2    2
(%o5)                        a  - a
(%i6) unorder();
(%o6)                          [a]
(%i7) %th(2);
                                2    2
(%o7)                      _101a  - a
Función: verbify (f)

Devuelve la forma verbal del nombre de función f.

Véanse también verb, noun y nounify.

Ejemplos:

(%i1) verbify ('foo);
(%o1)                          foo
(%i2) :lisp $%
$FOO
(%i2) nounify (foo);
(%o2)                          foo
(%i3) :lisp $%
%FOO

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

This document was generated by Robert on agosto, 12 2012 using texi2html 1.76.