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

7. Evaluación


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

7.1 Introducción a la evaluación

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

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

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

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

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

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

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

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

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

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

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

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

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

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


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

7.2 Funciones y variables para la evaluación

Operador: '

El operador comilla simple ' evita la evaluación.

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

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

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

La comilla simple no evita la simplificación.

Cuando el interruptor global noundisp es true, los nombres se muestran con una comilla simple. Este interruptor siempre tiene como valor true cuando se muestran definiciones de funciones.

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

Ejemplos:

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

(%i1) aa: 1024;
(%o1)                         1024
(%i2) aa^2;
(%o2)                        1048576
(%i3) 'aa^2;
                                 2
(%o3)                          aa
(%i4) ''%;
(%o4)                        1048576

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

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

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

(%i1) aa: 1024;
(%o1)                         1024
(%i2) bb: 19;
(%o2)                          19
(%i3) sqrt(aa) + bb;
(%o3)                          51
(%i4) '(sqrt(aa) + bb);
(%o4)                     bb + sqrt(aa)
(%i5) ''%;
(%o5)                          51

La comilla simple no evita la simplificación.

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

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

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

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

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

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

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

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

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

Ejemplos:

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

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

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

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

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

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

                         op(cc + aa) = +

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

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

                         op(dd + bb) = +

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

(%o5)                         done

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

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

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

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

(%t9)                    foo_2b(x) := %

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

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

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

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

    Los argumentos de ev pueden ser pasados en cualquier orden con excepción de la sustitución de ecuaciones las cuales son manipuladas en secuencia, de izquierda a derecha y las funciones de evaluación las cuales son compuestas, e.g., ev (expr, ratsimp, realpart) es manipulada como realpart (ratsimp (expr)).

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

    Si expr es una Expresión Racional Canónica (CRE, por sus siglas en inglés), entonces la expresión retornada por ev es también de tipo CRE, siempre que los interruptores numer y float no sean true.

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

Ejemplos:

(%i1) sin(x) + cos(y) + (w+1)^2 + 'diff (sin(w), w);
                                     d                    2
(%o1)              cos(y) + sin(x) + -- (sin(w)) + (w + 1)
                                     dw
(%i2) ev (%, numer, expand, diff, x=2, y=1);
                               2
(%o2)                cos(w) + w  + 2 w + 2.449599732693821

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

expr, arg_1, ..., arg_n

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

Nótese el proceso de vínculo en paralelo en el siguiente ejemplo:

(%i3) programmode: false;
(%o3)                                false
(%i4) x+y, x: a+y, y: 2;
(%o4)                              y + a + 2
(%i5) 2*x - 3*y = 3$
(%i6) -3*x + 2*y = -4$
(%i7) solve ([%o5, %o6]);
Solución

                                          1
(%t7)                               y = - -
                                          5

                                         6
(%t8)                                x = -
                                         5
(%o8)                            [[%t7, %t8]]
(%i8) %o6, %o8;
(%o8)                              - 4 = - 4
(%i9) x + 1/x > gamma (1/2);
                                   1
(%o9)                          x + - > sqrt(%pi)
                                   x
(%i10) %, numer, x=1/2;
(%o10)                      2.5 > 1.772453850905516
(%i11) %, pred;
(%o11)                               true
Símbolo especial: eval

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

Véase también ev.

Ejemplo:

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

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

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

Los interruptores que tienen la propiedad evflag son:

   algebraic           cauchysum       demoivre         
   dotscrules          %emode          %enumer     
   exponentialize      exptisolate     factorflag
   float               halfangles      infeval
   isolate_wrt_times   keepfloat       letrat
   listarith           logabs          logarc
   logexpand           lognegint
   m1pbranch           numer_pbranch   programmode
   radexpand           ratalgdenom     ratfac
   ratmx               ratsimpexpons   simp
   simpproduct         simpsum         sumexpand
   trigexpand

Ejemplos:

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

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

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

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

Las funciones que tienen la propiedad evfun por defecto son:

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

Ejemplos:

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

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

Símbolo especial: noeval

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

Símbolo especial: nouns

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

Símbolo especial: pred

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

Véase ev.

Ejemplo:

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

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

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