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

6. Expresiones


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

6.1 Introducción a las expresiones

Existe un cierto número de palabras reservadas que no pueden utilizarse como nombres de variables. Su uso podría causar errores críticos de sintaxis.

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] [ ? ]

6.2 Expresiones complejas

Una expresión compleja se especifica en Maxima añadiendo a la parte real de la expresión el producto de %i por la parte imaginaria. Así las raíces de la ecuación x^2 - 4*x + 13 = 0 son 2 + 3*%i y 2 - 3*%i. Nótese que la simplificación de productos de expresiones complejas puede ser efectuado expandiendo el producto. La simplificación de cocientes, raíces y otras funciones que contengan expresiones complejas pueden normalmente conseguirse a través de las funciones realpart, imagpart, rectform, polarform, abs o carg.


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

6.3 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] [ ? ]

6.4 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] [ ? ]

6.5 Cadenas de caracteres

Las cadenas de caracteres deben ir acotadas por comillas dobles (") al ser introducidas en Maxima, siendo luego mostradas con o sin ellas, dependiendo del valor de la variable global stringdisp.

Las cadenas pueden contener todo tipo de caracteres, incluyendo tabulaciones, caracteres de nueva línea y de retorno. La secuencia \" se reconoce literalmente como una comilla doble, al tiempo que \\ se interpreta como una barra invertida. Cuando la barra invertida aparece al final de una línea, tanto la barra como el final de línea (representado éste bien por el carácter de nueva línea o el de retorno) son ignorados, de forma que la cadena continúa en el siguiente renglón. No se reconocen más combinaciones especiales de la barra invertida con otros caracteres aparte de las comentadas; de modo que si la barra invertida aparece antes de cualquier otro carácter distinto de ", \, o de un final de línea, dicha barra será ignorada. No hay manera de representar los caracteres especiales (tabulación, nueva línea o retorno) de otra forma que no sea incluyéndolos literalmente en la cadena.

No existe en Maxima el tipo de variable carácter, debiéndose representar un carácter simple como una cadena de un solo carácter.

El paquete adicional stringproc contiene muchas funciones que permiten trabajar con cadenas.

Ejemplos:

(%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."

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

6.6 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] [ ? ]

6.7 Sintaxis

Es posible definir nuevos operadores con una precedencia especificada, o eliminar o redefinir la precedencia de operadores ya existentes. Un operador puede ser de tipo prefijo unario o postfijo unario, infijo binario, infijo n-ario, "bi-fijo" (matchfix) 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. A continuación ejemplos sobre los diferentes tipos de operadores.

prefijo unario

negación - a

postfijo unario

factorial a!

infijo binario

exponenciación a^b

n-ary infix

suma a + b

"bi-fijo"

construcción de una lista [a, b]

(Maxima no incluye operadores "no-fijos", pero se puede ver un ejemplo en nofix.)

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

Las funciones de Maxima que definen nuevos operadores se resumen en esta tabla, en la que se establecen las fuerzas de enlace a izquierda (lbp, de left binding power) y a derecha (rbp, de right binding power) por defecto. (La fuerza de enlace determina la precedencia del operador. Sin embargo, puesto que las fuerzas de enlace a izquierda y derecha pueden ser diferentes, la fuerza de enlace es algo más que la simple precedencia.) Algunas de las funciones para definir operadores toman argumentos adicionales; véanse las descripciones de estas funciones para más detalles.

prefix

rbp=180

postfix

lbp=180

infix

lbp=180, rbp=180

nary

lbp=180, rbp=180

matchfix

(la fuerza de enlace no se aplica aquí)

nofix

(la fuerza de enlace no se aplica aquí)

A efectos comparativos, aquí se presentan algunos operadores de Maxima junto con sus fuerzas de enlace a izquierda y derecha.

Operator   lbp     rbp

  :        180     20 
  ::       180     20 
  :=       180     20 
  ::=      180     20 
  !        160
  !!       160
  ^        140     139 
  .        130     129 
  *        120
  /        120     120 
  +        100     100 
  -        100     134 
  =        80      80 
  #        80      80 
  >        80      80 
  >=       80      80 
  <        80      80 
  <=       80      80 
  not              70 
  and      65
  or       60
  ,        10
  $        -1
  ;        -1

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)

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

6.8 Funciones y variables para expresiones

Función: at (expr, [eqn_1, ..., eqn_n])
Función: at (expr, eqn)

