| blob | 8bcdaf3bd24329840189c734a7d251a7df213266 |
1 @c English version 2013-03-31
2 @menu
3 * Introducción a la simplificación::
4 * Funciones y variables para simplificación::
5 @end menu
9 @node Introducción a la simplificación, Funciones y variables para simplificación, Simplificación, Simplificación
10 @section Introducción a la simplificación
12 Tras la evaluación de una expresión se procede a su simplificación. Las
13 funciones matemáticas que involucran cálculos simbólicos y las expresiones con
14 operadores aritméticos no son evaluadas, sino simplificadas, para lo cual Maxima
15 las representa internamente en forma nominal; de ahí que el
16 cálculo numérico de una suma o de una multiplicación no se considera una
17 evaluación, sino una simplificación. La evaluación de una expresión
18 puede inhibirse con el operador de comilla simple (@code{'}) y su simplificación
19 se puede controlar con el valor asignado a la variable opcional @code{simp}.
21 En el siguiente ejemplo, se evita la simplificación con el operador de comilla
22 simple, siendo el resultado una expresión nominal. A continuación, se inhibe la
23 simplificación tras la evaluación de la derivada, dejando sin reducir el resultado
24 a @code{2*x}.
26 @example
27 (%i1) 'diff(x*x,x);
28 d 2
29 (%o1) -- (x )
30 dx
31 (%i2) simp:false;
32 (%o2) false
33 (%i3) diff(x*x,x);
34 (%o3) 1 x + 1 x
35 @end example
37 Para cada función u operador matemático dispone Maxima de una rutina interna
38 que será utilizada para su simplificación siempre que se la encuentre en una
39 expresión. Estas rutinas implementan propiedades simétricas, valores especiales
40 de las funciones y otras propiedades y reglas. La gran cantidad de variables
41 opcionales permiten mantener bajo control la simplificación de funciones y
42 operadores.
44 Veamos un ejemplo. La simplificación de la función exponencial @code{exp}
45 se controla con las siguientes variables opcionales: @code{%enumer}, @code{%emode},
46 @code{%e_to_numlog}, @code{code}, @code{logsimp} y @code{demoivre}.
47 En el primer caso la expresión con la función exponencial no se simplifica,
48 pero en el segundo se reduce a @code{%i*%pi/2}.
50 @example
51 (%i1) exp(x+%i*%pi/2), %emode:false;
52 %i %pi
53 x + ------
54 2
55 (%o1) %e
56 (%i2) exp(x+%i*%pi/2), %emode:true;
57 x
58 (%o2) %i %e
59 @end example
61 Junto con la simplificación aislada de funciones y operadores que Maxima
62 realiza de forma automática, existen también funciones como @code{expand}
63 o @code{radcan} que realizan sobre las expresiones simplificaciones
64 especiales. Sigue un ejemplo:
66 @example
67 (%i1) (log(x+x^2)-log(x))^a/log(1+x)^(a/2);
68 2 a
69 (log(x + x) - log(x))
70 (%o1) -----------------------
71 a/2
72 log(x + 1)
73 (%i2) radcan(%);
74 a/2
75 (%o2) log(x + 1)
76 @end example
78 A un operador o función se le pueden asignar propiedades tales como la
79 linealidad, la simetría u otras. Maxima tiene en cuenta
80 estas propiedades durante la simplificación. Por ejemplo, la instrucción
81 @code{declare(f, oddfun)} declara la función como impar, con lo que
82 Maxima sabrá que las formas @code{f(-x)} y @code{-f(x)} son equivalentes,
83 llevando a cabo la reducción oportuna.
85 Las siguientes propiedades están en la lista @code{opproperties} y controlan
86 la simplificación de funciones y operadores:
88 @verbatim
89 additive lassociative oddfun
90 antisymmetric linear outative
91 commutative multiplicative rassociative
92 evenfun nary symmetric
93 @end verbatim
95 Tanto las propiedades como los hechos (o hipótesis) establecidos por el
96 usuario dentro de un contexto influyen sobre el proceso de simplificación.
97 Para más detalles véase el capítulo sobre la base de datos
98 de Maxima.
100 La función seno reduce los múltiplos enteros de @code{%pi} al valor cero.
101 En este ejemplo se muestra cómo al dotar al símbolo
102 @code{n} de la propiedad de ser entero, la función se simplifica de la forma
103 apropiada.
105 @example
106 (%i1) sin(n*%pi);
107 (%o1) sin(%pi n)
108 (%i2) declare(n, integer);
109 (%o2) done
110 (%i3) sin(n*%pi);
111 (%o3) 0
112 @end example
114 Si las técnicas anteriores no devuelven el resultado esperado por el usuario,
115 éste puede extender a voluntad las reglas que pueda aplicar Maxima; para más
116 información al respecto, véase el capítulo dedicado a las
117 reglas y patrones.
129 @node Funciones y variables para simplificación, , Introducción a la simplificación, Simplificación
130 @section Funciones y variables para simplificación
133 @defvr {Propiedad} additive
134 Si @code{declare(f,additive)} ha sido ejecutado, entonces:
136 (1) Si @code{f} es univariado, cada vez que el simplificador encuentre
137 @code{f} aplicada a una suma, @code{f} será distribuida bajo esta suma. Por ejemplo, @code{f(x+y)} se simplificará a @code{f(x)+f(y)}.
139 (2) Si @code{f} es una función de 2 o más argumentos, aditivamente es definida como aditiva en el primer argumento de @code{f}, como en el caso de @code{sum} o @code{integrate}. Por ejemplo, @code{f(h(x)+g(x),x)} se simplificará a @code{f(h(x),x)+f(g(x),x)}. Esta simplificación no ocurre cuando @code{f} se aplica a expresiones de la forma @code{sum(x[i],i,lower-limit,upper-limit)}.
141 Ejemplo:
143 @c ===beg===
144 @c F3 (a + b + c);
145 @c declare (F3, additive);
146 @c F3 (a + b + c);
147 @c ===end===
148 @example
149 (%i1) F3 (a + b + c);
150 (%o1) F3(c + b + a)
151 (%i2) declare (F3, additive);
152 (%o2) done
153 (%i3) F3 (a + b + c);
154 (%o3) F3(c) + F3(b) + F3(a)
155 @end example
156 @end defvr
159 @defvr {Propiedad} antisymmetric
160 Si @code{declare(h,antisymmetric)} es ejecutado, esto dice al
161 simplificador que @code{h} es antisimétrico. E.g. @code{h(x,z,y)} será
162 simplificado a @code{-h(x,y,z)}. Que es, el producto de (-1)^n por el resultado
163 dado por @code{symmetric} o @code{commutative}, donde n es el número de intercambios
164 necesarios de dos argumentos para convertirle a esta forma.
166 Ejemplos:
168 @c ===beg===
169 @c S (b, a);
170 @c declare (S, symmetric);
171 @c S (b, a);
172 @c S (a, c, e, d, b);
173 @c T (b, a);
174 @c declare (T, antisymmetric);
175 @c T (b, a);
176 @c T (a, c, e, d, b);
177 @c ===end===
178 @example
179 (%i1) S (b, a);
180 (%o1) S(b, a)
181 (%i2) declare (S, symmetric);
182 (%o2) done
183 (%i3) S (b, a);
184 (%o3) S(a, b)
185 (%i4) S (a, c, e, d, b);
186 (%o4) S(a, b, c, d, e)
187 (%i5) T (b, a);
188 (%o5) T(b, a)
189 (%i6) declare (T, antisymmetric);
190 (%o6) done
191 (%i7) T (b, a);
192 (%o7) - T(a, b)
193 (%i8) T (a, c, e, d, b);
194 (%o8) T(a, b, c, d, e)
195 @end example
196 @end defvr
199 @deffn {Función} combine (@var{expr})
200 Simplifica la suma @var{expr} combinando términos de con igual denominador reduciéndolos a un único término.
202 @end deffn
206 @defvr {Propiedad} commutative
207 Si @code{declare(h,commutative)} es ejecutado, le dice al simplificador
208 que @code{h} es una función conmutaiva. Por ejemplo, @code{h(x,z,y)} se simplificará a @code{h(x,y,z)}. Esto es lo mismo que @code{symmetric}.
210 @end defvr
213 @deffn {Función} demoivre (@var{expr})
214 @deffnx {Variable opcional} demoivre
216 La función @code{demoivre (expr)} convierte una expresión sin modificar la variable global @code{demoivre}.
218 Cuando @code{demoivre} vale @code{true}, los exponenciales complejos se convierten en expresiones equivalentes pero en términos de las funciones trigonométricas:
219 @code{exp (a + b*%i)} se reduce a @code{%e^a * (cos(b) + %i*sin(b))}
220 si @code{b} no contiene a @code{%i}. Las expresiones @code{a} y @code{b} no se expanden.
222 El valor por defecto de @code{demoivre} es @code{false}.
224 La función @code{exponentialize} convierte funciones trigonométricas e hiperbólicas a la forma exponencial, por lo que @code{demoivre} y @code{exponentialize} no pueden valer @code{true} al mismo tiempo.
226 @end deffn
229 @deffn {Función} distrib (@var{expr})
230 Distribuye sumas sobre productos. Difiere de @code{expand}
231 en que trabaja sólo al nivel superior de una expresión, siendo más rápida que @code{expand}. Difiere de @code{multthru} en que expande todas las sumas del nivel superior.
233 Ejemplos:
235 @example
236 (%i1) distrib ((a+b) * (c+d));
237 (%o1) b d + a d + b c + a c
238 (%i2) multthru ((a+b) * (c+d));
239 (%o2) (b + a) d + (b + a) c
240 (%i3) distrib (1/((a+b) * (c+d)));
241 1
242 (%o3) ---------------
243 (b + a) (d + c)
244 (%i4) expand (1/((a+b) * (c+d)), 1, 0);
245 1
246 (%o4) ---------------------
247 b d + a d + b c + a c
248 @end example
250 @end deffn
254 @defvr {Variable opcional} distribute_over
255 Valor por defecto: @code{true}
257 @code{distribute_over} controla la distribución de funciones sobre
258 estructuras como listas, matrices y ecuaciones. Actualmente, no todas
259 las funciones de Maxima tienen esta propiedad. Es posible consultar si
260 una función tiene esta propiedad con la instrucción @code{properties}.
262 La propiedad distributiva se desactiva asignándole a @code{distribute_over}
263 el valor @code{false}.
265 Ejemplos:
267 La función @code{sin} se distribuye sobre una lista:
269 @c ===beg===
270 @c sin([x,1,1.0]);
271 @c ===end===
272 @example
273 (%i1) sin([x,1,1.0]);
274 (%o1) [sin(x), sin(1), .8414709848078965]
275 @end example
277 @code{mod} es una función de dos argumentos que se distribuye sobre listas.
278 La distribución sobre listas anidadas también es posible.
280 @c ===beg===
281 @c mod([x,11,2*a],10);
282 @c mod([[x,y,z],11,2*a],10);
283 @c ===end===
284 @example
285 (%i2) mod([x,11,2*a],10);
286 (%o2) [mod(x, 10), 1, 2 mod(a, 5)]
287 (%i3) mod([[x,y,z],11,2*a],10);
288 (%o3) [[mod(x, 10), mod(y, 10), mod(z, 10)], 1, 2 mod(a, 5)]
289 @end example
291 Distribución de la función @code{floor} sobre una matriz y una
292 ecuación.
294 @c ===beg===
295 @c floor(matrix([a,b],[c,d]));
296 @c floor(a=b);
297 @c ===end===
298 @example
299 (%i4) floor(matrix([a,b],[c,d]));
300 [ floor(a) floor(b) ]
301 (%o4) [ ]
302 [ floor(c) floor(d) ]
303 (%i5) floor(a=b);
304 (%o5) floor(a) = floor(b)
305 @end example
307 Funciones con más de un argumento se distribuyen sobre cualquiera
308 de sus argumentos, o sobre todos ellos.
310 @c ===beg===
311 @c expintegral_e([1,2],[x,y]);
312 @c ===end===
313 @example
314 (%i6) expintegral_e([1,2],[x,y]);
315 (%o6) [[expintegral_e(1, x), expintegral_e(1, y)],
316 [expintegral_e(2, x), expintegral_e(2, y)]]
317 @end example
319 Comprueba si una función tiene la propiedad @code{distribute_over}:
321 @c ===beg===
322 @c properties(abs);
323 @c ===end===
324 @example
325 (%i7) properties(abs);
326 (%o7) [integral, distributes over bags, noun, rule, gradef]
327 @end example
328 @end defvr
331 @defvr {Variable opcional} domain
332 Valor por defecto: @code{real}
334 Si @code{domain} vale @code{complex}, @code{sqrt (x^2)} permanecerá como
335 @code{sqrt (x^2)} en lugar de devolver @code{abs(x)}.
337 @c PRESERVE EDITORIAL COMMENT -- MAY HAVE SOME SIGNIFICANCE NOT YET UNDERSTOOD !!!
338 @c The notion of a "domain" of simplification is still in its infancy,
339 @c and controls little more than this at the moment.
341 @end defvr
344 @defvr {Propiedad} evenfun
345 @defvrx {Propiedad} oddfun
347 @code{declare(f, evenfun} o @code{declare(f, oddfun)} indican a Maxima que reconozca
348 la función @code{f} como par o impar, respectivamente.
350 Ejemplos:
352 @example
353 (%i1) o (- x) + o (x);
354 (%o1) o(x) + o(- x)
355 (%i2) declare (o, oddfun);
356 (%o2) done
357 (%i3) o (- x) + o (x);
358 (%o3) 0
359 (%i4) e (- x) - e (x);
360 (%o4) e(- x) - e(x)
361 (%i5) declare (e, evenfun);
362 (%o5) done
363 (%i6) e (- x) - e (x);
364 (%o6) 0
365 @end example
366 @end defvr
371 @deffn {Función} expand (@var{expr})
372 @deffnx {Función} expand (@var{expr}, @var{p}, @var{n})
373 Expande la expresión @var{expr}. Los productos de sumas y de sumas con exponentes se multiplican, los numeradores de las expresiones racionales que son sumas se separan en sus respectivos términos, y las multiplicaciones (tanto las que son conmutativas como las que no) se distribuyen sobre las sumas en todos los niveles de @var{expr}.
375 En el caso de los polinomios es más aconsejable utilizar @code{ratexpand}, que utiliza un algoritmo más eficiente.
377 Las variables @code{maxnegex} y @code{maxposex} controlan los máximos exponentes negativos y positivos que se van a expandir.
379 La llamada @code{expand (@var{expr}, @var{p}, @var{n})} expande @var{expr} asignando a @code{maxposex} el valor @var{p} y a @code{maxnegex} el @var{n}. Esto es útil para expandir sólo parte de la expresión.
381 La variable @code{expon} guarda el mayor exponente negativo que será expandido automáticamente, independientemente de @code{expand}. Por ejemplo, si @code{expon} vale 4 entonces @code{(x+1)^(-5)} no se expandirá automáticamente.
383 La variable @code{expop} guarda el mayor exponente positivo que será expandido automáticamente. Así, @code{(x+1)^3} se expandirá automáticamente sólo si @code{expop} es mayor o igual que 3. Si se quiere expandir @code{(x+1)^n}, siendo @code{n} mayor que @code{expop}, entonces @code{expand ((x+1)^n)} se desarrollará sólo si @code{maxposex} no es menor que @code{n}.
385 @code{expand(expr, 0, 0)} provoca que se vuelva a simplificar @code{expr}.
386 @code{expr} no se vuelve a evaluar. A diferencia de @code{ev(expr, noeval)},
387 se elimina la representación canónica de la expresión.
388 Véase también @code{ev}.
390 La variable @code{expand} utilizada con @code{ev} provocará una expansión.
392 El fichero @file{share/simplification/facexp.mac}
393 contiene algunas funciones relacionadas con @code{expand} (en concreto, @code{facsum}, @code{factorfacsum}
394 y @code{collectterms}, que se cargan automáticamente) y variables (@code{nextlayerfactor}
395 y @code{facsum_combine}) que permiten al usuario estructurar las expresiones controlando la expansión.
396 @c MERGE share/simplification/facexp.usg INTO THIS FILE OR CREATE NEW FILE facexp.texi
397 En @file{simplification/facexp.usg} se pueden encontrar breves descripciones de estas funciones.
398 Se accederá a una demostración con la instrucción @code{demo("facexp")}.
400 Ejemplo:
402 @c ===beg===
403 @c expr:(x+1)^2*(y+1)^3;
404 @c expand(expr);
405 @c expand(expr,2);
406 @c expr:(x+1)^-2*(y+1)^3;
407 @c expand(expr);
408 @c expand(expr,2,2);
409 @c ===end===
410 @example
411 (%i1) expr:(x+1)^2*(y+1)^3;
412 2 3
413 (%o1) (x + 1) (y + 1)
414 (%i2) expand(expr);
415 2 3 3 3 2 2 2 2 2
416 (%o2) x y + 2 x y + y + 3 x y + 6 x y + 3 y + 3 x y
417 2
418 + 6 x y + 3 y + x + 2 x + 1
420 (%i3) expand(expr,2);
421 2 3 3 3
422 (%o3) x (y + 1) + 2 x (y + 1) + (y + 1)
424 (%i4) expr:(x+1)^-2*(y+1)^3;
425 3
426 (y + 1)
427 (%o4) --------
428 2
429 (x + 1)
430 (%i5) expand(expr);
431 3 2
432 y 3 y 3 y 1
433 (%o5) ------------ + ------------ + ------------ + ------------
434 2 2 2 2
435 x + 2 x + 1 x + 2 x + 1 x + 2 x + 1 x + 2 x + 1
437 (%i6) expand(expr,2,2);
438 3
439 (y + 1)
440 (%o6) ------------
441 2
442 x + 2 x + 1
443 @end example
445 Vuelve a simplificar una expresión pero sin expansión:
447 @c ===beg===
448 @c expr:(1+x)^2*sin(x);
449 @c exponentialize:true;
450 @c expand(expr,0,0);
451 @c ===end===
452 @example
453 (%i7) expr:(1+x)^2*sin(x);
454 2
455 (%o7) (x + 1) sin(x)
456 (%i8) exponentialize:true;
457 (%o8) true
458 (%i9) expand(expr,0,0);
459 2 %i x - %i x
460 %i (x + 1) (%e - %e )
461 (%o9) - -------------------------------
462 2
463 @end example
464 @end deffn
468 @deffn {Función} expandwrt (@var{expr}, @var{x_1}, ..., @var{x_n})
469 Expande la expresión @code{expr} con respecto a las variables @var{x_1}, ..., @var{x_n}.
470 Todos los productos que contengan a las variables aparecen explícitamente. El resultado que se obtenga no tendr'a productos de sumas de expresiones que contengan a las variables. Los argumentos @var{x_1}, ..., @var{x_n}
471 pueden ser variables, operadores o expresiones.
473 Por defecto, no se expanden los denominadores, pero esto puede cambiarse mediante el uso de la variable @code{expandwrt_denom}.
475 Esta función se carga automáticamente de @file{simplification/stopex.mac}.
477 @end deffn
480 @defvr {Variable opcional} expandwrt_denom
481 Valor por defecto: @code{false}
483 La variable @code{expandwrt_denom} controla el tratamiento de las expresiones racinales por parte de @code{expandwrt}. Si vale @code{true}, se expandirán tanto el numerador como el denominador de la expresión respecto de los argumentos de @code{expandwrt}, pero si @code{expandwrt_denom} vale @code{false}, sólo se expandirá el numerador.
485 @end defvr
488 @deffn {Función} expandwrt_factored (@var{expr}, @var{x_1}, ..., @var{x_n})
489 Es similar a @code{expandwrt}, pero trata a las expresiones que son productos de una forma algo diferente. La función
490 @code{expandwrt_factored} expande sólo aquellos factores de @code{expr} que contienen a las variables @var{x_1}, ..., @var{x_n}.
492 @c NOT SURE WHY WE SHOULD MENTION THIS HERE
493 Esta función se carga automáticamente de @file{simplification/stopex.mac}.
495 @end deffn
498 @defvr {Variable opcional} expon
499 Valor por defecto: 0
501 La variable @code{expon} guarda el mayor exponente negativo que será expandido automáticamente, independientemente de @code{expand}. Por ejemplo, si @code{expon} vale 4 entonces @code{(x+1)^(-5)} no se expandirá automáticamente.
503 @end defvr
507 @deffn {Función} exponentialize (@var{expr})
508 @deffnx {Variable opcional} exponentialize
510 La función @code{exponentialize (expr)} convierte las funciones trigonométricas e hiperbólicas de @var{expr} a exponenciales, sin alterar la variable global @code{exponentialize}.
512 Cuando la variable @code{exponentialize} vale @code{true}, todas las funciones trigonométricas e hiperbólicas se convierten a forma exponencial. El valor por defecto es @code{false}.
514 La función @code{demoivre} convierte funciones trigonométricas e hiperbólicas a la forma exponencial, por lo que @code{demoivre} y @code{exponentialize} no pueden valer @code{true} al mismo tiempo.
516 @end deffn
520 @defvr {Variable opcional} expop
521 Valor por defecto: 0
523 La variable @code{expop} guarda el mayor exponente positivo que será expandido automáticamente. Así, @code{(x+1)^3} se expandirá automáticamente sólo si @code{expop} es mayor o igual que 3. Si se quiere expandir @code{(x+1)^n}, siendo @code{n} mayor que @code{expop}, entonces @code{expand ((x+1)^n)} se desarrollará sólo si @code{maxposex} no es menor que @code{n}.
525 @end defvr
528 @defvr {Propiedad} lassociative
529 La instrucción @code{declare (g, lassociative)} le indica al simplificador de Maxima que @code{g} es asociativo por la izquierda. Por ejemplo, @code{g (g (a, b), g (c, d))}se reduce a @code{g (g (g (a, b), c), d)}.
531 @end defvr
534 @defvr {Propiedad} linear
535 Es una de las propiedades de operadores de Maxima. Si la función
536 univariante @code{f} se declara lineal, la expansión de @code{f(x + y)}
537 produce @code{f(x) + f(y)}, @code{f(a*x)} produce @code{a*f(x)} si @code{a}
538 es una constante. Si la función tiene dos o más argumentos, la linealidad
539 se interpreta como la de @code{sum} o @code{integrate}, esto es,
540 @code{f (a*x + b, x)} produce @code{a*f(x,x) + b*f(1,x)} si @code{a} y @code{b}
541 no contienen a @code{x}.
543 @code{linear} equivale a @code{additive} y @code{outative}.
544 Véase también @code{opproperties}.
546 Ejemplo:
548 @c ===beg===
549 @c 'sum (F(k) + G(k), k, 1, inf);
550 @c declare (nounify (sum), linear);
551 @c 'sum (F(k) + G(k), k, 1, inf);
552 @c ===end===
553 @example
554 (%i1) 'sum (F(k) + G(k), k, 1, inf);
555 inf
556 ====
557 \
558 (%o1) > (G(k) + F(k))
559 /
560 ====
561 k = 1
562 (%i2) declare (nounify (sum), linear);
563 (%o2) done
564 (%i3) 'sum (F(k) + G(k), k, 1, inf);
565 @group
566 inf inf
567 ==== ====
568 \ \
569 (%o3) > G(k) + > F(k)
570 / /
571 ==== ====
572 k = 1 k = 1
573 @end group
574 @end example
575 @end defvr
578 @defvr {Variable opcional} maxnegex
579 Valor por defecto: 1000
581 La variable @code{maxnegex} es el mayor exponente negativo que expandirá la función @code{expand}. Véase también @code{maxposex}.
583 @end defvr
587 @defvr {Variable opcional} maxposex
588 Valor por defecto: 1000
590 La variable @code{maxposex} es el mayor exponenteque expandirá la función @code{expand}. Véase también @code{maxnegex}.
592 @end defvr
596 @defvr {Propiedad} multiplicative
597 La instrucción @code{declare (f, multiplicative)} indica al simplificador de Maxima que @code{f} is multiplicativa.
599 @enumerate
600 @item
601 Si @code{f} es univariante, cada vez que el simplificador encuentre a @code{f} aplicad a un producto, @code{f} se distribuirá sobre ese producto. Por ejemplo, @code{f(x*y)} se reduciría a @code{f(x)*f(y)}.
602 @item
603 Si @code{f} es una función de 2 o más argumentos, la multiplicabilidad se define como multiplicabilidad para el primer argumento de @code{f}, de modo que @code{f (g(x) * h(x), x)} se reduciría a @code{f (g(x) ,x) * f (h(x), x)}.
604 @end enumerate
606 Esta transformación no se realiza cuando @code{f} se aplica a expresiones de la forma @code{product (x[i], i, m, n)}.
608 Ejemplo:
610 @c ===beg===
611 @c F2 (a * b * c);
612 @c declare (F2, multiplicative);
613 @c F2 (a * b * c);
614 @c ===end===
615 @example
616 (%i1) F2 (a * b * c);
617 (%o1) F2(a b c)
618 (%i2) declare (F2, multiplicative);
619 (%o2) done
620 (%i3) F2 (a * b * c);
621 (%o3) F2(a) F2(b) F2(c)
622 @end example
623 @end defvr
628 @deffn {Función} multthru (@var{expr})
629 @deffnx {Función} multthru (@var{expr_1}, @var{expr_2})
630 Multiplica un factor (que debería ser una suma) de @var{expr} por los otros factores de @var{expr}. Esto es, @var{expr} es @code{@var{f_1} @var{f_2} ... @var{f_n}}, donde al menos un factor, por ejemplo @var{f_i}, es una suma de términos. Cada término en esta suma se multiplica por los otros factores del producto, excepto el propio @var{f_i}. La función @code{multthru} no expande sumas elevadas a exponentes, siendo el método más rápido para distribuir productos (sean o no conmutativos) sobre sumas. Puesto que los cocientes se representan como productos, puede utilizarse@code{multthru} para dividir sumas entre productos.
632 La llamada @code{multthru (@var{expr_1}, @var{expr_2})} multiplica cada término de @var{expr_2} (que debería ser una suma o una ecuación) por @var{expr_1}. Si @var{expr_1} no es ella misma una suma, entonces la llamada es equivalente a @code{multthru (@var{expr_1}*@var{expr_2})}.
634 @example
635 (%i1) x/(x-y)^2 - 1/(x-y) - f(x)/(x-y)^3;
636 1 x f(x)
637 (%o1) - ----- + -------- - --------
638 x - y 2 3
639 (x - y) (x - y)
640 (%i2) multthru ((x-y)^3, %);
641 2
642 (%o2) - (x - y) + x (x - y) - f(x)
643 (%i3) ratexpand (%);
644 2
645 (%o3) - y + x y - f(x)
646 (%i4) ((a+b)^10*s^2 + 2*a*b*s + (a*b)^2)/(a*b*s^2);
647 10 2 2 2
648 (b + a) s + 2 a b s + a b
649 (%o4) ------------------------------
650 2
651 a b s
652 (%i5) multthru (%); /* note that this does not expand (b+a)^10 */
653 10
654 2 a b (b + a)
655 (%o5) - + --- + ---------
656 s 2 a b
657 s
658 (%i6) multthru (a.(b+c.(d+e)+f));
659 (%o6) a . f + a . c . (e + d) + a . b
660 (%i7) expand (a.(b+c.(d+e)+f));
661 (%o7) a . f + a . c . e + a . c . d + a . b
662 @end example
664 @end deffn
667 @defvr {Propiedad} nary
669 @code{declare(f, nary)} le indica a Maxima que reconozca la función @code{f}
670 como n-aria.
672 La declaración @code{nary} no equivale a invocar la función
673 @code{function_nary, nary}. El único efecto de @code{declare(f, nary)}
674 es indicar al simplificador de Maxima que aplane expresiones anidadas,
675 como simplificar @code{foo(x, foo(y, z))} a @code{foo(x, y, z)}.
676 Véase también @code{declare}.
678 Ejemplo:
680 @example
681 (%i1) H (H (a, b), H (c, H (d, e)));
682 (%o1) H(H(a, b), H(c, H(d, e)))
683 (%i2) declare (H, nary);
684 (%o2) done
685 (%i3) H (H (a, b), H (c, H (d, e)));
686 (%o3) H(a, b, c, d, e)
687 @end example
688 @end defvr
692 @defvr {Variable opcional} negdistrib
693 Valor por defecto: @code{true}
695 Si @code{negdistrib} vale @code{true}, -1 se distribuye sobre una expresión. Por ejemplo, @code{-(x + y)} se transforma en @code{- y - x}. Dándole el valor @code{false} se mostrará @code{- (x + y)} tal cual. Esto puede ser útil, pero también peligroso; al igual que el indicador @code{simp}, no conviene asignarle el valor @code{false}.
697 @end defvr
700 @defvr {Variable del sistema} opproperties
702 La variable @code{opproperties} es la lista con las propiedades especiales de los operadores reconocidas por el simplificador de Maxima:
703 @code{linear}, @code{additive}, @code{multiplicative}, @code{outative}, @code{evenfun},
704 @code{oddfun}, @code{commutative}, @code{symmetric}, @code{antisymmetric}, @code{nary},
705 @code{lassociative}, @code{rassociative}.
707 @end defvr
711 @defvr {Propiedad} outative
712 La instrucción @code{declare (f, outative)} le indica al simplificador de Maxima
713 que los factores constantes del argumento de la función @code{f} pueden ser
714 extraídos.
716 @enumerate
717 @item
718 Si @code{f} es univariante, cada vez que el simplificador se encuentra con @code{f}
719 aplicada a un producto, éste será particionado en factores que son constantes y
720 factores que no lo son, siendo entonces los constantes extraídos de la
721 función. Por ejemplo, @code{f(a*x)} se reducirá a @code{a*f(x)} siendo @code{a}
722 una constante. Las constantes no atómicas no serán extraídas.
723 @item
724 Si @code{f} es una función de 2 o más argumentos, esta propiedad se define como
725 en @code{sum} o @code{integrate}, esto es, @code{f (a*g(x), x)} se reducirá a
726 @code{a * f(g(x), x)} si @code{a} no contiene a @code{x}.
727 @end enumerate
729 Las funciones @code{sum}, @code{integrate} y @code{limit} han sido todas declaradas
730 con la propiedad @code{outative}.
732 Ejemplo:
734 @c ===beg===
735 @c F1 (100 * x);
736 @c declare (F1, outative);
737 @c F1 (100 * x);
738 @c declare (zz, constant);
739 @c F1 (zz * y);
740 @c ===end===
741 @example
742 (%i1) F1 (100 * x);
743 (%o1) F1(100 x)
744 (%i2) declare (F1, outative);
745 (%o2) done
746 (%i3) F1 (100 * x);
747 (%o3) 100 F1(x)
748 (%i4) declare (zz, constant);
749 (%o4) done
750 (%i5) F1 (zz * y);
751 (%o5) zz F1(y)
752 @end example
753 @end defvr
757 @deffn {Función} radcan (@var{expr})
758 Simplifica la expresión @var{expr}, que puede contener logaritmos, exponenciales y
759 radicales, convirtiéndola a una forma canónica, lo que significa que todas las expresiones funcionalmente equivalentes
760 se reducen a una forma única. Ciertas expresiones, sin embargo, son reducidas por @code{radcan} a una forma regular, lo que significa que dos expresiones equivalentes no tienen necesariamente el mismo aspecto, pero su diferencia puede ser reducida por @code{radcan} a cero.
762 Con algunas expresiones @code{radcan} puede consunir mucho tiempo. Este es el coste por explorar ciertas relaciones entre las componentes de la expresión para simplificaciones basadas en factorizaciones y expansiones parciales de fracciones de exponentes.
764 Ejemplos:
766 @c ===beg===
767 @c radcan((log(x+x^2)-log(x))^a/log(1+x)^(a/2));
768 @c radcan((log(1+2*a^x+a^(2*x))/log(1+a^x)));
769 @c radcan((%e^x-1)/(1+%e^(x/2)));
770 @c ===end===
771 @example
772 (%i1) radcan((log(x+x^2)-log(x))^a/log(1+x)^(a/2));
773 a/2
774 (%o1) log(x + 1)
776 (%i2) radcan((log(1+2*a^x+a^(2*x))/log(1+a^x)));
777 (%o2) 2
779 (%i3) radcan((%e^x-1)/(1+%e^(x/2)));
780 x/2
781 (%o3) %e - 1
782 @end example
784 @end deffn
788 @defvr {Variable opcional} radexpand
789 Valor por defecto: @code{true}
791 La variable @code{radexpand} controla algunas simplificaciones de radicales.
793 Si @code{radexpand} vale @code{all}, las raíces @var{n}-ésimas de los factores de un producto que sean potencias de @var{n} se extraen del símbolo radical. Por ejemplo, si @code{radexpand} vale @code{all}, @code{sqrt (16*x^2)} se reduce a @code{4*x}.
795 @c EXPRESS SIMPLIFICATON RULES IN GENERAL CASE, NOT SPECIAL CASE
796 Más concretamente, considérese @code{sqrt (x^2)}.
797 @itemize @bullet
798 @item
799 Si @code{radexpand} vale @code{all} o se ha ejecutado @code{assume (x > 0)},
800 @code{sqrt(x^2)} se reduce a @code{x}.
801 @item
802 Si @code{radexpand} vale @code{true} y @code{domain} es @code{real} (su valor por defecto),
803 @code{sqrt(x^2)} se reduce a @code{abs(x)}.
804 @item
805 Si @code{radexpand} vale @code{false} o @code{radexpand} vale @code{true} y @code{domain} es @code{complex},
806 @code{sqrt(x^2)} no se simplifica.
807 @end itemize
809 @c CORRECT STATEMENT HERE ???
810 Nótese que @code{domain} sólo se tiene en cuenta si @code{radexpand} vale @code{true}.
812 @end defvr
816 @defvr {Propiedad} rassociative
817 La instrucción @code{declare (g, rassociative)} le indica al simplificador de Maxima que @code{g} es asociativa por la derecha. Por ejemplo, @code{g(g(a, b), g(c, d))} se reduce a @code{g(a, g(b, g(c, d)))}.
819 @end defvr
822 @deffn {Función} scsimp (@var{expr}, @var{rule_1}, ..., @var{rule_n})
823 Es el "Sequential Comparative Simplification" (método debido a Stoute).
824 La función @code{scsimp} intenta simplificar @var{expr} de acuerdo con las reglas @var{rule_1}, ..., @var{rule_n}.
825 Si se obtiene una expresión más pequeña, el proceso se repite. En caso contrario, después de que se hayan intentado todas las simplificaciones, devuelve la respuesta original.
827 La instrucción @code{example (scsimp)} muestra algunos ejemplos.
829 @end deffn
833 @defvr {Variable opcional} simp
834 Valor por defecto: @code{true}
836 La variable @code{simp} activa y desactiva la simplificación.
837 La simplificación está activada por defecto. La variable @code{simp}
838 también es reconocida por la función @code{ev} como variable de entorno.
839 Véase también @code{ev}.
841 Cuando @code{simp} se utiliza en un entorno @code{ev} con el valor @code{false},
842 la simplificación se evita sólo durante la fase de evaluación de una
843 expresión. La variable no evita la simplificación que sigue a la fase de
844 evaluación.
846 Ejemplos:
848 La simplificación se suspende globalmente. La expresión @code{sin(1.0)}
849 no se simplifica a su valor numérico. La variable de entorno @code{simp}
850 conmuta el estado de la simplificación.
852 @c ===beg===
853 @c simp:false;
854 @c sin(1.0);
855 @c sin(1.0),simp;
856 @c ===end===
857 @example
858 (%i1) simp:false;
859 (%o1) false
860 (%i2) sin(1.0);
861 (%o2) sin(1.0)
862 (%i3) sin(1.0),simp;
863 (%o3) .8414709848078965
864 @end example
866 La simplificación se vuelve a activar. La variable de entorno @code{simp}
867 no puede suprimir totalmente la simplificación. El resultado muestra una
868 expresión simplificada, pero la variable @code{x} guarda como valor una
869 expresión sin simplificar, porque la asignación se realizó durante
870 la fase de evaluación de la expresión.
872 @c ===beg===
873 @c simp:true;
874 @c x:sin(1.0),simp:false;
875 @c :lisp $x
876 @c ===end===
877 @example
878 (%i4) simp:true;
879 (%o4) true
880 (%i5) x:sin(1.0),simp:false;
881 (%o5) .8414709848078965
882 (%i6) :lisp $X
883 ((%SIN) 1.0)
884 @end example
885 @end defvr
889 @defvr {Propiedad} symmetric
890 La instrucción @code{declare (h, symmetric)} le indica al simplificador de Maxima que @code{h} es una función simétrica. Por ejemplo, @code{h (x, z, y)} se reduce a @code{h (x, y, z)}.
892 El nombre @code{commutative} es sinónimo de @code{symmetric}.
894 @end defvr
898 @deffn {Función} xthru (@var{expr})
899 Combina todos los términos de @var{expr} (la cual debe ser una suma) sobre un común denominador sin expandir productos ni sumas elevadas a exponentes al modo que lo hace @code{ratsimp}. La función @code{xthru} cancela factores comunes en el numerador y denominador de expresiones racionales, pero sólo si los factores son explícitos.
901 En ocasiones puede ser útil el uso de @code{xthru} antes de la llamada a @code{ratsimp} a fin de cancelar factores explícitos del máximo común divisor del numerador y denominador y así simplificar la expresión a la que se va a aplicar @code{ratsimp}.
903 @c ===beg===
904 @c ((x+2)^20 - 2*y)/(x+y)^20 + (x+y)^(-19) - x/(x+y)^20;
905 @c xthru (%);
906 @c ===end===
907 @example
908 (%i1) ((x+2)^20 - 2*y)/(x+y)^20 + (x+y)^(-19) - x/(x+y)^20;
909 xthru (%);
910 20
911 1 (x + 2) - 2 y x
912 (%o1) --------- + --------------- - ---------
913 19 20 20
914 (y + x) (y + x) (y + x)
915 @end example
917 @end deffn