| blob | ad1fe06c416cd076f8b09f7200ad5e6fb68203c2 |
1 @c English version 2011-11-01
2 @menu
3 * Introducción a la evaluación::
4 * Funciones y variables para la evaluación::
5 @end menu
15 @node Introducción a la evaluación, Funciones y variables para la evaluación, Evaluación, Evaluación
16 @section Introducción a la evaluación
18 Las fases que se suceden desde que el usuario solicita un cálculo hasta que
19 obtiene el resultado son: la propia solicitud del cálculo, la evaluación,
20 la simplificación y la respuesta.
22 Toda expresión @var{expr} que se introduzca en Maxima será evaluada, de manera
23 que los símbolos que no tengan asociado ningún valor y los números
24 evalúan a sí mismos; en cambio, aquellos símbolos
25 que tengan un valor asociado serán sustituídos por tales valores.
27 Dos ejemplos. En el primero, los símbolos y los números se evalúan
28 a sí mismos; en el segundo ejemplo, al asignarle a la variable @code{a}
29 el valor @code{2}, allá donde se escriba @code{a} será sustituido por dicho valor.
31 @example
32 (%i1) [a, b, 2, 1/2, 1.0];
33 1
34 (%o1) [a, b, 2, -, 1.0]
35 2
36 (%i2) a:2$
38 (%i3) [a, sin(a), a^2];
39 (%o3) [2, sin(2), 4]
40 @end example
42 Maxima distingue entre funciones en forma verbal y funciones en forma
43 nominal. Las funciones en forma verbal son evaluadas tomando en cuenta
44 los valores dados a sus argumentos; en cambio, las funciones nominales
45 no son evaluadas, aunque sus argumentos tengan valores asignados. Las
46 funciones son susceptibles de ser tratadas de ambos modos; ejemplos
47 típicos son la función de diferenciación @code{diff}
48 y la de integración @code{integrate}.
50 En el siguiente ejemplo se le asigna a la variable @code{a} cierto
51 valor, a continuación se invoca la función @code{diff} en su
52 forma verbal con sus argumentos tomando los valores @code{a*x^2} y @code{x}.
53 Seguidamente se invoca a la misma función @code{diff} en su
54 forma nominal, lo cual se consigue mediante el operador de comilla simple (@code{'});
55 en este caso la función no es evaluada y devuelve una expresión simbólica
56 en la que los argumentos sí han sido evaluados, pues la variable
57 @code{a} es sustituida por el valor @code{1/2}.
59 @example
60 (%i1) a:1/2;
61 1
62 (%o1) -
63 2
64 (%i2) diff(a*x^2, x);
65 (%o2) x
66 (%i3) 'diff(a*x^2, x);
67 @group
68 2
69 d x
70 (%o3) -- (--)
71 dx 2
72 @end group
73 @end example
75 Sin embargo, no todas las funciones de Maxima sustituyen sus argumentos por
76 sus valores. La documentación para cada función informará si sus argumentos
77 son evaluados o no.
79 Por ejemplo, la función @code{properties} no evalúa sus argumentos, lo cual
80 resulta práctico para el usuario, ya que en caso contrario debería
81 utilizar el operador de comilla simple @code{'} a fin de poder mostrar las
82 propiedades del símbolo @code{a}. A continuación se muestra
83 como en el primer caso se devuelve una lista vacía, ya que no se
84 le ha encontrado ninguna propiedad al símbolo @code{a}; una vez
85 se le ha asignado el valor @code{2}, la función @code{properties} nos dice
86 que la variable guarda un valor y esto es así porque no ha sustituido
87 el símbolo @code{a} por su valor @code{2}. En consecuencia, la
88 función @code{properties} muestra las propiedades de @code{'a}.
90 @example
91 (%i1) properties(a);
92 (%o1) []
93 (%i2) a:2$
95 (%i3) properties(a);
96 (%o3) [value]
97 @end example
99 La evaluación de símbolos, funciones y expresiones se puede
100 controlar con los operadores de comilla simple (@code{'}) y de doble comilla
101 simple (@code{'@w{}'}). La evaluación se suprime con la comilla simple y se
102 fuerza con la doble comilla simple (que no comilla doble).
104 Con la función @code{ev} se evalúa una expresión dentro de un contexto
105 determinado controlado por el valor de ciertas variables @code{evflag} y
106 funciones de evaluación @code{evfun}.
117 @node Funciones y variables para la evaluación, , Introducción a la evaluación, Evaluación
118 @section Funciones y variables para la evaluación
121 @deffn {Operador} '
122 @ifinfo
123 @fnindex Operador comilla
124 @end ifinfo
125 El operador comilla simple @code{'} evita la evaluación.
127 Aplicado a un símbolo,
128 la comilla simple evita la evaluación del símbolo.
130 Aplicado a la llamada de una función,
131 la comilla simple evita la evaluación de la función llamada,
132 aunque los argumentos de la función son evaluados (siempre y cuando
133 la evaluación no se evite de otra manera).
134 El resultado es una forma de nombre de la función llamada.
136 Aplicado a una expresión con paréntesis,
137 la comilla simple evita la evaluación de todos los símbolos y llamadas a funciones que hayan en la expresión.
138 @c DUNNO IF THESE EXAMPLES ARE STILL NEEDED -- COVERED BY ITEMS UNDER "Examples"
139 E.g., @code{'(f(x))} significa que no se evalua la expresión @code{f(x)}.
140 @code{'f(x)} (con la comilla simple aplicada a @code{f} en cambio de a @code{f(x)})
141 significa el retorno de la forma de nombre de @code{f} aplicada a @code{[x]}.
143 La comilla simple no evita la simplificación.
145 Cuando el interruptor global @code{noundisp} es @code{true},
146 los nombres se muestran con una comilla simple.
147 Este interruptor siempre tiene como valor @code{true} cuando
148 se muestran definiciones de funciones.
150 Ver también los operadores comilla-comilla @code{'@w{}'} y @code{nouns}.
152 Ejemplos:
154 Aplicado a un símbolo,
155 la comilla simple evita la evaluación del símbolo.
157 @c ===beg===
158 @c aa: 1024;
159 @c aa^2;
160 @c 'aa^2;
161 @c ''%;
162 @c ===end===
163 @example
164 (%i1) aa: 1024;
165 (%o1) 1024
166 (%i2) aa^2;
167 (%o2) 1048576
168 (%i3) 'aa^2;
169 2
170 (%o3) aa
171 (%i4) ''%;
172 (%o4) 1048576
173 @end example
175 Aplicado a la llamada de una función,
176 la comilla simple evita la evaluación de la función llamada,
177 aunque los argumentos de la función son evaluados (siempre y cuando
178 la evaluación no se evite de otra manera).
179 El resultado es una forma de nombre de la función llamada.
181 @c ===beg===
182 @c x0: 5;
183 @c x1: 7;
184 @c integrate (x^2, x, x0, x1);
185 @c 'integrate (x^2, x, x0, x1);
186 @c %, nouns;
187 @c ===end===
188 @example
189 (%i1) x0: 5;
190 (%o1) 5
191 (%i2) x1: 7;
192 (%o2) 7
193 (%i3) integrate (x^2, x, x0, x1);
194 218
195 (%o3) ---
196 3
197 (%i4) 'integrate (x^2, x, x0, x1);
198 7
199 /
200 [ 2
201 (%o4) I x dx
202 ]
203 /
204 5
205 (%i5) %, nouns;
206 218
207 (%o5) ---
208 3
209 @end example
211 Aplicado a una expresión con paréntesis, la comilla simple evita
212 la evaluación de todos los símbolos y llamadas a
213 funciones que haya dentro en la expresión.
215 @c ===beg===
216 @c aa: 1024;
217 @c bb: 19;
218 @c sqrt(aa) + bb;
219 @c '(sqrt(aa) + bb);
220 @c ''%;
221 @c ===end===
222 @example
223 (%i1) aa: 1024;
224 (%o1) 1024
225 (%i2) bb: 19;
226 (%o2) 19
227 (%i3) sqrt(aa) + bb;
228 (%o3) 51
229 (%i4) '(sqrt(aa) + bb);
230 (%o4) bb + sqrt(aa)
231 (%i5) ''%;
232 (%o5) 51
233 @end example
235 La comilla simple no evita la simplificación.
237 @c ===beg===
238 @c sin (17 * %pi) + cos (17 * %pi);
239 @c '(sin (17 * %pi) + cos (17 * %pi));
240 @c ===end===
241 @example
242 (%i1) sin (17 * %pi) + cos (17 * %pi);
243 (%o1) - 1
244 (%i2) '(sin (17 * %pi) + cos (17 * %pi));
245 (%o2) - 1
246 @end example
248 Internamente, Maxima considera que las operaciones con números
249 decimales de coma flotante son simples simplificaciones.
251 @c ===beg===
252 @c sin(1.0);
253 @c '(sin(1.0));
254 @c ===end===
255 @example
256 (%i1) sin(1.0);
257 (%o1) .8414709848078965
258 (%i2) '(sin(1.0));
259 (%o2) .8414709848078965
260 @end example
262 @end deffn
268 @deffn {Operador} ''
269 @ifinfo
270 @fnindex Operador comilla-comilla
271 @end ifinfo
272 El operador comilla-comilla @code{'@w{}'} (dos comillas simples) modifica la evaluación
273 en las expresiones de entrada.
275 Aplicado a cualquier expresión general @var{expr}, las dos comillas simples hacen que
276 el valor de @var{expr} sea sustituido por @var{expr} en la expresión de entrada.
278 Aplicado al operador de una expresión, el operador comilla-comilla hace que el operador
279 pase de ser un nombre a ser un verbo, a menos que ya sea un verbo.
281 El operador comilla-comilla es aplicado por el analizador sintáctico de entrada;
282 no se almacena como una parte de la expresión de entrada analizada.
283 Este operador se aplica siempre tan pronto como es detectado y no puede ser comentado con
284 una comilla simple. De esta manera, el operador comilla-comilla provoca la evaluación de
285 una expresión cuando ésta no estaba previsto que fuese evaluada, como en la
286 definición de funciones, expresiones lambda y expresiones comentadas con una comilla simple
287 @code{'}.
289 El operador comilla-comilla es reconocido tanto por @code{batch} como por @code{load}.
291 Véanse también el operador comilla simple @code{'} y @code{nouns}.
293 Ejemplos:
295 Aplicado a cualquier expresión general @var{expr}, las dos comillas simples hacen que
296 el valor de @var{expr} sea sustituido por @var{expr} en la expresión de entrada.
298 @c ===beg===
299 @c expand ((a + b)^3);
300 @c [_, ''_];
301 @c [%i1, ''%i1];
302 @c [aa : cc, bb : dd, cc : 17, dd : 29];
303 @c foo_1 (x) := aa - bb * x;
304 @c foo_1 (10);
305 @c ''%;
306 @c ''(foo_1 (10));
307 @c foo_2 (x) := ''aa - ''bb * x;
308 @c foo_2 (10);
309 @c [x0 : x1, x1 : x2, x2 : x3];
310 @c x0;
311 @c ''x0;
312 @c '' ''x0;
313 @c ===end===
314 @example
315 (%i1) expand ((a + b)^3);
316 3 2 2 3
317 (%o1) b + 3 a b + 3 a b + a
318 (%i2) [_, ''_];
319 3 3 2 2 3
320 (%o2) [expand((b + a) ), b + 3 a b + 3 a b + a ]
321 (%i3) [%i1, ''%i1];
322 3 3 2 2 3
323 (%o3) [expand((b + a) ), b + 3 a b + 3 a b + a ]
324 (%i4) [aa : cc, bb : dd, cc : 17, dd : 29];
325 (%o4) [cc, dd, 17, 29]
326 (%i5) foo_1 (x) := aa - bb * x;
327 (%o5) foo_1(x) := aa - bb x
328 (%i6) foo_1 (10);
329 (%o6) cc - 10 dd
330 (%i7) ''%;
331 (%o7) - 273
332 (%i8) ''(foo_1 (10));
333 (%o8) - 273
334 (%i9) foo_2 (x) := ''aa - ''bb * x;
335 (%o9) foo_2(x) := cc - dd x
336 (%i10) foo_2 (10);
337 (%o10) - 273
338 (%i11) [x0 : x1, x1 : x2, x2 : x3];
339 (%o11) [x1, x2, x3]
340 (%i12) x0;
341 (%o12) x1
342 (%i13) ''x0;
343 (%o13) x2
344 (%i14) '' ''x0;
345 (%o14) x3
346 @end example
348 Aplicado al operador de una expresión, la
349 doble comilla simple hace que el operador
350 pase de ser nominal a verbal, a menos que ya sea un verbo.
352 @c ===beg===
353 @c declare (foo, noun);
354 @c foo (x) := x - 1729;
355 @c foo (100);
356 @c ''foo (100);
357 @c ===end===
358 @example
359 (%i1) declare (foo, noun);
360 (%o1) done
361 (%i2) foo (x) := x - 1729;
362 (%o2) ''foo(x) := x - 1729
363 (%i3) foo (100);
364 (%o3) foo(100)
365 (%i4) ''foo (100);
366 (%o4) - 1629
367 @end example
370 El operador comilla-comilla es aplicado por el analizador sintáctico de entrada;
371 no se almacena como una parte de la expresión de entrada analizada.
373 @c ===beg===
374 @c [aa : bb, cc : dd, bb : 1234, dd : 5678];
375 @c aa + cc;
376 @c display (_, op (_), args (_));
377 @c ''(aa + cc);
378 @c display (_, op (_), args (_));
379 @c ===end===
380 @example
381 (%i1) [aa : bb, cc : dd, bb : 1234, dd : 5678];
382 (%o1) [bb, dd, 1234, 5678]
383 (%i2) aa + cc;
384 (%o2) dd + bb
385 (%i3) display (_, op (_), args (_));
386 _ = cc + aa
388 op(cc + aa) = +
390 args(cc + aa) = [cc, aa]
392 (%o3) done
393 (%i4) ''(aa + cc);
394 (%o4) 6912
395 (%i5) display (_, op (_), args (_));
396 _ = dd + bb
398 op(dd + bb) = +
400 args(dd + bb) = [dd, bb]
402 (%o5) done
403 @end example
405 El operador comilla-comilla provoca la evaluación de
406 una expresión cuando ésta no estaba previsto que fuese evaluada, como en la
407 definición de funciones, expresiones lambda y expresiones comentadas con una comilla simple
408 @code{'}.
410 @c ===beg===
411 @c foo_1a (x) := ''(integrate (log (x), x));
412 @c foo_1b (x) := integrate (log (x), x);
413 @c dispfun (foo_1a, foo_1b);
414 @c integrate (log (x), x);
415 @c foo_2a (x) := ''%;
416 @c foo_2b (x) := %;
417 @c dispfun (foo_2a, foo_2b);
418 @c F : lambda ([u], diff (sin (u), u));
419 @c G : lambda ([u], ''(diff (sin (u), u)));
420 @c '(sum (a[k], k, 1, 3) + sum (b[k], k, 1, 3));
421 @c '(''(sum (a[k], k, 1, 3)) + ''(sum (b[k], k, 1, 3)));
422 @c ===end===
423 @example
424 (%i1) foo_1a (x) := ''(integrate (log (x), x));
425 (%o1) foo_1a(x) := x log(x) - x
426 (%i2) foo_1b (x) := integrate (log (x), x);
427 (%o2) foo_1b(x) := integrate(log(x), x)
428 (%i3) dispfun (foo_1a, foo_1b);
429 (%t3) foo_1a(x) := x log(x) - x
431 (%t4) foo_1b(x) := integrate(log(x), x)
433 (%o4) [%t3, %t4]
434 (%i5) integrate (log (x), x);
435 (%o5) x log(x) - x
436 (%i6) foo_2a (x) := ''%;
437 (%o6) foo_2a(x) := x log(x) - x
438 (%i7) foo_2b (x) := %;
439 (%o7) foo_2b(x) := %
440 (%i8) dispfun (foo_2a, foo_2b);
441 (%t8) foo_2a(x) := x log(x) - x
443 (%t9) foo_2b(x) := %
445 (%o9) [%t7, %t8]
446 (%i10) F : lambda ([u], diff (sin (u), u));
447 (%o10) lambda([u], diff(sin(u), u))
448 (%i11) G : lambda ([u], ''(diff (sin (u), u)));
449 (%o11) lambda([u], cos(u))
450 (%i12) '(sum (a[k], k, 1, 3) + sum (b[k], k, 1, 3));
451 (%o12) sum(b , k, 1, 3) + sum(a , k, 1, 3)
452 k k
453 (%i13) '(''(sum (a[k], k, 1, 3)) + ''(sum (b[k], k, 1, 3)));
454 (%o13) b + a + b + a + b + a
455 3 3 2 2 1 1
456 @end example
458 @end deffn
462 @deffn {Función} ev (@var{expr}, @var{arg_1}, @dots{}, @var{arg_n})
463 Evalua la expresión @var{expr} en el entorno especificado
464 por los argumentos @var{arg_1}, ..., @var{arg_n}.
465 Los argumentos son interruptores (Variables Booleanas), variables de
466 asignación, ecuaciones y funciones.
467 @code{ev} retorna el resultado (otra expresión) de la evaluación.
469 La evaluación se realiza por etapas, como sigue:
471 @enumerate
472 @item
473 Primero se configura el entorno de acuerdo a los argumentos los
474 cuales pueden ser algunos o todos de la siguiente lista:
476 @itemize @bullet
477 @item
478 @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}.
479 @item
480 @code{noeval} suprime la fase de evaluación de @code{ev} (Vea el paso (4) más adelante).
481 Esto es muy útil en conjunción con otras variables interruptor y causan en @var{expr} que sea resimplificada sin ser reevaluada.
482 @item
483 @code{nouns} causa la evaluación de las formas nominales
484 (típicamente funciones sin evaluar tales como
485 @code{'integrate} or @code{'diff}) en @code{expr}.
486 @item
487 @code{expand} causa expansión.
488 @item
489 @code{expand (@var{m}, @var{n})} causa expansión, asignando los valores de @code{maxposex} y
490 @code{maxnegex} a @var{m} y @var{n}, respectivamente.
491 @item
492 @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.
493 @item
494 @code{diff} realiza todas las diferenciaciones indicadas en @var{expr}.
495 @item
496 @code{derivlist (@var{x}, @var{y}, @var{z}, ...)} realiza sólo las diferenciaciones con respecto a las variables indicadas.
497 @item
498 @code{risch} hace que las integrales presentes en @var{expr} se evalúen mediante
499 el algoritmo de Risch. Véase también @code{risch}. Cuando se utiliza el
500 símbolo especial @code{nouns}, se aplica la rutina estándar de integración.
501 @item
502 @code{float} provoca la conversión de los números racionales no-enteros a números decimales de coma flotante.
503 @item
504 @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}.
505 @item
506 @code{pred} provoca la evaluación de los predicados (expresiones las cuales se evaluan a @code{true} o @code{false}).
507 @item
508 @code{eval} provoca una post-evaluación extra de @var{expr} (véase el paso (5) más adelante), pudiendo aparecer
509 @code{eval} varias veces; por cada aparición de @code{eval}, la expresión es reevaluada.
510 @item
511 @code{A}, donde @code{A} es un átomo declarado como una variable de tipo interruptor, (Vea @code{evflag})
512 causa que @code{A} tenga como valor @code{true} durante
513 la evaluación de @var{expr}.
514 @item
515 @code{V: expresion} (o alternativamente @code{V=expresion}) causa que
516 @code{V} tenga el valor de @code{expresion} durante la evaluación
517 de @var{expr}. Notese que si @code{V} es una opción Maxima, entonces
518 @code{expresion} se usa como su valor durante la evaluación de
519 @var{expr}. Si más de un argumento de @code{ev} es de este
520 tipo entonces el vínculo se hace en paralelo. Si @code{V} es una
521 expresión no atómica entonces se hace una sustitución más que
522 un vínculo.
523 @item
524 @code{F} donde @code{F}, un nombre de función, ha sido declarado para
525 ser una función de evaluación (Vea @code{evfun}) causa que
526 @code{F} sea aplicada a @var{expr}.
527 @item
528 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
529 verbos.
530 @item
531 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
532 de @var{expr} pasando @code{F(x) := expresion} como un argumento a
533 @code{ev}.
534 @item
535 Si un átomo no mencionado anteriormente o una variable o expresión
536 con subíndices fueran pasadas como un argumento, esta es evaluada y
537 si el resultado es una ecuación o una asignación entonces el
538 vínculo o sustitución se llevará a cabo. Si el resultado es una
539 lista entonces los miembros de la lista tratados como si ellos fueran
540 argumentos adicionales pasados a @code{ev}. Esto permite que una
541 lista de argumentos sea pasada (e.g., @code{[X=1, Y=A**2]}) o una lista
542 de nombres de ecuaciones (e.g., @code{[%t1, %t2]} donde @code{%t1} y
543 @code{%t2} son ecuaciones) tal como lo que es retornado por
544 @code{solve}.
545 @end itemize
547 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
548 secuencia, de izquierda a derecha y las funciones de evaluación las
549 cuales son compuestas, e.g., @code{ev (@var{expr}, ratsimp, realpart)}
550 es manipulada como @code{realpart (ratsimp (@var{expr}))}.
552 Los interruptores @code{simp}, @code{numer} y @code{float}
553 pueden también ser configurados localmente en una sentencia block, o
554 globalmente en Maxima para que su efecto permanezca hasta que
555 sean reconfiguradas.
557 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
558 de tipo CRE, siempre que los interruptores @code{numer} y @code{float} no sean @code{true}.
560 @item
561 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
562 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.
563 Usualmente, @var{expr} es sólo una etiqueta o un @code{%}
564 (como en @code{%i2} en el ejemplo de más abajo) así que
565 este paso simplemente recupera la expresión a la que hace referencia
566 la etiqueta y así @code{ev} puede trabajarla.
568 @item
569 Si algunas sustituciones son indicadas por los argumentos, ellas
570 serán llevadas a cabo ahora.
572 @item
573 La expresión resultante es también reevaluada (a menos que uno de
574 los argumentos fuese @code{noeval}) y simplificada de acuerdo a los
575 argumentos. Notese que cualquier llamada a una función en @var{expr}
576 será llevada a cabo después de que las variables sean evaluadas
577 en ella y que @code{ev(F(x))} pueda comportarse como @code{F(ev(x))}.
579 @item
580 Por cada aparición de @code{eval} en los argumentos, se repetirán los pasos (3) y (4).
581 @end enumerate
583 Ejemplos:
585 @c ===beg===
586 @c sin(x) + cos(y) + (w+1)^2 + 'diff (sin(w), w);
587 @c ev (%, numer, expand, diff, x=2, y=1);
588 @c ===end===
589 @example
590 (%i1) sin(x) + cos(y) + (w+1)^2 + 'diff (sin(w), w);
591 d 2
592 (%o1) cos(y) + sin(x) + -- (sin(w)) + (w + 1)
593 dw
594 (%i2) ev (%, numer, expand, diff, x=2, y=1);
595 2
596 (%o2) cos(w) + w + 2 w + 2.449599732693821
597 @end example
600 Una sintaxis alternativa de alto nivel ha sido desarrollada para @code{ev}
601 por medio de la cual se pueden escribir solamente sus argumentos, sin
602 el comando @code{ev()}; se trata de una forma de escritura simplificada:
604 @example
605 @var{expr}, @var{arg_1}, ..., @var{arg_n}
606 @end example
608 Esta sintaxis no está permitida dentro de otras expresiones, como
609 funciones, bloques, etc.
611 Nótese el proceso de vínculo en paralelo en el siguiente ejemplo:
613 @example
614 (%i3) programmode: false;
615 (%o3) false
616 (%i4) x+y, x: a+y, y: 2;
617 (%o4) y + a + 2
618 (%i5) 2*x - 3*y = 3$
619 (%i6) -3*x + 2*y = -4$
620 (%i7) solve ([%o5, %o6]);
621 Solución
623 1
624 (%t7) y = - -
625 5
627 6
628 (%t8) x = -
629 5
630 (%o8) [[%t7, %t8]]
631 (%i8) %o6, %o8;
632 (%o8) - 4 = - 4
633 (%i9) x + 1/x > gamma (1/2);
634 1
635 (%o9) x + - > sqrt(%pi)
636 x
637 (%i10) %, numer, x=1/2;
638 (%o10) 2.5 > 1.772453850905516
639 (%i11) %, pred;
640 (%o11) true
641 @end example
643 @end deffn
647 @defvr {Símbolo especial} eval
648 Como argumento en una llamada a @code{ev (@var{expr})}, @code{eval}
649 fuerza una evaluación extra de @var{expr}.
651 Véase también @code{ev}.
653 Ejemplo:
655 @c ===beg===
656 @c [a:b,b:c,c:d,d:e];
657 @c a;
658 @c ev(a);
659 @c ev(a),eval;
660 @c a,eval,eval;
661 @c ===end===
662 @example
663 (%i1) [a:b,b:c,c:d,d:e];
664 (%o1) [b, c, d, e]
665 (%i2) a;
666 (%o2) b
667 (%i3) ev(a);
668 (%o3) c
669 (%i4) ev(a),eval;
670 (%o4) e
671 (%i5) a,eval,eval;
672 (%o5) e
673 @end example
675 @end defvr
680 @defvr {Propiedad} evflag
681 Cuando un símbolo @var{x} goza de la propiedad @code{evflag},
682 las expresiones @code{ev(@var{expr}, @var{x})} y @code{@var{expr}, @var{x}}
683 (en modo interactivo) equivalen a @code{ev(@var{expr}, @var{x} = true)}.
684 Esto es, a @var{x} se le asigna @code{true} al tiempo que se evalúa @var{expr}.
686 La expresión @code{declare(@var{x}, evflag)} dota a la variable @var{x}
687 de la propiedad @code{evflag}.
689 Los interruptores que tienen la propiedad @code{evflag} son:
691 @verbatim
692 algebraic cauchysum demoivre
693 dotscrules %emode %enumer
694 exponentialize exptisolate factorflag
695 float halfangles infeval
696 isolate_wrt_times keepfloat letrat
697 listarith logabs logarc
698 logexpand lognegint
699 m1pbranch numer_pbranch programmode
700 radexpand ratalgdenom ratfac
701 ratmx ratsimpexpons simp
702 simpproduct simpsum sumexpand
703 trigexpand
704 @end verbatim
706 Ejemplos:
708 @c ===beg===
709 @c sin (1/2);
710 @c sin (1/2), float;
711 @c sin (1/2), float=true;
712 @c simp : false;
713 @c 1 + 1;
714 @c 1 + 1, simp;
715 @c simp : true;
716 @c sum (1/k^2, k, 1, inf);
717 @c sum (1/k^2, k, 1, inf), simpsum;
718 @c declare (aa, evflag);
719 @c if aa = true then YES else NO;
720 @c if aa = true then YES else NO, aa;
721 @c ===end===
722 @example
723 (%i1) sin (1/2);
724 1
725 (%o1) sin(-)
726 2
727 (%i2) sin (1/2), float;
728 (%o2) 0.479425538604203
729 (%i3) sin (1/2), float=true;
730 (%o3) 0.479425538604203
731 (%i4) simp : false;
732 (%o4) false
733 (%i5) 1 + 1;
734 (%o5) 1 + 1
735 (%i6) 1 + 1, simp;
736 (%o6) 2
737 (%i7) simp : true;
738 (%o7) true
739 (%i8) sum (1/k^2, k, 1, inf);
740 inf
741 ====
742 \ 1
743 (%o8) > --
744 / 2
745 ==== k
746 k = 1
747 (%i9) sum (1/k^2, k, 1, inf), simpsum;
748 2
749 %pi
750 (%o9) ----
751 6
752 (%i10) declare (aa, evflag);
753 (%o10) done
754 (%i11) if aa = true then YES else NO;
755 (%o11) NO
756 (%i12) if aa = true then YES else NO, aa;
757 (%o12) YES
758 @end example
760 @end defvr
765 @defvr {Propiedad} evfun
766 Cuando la función @var{F} goza de la propiedad @code{evfun},
767 las expresiones @code{ev(@var{expr}, @var{F})} y @code{@var{expr}, @var{F}}
768 (en modo interactivo) equivalen a @code{@var{F}(ev(@var{expr}))}.
770 Si se especifican dos o más funciones, @var{F}, @var{G}, etc., como poseedoras
771 de la propiedad @code{evfun}, éstas se aplican en el mismo orden en el que han sido
772 especificadas como tales.
774 La expresión @code{declare(@var{F}, evfun)} dota a la función @var{F}
775 de la propiedad @code{evfun}.
777 Las funciones que tienen la propiedad @code{evfun} por defecto son:
779 @c FOLLOWING LIST CONSTRUCTED FROM LIST UNDER (prog1 '(evfun properties) ...)
780 @c NEAR LINE 2643 IN mlisp.lisp AT PRESENT (2004/11).
781 @verbatim
782 bfloat factor fullratsimp
783 logcontract polarform radcan
784 ratexpand ratsimp rectform
785 rootscontract trigexpand trigreduce
786 @end verbatim
788 Ejemplos:
790 @c ===beg===
791 @c x^3 - 1;
792 @c x^3 - 1, factor;
793 @c factor (x^3 - 1);
794 @c cos(4 * x) / sin(x)^4;
795 @c cos(4 * x) / sin(x)^4, trigexpand;
796 @c cos(4 * x) / sin(x)^4, trigexpand, ratexpand;
797 @c ratexpand (trigexpand (cos(4 * x) / sin(x)^4));
798 @c declare ([F, G], evfun);
799 @c (aa : bb, bb : cc, cc : dd);
800 @c aa;
801 @c aa, F;
802 @c F (aa);
803 @c F (ev (aa));
804 @c aa, F, G;
805 @c G (F (ev (aa)));
806 @c ===end===
807 @example
808 (%i1) x^3 - 1;
809 3
810 (%o1) x - 1
811 (%i2) x^3 - 1, factor;
812 2
813 (%o2) (x - 1) (x + x + 1)
814 (%i3) factor (x^3 - 1);
815 2
816 (%o3) (x - 1) (x + x + 1)
817 (%i4) cos(4 * x) / sin(x)^4;
818 cos(4 x)
819 (%o4) --------
820 4
821 sin (x)
822 (%i5) cos(4 * x) / sin(x)^4, trigexpand;
823 4 2 2 4
824 sin (x) - 6 cos (x) sin (x) + cos (x)
825 (%o5) -------------------------------------
826 4
827 sin (x)
828 (%i6) cos(4 * x) / sin(x)^4, trigexpand, ratexpand;
829 2 4
830 6 cos (x) cos (x)
831 (%o6) - --------- + ------- + 1
832 2 4
833 sin (x) sin (x)
834 (%i7) ratexpand (trigexpand (cos(4 * x) / sin(x)^4));
835 2 4
836 6 cos (x) cos (x)
837 (%o7) - --------- + ------- + 1
838 2 4
839 sin (x) sin (x)
840 (%i8) declare ([F, G], evfun);
841 (%o8) done
842 (%i9) (aa : bb, bb : cc, cc : dd);
843 (%o9) dd
844 (%i10) aa;
845 (%o10) bb
846 (%i11) aa, F;
847 (%o11) F(cc)
848 (%i12) F (aa);
849 (%o12) F(bb)
850 (%i13) F (ev (aa));
851 (%o13) F(cc)
852 (%i14) aa, F, G;
853 (%o14) G(F(cc))
854 (%i15) G (F (ev (aa)));
855 (%o15) G(F(cc))
856 @end example
858 @end defvr
862 @defvr {Variable opcional} infeval
863 Habilita el modo de "evaluación infinita". @code{ev} repetidamente
864 evalua una expresión hasta que se pare de hacer cambios. Para prevenir
865 que una variable, digamos @code{X}, sea evaluada sin parar en este modo,
866 simplemente incluya @code{X='X} como argumento de @code{ev}.
867 Esta claro que expresiones como @code{ev (X, X=X+1, infeval)} generarán un bucle infinito.
868 @end defvr
872 @defvr {Símbolo especial} noeval
873 El símbolo @code{noeval} evita la fase de evaluación de @code{ev}.
874 Es útil conjuntamente con otras variables globales y para poder volver a
875 simplificar expresiones sin tener que evaluarlas otra vez.
877 @end defvr
881 @defvr {Símbolo especial} nouns
882 El símbolo @code{nouns} es una @code{evflag}, lo que significa
883 que cuando se utilice como una opción de la instrucción @code{ev},
884 todas las formas nominales que aparezcan en una expresión las convierte en
885 verbales, esto es, las evalúa. Véanse también @code{noun}, @code{nounify},
886 @code{verb} y @code{verbify}.
888 @end defvr
892 @defvr {Símbolo especial} pred
893 Cuando se utiliza como argumento en una llamada a
894 @code{ev (@var{expr})}, @code{pred} provoca que los
895 predicados (expresiones que se reducen a @code{true} o
896 @code{false}) se evalúen.
898 Véase @code{ev}.
900 Ejemplo:
902 @c ===beg===
903 @c 1<2;
904 @c 1<2,pred;
905 @c ===end===
906 @example
907 (%i1) 1<2;
908 (%o1) 1 < 2
909 (%i2) 1<2,pred;
910 (%o2) true
911 @end example
912 @end defvr