Evalúa la expresión expr asignando a las variables los valores especificados para ellas en la lista de ecuaciones [eqn_1, ..., eqn_n] o en la ecuación simple eqn.

Si una subexpresión depende de cualquiera de las variables para la cual se especifica un valor, pero no puede ser evaluado, entonces at devuelve una forma nominal.

La función at realiza múltiples sustituciones en serie, no en paralelo.

Véase también atvalue. Para otras funciones que también llevan a cabo sustituciones, consúltense subst y ev.

Ejemplos:

(%i1) atvalue (f(x,y), [x = 0, y = 1], a^2);
                                2
(%o1)                          a
(%i2) atvalue ('diff (f(x,y), x), x = 0, 1 + y);
(%o2)                        @2 + 1
(%i3) printprops (all, atvalue);
                                !
                  d             !
                 --- (f(@1, @2))!       = @2 + 1
                 d@1            !
                                !@1 = 0

                                     2
                          f(0, 1) = a

(%o3)                         done
(%i4) diff (4*f(x, y)^2 - u(x, y)^2, x);
                  d                          d
(%o4)  8 f(x, y) (-- (f(x, y))) - 2 u(x, y) (-- (u(x, y)))
                  dx                         dx
(%i5) at (%, [x = 0, y = 1]);
                                         !
              2              d           !
(%o5)     16 a  - 2 u(0, 1) (-- (u(x, y))!            )
                             dx          !
                                         !x = 0, y = 1
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: carg (z)

Devuelve el argumento complejo de z. El argumento complejo es un ángulo theta en (-%pi, %pi] tal que r exp (theta %i) = z donde r es la magnitud de z.

La función carg es computacional, no simplificativa.

La función carg ignora la declaración declare (x, complex), y trata a x como una variable real. Se trata de un fallo conocido en Maximo.

Véanse también abs (módulo complejo), polarform, rectform, realpart y imagpart.

Ejemplos:

(%i1) carg (1);
(%o1)                           0
(%i2) carg (1 + %i);
                               %pi
(%o2)                          ---
                                4
(%i3) carg (exp (%i));
(%o3)                           1
(%i4) carg (exp (%pi * %i));
(%o4)                          %pi
(%i5) carg (exp (3/2 * %pi * %i));
                                %pi
(%o5)                         - ---
                                 2
(%i6) carg (17 * exp (2 * %i));
(%o6)                           2
Operator especial: constant

La llamada declare (a, constant) declara a como constante. Véase declare.

Función: constantp (expr)

Devuelve true si expr es una expresión constante y false en caso contrario.

Una expresión se considera constante si sus argumentos son números (incluidos los números racionales que se muestran con /R/), constantes simbólicas como %pi, %e o %i, variables con valor constante o declarada como constante por declare, o funciones cuyos argumentos son constantes.

La función constantp evalúa sus argumentos.

Ejemplos:

(%i1) constantp (7 * sin(2));
(%o1)                                true
(%i2) constantp (rat (17/29));
(%o2)                                true
(%i3) constantp (%pi * sin(%e));
(%o3)                                true
(%i4) constantp (exp (x));
(%o4)                                false
(%i5) declare (x, constant);
(%o5)                                done
(%i6) constantp (exp (x));
(%o6)                                true
(%i7) constantp (foo (x) + bar (%e) + baz (2));
(%o7)                                false
(%i8) 
Función: declare (a_1, f_1, a_2, f_2, ...)

Asigna al átomo o lista de átomos a_i la propiedad o lista de propiedadesp_i. Si a_i y/o p_i son listas, cada uno de los átomos adquiere todas las propiedades.

La función declare no evalúa sus argumentos y siempre devuelve la expresión done.

La llamada featurep (object, feature) devuelve true si object ha sido previamente declarado como poseedor de la propiedad feature. No obstante, featurep no reconoce algunas propiedades, lo cual es un fallo conocido de Maxima.

Véase también features.

La función declare reconoce las siguientes propiedades:

evfun Hace que a_i sea reconocida por ev, de manera que la función nombrada por a_i se aplique cuando a_i aparezca como argumento de control de ev. Véase evfun.

evflag

Hace que a_i sea reconocida por ev, de manera que a a_i se le asigne el valor true durante la ejecución de ev cuando a_i aparezca como argumento de control de ev.

bindtest

Hace que Maxima envíe un error si a_i es evaluado sin habérsele asignado un valor.

noun

Hace que Maxima considere a a_i como un nombre. El efecto que se obtiene es que se reemplazan todas las expresiones a_i por 'a_i o nounify (a_i), dependiendo del contexto.

constant

Hace que Maxima considere a a_i como una constante simbólica.

scalar

Hace que Maxima considere a a_i como una variable escalar.

nonscalar

Hace que Maxima considere a a_i como una variable no escalar. Se aplica comúnmente para declarar una variable como un vector simbólico o una matriz simbólica.

mainvar

Hace que Maxima considere a a_i como una "variable principal" (mainvar); ordergreatp determina la ordenación de los átomos como sigue:

(variables principales) > (otras variables) > (variables escalares) > (constantes) > (números)

alphabetic

Indica a Maxima que reconozca todos los caracteres de la cadena alfanumérica a_i como caracteres alfabéticos.

feature

Hace que Maxima considere a a_i como el nombre de una propiedad. Otros átomos podrán ser declarados entonces como poseedores de la propiedad a_i.

rassociative, lassociative

Hace que Maxima reconozca a a_i como una función asociativa por la derecha o por la izquierda.

nary

Hace que Maxima reconozca a a_i como una función n-aria.

La declaración nary no es equivalente a la función nary. El único efecto de declare(foo, nary) consiste en hacer que el simplificador de Maxima reduzca expresiones anidadas; por ejemplo, para transformar foo(x, foo(y, z)) a foo(x, y, z).

symmetric, antisymmetric, commutative

Hace que Maxima reconozca a a_i como una función simétrica o antisimétrica. La propiedad commutative equivale a symmetric.

evenfun, oddfun

Hace que Maxima reconozca a a_i como una función par o impar.

outative

Hace que Maxima simplifique las expresiones a_i extrayendo los factores constantes del primer argumento.

Cuando a_i tenga un único argumento, un factor se considerará constante si es una constante literal o declarada.

Cuando a_i tenga dos o más argumentos, un factor se considerará constante si el segundo argumento es un símbolo y el factor no contiene al segundo argumento.

multiplicative

Hace que Maxima simplifique las expresiones a_i haciendo uso de la sustitución a_i(x * y * z * ...) --> a_i(x) * a_i(y) * a_i(z) * .... Tal sustitución se aplica únicamente al primer argumento.

additive

Hace que Maxima simplifique las expresiones a_i haciendo uso de la sustitución a_i(x + y + z + ...) --> a_i(x) + a_i(y) + a_i(z) + .... Tal sustitución se aplica únicamente al primer argumento.

linear

Equivale a declarar a_i conjuntamente como outative y additive.

integer, noninteger

Hace que Maxima reconozca a a_i como una variable entera o no entera.

even, odd

Hace que Maxima reconozca a a_i como una variable entera par o impar.

rational, irrational

Hace que Maxima reconozca a a_i como una variable real racional o irracional.

real, imaginary, complex

Hace que Maxima reconozca a a_i como una variable real, imaginaria o compleja.

increasing, decreasing Hace que Maxima reconozca a a_i como una función creciente o decreciente.

posfun

Hace que Maxima reconozca a a_i como una función positiva.

integervalued

Hace que Maxima reconozca a a_i como una función de valor entero.

Ejemplos:

Declaraciones en base a evfun y evflag.

(%i1) declare (expand, evfun);
(%o1)                         done
(%i2) (a + b)^3;
                                   3
(%o2)                       (b + a)
(%i3) (a + b)^3, expand;
                     3        2      2      3
(%o3)               b  + 3 a b  + 3 a  b + a
(%i4) declare (demoivre, evflag);
(%o4)                         done
(%i5) exp (a + b*%i);
                             %i b + a
(%o5)                      %e
(%i6) exp (a + b*%i), demoivre;
                      a
(%o6)               %e  (%i sin(b) + cos(b))

Declaración en base a bindtest.

(%i1) aa + bb;
(%o1)                        bb + aa
(%i2) declare (aa, bindtest);
(%o2)                         done
(%i3) aa + bb;
aa unbound variable
 -- an error.  Quitting.  To debug this try debugmode(true);
(%i4) aa : 1234;
(%o4)                         1234
(%i5) aa + bb;
(%o5)                       bb + 1234

Declaración en base a noun.

(%i1) factor (12345678);
                             2
(%o1)                     2 3  47 14593
(%i2) declare (factor, noun);
(%o2)                         done
(%i3) factor (12345678);
(%o3)                   factor(12345678)
(%i4) ''%, nouns;
                             2
(%o4)                     2 3  47 14593

Declaraciones en base a constant, scalar, nonscalar y mainvar.

Declaración en base a alphabetic.

(%i1) xx\~yy\`\@ : 1729;
(%o1)                         1729
(%i2) declare ("~`@", alphabetic);
(%o2)                         done
(%i3) xx~yy`@ + @yy`xx + `xx@@yy~;
(%o3)               `xx@@yy~ + @yy`xx + 1729
(%i4) listofvars (%);
(%o4)                  [@yy`xx, `xx@@yy~]

Declaración en base a feature.

(%i1) declare (FOO, feature);
(%o1)                         done
(%i2) declare (x, FOO);
(%o2)                         done
(%i3) featurep (x, FOO);
(%o3)                         true

Declaraciones en base a rassociative y lassociative.

Declaración en base a nary.

(%i1) H (H (a, b), H (c, H (d, e)));
(%o1)               H(H(a, b), H(c, H(d, e)))
(%i2) declare (H, nary);
(%o2)                         done
(%i3) H (H (a, b), H (c, H (d, e)));
(%o3)                   H(a, b, c, d, e)

Declaraciones en base a symmetric y antisymmetric.

(%i1) S (b, a);
(%o1)                        S(b, a)
(%i2) declare (S, symmetric);
(%o2)                         done
(%i3) S (b, a);
(%o3)                        S(a, b)
(%i4) S (a, c, e, d, b);
(%o4)                   S(a, b, c, d, e)
(%i5) T (b, a);
(%o5)                        T(b, a)
(%i6) declare (T, antisymmetric);
(%o6)                         done
(%i7) T (b, a);
(%o7)                       - T(a, b)
(%i8) T (a, c, e, d, b);
(%o8)                   T(a, b, c, d, e)

Declaraciones en base a oddfun y evenfun.

(%i1) o (- u) + o (u);
(%o1)                     o(u) + o(- u)
(%i2) declare (o, oddfun);
(%o2)                         done
(%i3) o (- u) + o (u);
(%o3)                           0
(%i4) e (- u) - e (u);
(%o4)                     e(- u) - e(u)
(%i5) declare (e, evenfun);
(%o5)                         done
(%i6) e (- u) - e (u);
(%o6)                           0

Declaración en base a outative.

(%i1) F1 (100 * x);
(%o1)                       F1(100 x)
(%i2) declare (F1, outative);
(%o2)                         done
(%i3) F1 (100 * x);
(%o3)                       100 F1(x)
(%i4) declare (zz, constant);
(%o4)                         done
(%i5) F1 (zz * y);
(%o5)                       zz F1(y)

Declaración en base a multiplicative.

(%i1) F2 (a * b * c);
(%o1)                       F2(a b c)
(%i2) declare (F2, multiplicative);
(%o2)                         done
(%i3) F2 (a * b * c);
(%o3)                   F2(a) F2(b) F2(c)

Declaración en base a additive.

(%i1) F3 (a + b + c);
(%o1)                     F3(c + b + a)
(%i2) declare (F3, additive);
(%o2)                         done
(%i3) F3 (a + b + c);
(%o3)                 F3(c) + F3(b) + F3(a)

Declaración en base a linear.

(%i1) 'sum (F(k) + G(k), k, 1, inf);
                       inf
                       ====
                       \
(%o1)                   >    (G(k) + F(k))
                       /
                       ====
                       k = 1
(%i2) declare (nounify (sum), linear);
(%o2)                         done
(%i3) 'sum (F(k) + G(k), k, 1, inf);
                     inf          inf
                     ====         ====
                     \            \
(%o3)                 >    G(k) +  >    F(k)
                     /            /
                     ====         ====
                     k = 1        k = 1
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)

Devuelve la representación externa de expr con respecto a su operador principal. Es útil cuando se usa conjuntamente con part, que también trata de la representación externa. Sipóngase que expr es -A . Entonces la representación interna de expr es "*"(-1,A), mientras que la representación externa es "-"(A). La llamada dispform (expr, all) convierte la expresión entera al formato externo. Por ejemplo, si expr: sin (sqrt (x)), entonces freeof (sqrt, expr) y freeof (sqrt, dispform (expr)) dan true, mientras que freeof (sqrt, dispform (expr, all)) da false.

Función: distrib (expr)

Diistribuye sumas sobre productos. Difiere de expand en que trabaja sólo al nivel superior de una expresión, siendo más rápida que expand. Difiere de multthru en que expande todas las sumas del nivel superior.

Ejemplos:

(%i1) distrib ((a+b) * (c+d));
(%o1)                 b d + a d + b c + a c
(%i2) multthru ((a+b) * (c+d));
(%o2)                 (b + a) d + (b + a) c
(%i3) distrib (1/((a+b) * (c+d)));
                                1
(%o3)                    ---------------
                         (b + a) (d + c)
(%i4) expand (1/((a+b) * (c+d)), 1, 0);
                                1
(%o4)                 ---------------------
                      b d + a d + b c + a c
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"
                            """
Función: exp (x)

Representa la función exponencial. La expresión exp (x) en la entrada se simplifica en %e^x; exp no aparece en expresiones simplificadas.

Si la variable demoivre vale true hace que %e^(a + b %i) se simplifique a %e^(a (cos(b) + %i sin(b))) si b no contiene a %i. Véase demoivre.

Si la variable %emode vale true, hace que %e^(%pi %i x) se simplifique. Véase %emode.

Si la variable %enumer vale true hace que %e se reemplace por 2.718... siempre que numer valga true. Véase %enumer.

Variable opcional: %emode

Valor por defecto: true

Si %emode vale true, %e^(%pi %i x) se simplifica como sigue.

%e^(%pi %i x) se simplifica a cos (%pi x) + %i sin (%pi x) si x es un entero o múltiplo de 1/2, 1/3, 1/4 o 1/6, y luego se sigue simplificando.

Para otros valores numéricos de x, %e^(%pi %i x) se simplifica a %e^(%pi %i y) donde y es x - 2 k para algún entero k tal que abs(y) < 1.

Si %emode vale false, no se realizan simplificaciones especiales a %e^(%pi %i x).

Variable opcional: %enumer

Valor por defecto: false

Si la variable %enumer vale true hace que %e se reemplace por 2.718... siempre que numer valga true.

Si %enumer vale false, esta sustitución se realiza sólo si el exponente en %e^x tiene un valor numérico.

Véanse también ev y numer.

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 es igual a x_1 o si x_1 aparece como variable muda 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. Las variables locales en block no son reconocidas por freeof como variables mudas; esto es un fallo de Maxima.

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

Función: genfact (x, y, z)

Devuelve el factorial generalizado, definido como x (x-z) (x - 2 z) ... (x - (y - 1) z). Así, para el entero x, genfact (x, x, 1) = x! y genfact (x, x/2, 2) = x!!.

Función: imagpart (expr)

Devuelve la parte imaginaria de la expresión expr.

La función imagpart es computacional, no simplificativa.

Véanse también abs, carg, polarform, rectform y realpart.

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
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, %iy cualquier otra variable declarada constante de las que aparezcan en expr. Estas constantes se omiten por defecto.

(%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: lopow (expr, x)

Devuelve el mínimo exponente de x que aparece explícitamente en expr. Así,

(%i1) lopow ((x+y)^2 + (x+y)^a, x+y);
(%o1)                       min(a, 2)
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.

Función: multthru (expr)
Función: multthru (expr_1, expr_2)

Multiplica un factor (que debería ser una suma) de expr por los otros factores de expr. Esto es, expr es f_1 f_2 ... f_n, donde al menos un factor, por ejemplo f_i, es una suma de términos. Cada término en esta suma se multiplica por los otros factores del producto, excepto el propio f_i. La función multthru no expande sumas elevadas a exponentes, siendo el método más rápido para distribuir productos (sean o no conmutativos) sobre sumas. Puesto que los cocientes se representan como productos, puede utilizarsemultthru para dividir sumas entre productos.

La llamada multthru (expr_1, expr_2) multiplica cada término de expr_2 (que debería ser una suma o una ecuación) por expr_1. Si expr_1 no es ella misma una suma, entonces la llamada es equivalente a multthru (expr_1*expr_2).

(%i1) x/(x-y)^2 - 1/(x-y) - f(x)/(x-y)^3;
                      1        x         f(x)
(%o1)             - ----- + -------- - --------
                    x - y          2          3
                            (x - y)    (x - y)
(%i2) multthru ((x-y)^3, %);
                           2
(%o2)             - (x - y)  + x (x - y) - f(x)
(%i3) ratexpand (%);
                           2
(%o3)                   - y  + x y - f(x)
(%i4) ((a+b)^10*s^2 + 2*a*b*s + (a*b)^2)/(a*b*s^2);
                        10  2              2  2
                 (b + a)   s  + 2 a b s + a  b
(%o4)            ------------------------------
                                  2
                             a b s
(%i5) multthru (%);  /* note that this does not expand (b+a)^10 */
                                        10
                       2   a b   (b + a)
(%o5)                  - + --- + ---------
                       s    2       a b
                           s
(%i6) multthru (a.(b+c.(d+e)+f));
(%o6)            a . f + a . c . (e + d) + a . b
(%i7) expand (a.(b+c.(d+e)+f));
(%o7)         a . f + a . c . e + a . c . d + a . b
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.

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)

Establece una ordenación para las variables v_1, ..., v_n de manera que v_1 > v_2 > ... > v_n y v_n > cualquier otra variable no mencionada como argumento.

Véase también orderless.

Función: ordergreatp (expr_1, expr_2)

Devuelve true si expr_2 precede a expr_1 según el orden establecido con la función ordergreat.

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

Establece una ordenación para las variables v_1, ..., v_n de manera que v_1 < v_2 < ... < v_n y v_n < cualquier otra variable no mencionada como argumento.

Así, la ordenación completa de objetos es: constantes numéricas < constantes declaradas < escalares declarados < primer argumento de orderless < ... < último argumento de orderless < variables que empiezan por A < ... < variables que empiezan por Z < último argumento de ordergreat < ... < primer argumento de ordergreat < objetos declarados como mainvar.

Véanse también ordergreat y mainvar.

Función: orderlessp (expr_1, expr_2)

Devuelve true si expr_1 precede a expr_2 según el orden establecido con la función orderless.

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.

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.

Ejemplo: part (z+2*y, 2, 1) devuelve 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
System variable: piece

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

Función: polarform (expr)

Devuelve una expresión de la forma r %e^(%i theta) equivalente a expr, con r y theta son reales.

Función: powers (expr, x)

Devuelve las potencias de x dentro de expr.

La instrucción load (powers) carga esta función.

Función: product (expr, i, i_0, i_1)

Representa el producto de los valores de expr según el índice i varía de i_0 hasta i_1. La forma nominal 'product se presenta en forma de letra pi mayúscula.

La función product evalúa expr y los límites inferior y superior, i_0 y i_1, pero no evalúa el índice i.

Si la diferencia entre los límites superior e inferior es un número entero, la expresión expr se evalúa para cada valor del índice i, siendo el resultado un producto en forma explícita.

En caso contrario, el rango del índice no está definido, aplicándose entonces algunas reglas que permitan simplificar el producto. Cuando la variable global simpproduct valga true, se aplicarán reglas adicionales. En ciertos casos, la simplificación dará lugar a un resultado que ya no tenga el formato del producto; en caso contrario se devolverá una forma nominal 'product.

Véanse también nouns y evflag.

Ejemplos:

(%i1) product (x + i*(i+1)/2, i, 1, 4);
(%o1)           (x + 1) (x + 3) (x + 6) (x + 10)
(%i2) product (i^2, i, 1, 7);
(%o2)                       25401600
(%i3) product (a[i], i, 1, 7);
(%o3)                 a  a  a  a  a  a  a
                       1  2  3  4  5  6  7
(%i4) product (a(i), i, 1, 7);
(%o4)          a(1) a(2) a(3) a(4) a(5) a(6) a(7)
(%i5) product (a(i), i, 1, n);
                             n
                           /===\
                            ! !
(%o5)                       ! !  a(i)
                            ! !
                           i = 1
(%i6) product (k, k, 1, n);
                               n
                             /===\
                              ! !
(%o6)                         ! !  k
                              ! !
                             k = 1
(%i7) product (k, k, 1, n), simpproduct;
(%o7)                          n!
(%i8) product (integrate (x^k, x, 0, 1), k, 1, n);
                             n
                           /===\
                            ! !    1
(%o8)                       ! !  -----
                            ! !  k + 1
                           k = 1
(%i9) product (if k <= 5 then a^k else b^k, k, 1, 10);
                              15  40
(%o9)                        a   b
Función: realpart (expr)

Devuelve la parte real de expr. La funciones realpart y imagpart operan también con expresiones que contengan funciones trigonométricas e hiperbólicas, raíces cuadradas, logaritmos y exponentes.

Función: rectform (expr)

Devuelve una expresión de la forma a + b %i equivalente a expr, con a y b reales.

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: sum (expr, i, i_0, i_1)

Representa la suma de los valores de expr según el índice i varía de i_0 hasta i_1. La forma nominal 'sum se presenta en forma de letra sigma mayúscula.

La función sum evalúa su sumando expr y los límites inferior y superior, i_0 y i_1, pero no evalúa el índice i.

Si la diferencia entre los límites superior e inferior es un número entero, el sumando expr se evalúa para cada valor del índice i, siendo el resultado una suma en forma explícita.

En caso contrario, el rango del índice no está definido, aplicándose entonces algunas reglas que permitan simplificar la suma. Cuando la variable global simpsum valga true, se aplicarán reglas adicionales. En ciertos casos, la simplificación dará lugar a un resultado que ya no tenga el formato del sumatorio; en caso contrario se devolverá una forma nominal 'product.

Cuando cauchysum vale true, el producto de sumatorios se expresa como un producto de Cauchy, en cuyo caso el índice del sumatorio interior es función del índice del exterior, en lugar de variar independientemente.

La variable global genindex guarda el prefijo alfabético a utilizar cuando sea necesario generar automáticamente el siguiente índice de sumatorio.

La variable global gensumnum guarda el sufijo numérico a utilizar cuando sea necesario generar automáticamente el siguiente índice de sumatorio. Si gensumnum vale false, un índice generado automáticamente constará sólo de genindex, sin sufijo numérico.

Véanse también sumcontract, intosum, bashindices, niceindices, nouns y evflag.

Ejemplos:

(%i1) sum (i^2, i, 1, 7);
(%o1)                          140
(%i2) sum (a[i], i, 1, 7);
(%o2)           a  + a  + a  + a  + a  + a  + a
                 7    6    5    4    3    2    1
(%i3) sum (a(i), i, 1, 7);
(%o3)    a(7) + a(6) + a(5) + a(4) + a(3) + a(2) + a(1)
(%i4) sum (a(i), i, 1, n);
                            n
                           ====
                           \
(%o4)                       >    a(i)
                           /
                           ====
                           i = 1
(%i5) sum (2^i + i^2, i, 0, n);
                          n
                         ====
                         \       i    2
(%o5)                     >    (2  + i )
                         /
                         ====
                         i = 0
(%i6) sum (2^i + i^2, i, 0, n), simpsum;
                              3      2
                   n + 1   2 n  + 3 n  + n
(%o6)             2      + --------------- - 1
                                  6
(%i7) sum (1/3^i, i, 1, inf);
                            inf
                            ====
                            \     1
(%o7)                        >    --
                            /      i
                            ====  3
                            i = 1
(%i8) sum (1/3^i, i, 1, inf), simpsum;
                                1
(%o8)                           -
                                2
(%i9) sum (i^2, i, 1, 4) * sum (1/i^2, i, 1, inf);
                              inf
                              ====
                              \     1
(%o9)                      30  >    --
                              /      2
                              ====  i
                              i = 1
(%i10) sum (i^2, i, 1, 4) * sum (1/i^2, i, 1, inf), simpsum;
                                  2
(%o10)                       5 %pi
(%i11) sum (integrate (x^k, x, 0, 1), k, 1, n);
                            n
                           ====
                           \       1
(%o11)                      >    -----
                           /     k + 1
                           ====
                           k = 1
(%i12) sum (if k <= 5 then a^k else b^k, k, 1, 10));
          10    9    8    7    6    5    4    3    2
(%o12)   b   + b  + b  + b  + b  + a  + a  + a  + a  + a
Función: lsum (expr, x, L)

Representa la suma de expr para cada elemento x en L.

Se retornará la forma nominal 'lsum si el argumento L no es una lista.

Ejemplos:

(%i1) lsum (x^i, i, [1, 2, 7]);
                            7    2
(%o1)                      x  + x  + x
(%i2) lsum (i^2, i, rootsof (x^3 - 1));
                     ====
                     \      2
(%o2)                 >    i
                     /
                     ====
                                   3
                     i in rootsof(x  - 1)
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 Dodier on diciembre, 22 2007 using texi2html 1.76.