[ < ] [ > ]   [ << ] [ 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 Asignación

Existen dos operadores de asignación en Maxima, : y ::. Por ejemplo, a: 3 asigna a la variable a el valor de 3. Por otro lado, :: asigna el valor de la expresión de su derecha al valor de la cantidad de su izquierda, el cual debe evaluarse a una variable de tipo átomo o una variable subindicada.


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

6.3 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.4 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.5 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.

Un carácter especial puede declararse alfabético con la función declare. Así declarado, no necesita ir precedido 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.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 an infix 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 an infix operator
5 @
 ^
(%i9) "@" (5, 3);
(%o9)                        @(5, 3)

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

6.8 Definiciones 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 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) box (a^2 + b^2, term_1);
             term_1"""
             " 2   2 "
(%o2)        "b  + a "
             """""""""
(%i3) 1729 - box (1729);
                  """"""
(%o3)      1729 - "1729"
                  """"""
(%i4) boxchar: "-";
(%o4)            -
(%i5) box (sin(x) + cos(y));
                -----------------
(%o5)           -COS(y) + SIN(x)-
                -----------------
(%i6) 
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 a_i la característica f_i. Las a_i y las f_i también pueden ser listas de átomos y características, respectivamente, en cuyo caso cada átomo toma todas las características.

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

Las posibles características y sus significados son:

constant convierte a a_i en una constante, como %pi.

mainvar convierte a a_i en mainvar. Ordenación de los átomos: números < constantes (como %e, %pi) < escalares < otras variables < mainvars.

scalar convierte a a_i en escalar.

nonscalar hace que a_i se comporte como una lista o matriz ante el operador punto.

noun convierte la función a_i en un nombre, de manera que no se evalúe automáticamente.

evfun hace que a_i sea reconocida por la función ev de manera que se aplique cuando se mencione su nombre. Véase evfun.

evflag hace que a_i sea reconocida por la función ev de manera que tome el valor true durante la ejecución de ev si es mencionada. Véase evflag.

bindtest hace que a_i envíe un error si en algún momento es utilizada en un cálculo sin habérsele asignado un valor.

Maxima reconoce y utiliza las siguientes propiedades de objetos:

 
even, odd, integer, rational, irrational, real, imaginary,
and complex

Propiedades útiles para funciones son:

 
increasing,
decreasing, oddfun (odd function), evenfun (even function),
commutative (or symmetric), antisymmetric, lassociative and
rassociative

La llamada featurep (object, feature) determina si object ha sido declarado con la propiedad feature.

Véase también features.

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 y partes declaradas en los argumentos.

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:

 
(%i1) "@"(a, b) := sconcat("(", a, ",", b, ")")$
(%i2) :lisp (get '$+ 'lbp)
100
(%i2) :lisp (get '$+ 'rbp)
100
(%i2) infix ("@", 101, 101)$
(%i3) 1 + a@b + 2;
(%o3)                       (a,b) + 3
(%i4) infix ("@", 99, 99)$
(%i5) 1 + a@b + 2;
(%o5)                       (a+1,b+2)
 
(%i1) "@"(a, b) := sconcat("(", a, ",", b, ")")$
(%i2) infix ("@", 100, 99)$
(%i3) foo @ bar @ baz;
(%o3)                    (foo,(bar,baz))
(%i4) infix ("@", 100, 101)$
(%i5) foo @ bar @ baz;
(%o5)                    ((foo,bar),baz)
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 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 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). En cualquier otro caso 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"
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));
Incorrect syntax: Too many )'s
else b^k, k, 1, 10))
                  ^
(%i12) linenum:11;
(%o11)                         11
(%i12) sum (integrate (x^k, x, 0, 1), k, 1, n);
                            n
                           ====
                           \       1
(%o12)                      >    -----
                           /     k + 1
                           ====
                           k = 1
(%i13) sum (if k <= 5 then a^k else b^k, k, 1, 10);
          10    9    8    7    6    5    4    3    2
(%o13)   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 root on octubre, 3 2006 using texi2html 1.76.