| blob | d6aa6a691712e8e21f2a8335ac89da51ee697d38 |
1 @c English version 2011-09-03
2 @menu
3 * Introducción a las expresiones::
4 * Nombres y verbos::
5 * Identificadores::
6 * Desigualdades::
7 * Funciones y variables para expresiones::
8 @end menu
10 @node Introducción a las expresiones, Nombres y verbos, Expresiones, Expresiones
11 @section Introducción a las expresiones
13 Existe un cierto número de palabras reservadas
14 que no deberían
15 utilizarse como nombres de variables. Su uso podría causar
16 errores sintácticos.
18 @example
19 integrate next from diff
20 in at limit sum
21 for and elseif then
22 else do or if
23 unless product while thru
24 step
25 @end example
27 La mayoría de los objetos en Maxima son expresiones. Una secuencia
28 de expresiones puede constituir una expresión, separándolas por
29 comas y colocando paréntesis alrededor de ellas. Esto es similar a
30 las @i{expresiones con coma} en @b{C}.
32 @example
33 (%i1) x: 3$
34 (%i2) (x: x+1, x: x^2);
35 (%o2) 16
36 (%i3) (if (x > 17) then 2 else 4);
37 (%o3) 4
38 (%i4) (if (x > 17) then x: 2 else y: 4, y+x);
39 (%o4) 20
40 @end example
42 Incluso los bucles en Maxima son expresiones, aunque el valor que
43 retornan (@code{done}) no es muy útil.
45 @example
46 (%i1) y: (x: 1, for i from 1 thru 10 do (x: x*i))$
47 (%i2) y;
48 (%o2) done
49 @end example
51 pero quizás se quiera incluir un tercer término en la @i{expresión con coma} para que devuelva el valor de interés.
53 @example
54 (%i3) y: (x: 1, for i from 1 thru 10 do (x: x*i), x)$
55 (%i4) y;
56 (%o4) 3628800
57 @end example
68 @node Nombres y verbos, Identificadores, Introducción a las expresiones, Expresiones
69 @section Nombres y verbos
71 Maxima distingue entre operadores que son "nombres" y operadores que son "verbos".
72 Un verbo es un operador que puede ser ejecutado.
73 Un nombre es un operador que aparece como un símbolo en una expresión pero sin ser ejecutado.
74 Por defecto, los nombres de funciones son verbos.
75 Un verbo puede transformarse en nombre utilizando el apóstrofo o aplicando la función @code{nounify}.
76 Un nombre puede transformarse en verbo aplicando la función @code{verbify}.
77 La variable @code{nouns} hace que @code{ev} evalúe los nombres presentes en una expresión.
79 La forma verbal se distingue mediante la precedencia del carácter dólar @code{$} al correspondiente símbolo de Lisp.
80 Por otro lado, la forma nominal se distingue mediante la precedencia del carácter porcentaje @code{%} al correspondiente símbolo de Lisp.
81 Algunos nombres gozan de propiedades especiales para su representación, como @code{'integrate} o @code{'derivative}
82 (devuelto por @code{diff}), pero la mayoría no.
83 Por defecto, las formas nominal y verbal de una función son idénticas cuando se muestran en un terminal.
84 La variable global @code{noundisp} hace que Maxima muestre los nombres precedidos del apóstrofo @code{'}.
86 Véanse también @code{noun}, @code{nouns}, @code{nounify} y @code{verbify}.
88 Ejemplos:
90 @c ===beg===
91 @c foo (x) := x^2;
92 @c foo (42);
93 @c 'foo (42);
94 @c 'foo (42), nouns;
95 @c declare (bar, noun);
96 @c bar (x) := x/17;
97 @c bar (52);
98 @c bar (52), nouns;
99 @c integrate (1/x, x, 1, 42);
100 @c 'integrate (1/x, x, 1, 42);
101 @c ev (%, nouns);
102 @c ===end===
103 @example
104 (%i1) foo (x) := x^2;
105 2
106 (%o1) foo(x) := x
107 (%i2) foo (42);
108 (%o2) 1764
109 (%i3) 'foo (42);
110 (%o3) foo(42)
111 (%i4) 'foo (42), nouns;
112 (%o4) 1764
113 (%i5) declare (bar, noun);
114 (%o5) done
115 (%i6) bar (x) := x/17;
116 x
117 (%o6) ''bar(x) := --
118 17
119 (%i7) bar (52);
120 (%o7) bar(52)
121 (%i8) bar (52), nouns;
122 52
123 (%o8) --
124 17
125 (%i9) integrate (1/x, x, 1, 42);
126 (%o9) log(42)
127 (%i10) 'integrate (1/x, x, 1, 42);
128 42
129 /
130 [ 1
131 (%o10) I - dx
132 ] x
133 /
134 1
135 (%i11) ev (%, nouns);
136 (%o11) log(42)
137 @end example
146 @node Identificadores, Desigualdades, Nombres y verbos, Expresiones
147 @section Identificadores
150 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 @code{\}.
152 Un identificador puede comenzar con un carácter numérico si éste va precedido de la barra invertida @code{\}.
153 Los caracteres numéricos que ocupen la segunda posición o posterior no necesitan ir precedidos de la barra invertida.
155 Los caracteres pueden declararse como alfabéticos con la función @code{declare}.
156 Así declarados, no necesitan ir precedidos de la barra invertida en un identificador.
157 En principio, los caracteres alfabéticos son las letras de @code{A} a @code{Z} y
158 @code{a} a @code{z}, junto con @code{%} y @code{_}.
160 Maxima distingue minúsculas y mayúsculas. Los identificadores @code{foo}, @code{FOO} y @code{Foo} son distintos.
161 Véase @ref{Lisp y Maxima} para más información.
163 Un identificador en Maxima es un símbolo Lisp que comienza con el símbolo dólar @code{$}.
164 Cualquier otro símbolo de Lisp va precedido de la interrogación @code{?} cuando aparece en Maxima.
165 Véase @ref{Lisp y Maxima} para más información.
167 Ejemplos:
169 @c ===beg===
170 @c %an_ordinary_identifier42;
171 @c embedded\ spaces\ in\ an\ identifier;
172 @c symbolp (%);
173 @c [foo+bar, foo\+bar];
174 @c [1729, \1729];
175 @c [symbolp (foo\+bar), symbolp (\1729)];
176 @c [is (foo\+bar = foo+bar), is (\1729 = 1729)];
177 @c baz\~quux;
178 @c declare ("~", alphabetic);
179 @c baz~quux;
180 @c [is (foo = FOO), is (FOO = Foo), is (Foo = foo)];
181 @c :lisp (defvar *my-lisp-variable* '$foo)
182 @c ?\*my\-lisp\-variable\*;
183 @c ===end===
185 @example
186 (%i1) %an_ordinary_identifier42;
187 (%o1) %an_ordinary_identifier42
188 (%i2) embedded\ spaces\ in\ an\ identifier;
189 (%o2) embedded spaces in an identifier
190 (%i3) symbolp (%);
191 (%o3) true
192 (%i4) [foo+bar, foo\+bar];
193 (%o4) [foo + bar, foo+bar]
194 (%i5) [1729, \1729];
195 (%o5) [1729, 1729]
196 (%i6) [symbolp (foo\+bar), symbolp (\1729)];
197 (%o6) [true, true]
198 (%i7) [is (foo\+bar = foo+bar), is (\1729 = 1729)];
199 (%o7) [false, false]
200 (%i8) baz\~quux;
201 (%o8) baz~quux
202 (%i9) declare ("~", alphabetic);
203 (%o9) done
204 (%i10) baz~quux;
205 (%o10) baz~quux
206 (%i11) [is (foo = FOO), is (FOO = Foo), is (Foo = foo)];
207 (%o11) [false, false, false]
208 (%i12) :lisp (defvar *my-lisp-variable* '$foo)
209 *MY-LISP-VARIABLE*
210 (%i12) ?\*my\-lisp\-variable\*;
211 (%o12) foo
212 @end example
222 @node Desigualdades, Funciones y variables para expresiones, Identificadores, Expresiones
223 @section Desigualdades
226 Maxima dispone de los operadores de desigualdad @code{<}, @code{<=}, @code{>=}, @code{>}, @code{#} y @code{notequal}.
227 Véase @code{if} para una descripción de las expresiones condicionales.
235 @node Funciones y variables para expresiones, , Desigualdades, Expresiones
236 @section Funciones y variables para expresiones
239 @deffn {Función} alias (@var{new_name_1}, @var{old_name_1}, ..., @var{new_name_n}, @var{old_name_n})
240 provee un nombre
241 alternativo para una (bien sea definida por el usuario o por el sistema) función, variable, arreglo, etc.
242 Cualquier número par de argumentos puede ser usado.
243 @end deffn
246 @defvr {Variable del sistema} aliases
247 Valor por defecto: @code{[]}
249 La variable @code{aliases} es la lista de átomos que tienen un "alias" definido por el usuario (establecido mediante las funciones @code{alias}, @code{ordergreat} o @code{orderless} o declarando el átomo como un @code{noun} (nombre) con @code{declare}.
250 @end defvr
254 @defvr {Clave} allbut
255 Opera con los comandos @code{part} (como @code{part}, @code{inpart}, @code{substpart},
256 @code{substinpart}, @code{dpart} y @code{lpart}). Por ejemplo:
258 @c ===beg===
259 @c expr : e + d + c + b + a;
260 @c part (expr, [2, 5]);
261 @c ===end===
262 @example
263 (%i1) expr : e + d + c + b + a;
264 (%o1) e + d + c + b + a
265 (%i2) part (expr, [2, 5]);
266 (%o2) d + a
267 @end example
269 mientras que:
271 @c ===beg===
272 @c expr : e + d + c + b + a;
273 @c part (expr, allbut (2, 5));
274 @c ===end===
275 @example
276 (%i1) expr : e + d + c + b + a;
277 (%o1) e + d + c + b + a
278 (%i2) part (expr, allbut (2, 5));
279 (%o2) e + c + b
280 @end example
282 La función @code{kill} también reconoce a @code{allbut}.
284 @c ===beg===
285 @c [aa : 11, bb : 22, cc : 33, dd : 44, ee : 55];
286 @c kill (allbut (cc, dd));
287 @c [aa, bb, cc, dd];
288 @c ===end===
289 @example
290 (%i1) [aa : 11, bb : 22, cc : 33, dd : 44, ee : 55];
291 (%o1) [11, 22, 33, 44, 55]
292 (%i2) kill (allbut (cc, dd));
293 (%o0) done
294 (%i1) [aa, bb, cc, dd];
295 (%o1) [aa, bb, 33, 44]
296 @end example
298 La sentencia @code{kill(allbut(@var{a_1}, @var{a_2}, ...))}
299 tiene el mismo efecto que @code{kill(all)}, excepto que no
300 elimina los símbolos @var{a_1}, @var{a_2}, ... .
302 @end defvr
306 @deffn {Función} args (@var{expr})
308 Devuelve la lista de argumentos de @code{expr}, que puede ser cualquier tipo de expresión a excepción de un átomo. Tan solo se muestran los argumentos del operador principal; subexpresiones de @code{expr} aparecen como elementos o subexpresiones de elementos de la lista de argumentos.
310 El orden de los miembros de la lista puede depender de la variable global @code{inflag}.
312 La llamada @code{args (@var{expr})} es equivalente a @code{substpart ("[", @var{expr}, 0)}.
314 Véanse también @code{substpart} y @code{op}.
316 @end deffn
320 @deffn {Función} atom (@var{expr})
322 Devuelve @code{true} si @var{expr} es un átomo (número, nombre o cadena alfanumérica) y @code{false} en caso contario. Así, @code{atom(5)} devolverá @code{true}, mientras que @code{atom(a[1])} y @code{atom(sin(x))} darán como resultado @code{false} (dando por hecho que tanto @code{a[1]} como @code{x} no tienen valores asignados).
324 @end deffn
328 @deffn {Función} box (@var{expr})
329 @deffnx {Función} box (@var{expr}, @var{a})
330 Devuelve @var{expr} encerrada en una caja.
331 El valor devuelto es una expresión con @code{box} como operador y @var{expr} como argumento.
332 Se dibujará una caja cuando @code{display2d} valga @code{true}.
334 La llamada @code{box (@var{expr}, @var{a})}
335 encierra @var{expr} en una caja etiquetada con el símbolo @var{a}.
336 La etiqueta se recorta si es más larga que el ancho de la caja.
338 La función @code{box} evalúa su argumento. Sin embargo, la expresión
339 encerrada no se evalúa, siendo excluída de los cálculos.
341 La variable @code{boxchar} guarda el carácter a utilizar para dibujar la caja en las funciones @code{box}, @code{dpart} y @code{lpart}.
343 Ejemplos:
345 @c ===beg===
346 @c box (a^2 + b^2);
347 @c a : 1234;
348 @c b : c - d;
349 @c box (a^2 + b^2);
350 @c box (a^2 + b^2, term_1);
351 @c 1729 - box (1729);
352 @c boxchar: "-";
353 @c box (sin(x) + cos(y));
354 @c ===end===
355 @example
356 (%i1) box (a^2 + b^2);
357 """""""""
358 " 2 2"
359 (%o1) "b + a "
360 """""""""
361 (%i2) a : 1234;
362 (%o2) 1234
363 (%i3) b : c - d;
364 (%o3) c - d
365 (%i4) box (a^2 + b^2);
366 """"""""""""""""""""
367 " 2 "
368 (%o4) "(c - d) + 1522756"
369 """"""""""""""""""""
370 (%i5) box (a^2 + b^2, term_1);
371 term_1""""""""""""""
372 " 2 "
373 (%o5) "(c - d) + 1522756"
374 """"""""""""""""""""
375 (%i6) 1729 - box (1729);
376 """"""
377 (%o6) 1729 - "1729"
378 """"""
379 (%i7) boxchar: "-";
380 (%o7) -
381 (%i8) box (sin(x) + cos(y));
382 -----------------
383 (%o8) -cos(y) + sin(x)-
384 -----------------
385 @end example
387 @end deffn
391 @defvr {Variable opcional} boxchar
392 Valor por defecto: @code{"}
394 La variable @code{boxchar} guarda el carácter a utilizar para dibujar la caja en las funciones @code{box}, @code{dpart} y @code{lpart}.
396 Todas las cajas en una expresión se dibujan con el valor actual de @code{boxchar}, carácter que no se almacena con las expresión encerrada.
398 @end defvr
402 @deffn {Función} collapse (@var{expr})
404 Colapsa @var{expr} haciendo que todas las subexpresiones que sean iguales
405 compartan las mismas celdas, ahorrando espacio. @code{collapse} es una
406 subrutina utilizada por la instrucción @code{optimize}. El uso de
407 @code{collapse} puede ser útil después de cargar un fichero
408 creado con @code{save}. Se pueden colapsar varias expresiones de forma
409 conjunta utilizando @code{collapse ([@var{expr_1}, ..., @var{expr_n}])}.
410 También se pueden colapsar los elementos del array @code{A}
411 haciendo @code{collapse (listarray ('A))}.
412 @end deffn
417 @deffn {Función} disolate (@var{expr}, @var{x_1}, ..., @var{x_n})
418 Es similar a @code{isolate (@var{expr}, @var{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
419 @file{simplification/disol.mac}. Se dispone de una demostyración en @code{demo("disol")$}.
421 @end deffn
423 @deffn {Función} dispform (@var{expr})
424 @deffnx {Function} dispform (@var{expr}, all)
426 @code{dispform(@var{expr})} devuelve la representación externa de
427 @var{expr} respecto del operador del nivel superior.
428 @code{dispform(@var{expr}, all)} devuelve la representación
429 externa respecto de todos los operadores que haya en @var{expr}.
431 Véase también @code{part}, @code{inpart} y @code{inflag}.
433 Ejemplos:
435 La representación interna de @code{- x} es "menos uno
436 multiplicado por @code{x}", mientras que la representación externa es
437 "menos @code{x}".
439 @c ===beg===
440 @c - x;
441 @c ?format (true, "~S~%", %);
442 @c dispform (- x);
443 @c ?format (true, "~S~%", %);
444 @c ===end===
445 @example
446 (%i1) - x;
447 (%o1) - x
448 (%i2) ?format (true, "~S~%", %);
449 ((MTIMES SIMP) -1 $X)
450 (%o2) false
451 (%i3) dispform (- x);
452 (%o3) - x
453 (%i4) ?format (true, "~S~%", %);
454 ((MMINUS SIMP) $X)
455 (%o4) false
456 @end example
458 La representación interna de @code{sqrt(x)} es
459 "@code{x} elevado a 1/2", mientras que su representación
460 externa es "raíz de @code{x}".
462 @c ===beg===
463 @c sqrt (x);
464 @c ?format (true, "~S~%", %);
465 @c dispform (sqrt (x));
466 @c ?format (true, "~S~%", %);
467 @c ===end===
468 @example
469 (%i1) sqrt (x);
470 (%o1) sqrt(x)
471 (%i2) ?format (true, "~S~%", %);
472 ((MEXPT SIMP) $X ((RAT SIMP) 1 2))
473 (%o2) false
474 (%i3) dispform (sqrt (x));
475 (%o3) sqrt(x)
476 (%i4) ?format (true, "~S~%", %);
477 ((%SQRT SIMP) $X)
478 (%o4) false
479 @end example
481 Utilización del argumento opcional @code{all}.
483 @c ===beg===
484 @c expr : sin (sqrt (x));
485 @c freeof (sqrt, expr);
486 @c freeof (sqrt, dispform (expr));
487 @c freeof (sqrt, dispform (expr, all));
488 @c ===end===
489 @example
490 (%i1) expr : sin (sqrt (x));
491 (%o1) sin(sqrt(x))
492 (%i2) freeof (sqrt, expr);
493 (%o2) true
494 (%i3) freeof (sqrt, dispform (expr));
495 (%o3) true
496 (%i4) freeof (sqrt, dispform (expr, all));
497 (%o4) false
498 @end example
499 @end deffn
503 @deffn {Función} dpart (@var{expr}, @var{n_1}, ..., @var{n_k})
504 Selecciona la misma expresión que @code{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.
506 @example
507 (%i1) dpart (x+y/z^2, 1, 2, 1);
508 y
509 (%o1) ---- + x
510 2
511 """
512 "z"
513 """
514 @end example
515 @end deffn
519 @defvr {Variable opcional} exptisolate
520 Valor por defecto: @code{false}
522 Véase @code{isolate}.
524 @end defvr
528 @defvr {Variable opcional} exptsubst
529 Valor por defecto: @code{false}
531 Si @code{exptsubst} vale @code{true} permite la sustitución @code{y} por @code{%e^x} en @code{%e^(a x)}.
533 @c NEED EXAMPLES HERE
534 @end defvr
539 @deffn {Función} freeof (@var{x_1}, ..., @var{x_n}, @var{expr})
541 @code{freeof (@var{x_1}, @var{expr})}
542 devuelve @code{true} si ninguna subexpresión de @var{expr} coincide con @var{x_1},
543 o si @var{x_1} aparece como variable muda en @var{expr}, o si @var{x_1} no es ni
544 una forma nominal ni verbal de cualesquiera operadores presentes en @var{expr},
545 devolviendo @code{false} en otro caso.
547 La llamada @code{freeof (@var{x_1}, ..., @var{x_n}, @var{expr})}
548 equivale a @code{freeof (@var{x_1}, @var{expr}) and ... and freeof (@var{x_n}, @var{expr})}.
550 Los argumentos @var{x_1}, ..., @var{x_n}
551 pueden seer nombres de funciones y variables, nombres subindicados,
552 operadores (encerrados entre comillas dobles) o expresiones generales.
554 La función @code{freeof} evalúa sus argumentos.
556 Una variable es una variable muda en una expresión si no tiene valor asignado fuera de la expresión.
557 Variable mudas reconocidas por @code{freeof} son el índice de una suma o producto, la variable límite en @code{limit},
558 la variable de integración en la versión de integral definida de @code{integrate},
559 la variable original en @code{laplace},
560 variables formales en expresiones @code{at} y
561 los argumentos de las expresiones @code{lambda}.
563 La versión indefinida de @code{integrate} no está libre de su variable de integración.
565 Ejemplos:
567 Los argumentos son nombres de funciones, variables, nombres subindicados, operaores y expresiones. La llamada @code{freeof (a, b, expr)} equivale a @code{freeof (a, expr) and freeof (b, expr)}.
569 @example
570 (%i1) expr: z^3 * cos (a[1]) * b^(c+d);
571 d + c 3
572 (%o1) cos(a ) b z
573 1
574 (%i2) freeof (z, expr);
575 (%o2) false
576 (%i3) freeof (cos, expr);
577 (%o3) false
578 (%i4) freeof (a[1], expr);
579 (%o4) false
580 (%i5) freeof (cos (a[1]), expr);
581 (%o5) false
582 (%i6) freeof (b^(c+d), expr);
583 (%o6) false
584 (%i7) freeof ("^", expr);
585 (%o7) false
586 (%i8) freeof (w, sin, a[2], sin (a[2]), b*(c+d), expr);
587 (%o8) true
588 @end example
590 @code{freeof} evalúa sus argumentos.
592 @example
593 (%i1) expr: (a+b)^5$
594 (%i2) c: a$
595 (%i3) freeof (c, expr);
596 (%o3) false
597 @end example
599 @code{freeof} no considera funciones equivalentes.
600 La simplificación puede dar una expresión equivalente pero diferente.
602 @example
603 (%i1) expr: (a+b)^5$
604 (%i2) expand (expr);
605 5 4 2 3 3 2 4 5
606 (%o2) b + 5 a b + 10 a b + 10 a b + 5 a b + a
607 (%i3) freeof (a+b, %);
608 (%o3) true
609 (%i4) freeof (a+b, expr);
610 (%o4) false
611 (%i5) exp (x);
612 x
613 (%o5) %e
614 (%i6) freeof (exp, exp (x));
615 (%o6) true
616 @end example
618 Un sumatorio o integral definida está libre de su variable muda.
619 Una integral indefinida de @code{integrate} no está libre de su variable de integración.
621 @example
622 (%i1) freeof (i, 'sum (f(i), i, 0, n));
623 (%o1) true
624 (%i2) freeof (x, 'integrate (x^2, x, 0, 1));
625 (%o2) true
626 (%i3) freeof (x, 'integrate (x^2, x));
627 (%o3) false
628 @end example
629 @end deffn
634 @defvr {Variable opcional} inflag
635 Valor por defecto: @code{false}
637 Si @code{inflag} vale @code{true}, las funciones para la extracción de partes inspeccionan la forma interna de @code{expr}.
639 Nótese que el simplificador reordena expresiones.
640 Así, @code{first (x + y)} devuelve @code{x} si @code{inflag}
641 vale @code{true} y @code{y} si @code{inflag} vale @code{false}.
642 (@code{first (y + x)} devuelve el mismo resultado.)
644 Además, dándole a @code{inflag} el valor @code{true} y llamando a @code{part} o a @code{substpart} es lo mismo que llamar a @code{inpart} o a @code{substinpart}.
646 Las funciones que se ven afectadas por el valor de @code{inflag} son:
647 @code{part}, @code{substpart}, @code{first}, @code{rest}, @code{last}, @code{length},
648 la construcción @code{for} ... @code{in},
649 @code{map}, @code{fullmap}, @code{maplist}, @code{reveal} y @code{pickapart}.
651 @c NEED EXAMPLES HERE
652 @end defvr
657 @c NEEDS WORK
658 @deffn {Función} inpart (@var{expr}, @var{n_1}, ..., @var{n_k})
659 Similar a @code{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 @code{part (x+y, 0)} o @code{inpart (x+y, 0)} devuelven @code{+}, siendo necesario encerrar el operador entre comillas dobles cuando se haga referencia aél. Por ejemplo,
660 @code{... if inpart (%o9,0) = "+" then ...}.
662 Ejemplos:
664 @example
665 (%i1) x + y + w*z;
666 (%o1) w z + y + x
667 (%i2) inpart (%, 3, 2);
668 (%o2) z
669 (%i3) part (%th (2), 1, 2);
670 (%o3) z
671 (%i4) 'limit (f(x)^g(x+1), x, 0, minus);
672 g(x + 1)
673 (%o4) limit f(x)
674 x -> 0-
675 (%i5) inpart (%, 1, 2);
676 (%o5) g(x + 1)
677 @end example
679 @end deffn
684 @c NEEDS WORK
685 @deffn {Función} isolate (@var{expr}, @var{x})
686 Devuelve @var{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 @code{%t1}, @code{%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.
688 Si la variable @code{exptisolate}, cuyo valor por defecto es @code{false}, vale @code{true} hará que @code{isolate} busque exponentes de átomos (como @code{%e}) que contengan la variable.
690 Si @code{isolate_wrt_times} vale @code{true}, entonces @code{isolate} también aislará respecto de los productos. Véase @code{isolate_wrt_times}.
692 Para ejemplos, ejecútese @code{example (isolate)}.
694 @end deffn
696 @c NEEDS WORK
697 @defvr {Variable opcional} isolate_wrt_times
698 Valor por defecto: @code{false}
700 Si @code{isolate_wrt_times} vale @code{true}, entonces @code{isolate} también aislará respecto de los productos. Compárese el comportamiento de @code{isolate} al cambiar el valor de esta variable global en el siguiente ejemplo,
702 @example
703 (%i1) isolate_wrt_times: true$
704 (%i2) isolate (expand ((a+b+c)^2), c);
706 (%t2) 2 a
709 (%t3) 2 b
712 2 2
713 (%t4) b + 2 a b + a
715 2
716 (%o4) c + %t3 c + %t2 c + %t4
717 (%i4) isolate_wrt_times: false$
718 (%i5) isolate (expand ((a+b+c)^2), c);
719 2
720 (%o5) c + 2 b c + 2 a c + %t4
721 @end example
723 @end defvr
728 @c NEEDS EXAMPLES
729 @defvr {Variable opcional} listconstvars
730 Valor por defecto: @code{false}
732 Si @code{listconstvars} vale @code{true}, hará que @code{listofvars} incluya @code{%e}, @code{%pi}, @code{%i} y cualquier otra variable que sea declarada constante de las que aparezcan en el argumento de @code{listofvars}.
733 Estas constantes se omiten por defecto.
735 @end defvr
737 @defvr {Variable opcional} listdummyvars
738 Valor por defecto: @code{true}
740 Si @code{listdummyvars} vale @code{false}, las "variables mudas" de la expresión no serán incluídas en la lista devuelta por @code{listofvars}. (La definición de "variables mudas" se encuentra en la descripción de @code{freeof}.
741 "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.)
742 Ejemplo:
744 @example
745 (%i1) listdummyvars: true$
746 (%i2) listofvars ('sum(f(i), i, 0, n));
747 (%o2) [i, n]
748 (%i3) listdummyvars: false$
749 (%i4) listofvars ('sum(f(i), i, 0, n));
750 (%o4) [n]
751 @end example
753 @end defvr
758 @c NEEDS WORK
759 @deffn {Función} listofvars (@var{expr})
760 Devuelve una lista con las variables presentes en @var{expr}.
762 Si la variable @code{listconstvars} vale @code{true} entonces
763 @code{listofvars} incluirá @code{%e}, @code{%pi}, @code{%i}
764 y cualquier otra variable declarada constante de las que aparezcan
765 en @var{expr}. Estas constantes se omiten por defecto.
767 Véase también la variable opcional @code{listdummyvars} para
768 excluir o incluir variables ficticias en la lista de variables.
770 Ejemplo:
772 @example
773 (%i1) listofvars (f (x[1]+y) / g^(2+a));
774 (%o1) [g, a, x , y]
775 1
776 @end example
778 @end deffn
780 @c NEEDS WORK
781 @deffn {Función} lfreeof (@var{list}, @var{expr})
782 Para cada miembro @var{m} de @var{list}, realiza la llamada @code{freeof (@var{m}, @var{expr})}.
783 Devuelve @code{false} si alguna de estas llamadas a @code{freeof} retornó @code{false}, y @code{true} en caso contrario.
784 @end deffn
788 @c NEEDS WORK
789 @deffn {Función} lpart (@var{label}, @var{expr}, @var{n_1}, ..., @var{n_k})
790 Similar a @code{dpart} pero utiliza una caja etiquetada. Una caja etiquetada es similar a la que produce @code{dpart}, pero con un nombre en la línea superior.
791 @end deffn
796 @defvr {Propiedad} mainvar
797 Se pueden declarar variables de tipo @code{mainvar}. El orden de los átomos
798 es: números < constantes (como @code{%e} o @code{%pi}) <
799 escalares < otras variables < "mainvars". Por ejemplo, compárese @code{expand ((X+Y)^4)}
800 con @code{(declare (x, mainvar), expand ((x+y)^4))}. (Nota: Se debe tener cuidado si se quiere hacer uso de esta declaración. Por ejemplo, si se resta una expresión en la que @code{x} ha sido declarada como @code{mainvar} de otra en la que @code{x} no es @code{mainvar}, puede ser necesario volver a simplificar, @code{ev (expr, simp)}, a fin de obtener cancelaciones. Además, si se guarda una expresión en la que @code{x} es @code{mainvar}, quizás sea necesario guardar también @code{x}.)
802 @end defvr
806 @defvr {Propiedad} noun
807 El símbolo @code{noun} es una de las opciones de la instrucción @code{declare}. Hace que una función se declare como "nombre", lo que significa que no se evaluará automáticamente.
809 @end defvr
814 @defvr {Variable opcional} noundisp
815 Valor por defecto: @code{false}
817 Si @code{noundisp} vale @code{true}, los nombres se muestran precedidos de un apóstrofo. Siempre debe valer @code{true} cuando se quiera representar la definición de funciones.
819 @end defvr
823 @c NEEDS WORK
824 @deffn {Función} nounify (@var{f})
825 Devuelve la forma nominal de la función cuyo nombre es @var{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.
827 @end deffn
829 @c NEEDS WORK
830 @deffn {Función} nterms (@var{expr})
831 Devuelve el número de términos que @var{expr} llegaría a tener si fuese completamente expandida y no hubiesen cancelaciones ni combinaciones de términos semejantes.
832 Nótese que expresiones como @code{sin (@var{expr})}, @code{sqrt (@var{expr})}, @code{exp (@var{expr})}, etc.
833 cuentan como un sólo término, independientemente de cuántos términos tenga a su vez @var{expr} en caso de tratarse de una suma.
835 @end deffn
840 @c NEEDS WORK
841 @deffn {Función} op (@var{expr})
842 Devuelve el operador principal de la expresión @var{expr}. La llamada
843 @code{op (@var{expr})} equivale a @code{part (@var{expr}, 0)}.
845 La función @code{op} devuelve una cadena si el operador principal es un operador prefijo, infijo (binario o @code{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).
846 Si @var{expr} es la expresión de una función
847 subindicada, @code{op} devuelve la función subindicada;
848 en cuyo caso el valor devuelto no es un átomo.
849 En otro caso, @var{expr} es la expresión de una función array u
850 ordinaria, y entonces @code{op} devuelve un símbolo.
852 La función @code{op} observa el valor de la variable global @code{inflag}.
854 La función @code{op} evalúa sus argumentos.
856 Véase también @code{args}.
858 Ejemplos:
860 @c ===beg===
861 @c stringdisp: true$
862 @c op (a * b * c);
863 @c op (a * b + c);
864 @c op ('sin (a + b));
865 @c op (a!);
866 @c op (-a);
867 @c op ([a, b, c]);
868 @c op ('(if a > b then c else d));
869 @c op ('foo (a));
870 @c prefix (foo);
871 @c op (foo a);
872 @c op (F [x, y] (a, b, c));
873 @c op (G [u, v, w]);
874 @c ===end===
876 @example
877 (%i1) stringdisp: true$
878 (%i2) op (a * b * c);
879 (%o2) "*"
880 (%i3) op (a * b + c);
881 (%o3) "+"
882 (%i4) op ('sin (a + b));
883 (%o4) sin
884 (%i5) op (a!);
885 (%o5) "!"
886 (%i6) op (-a);
887 (%o6) "-"
888 (%i7) op ([a, b, c]);
889 (%o7) "["
890 (%i8) op ('(if a > b then c else d));
891 (%o8) "if"
892 (%i9) op ('foo (a));
893 (%o9) foo
894 (%i10) prefix (foo);
895 (%o10) "foo"
896 (%i11) op (foo a);
897 (%o11) "foo"
898 (%i12) op (F [x, y] (a, b, c));
899 (%o12) F
900 x, y
901 (%i13) op (G [u, v, w]);
902 (%o13) G
903 @end example
905 @end deffn
908 @c NEEDS WORK
909 @deffn {Función} operatorp (@var{expr}, @var{op})
910 @deffnx {Función} operatorp (@var{expr}, [@var{op_1}, ..., @var{op_n}])
912 La llamada @code{operatorp (@var{expr}, @var{op})} devuelve @code{true}
913 si @var{op} es igual al operador de @var{expr}.
915 La llamada @code{operatorp (@var{expr}, [@var{op_1}, ..., @var{op_n}])} devuelve @code{true}
916 si algún elemento @var{op_1}, ..., @var{op_n} es igual al operador de @var{expr}.
918 @end deffn
922 @defvr {Variable opcional} opsubst
923 Valor por defecto: @code{true}
925 Si @code{opsubst} vale @code{false}, @code{subst} no sustituye el operdor de una expresión, de manera que @code{(opsubst: false, subst (x^2, r, r+r[0]))} trabajará correctamente.
927 @end defvr
932 @c NEEDS WORK
933 @deffn {Función} optimize (@var{expr})
934 Devuelve una expresión que produce el mismo valor y efectos secundarios que @var{expr}, pero de forma más eficiente al evitar recalcular subexpresiones comunes. La función @code{optimize} también tiene el efecto secundario de colapsar su argumento de manera que se compartan todas sus subexpresiones comunes.
935 Hágase @code{example (optimize)} para ver ejemplos.
937 @end deffn
939 @defvr {Variable opcional} optimprefix
940 Valor por defecto: @code{%}
942 La variable @code{optimprefix} es el prefijo utilizado para los símbolos generados por la instrucción @code{optimize}.
944 @end defvr
946 @deffn {Función} ordergreat (@var{v_1}, ..., @var{v_n})
947 @deffnx {Función} orderless (@var{v_1}, ..., @var{v_n})
949 @code{ordergreat} cambia el orden canónico de las expresiones de
950 Maxima, de manera que @var{v_1} prevalece sobre @var{v_2}, que
951 prevalece sobre ..., que prevalece sobre @var{v_n}, que prevalece
952 sobre cualquier otro símbolo no presente en la
953 lista de argumentos.
955 @code{orderless} cambia el orden canónico de las expresiones de
956 Maxima, de manera que @var{v_1} precede a @var{v_2}, que precede a ...,
957 que precede a @var{v_n}, que precede a cualquier otra variable no
958 presente en la lista de argumentos.
960 El orden impuesto por @code{ordergreat} y @code{orderless} se
961 destruye con @code{unorder}. @code{ordergreat} y @code{orderless}
962 sólo se pueden llamar una vez, a menos que se invoque a @code{unorder}.
963 La última llamada a @code{ordergreat} y @code{orderless} es la que
964 se mantiene activa.
966 Véase también @code{ordergreatp}.
968 @end deffn
971 @deffn {Función} ordergreatp (@var{expr_1}, @var{expr_2})
972 @deffnx {Función} orderlessp (@var{expr_1}, @var{expr_2})
974 @code{ordergreatp} devuelve @code{true} si @var{expr_1} prevalece sobre
975 @var{expr_2} en el orden canónico de las expresiones de Maxima, o
976 @code{false} en caso contrario.
978 @code{orderlessp} devuelve @code{true} si @var{expr_1} precede a
979 @var{expr_2} en el orden canónico de las expresiones de Maxima, o
980 @code{false} en caso contrario.
982 Todos los átomos y expresiones de Maxima son comparables bajo
983 @code{ordergreatp} y @code{orderlessp}, aunque existen ejemplos aislados
984 de expresiones para los que estos predicados no son transitivos.
986 La ordenación canónica de átomos (símbolos, números
987 literales y cadenas) es la siguiente: (enteros y decimales en coma flotante)
988 preceden a (números decimales grandes o @i{bigfloats}), que preceden a (constantes
989 declaradas), que preceden a (cadenas), que preceden a (escalares declarados), que preceden a
990 (primer argumento de @code{orderless}), que precede a ..., que precede a (último
991 argumento de @code{orderless}), que precede a (otros símbolos), que
992 preceden a (último argumento de @code{ordergreat}), que precede a ..., que
993 precede a (primer argumento de @code{ordergreat}), que precede a (variables
994 principales declaradas).
996 Para las expresiones no atómicas, la ordenación canónica se deriva de la
997 ordenación de átomos. Para los operadores nativos @code{+}, @code{*} y @code{^},
998 los criterios de ordenación no son sencillos de resumir.
999 Para otros operadores nativos, y todas las demás funciones y operadores,
1000 las expresiones se ordenan por sus argumentos (empezando por el primero),
1001 después por el nombre del operador o función. En caso de expresiones
1002 con subíndices, el símbolo subindicado se
1003 considera operador y el subíndice un argumento del mismo.
1005 El orden canónico de expresiones se modifica mediante las funciones
1006 @code{ordergreat} y @code{orderless}, así como por las
1007 declaraciones @code{mainvar}, @code{constant} y @code{scalar}.
1009 Véase también @code{sort}.
1011 Ejemplos:
1013 Ordenación de símbolos comunes y constantes.
1014 Nótese que @code{%pi} no se ordena en función de su valor
1015 numérico.
1017 @c ===beg===
1018 @c stringdisp : true;
1019 @c sort ([%pi, 3b0, 3.0, x, X, "foo", 3, a, 4, "bar", 4.0, 4b0]);
1020 @c ===end===
1021 @example
1022 (%i1) stringdisp : true;
1023 (%o1) true
1024 (%i2) sort ([%pi, 3b0, 3.0, x, X, "foo", 3, a, 4, "bar", 4.0, 4b0]);
1025 (%o2) [3, 3.0, 4, 4.0, 3.0b0, 4.0b0, %pi, "bar", "foo", a, x, X]
1026 @end example
1028 Efecto producido por las funciones @code{ordergreat} y @code{orderless}.
1030 @c ===beg===
1031 @c sort ([M, H, K, T, E, W, G, A, P, J, S]);
1032 @c ordergreat (S, J);
1033 @c orderless (M, H);
1034 @c sort ([M, H, K, T, E, W, G, A, P, J, S]);
1035 @c ===end===
1036 @example
1037 (%i1) sort ([M, H, K, T, E, W, G, A, P, J, S]);
1038 (%o1) [A, E, G, H, J, K, M, P, S, T, W]
1039 (%i2) ordergreat (S, J);
1040 (%o2) done
1041 (%i3) orderless (M, H);
1042 (%o3) done
1043 (%i4) sort ([M, H, K, T, E, W, G, A, P, J, S]);
1044 (%o4) [M, H, A, E, G, K, P, T, W, J, S]
1045 @end example
1047 Efecto producido por las declaraciones @code{mainvar}, @code{constant} y @code{scalar}.
1049 @c ===beg===
1050 @c sort ([aa, foo, bar, bb, baz, quux, cc, dd, A1, B1, C1]);
1051 @c declare (aa, mainvar);
1052 @c declare ([baz, quux], constant);
1053 @c declare ([A1, B1], scalar);
1054 @c sort ([aa, foo, bar, bb, baz, quux, cc, dd, A1, B1, C1]);
1055 @c ===end===
1056 @example
1057 (%i1) sort ([aa, foo, bar, bb, baz, quux, cc, dd, A1, B1, C1]);
1058 (%o1) [aa, bar, baz, bb, cc, dd, foo, quux, A1, B1, C1]
1059 (%i2) declare (aa, mainvar);
1060 (%o2) done
1061 (%i3) declare ([baz, quux], constant);
1062 (%o3) done
1063 (%i4) declare ([A1, B1], scalar);
1064 (%o4) done
1065 (%i5) sort ([aa, foo, bar, bb, baz, quux, cc, dd, A1, B1, C1]);
1066 (%o5) [baz, quux, A1, B1, bar, bb, cc, dd, foo, C1, aa]
1067 @end example
1069 Ordenación de expresiones no atómicas.
1071 @c ===beg===
1072 @c sort ([1, 2, n, f(1), f(2), f(2, 1), g(1), g(1, 2), g(n), f(n, 1)]);
1073 @c sort ([foo(1), X[1], X[k], foo(k), 1, k]);
1074 @c ===end===
1075 @example
1076 (%i1) sort ([1, 2, n, f(1), f(2), f(2, 1), g(1), g(1, 2), g(n), f(n, 1)]);
1077 (%o1) [1, 2, f(1), g(1), g(1, 2), f(2), f(2, 1), n, g(n),
1078 f(n, 1)]
1079 (%i2) sort ([foo(1), X[1], X[k], foo(k), 1, k]);
1080 (%o2) [1, foo(1), X , k, foo(k), X ]
1081 1 k
1082 @end example
1083 @end deffn
1086 @c NEEDS WORK
1087 @deffn {Función} part (@var{expr}, @var{n_1}, ..., @var{n_k})
1088 Devuelve partes de la forma mostrada de @code{expr}. Obtiene la
1089 parte de @code{expr} que se especifica por los índices
1090 @var{n_1}, ..., @var{n_k}. Primero se obtiene la parte @var{n_1} de
1091 @code{expr}, después la parte @var{n_2} del resultado anterior,
1092 y así sucesivamente. El resultado que se obtiene es
1093 la parte @var{n_k} de ... la parte @var{n_2} de la parte @var{n_1} de @code{expr}.
1094 Si no se especifican índices, devuelve @code{expr}.
1096 La función @code{part} se puede utilizar para obtener un elemento
1097 de una lista, una fila de una matriz, etc.
1099 @c "If the last argument to a part function" => FOLLOWING APPLIES TO OTHER FUNCTIONS ??
1100 @c ATTEMPT TO VERIFY; IF SO, COPY THIS COMMENTARY TO DESCRIPTIONS OF OTHER FUNCTIONS
1101 Si el último argumento de la función @code{part} es una lista de
1102 índices, entonces se toman varias subexpresiones, cada
1103 una de las cuales correspondiente a un índice de la lista.
1104 Así, @code{part (x + y + z, [1, 3])} devuelve @code{z+x}.
1106 La variable @code{piece} guarda la última expresión seleccionada
1107 con la función @code{part}. Se actualiza durante la ejecución de
1108 la función, por lo que puede ser referenciada en la misma función.
1110 Si @code{partswitch} vale @code{true} entonces de devuelve @code{end}
1111 cuando no exista la parte seleccionada de una expresión, si vale
1112 @code{false} se mostrará un mensaje de error.
1114 Véanse también @code{inpart}, @code{substpart}, @code{substinpart},
1115 @code{dpart} y @code{lpart}.
1117 Ejemplos:
1119 @c ===beg===
1120 @c part(z+2*y+a,2);
1121 @c part(z+2*y+a,[1,3]);
1122 @c part(z+2*y+a,2,1);
1123 @c ===end===
1124 @example
1125 (%i1) part(z+2*y+a,2);
1126 (%o1) 2 y
1127 (%i2) part(z+2*y+a,[1,3]);
1128 (%o2) z + a
1129 (%i3) part(z+2*y+a,2,1);
1130 (%o3) 2
1131 @end example
1133 La instrucción @code{example (part)} muestra más ejemplos.
1135 @end deffn
1140 @c NEEDS WORK
1141 @deffn {Función} partition (@var{expr}, @var{x})
1142 Devuelve una lista con dos expresiones, que son: (1) los factores de
1143 @var{expr} si es un producto, los términos de @var{expr} si es una
1144 suma, o los elementos de @var{expr}, si es una lista, que no contengan
1145 a @var{x}, (2) los factores, términos o lista que contengan a @var{x}.
1147 @example
1148 (%i1) partition (2*a*x*f(x), x);
1149 (%o1) [2 a, x f(x)]
1150 (%i2) partition (a+b, x);
1151 (%o2) [b + a, 0]
1152 (%i3) partition ([a, b, f(a), c], a);
1153 (%o3) [[b, c], [a, f(a)]]
1154 @end example
1156 @end deffn
1158 @c NEEDS EXAMPLE
1159 @defvr {Variable opcional} partswitch
1160 Valor por defecto: @code{false}
1162 Si @code{partswitch} vale @code{true} entonces de devuelve @code{end} cuando no exista la parte seleccionada de una expresión, si vale @code{false} se mostrará un mensaje de error.
1164 @end defvr
1166 @deffn {Función} pickapart (@var{expr}, @var{n})
1167 Asigna etiquetas de expresiones intermedias a subexpresiones de @var{expr} al nivel de profundidad @var{n}, que es un entero. A las subexpresiones a un nivel de profundidad mayor o menor no se les asignan etiquetas. La función
1168 @code{pickapart} devuelve una expresión en términos de expresiones intermedias equivalente a la expresión original @var{expr}.
1170 Véanse también @code{part}, @code{dpart}, @code{lpart}, @code{inpart} y @code{reveal}.
1172 Ejemplos:
1174 @example
1175 (%i1) expr: (a+b)/2 + sin (x^2)/3 - log (1 + sqrt(x+1));
1176 2
1177 sin(x ) b + a
1178 (%o1) - log(sqrt(x + 1) + 1) + ------- + -----
1179 3 2
1180 (%i2) pickapart (expr, 0);
1182 2
1183 sin(x ) b + a
1184 (%t2) - log(sqrt(x + 1) + 1) + ------- + -----
1185 3 2
1187 (%o2) %t2
1188 (%i3) pickapart (expr, 1);
1190 (%t3) - log(sqrt(x + 1) + 1)
1193 2
1194 sin(x )
1195 (%t4) -------
1196 3
1199 b + a
1200 (%t5) -----
1201 2
1203 (%o5) %t5 + %t4 + %t3
1204 (%i5) pickapart (expr, 2);
1206 (%t6) log(sqrt(x + 1) + 1)
1209 2
1210 (%t7) sin(x )
1213 (%t8) b + a
1215 %t8 %t7
1216 (%o8) --- + --- - %t6
1217 2 3
1218 (%i8) pickapart (expr, 3);
1220 (%t9) sqrt(x + 1) + 1
1223 2
1224 (%t10) x
1226 b + a sin(%t10)
1227 (%o10) ----- - log(%t9) + ---------
1228 2 3
1229 (%i10) pickapart (expr, 4);
1231 (%t11) sqrt(x + 1)
1233 2
1234 sin(x ) b + a
1235 (%o11) ------- + ----- - log(%t11 + 1)
1236 3 2
1237 (%i11) pickapart (expr, 5);
1239 (%t12) x + 1
1241 2
1242 sin(x ) b + a
1243 (%o12) ------- + ----- - log(sqrt(%t12) + 1)
1244 3 2
1245 (%i12) pickapart (expr, 6);
1246 2
1247 sin(x ) b + a
1248 (%o12) ------- + ----- - log(sqrt(x + 1) + 1)
1249 3 2
1250 @end example
1252 @end deffn
1254 @c NEEDS WORK
1255 @defvr {Variable del sistema} piece
1256 Guarda la última expresión seleccionada por las funciones @code{part}.
1258 @c NEED "SEE ALSO" TO POINT TO LIST OF ALL RELEVANT FUNCTIONS
1260 @end defvr
1264 @deffn {Función} psubst (@var{list}, @var{expr})
1265 @deffnx {Función} psubst (@var{a}, @var{b}, @var{expr})
1267 @code{psubst(@var{a}, @var{b}, @var{expr})} es simliar a @code{subst}. Véase
1268 @code{subst}.
1270 A diferencia de @code{subst}, la función @code{psubst} hace sustituciones
1271 en paralelo si su primer argumento es una lista de ecuaciones.
1273 Véase también @code{sublis} para hacer sustituciones en paralelo.
1275 Ejemplo:
1277 El primer ejemplo muestra la sustitución en paralelo con @code{psubst}.
1278 El segundo ejemplo muestra el resultado de la función @code{subst},
1279 que realiza la sustitución en serie.
1281 @c ===beg===
1282 @c psubst ([a^2=b, b=a], sin(a^2) + sin(b));
1283 @c subst ([a^2=b, b=a], sin(a^2) + sin(b));
1284 @c ===end===
1285 @example
1286 (%i4) psubst ([a^2=b, b=a], sin(a^2) + sin(b));
1287 (%o4) sin(b) + sin(a)
1288 (%i5) subst ([a^2=b, b=a], sin(a^2) + sin(b));
1289 (%o5) 2 sin(a)
1290 @end example
1292 @end deffn
1297 @deffn {Función} rembox (@var{expr}, unlabelled)
1298 @deffnx {Función} rembox (@var{expr}, @var{label})
1299 @deffnx {Función} rembox (@var{expr})
1300 Elimina cajas de @var{expr}.
1302 La llamada @code{rembox (@var{expr}, unlabelled)} elimina todas las cajas no etiquetadas de @var{expr}.
1304 La llamada @code{rembox (@var{expr}, @var{label})} sólo elimina las cajas etiquetadas con @var{label}.
1306 La llamada @code{rembox (@var{expr})} elimina todas las caajs, independientemente de que estén etiquetadas o no.
1308 Las cajas son dibujadas por las funciones @code{box}, @code{dpart} y @code{lpart}.
1310 Ejemplos:
1312 @c ===beg===
1313 @c expr: (a*d - b*c)/h^2 + sin(%pi*x);
1314 @c dpart (dpart (expr, 1, 1), 2, 2);
1315 @c expr2: lpart (BAR, lpart (FOO, %, 1), 2);
1316 @c rembox (expr2, unlabelled);
1317 @c rembox (expr2, FOO);
1318 @c rembox (expr2, BAR);
1319 @c rembox (expr2);
1320 @c ===end===
1321 @example
1322 (%i1) expr: (a*d - b*c)/h^2 + sin(%pi*x);
1323 a d - b c
1324 (%o1) sin(%pi x) + ---------
1325 2
1326 h
1327 (%i2) dpart (dpart (expr, 1, 1), 2, 2);
1328 """"""" a d - b c
1329 (%o2) sin("%pi x") + ---------
1330 """"""" """"
1331 " 2"
1332 "h "
1333 """"
1334 (%i3) expr2: lpart (BAR, lpart (FOO, %, 1), 2);
1335 FOO""""""""""" BAR""""""""
1336 " """"""" " "a d - b c"
1337 (%o3) "sin("%pi x")" + "---------"
1338 " """"""" " " """" "
1339 """""""""""""" " " 2" "
1340 " "h " "
1341 " """" "
1342 """""""""""
1343 (%i4) rembox (expr2, unlabelled);
1344 BAR""""""""
1345 FOO""""""""" "a d - b c"
1346 (%o4) "sin(%pi x)" + "---------"
1347 """""""""""" " 2 "
1348 " h "
1349 """""""""""
1350 (%i5) rembox (expr2, FOO);
1351 BAR""""""""
1352 """"""" "a d - b c"
1353 (%o5) sin("%pi x") + "---------"
1354 """"""" " """" "
1355 " " 2" "
1356 " "h " "
1357 " """" "
1358 """""""""""
1359 (%i6) rembox (expr2, BAR);
1360 FOO"""""""""""
1361 " """"""" " a d - b c
1362 (%o6) "sin("%pi x")" + ---------
1363 " """"""" " """"
1364 """""""""""""" " 2"
1365 "h "
1366 """"
1367 (%i7) rembox (expr2);
1368 a d - b c
1369 (%o7) sin(%pi x) + ---------
1370 2
1371 h
1372 @end example
1374 @end deffn
1379 @deffn {Función} reveal (@var{expr}, @var{nivel})
1380 Reemplaza partes de @var{expr} al @var{nivel} especificado y las sutituye por descripciones cortas.
1382 @itemize @bullet
1383 @item
1384 Las sumas y restas se reemplazan por @code{Sum(@var{n})},
1385 siendo @var{n} el número de términos de la suma.
1386 @item
1387 Los productos se reemplazan por @code{Product(@var{n})},
1388 siendo @var{n} el número de factores del producto.
1389 @item
1390 Las potencias se reemplazan por @code{Expt}.
1391 @item
1392 Los cocientes se reemplazan por @code{Quotient}.
1393 @item
1394 El símbolo negativo se reemplaza por @code{Negterm}.
1395 @item
1396 Las listas se reemplazan por @code{List(@var{n})}, siendo @var{n} el número de
1397 elementos de la lista.
1398 @end itemize
1400 Si el entero @var{depth} es mayor o igual que la profundidad máxima de @var{expr},
1401 @code{reveal (@var{expr}, @var{depth})} devuelve @var{expr} sin modificar.
1403 La función @code{reveal} evalúa sus argumentos y devuelve la expresión con las modificaciones solicitadas.
1405 Ejemplo:
1407 @c ===beg===
1408 @c e: expand ((a - b)^2)/expand ((exp(a) + exp(b))^2);
1409 @c reveal (e, 1);
1410 @c reveal (e, 2);
1411 @c reveal (e, 3);
1412 @c reveal (e, 4);
1413 @c reveal (e, 5);
1414 @c reveal (e, 6);
1415 @c ===end===
1416 @example
1417 (%i1) e: expand ((a - b)^2)/expand ((exp(a) + exp(b))^2);
1418 2 2
1419 b - 2 a b + a
1420 (%o1) -------------------------
1421 b + a 2 b 2 a
1422 2 %e + %e + %e
1423 (%i2) reveal (e, 1);
1424 (%o2) Quotient
1425 (%i3) reveal (e, 2);
1426 Sum(3)
1427 (%o3) ------
1428 Sum(3)
1429 (%i4) reveal (e, 3);
1430 Expt + Negterm + Expt
1431 (%o4) ------------------------
1432 Product(2) + Expt + Expt
1433 (%i5) reveal (e, 4);
1434 2 2
1435 b - Product(3) + a
1436 (%o5) ------------------------------------
1437 Product(2) Product(2)
1438 2 Expt + %e + %e
1439 (%i6) reveal (e, 5);
1440 2 2
1441 b - 2 a b + a
1442 (%o6) --------------------------
1443 Sum(2) 2 b 2 a
1444 2 %e + %e + %e
1445 (%i7) reveal (e, 6);
1446 2 2
1447 b - 2 a b + a
1448 (%o7) -------------------------
1449 b + a 2 b 2 a
1450 2 %e + %e + %e
1451 @end example
1452 @end deffn
1456 @deffn {Función} sublis (@var{list}, @var{expr})
1458 Hace sustituciones múltiples en paralelo dentro de las expresiones.
1459 @var{list} es una lista de ecuaciones, cuyos miembros izquierdos deben
1460 ser átomos.
1462 La variable @code{sublis_apply_lambda} controla la simplificación
1463 después de @code{sublis}.
1465 Véase también @code{psubst} para hacer sustituciones en paralelo.
1467 Ejemplo:
1469 @c ===beg===
1470 @c sublis ([a=b, b=a], sin(a) + cos(b));
1471 @c ===end===
1472 @example
1473 (%i1) sublis ([a=b, b=a], sin(a) + cos(b));
1474 (%o1) sin(b) + cos(a)
1475 @end example
1476 @end deffn
1480 @defvr {Variable opcional} sublis_apply_lambda
1481 Valor por defecto: @code{true}
1483 Controla si los @code{lambda} sustituidos son aplicados en la simplificación después de invocar a @code{sublis}, o si se tiene que hacer un @code{ev} para hacerlo. Si @code{sublis_apply_lambda} vale @code{true}, significa que se ejecute la aplicación.
1485 @end defvr
1489 @defvr {Variable opcional} subnumsimp
1490 Valor por defecto: @code{false}
1492 Si vale @code{true}, las funciones @code{subst} y @code{psubst} puede sustituir
1493 una variable subindicada @code{f[x]} por un número simplemente utilizando el
1494 símbolo @code{f}.
1496 Véase también @code{subst}.
1498 @example
1499 (%i1) subst(100,g,g[x]+2);
1501 subst: cannot substitute 100 for operator g in expression g
1502 x
1503 -- an error. To debug this try: debugmode(true);
1505 (%i2) subst(100,g,g[x]+2),subnumsimp:true;
1506 (%o2) 102
1507 @end example
1509 @end defvr
1514 @deffn {Función} subst (@var{a}, @var{b}, @var{c})
1515 Sustituye @var{a} por @var{b} en @var{c}. El argumento @var{b} debe ser un átomo o una subexpresión completa de @var{c}. Por ejemplo, @code{x+y+z} es una subexpresión completa de @code{2*(x+y+z)/w} mientras que @code{x+y} no lo es. Cuando @var{b} no cumple esta característica, se puede utilizar en algunos casos @code{substpart} o @code{ratsubst}
1516 (ver más abajo). Alternativamente, si @var{b} no es de la forma @code{e/f} entonces se puede usar @code{subst (a*f, e, c)}, pero si @var{b} es de la forma @code{e^(1/f)} se debe usar @code{subst (a^f, e, c)}. La instrucción @code{subst} también reconoce @code{x^y} en @code{x^-y}, de manera que @code{subst (a, sqrt(x), 1/sqrt(x))} da @code{1/a}. Los argumentos @var{a} y @var{b} también pueden ser operadores de una expresión acotados por comillas dobles @code{"} o nombres de funciones. Si se quiere sustituir la variable independiente en expresiones con derivadas se debe utilizar la función @code{at} (ver más abajo).
1518 La función @code{subst} es sinónimo de @code{substitute}.
1520 La llamada @code{subst (@var{eq_1}, @var{expr})} o
1521 @code{subst ([@var{eq_1}, ..., @var{eq_k}], @var{expr})}
1522 están permitidas. Las @var{eq_i} son ecuaciones que indican las sustituciones a realizar.
1523 Para cada ecuación, el miembro izquierdo será sustituido por la expresión del
1524 miembro derecho en @var{expr}. Las ecuaciones se sustituyen secuencialmente de
1525 izquierda a derecha en @var{expr}. Véanse las funciones @code{sublis} y @code{psubst}
1526 para sustituciones en paralelo.
1528 Si la variable @code{exptsubst} vale @code{true} se permiten ciertas
1529 sustituciones de exponentes; por ejemplo, sustituir @code{y} por @code{%e^x}
1530 en @code{%e^(a*x)}.
1532 Si @code{opsubst} vale @code{false},
1533 @code{subst} no intentará sustituir un operador de una expresión. Por ejemplo,
1534 @code{(opsubst: false, subst (x^2, r, r+r[0]))} trabajará sin problemas.
1536 Ejemplos:
1538 @c ===beg===
1539 @c subst (a, x+y, x + (x+y)^2 + y);
1540 @c subst (-%i, %i, a + b*%i);
1541 @c ===end===
1542 @example
1543 (%i1) subst (a, x+y, x + (x+y)^2 + y);
1544 2
1545 (%o1) y + x + a
1546 (%i2) subst (-%i, %i, a + b*%i);
1547 (%o2) a - %i b
1548 @end example
1550 La sustitución se hace secuencialmente según una lista de
1551 ecuaciones. Compárese con la sustitución en paralelo.
1553 @c ===beg===
1554 @c subst([a=b, b=c], a+b);
1555 @c sublis([a=b, b=c], a+b);
1556 @c ===end===
1557 @example
1558 (%i3) subst([a=b, b=c], a+b);
1559 (%o3) 2 c
1560 (%i4) sublis([a=b, b=c], a+b);
1561 (%o4) c + b
1562 @end example
1564 @noindent
1565 Para más ejemplos, ejecútese @code{example (subst)}.
1567 @end deffn
1571 @deffn {Función} substinpart (@var{x}, @var{expr}, @var{n_1}, @dots{}, @var{n_k})
1573 Es similar a @code{substinpart}, pero trabaja con la representación interna de @var{expr}.
1575 Ejemplos:
1577 @c ===beg===
1578 @c x . 'diff (f(x), x, 2);
1579 @c substinpart (d^2, %, 2);
1580 @c substinpart (f1, f[1](x + 1), 0);
1581 @c ===end===
1582 @example
1583 (%i1) x . 'diff (f(x), x, 2);
1584 2
1585 d
1586 (%o1) x . (--- (f(x)))
1587 2
1588 dx
1589 (%i2) substinpart (d^2, %, 2);
1590 2
1591 (%o2) x . d
1592 (%i3) substinpart (f1, f[1](x + 1), 0);
1593 (%o3) f1(x + 1)
1594 @end example
1596 Si el último argumento pasado a la función @code{part} es una
1597 lista de índices, se obtendrá la lista de subexpresiones
1598 correspondientes a cada uno de los índices.
1600 @c ===beg===
1601 @c part (x + y + z, [1, 3]);
1602 @c ===end===
1603 @example
1604 (%i1) part (x + y + z, [1, 3]);
1605 (%o1) z + x
1606 @end example
1608 La variable @code{piece} guarda el valor de la última expresión seleccionada al
1609 utilizar las funciones @code{part}. El valor es asignado durante la
1610 ejecución de la función y puede ser utilizada tal como se muestra más
1611 abajo. Si a @code{partswitch} se le asigna el valor @code{true} entonces se
1612 devolverá @code{end} cuando no existe la parte solicitada; con otro
1613 valor devuelve un mensaje de error.
1615 @c ===beg===
1616 @c expr: 27*y^3 + 54*x*y^2 + 36*x^2*y + y + 8*x^3 + x + 1;
1617 @c part (expr, 2, [1, 3]);
1618 @c sqrt (piece/54);
1619 @c substpart (factor (piece), expr, [1, 2, 3, 5]);
1620 @c expr: 1/x + y/x - 1/z;
1621 @c substpart (xthru (piece), expr, [2, 3]);
1622 @c ===end===
1623 @example
1624 (%i1) expr: 27*y^3 + 54*x*y^2 + 36*x^2*y + y + 8*x^3 + x + 1;
1625 3 2 2 3
1626 (%o1) 27 y + 54 x y + 36 x y + y + 8 x + x + 1
1627 (%i2) part (expr, 2, [1, 3]);
1628 2
1629 (%o2) 54 y
1630 (%i3) sqrt (piece/54);
1631 (%o3) abs(y)
1632 (%i4) substpart (factor (piece), expr, [1, 2, 3, 5]);
1633 3
1634 (%o4) (3 y + 2 x) + y + x + 1
1635 (%i5) expr: 1/x + y/x - 1/z;
1636 1 y 1
1637 (%o5) - - + - + -
1638 z x x
1639 (%i6) substpart (xthru (piece), expr, [2, 3]);
1640 y + 1 1
1641 (%o6) ----- - -
1642 x z
1643 @end example
1645 Además, dándole a @code{inflag} el valor @code{true} y llamando a
1646 @code{part} o @code{substpart} es lo mismo que invocar a @code{inpart} o @code{substinpart}.
1648 @end deffn
1652 @deffn {Función} substpart (@var{x}, @var{expr}, @var{n_1}, @dots{}, @var{n_k})
1654 Sustituye por @var{x} la subexpresión que se obtiene de aplicar el resto de
1655 argumentos a la función @code{part}, devolviendo el nuevo valor de @var{expr}.
1656 @var{x} puede ser un operador que sustituya otro operador de @var{expr}. En
1657 ciertos casos, @var{x} necesita estar entrecomillado por comillas dobles (@code{"});
1658 por ejemplo, de @code{substpart ("+", a*b, 0)} se obtiene @code{b + a}.
1660 Ejemplo:
1662 @c ===beg===
1663 @c 1/(x^2 + 2);
1664 @c substpart (3/2, %, 2, 1, 2);
1665 @c a*x + f(b, y);
1666 @c substpart ("+", %, 1, 0);
1667 @c ===end===
1668 @example
1669 (%i1) 1/(x^2 + 2);
1670 1
1671 (%o1) ------
1672 2
1673 x + 2
1674 (%i2) substpart (3/2, %, 2, 1, 2);
1675 1
1676 (%o2) --------
1677 3/2
1678 x + 2
1679 (%i3) a*x + f(b, y);
1680 (%o3) a x + f(b, y)
1681 (%i4) substpart ("+", %, 1, 0);
1682 (%o4) x + f(b, y) + a
1683 @end example
1685 Además, dándole a @code{inflag} el valor @code{true} y llamando a
1686 @code{part} o @code{substpart} es lo mismo que invocar a @code{inpart} o @code{substinpart}.
1688 @end deffn
1692 @deffn {Función} symbolp (@var{expr})
1693 Devuelve @code{true} si @var{expr} es un símbolo y @code{false} en caso contrario.
1694 La llamada @code{symbolp(x)} equivale al predicado @code{atom(x) and not numberp(x)}.
1696 Véase también @code{Identifiers}.
1698 @end deffn
1703 @deffn {Función} unorder ()
1704 Desactiva las asociaciones creadas por la última utilización de los comandos de ordenación @code{ordergreat} y @code{orderless}, los cuales no pueden ser utilizados más de una vez sin invocar a @code{unorder}.
1706 @code{unorder} no sustituye en expresiones los símbolos originales
1707 por los alias introducidos por @code{ordergreat} y @code{orderless}. Es por ello
1708 que tras la ejecución de @code{unorder} los alias aparecen en expresiones
1709 anteriores.
1711 Véase también @code{ordergreat} y @code{orderless}.
1713 Ejemplos:
1715 @code{ordergreat(a)} introduce un alias para el símbolo @code{a},
1716 razón por la cual la diferencia de @code{%o2} y @code{%o4} no se anula.
1717 @code{unorder} no restablece el símbolo @code{a} y el alias
1718 aparece en el resultado @code{%o7}.
1720 @c ===beg===
1721 @c unorder();
1722 @c b*x + a^2;
1723 @c ordergreat (a);
1724 @c b*x + a^2;
1725 @c %th(1) - %th(3);
1726 @c unorder();
1727 @c %th(2);
1728 @c ===end===
1729 @example
1730 (%i1)
1731 (%o1) []
1732 (%i2) b*x+a^2;
1733 2
1734 (%o2) b x + a
1735 (%i3) ordergreat(a);
1736 (%o3) done
1737 (%i4) b*x+a^2;
1738 2
1739 (%o4) a + b x
1740 (%i5) %th(1)-%th(3);
1741 2 2
1742 (%o5) a - a
1743 (%i6) unorder();
1744 (%o6) [a]
1745 (%i7) %th(2);
1746 2 2
1747 (%o7) _101a - a
1748 @end example
1749 @end deffn
1754 @deffn {Función} verbify (@var{f})
1755 Devuelve la forma verbal del nombre de función @var{f}.
1757 Véanse también @code{verb}, @code{noun} y @code{nounify}.
1759 Ejemplos:
1761 @c ===beg===
1762 @c verbify ('foo);
1763 @c :lisp $%
1764 @c nounify (foo);
1765 @c :lisp $%
1766 @c ===end===
1767 @example
1768 (%i1) verbify ('foo);
1769 (%o1) foo
1770 (%i2) :lisp $%
1771 $FOO
1772 (%i2) nounify (foo);
1773 (%o2) foo
1774 (%i3) :lisp $%
1775 %FOO
1776 @end example
1778 @end deffn