@c English version 2011-11-01
@menu
* Introducción a la evaluación::
* Funciones y variables para la evaluación::
@end menu









@node Introducción a la evaluación, Funciones y variables para la evaluación, Evaluación, Evaluación
@section 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 @var{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 @code{a}
el valor @code{2}, allá donde se escriba @code{a} será sustituido por dicho valor.

@example
(%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]
@end example

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 @code{diff}
y la de integración @code{integrate}.

En el siguiente ejemplo se le asigna a la variable @code{a} cierto
valor, a continuación se invoca la función @code{diff} en su
forma verbal con sus argumentos tomando los valores @code{a*x^2} y @code{x}.
Seguidamente se invoca a la misma función @code{diff} en su
forma nominal, lo cual se consigue mediante el operador de comilla simple (@code{'});
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
@code{a} es sustituida por el valor @code{1/2}.

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

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 @code{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 @code{'} a fin de poder mostrar las
propiedades del símbolo @code{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 @code{a}; una vez
se le ha asignado el valor @code{2}, la función @code{properties} nos dice
que la variable guarda un valor y esto es así porque no ha sustituido
el símbolo @code{a} por su valor @code{2}. En consecuencia, la
función @code{properties} muestra las propiedades de @code{'a}.

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

(%i3) properties(a);
(%o3)                        [value]
@end example

La evaluación de símbolos, funciones y expresiones se puede
controlar con los operadores de comilla simple (@code{'}) y de doble comilla
simple (@code{'@w{}'}). 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 @code{ev} se evalúa una expresión dentro de un contexto
determinado controlado por el valor de ciertas variables @code{evflag} y
funciones de evaluación @code{evfun}.










@node Funciones y variables para la evaluación,  , Introducción a la evaluación, Evaluación
@section Funciones y variables para la evaluación


@deffn {Operador} '
@ifinfo
@fnindex Operador comilla
@end ifinfo
El operador comilla simple @code{'} 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. 
@c DUNNO IF THESE EXAMPLES ARE STILL NEEDED -- COVERED BY ITEMS UNDER "Examples"
E.g., @code{'(f(x))} significa que no se evalua la expresión @code{f(x)}. 
@code{'f(x)} (con la comilla simple aplicada a @code{f} en cambio de a @code{f(x)})
significa el retorno de la forma de nombre de @code{f} aplicada a @code{[x]}. 

La comilla simple no evita la simplificación. 

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

Ver también los operadores comilla-comilla @code{'@w{}'} y @code{nouns}. 

Ejemplos:

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

@c ===beg===
@c aa: 1024;
@c aa^2;
@c 'aa^2;
@c ''%;
@c ===end===
@example
(%i1) aa: 1024;
(%o1)                         1024
(%i2) aa^2;
(%o2)                        1048576
(%i3) 'aa^2;
                                 2
(%o3)                          aa
(%i4) ''%;
(%o4)                        1048576
@end example

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.  

@c ===beg===
@c x0: 5;
@c x1: 7;
@c integrate (x^2, x, x0, x1);
@c 'integrate (x^2, x, x0, x1);
@c %, nouns;
@c ===end===
@example
(%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
@end example

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. 

@c ===beg===
@c aa: 1024;
@c bb: 19;
@c sqrt(aa) + bb;
@c '(sqrt(aa) + bb);
@c ''%;
@c ===end===
@example
(%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
@end example

La comilla simple no evita la simplificación. 

@c ===beg===
@c sin (17 * %pi) + cos (17 * %pi);
@c '(sin (17 * %pi) + cos (17 * %pi));
@c ===end===
@example
(%i1) sin (17 * %pi) + cos (17 * %pi);
(%o1)                          - 1
(%i2) '(sin (17 * %pi) + cos (17 * %pi));
(%o2)                          - 1
@end example

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

@c ===beg===
@c sin(1.0);
@c '(sin(1.0));
@c ===end===
@example
(%i1) sin(1.0);
(%o1)                          .8414709848078965
(%i2) '(sin(1.0));
(%o2)                          .8414709848078965
@end example

@end deffn





@deffn {Operador} ''
@ifinfo
@fnindex Operador comilla-comilla
@end ifinfo
El operador comilla-comilla @code{'@w{}'} (dos comillas simples) modifica la evaluación
en las expresiones de entrada.

Aplicado a cualquier expresión general @var{expr}, las dos comillas simples hacen que
el valor de @var{expr} sea sustituido por @var{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
@code{'}.

El operador comilla-comilla es reconocido tanto por @code{batch} como por @code{load}.

Véanse también el operador comilla simple @code{'} y @code{nouns}.

Ejemplos:

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

@c ===beg===
@c expand ((a + b)^3);
@c [_, ''_];
@c [%i1, ''%i1];
@c [aa : cc, bb : dd, cc : 17, dd : 29];
@c foo_1 (x) := aa - bb * x;
@c foo_1 (10);
@c ''%;
@c ''(foo_1 (10));
@c foo_2 (x) := ''aa - ''bb * x;
@c foo_2 (10);
@c [x0 : x1, x1 : x2, x2 : x3];
@c x0;
@c ''x0;
@c '' ''x0;
@c ===end===
@example
(%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
@end example

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.

@c ===beg==
@c declare (foo, noun);
@c foo (x) := x - 1729;
@c foo (100);
@c ''foo (100);
@c ===end==
@example
(%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
@end example


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.

@c ===beg===
@c [aa : bb, cc : dd, bb : 1234, dd : 5678];
@c aa + cc;
@c display (_, op (_), args (_));
@c ''(aa + cc);
@c display (_, op (_), args (_));
@c ===end===
@example
(%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
@end example

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
@code{'}.

@c ===beg===
@c foo_1a (x) := ''(integrate (log (x), x));
@c foo_1b (x) := integrate (log (x), x);
@c dispfun (foo_1a, foo_1b);
@c integrate (log (x), x);
@c foo_2a (x) := ''%;
@c foo_2b (x) := %;
@c dispfun (foo_2a, foo_2b);
@c F : lambda ([u], diff (sin (u), u));
@c G : lambda ([u], ''(diff (sin (u), u)));
@c '(sum (a[k], k, 1, 3) + sum (b[k], k, 1, 3));
@c '(''(sum (a[k], k, 1, 3)) + ''(sum (b[k], k, 1, 3)));
@c ===end===
@example
(%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
@end example

@end deffn



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

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

@enumerate
@item
Primero se configura el entorno de acuerdo a los argumentos los
cuales pueden ser algunos o todos de la siguiente lista:  

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

Los argumentos de @code{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., @code{ev (@var{expr}, ratsimp, realpart)}
es manipulada como @code{realpart (ratsimp (@var{expr}))}. 

Los interruptores @code{simp}, @code{numer} y @code{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 @var{expr} es una Expresión Racional Canónica (CRE, por sus siglas en inglés), entonces la expresión retornada por @code{ev} es también 
de tipo CRE, siempre que los interruptores @code{numer} y @code{float} no sean @code{true}. 

@item
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 @var{expr} son reemplazadas por sus valores globales, excepto por aquellos que aparezcan en esa lista. 
Usualmente, @var{expr} es sólo una etiqueta o un @code{%} 
(como en @code{%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í @code{ev} puede trabajarla. 

@item
Si algunas sustituciones son indicadas por los argumentos, ellas
serán llevadas a cabo ahora. 

@item
La expresión resultante es también reevaluada (a menos que uno de 
los argumentos fuese @code{noeval}) y simplificada de acuerdo a los 
argumentos. Notese que cualquier llamada a una función en @var{expr} 
será llevada a cabo después de que las variables sean evaluadas 
en ella y que @code{ev(F(x))} pueda comportarse como @code{F(ev(x))}. 

@item
Por cada aparición de @code{eval} en los argumentos, se repetirán los pasos (3) y (4).
@end enumerate

Ejemplos:

@c ===beg===
@c sin(x) + cos(y) + (w+1)^2 + 'diff (sin(w), w);
@c ev (%, numer, expand, diff, x=2, y=1);
@c ===end===
@example
(%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
@end example


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

@example
@var{expr}, @var{arg_1}, ..., @var{arg_n}
@end example

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:

@example
(%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
@end example

@end deffn



@defvr {Símbolo especial} eval
Como argumento en una llamada a @code{ev (@var{expr})}, @code{eval} 
fuerza una evaluación extra de @var{expr}.

Véase también @code{ev}.

Ejemplo:

@c ===beg===
@c [a:b,b:c,c:d,d:e];
@c a;
@c ev(a);
@c ev(a),eval;
@c a,eval,eval;
@c ===end===
@example
(%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
@end example

@end defvr




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

La expresión @code{declare(@var{x}, evflag)} dota a la variable @var{x}
de la propiedad @code{evflag}.

Los interruptores que tienen la propiedad @code{evflag} son: 

@verbatim
   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
@end verbatim

Ejemplos:

@c ===beg===
@c sin (1/2);
@c sin (1/2), float;
@c sin (1/2), float=true;
@c simp : false;
@c 1 + 1;
@c 1 + 1, simp;
@c simp : true;
@c sum (1/k^2, k, 1, inf);
@c sum (1/k^2, k, 1, inf), simpsum;
@c declare (aa, evflag);
@c if aa = true then YES else NO;
@c if aa = true then YES else NO, aa;
@c ===end===
@example
(%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
@end example
 
@end defvr




@defvr {Propiedad} evfun
Cuando la función @var{F} goza de la propiedad @code{evfun},
las expresiones @code{ev(@var{expr}, @var{F})} y @code{@var{expr}, @var{F}}
(en modo interactivo) equivalen a @code{@var{F}(ev(@var{expr}))}.

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

La expresión @code{declare(@var{F}, evfun)} dota a la función  @var{F}
de la propiedad @code{evfun}.

Las funciones que tienen la propiedad @code{evfun} por defecto son: 

@c FOLLOWING LIST CONSTRUCTED FROM LIST UNDER (prog1 '(evfun properties) ...)
@c NEAR LINE 2643 IN mlisp.lisp AT PRESENT (2004/11).
@verbatim
   bfloat          factor       fullratsimp
   logcontract     polarform    radcan
   ratexpand       ratsimp      rectform
   rootscontract   trigexpand   trigreduce
@end verbatim

Ejemplos:

@c ===beg===
@c x^3 - 1;
@c x^3 - 1, factor;
@c factor (x^3 - 1);
@c cos(4 * x) / sin(x)^4;
@c cos(4 * x) / sin(x)^4, trigexpand;
@c cos(4 * x) / sin(x)^4, trigexpand, ratexpand;
@c ratexpand (trigexpand (cos(4 * x) / sin(x)^4));
@c declare ([F, G], evfun);
@c (aa : bb, bb : cc, cc : dd);
@c aa;
@c aa, F;
@c F (aa);
@c F (ev (aa));
@c aa, F, G;
@c G (F (ev (aa)));
@c ===end===
@example
(%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))
@end example
 
@end defvr



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



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

@end defvr



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

@end defvr



@defvr {Símbolo especial} pred
Cuando se utiliza como argumento en una llamada a
@code{ev (@var{expr})}, @code{pred} provoca que los
predicados (expresiones que se reducen a @code{true} o
@code{false}) se evalúen.

Véase @code{ev}.

Ejemplo:

@c ===beg===
@c 1<2;
@c 1<2,pred;
@c ===end===
@example
(%i1) 1<2;
(%o1)                                1 < 2
(%i2) 1<2,pred;
(%o2)                                true
@end example
@end defvr

