| blob | cc458f9eb20b7143be8e7dfa3876efd2dcee802a |
1 @c English version 2013-06-15
2 @menu
3 * Funciones y variables para to_poly_solve::
4 @end menu
6 @node Funciones y variables para to_poly_solve, , to_poly_solve, to_poly_solve
7 @section Funciones y variables para to_poly_solve
9 Los paquetes @code{to_poly} y @code{to_poly_solve} son experimentales,
10 siendo posible que las especificaciones de sus funciones puedan
11 cambiar en el futuro, o que algunas de estas funciones puedan ser
12 incorporadas a otras partes de Maxima.
14 Los paquetes @code{to_poly} y @code{to_poly_solve}, junto con su documentación,
15 fue escrito por Barton Willis de la Universidad de Nebraska en Kearney.
22 @deffn {Operador} %and
23 @ifinfo
24 @fnindex Conjunción lógica
25 @end ifinfo
27 El operador @code{%and} es una conjunción lógica. Maxima simplifica
28 una expresión @code{%and} a @code{true}, @code{false} o a una expresión
29 lógicamente equivalente, pero simplificada. El operador @code{%and}
30 es asociativo, conmutativo e idempotente. Así, cuando @code{%and}
31 devuelva una forma nominal, sus argumentos no serán redundantes; por ejemplo,
33 @example
34 (%i1) a %and (a %and b);
35 (%o1) a %and b
36 @end example
38 Si uno de los argumentos de la conjunción es la negación de otro argumento,
39 @code{%and} devuelve @code{false}:
41 @example
42 (%i2) a %and (not a);
43 (%o2) false
44 @end example
46 Si cualquiera de los argumentos vale @code{false}, la conjunción devuelve
47 @code{false}, incluso cuando haya algún otro argumento que sea una
48 expresión no booleana; por ejemplo,
50 @example
51 (%i2) a %and (not a);
52 (%o2) false
53 @end example
55 Los argumentos de la expresión @code{%and} que sean inecuaciones se
56 reducen con la simplificación de Fourier; el método que se
57 aplica dispone de un pre-procesador que convierte algunas, pero no
58 todas, las inecuaciones no lineales a lineales. Por ejemplo, el
59 método de simplificación de Fourier simplifica @code{abs(x) + 1 > 0}
60 a @code{true}:
62 @example
63 (%i4) (x < 1) %and (abs(x) + 1 > 0);
64 (%o4) x < 1
65 @end example
67 @b{Notas}
68 @itemize @bullet
69 @item La variable opcional @code{prederror} no altera la
70 simplificación de las expresiones @code{%and}.
72 @item Para evitar errores en la precedencia de las operaciones,
73 se recomienda utilizar paréntesis en las expresiones combinadas
74 en las que aparezcan los operadores @code{%and}, @code{%or} y @code{not} .
76 @item Los operadores @code{and} y @code{or}, tal como están
77 programados en Maxima, no conocen las propiedades asociativa
78 ni conmutativa.
80 @end itemize
82 @b{Limitaciones} La conjunción @code{%and} simplifica inecuaciones
83 @i{locamente}, no @i{globalmente}, lo que significa que conjunciones tales como
85 @example
86 (%i5) (x < 1) %and (x > 1);
87 (%o5) (x > 1) %and (x < 1)
88 @end example
90 @i{no} simplifican a @code{false}. Además, las rutinas de eliminación de Fourier
91 ignoran los hechos almacenados en la base de datos.
93 @example
94 (%i6) assume(x > 5);
95 (%o6) [x > 5]
96 (%i7) (x > 1) %and (x > 2);
97 (%o7) (x > 1) %and (x > 2)
98 @end example
100 Por último, las inecuaciones no lineales que no se puedan reducir de
101 manera sencilla a formas lineales, no se simplifican.
103 No está soportada la distributividad de @code{%and} respecto de @code{%or},
104 ni la negación respecto de @code{%and}.
106 Para hacer uso de este operador, ejecútese @code{load("to_poly_solve")}.
108 Véanse también @code{%or}, @code{%if}, @code{and}, @code{or} y @code{not}.
110 @end deffn
117 @deffn {Operador} %if ( @var{bool}, @var{a}, @var{b})
118 @ifinfo
119 @fnindex Evaluación condicionada
120 @end ifinfo
122 El operador @code{%if} es un condicional. La condición @var{bool}
123 debe tomar un valor lógico; cuando sea @code{true}, se devolverá
124 el segundo argumento, y cuando valga @code{false}, el segundo. En
125 cualquier otro caso, se obtiene una forma nominal.
127 En Maxima, las expresiones con desigualdades o igualdades no adquieren
128 valores lógicos; por ejemplo, @math{5 < 6} no se simplifica a @code{true},
129 ni @math{5 = 6} @code{false}. Sin embargo, en la condición de una
130 sentencia @code{%if}, Maxima intenta determinar el valor lógico
131 de la expresión de forma automática. Véase un ejemplo:
133 @example
134 (%i1) f : %if(x # 1, 2, 8);
135 (%o1) %if(x - 1 # 0, 2, 8)
136 (%i2) [subst(x = -1,f), subst(x=1,f)];
137 (%o2) [2, 8]
138 @end example
140 Si en la condición aparece una inecuación, Maxima la
141 reduce con una simplificación de Fourier.
143 @b{Notas}
144 @itemize bullet
145 @item Si la condición no se reduce a un valor lógico, Maxima devuelve
146 una forma nominal:
147 @example
148 (%i3) %if(42,1,2);
149 (%o3) %if(42, 1, 2)
150 @end example
152 @item El operador @code{if} de Maxima es n-ario, pero el operador @code{%if} no lo es.
153 @end itemize
155 Por último, las inecuaciones no lineales que no se puedan reducir de
156 manera sencilla a formas lineales, no se simplifican.
158 Para hacer uso de este operador, ejecútese @code{load("to_poly_solve")}.
159 @end deffn
165 @deffn {Operador} %or
166 @ifinfo
167 @fnindex Disyunción lógica
168 @end ifinfo
170 El operador @code{%or} es una disyunción lógica. Maxima simplifica
171 una expresión @code{%or} a @code{true}, @code{false} o a una expresión
172 lógicamente equivalente, pero simplificada. El operador @code{%or}
173 es asociativo, conmutativo e idempotente. Así, cuando @code{%or}
174 devuelva una forma nominal, sus argumentos no serán redundantes; por ejemplo,
176 @example
177 (%i1) a %or (a %or b);
178 (%o1) a %or b
179 @end example
181 Si uno de los argumentos de la disyunción es la negación de otro argumento,
182 @code{%or} devuelve @code{true}:
184 @example
185 (%i2) a %or (not a);
186 (%o2) true
187 @end example
189 Si cualquiera de los argumentos vale @code{true}, la disyunción devuelve
190 @code{true}, incluso cuando haya algún otro argumento que sea una
191 expresión no booleana; por ejemplo,
193 @example
194 (%i3) 42 %or true;
195 (%o3) true
196 @end example
198 Los argumentos de la expresión @code{%or} que sean inecuaciones se
199 reducen con la simplificación de Fourier. Por ejemplo, el
200 método de simplificación de Fourier simplifica @code{abs(x) + 1 > 0}
201 a @code{true}:
203 @example
204 (%i4) (x < 1) %or (abs(x) + 1 > 0);
205 (%o4) true
206 @end example
208 @b{Notas}
209 @itemize @bullet
210 @item La variable opcional @code{prederror} no altera la
211 simplificación de las expresiones @code{%or}.
213 @item Para evitar errores en la precedencia de las operaciones,
214 se recomienda utilizar paréntesis en las expresiones combinadas
215 en las que aparezcan los operadores @code{%and}, @code{%or} y @code{not} .
217 @item Los operadores @code{and} y @code{or}, tal como están
218 programados en Maxima, no conocen las propiedades asociativa
219 ni conmutativa.
221 @end itemize
223 @b{Limitaciones} La conjunción @code{%or} simplifica inecuaciones
224 @i{locamente}, no @i{globalmente}, lo que significa que disyunciones tales como
226 @example
227 (%i1) (x < 1) %or (x >= 1);
228 (%o1) (x > 1) %or (x >= 1)
229 @end example
231 @i{no} simplifican a @code{true}. Además, las rutinas de eliminación de Fourier
232 ignoran los hechos almacenados en la base de datos.
234 @example
235 (%i2) assume(x > 5);
236 (%o2) [x > 5]
237 (%i3) (x > 1) %and (x > 2);
238 (%o3) (x > 1) %and (x > 2)
239 @end example
241 Por último, las inecuaciones no lineales que no se puedan reducir de
242 manera sencilla a formas lineales, no se simplifican.
244 No está soportada la distributividad de @code{%or} respecto de @code{%and},
245 ni la negación respecto de @code{%or}.
247 Para hacer uso de este operador, ejecútese @code{load("to_poly_solve")}.
249 Véanse también @code{%and}, @code{%if}, @code{and}, @code{or} y @code{not}.
251 @end deffn
257 @deffn {Función} complex_number_p (@var{x})
259 La función @code{complex_number_p} devuelve @code{true} si su
260 argumento es de cualquiera de las formas @code{a + %i * b}, @code{a}, @code{%i b} o
261 @code{%i}, donde @code{a} y @code{b} son racionales o decimales en coma flotante,
262 de precisión doble o arbitraria (@i{bigfloats}); para cualesquiera otros argumentos,
263 @code{complex_number_p} devuelve @code{false}.
265 Ejemplo:
267 @example
268 (%i1) map('complex_number_p,[2/3, 2 + 1.5 * %i, %i]);
269 (%o1) [true, true, true]
270 (%i2) complex_number_p((2+%i)/(5-%i));
271 (%o2) false
272 (%i3) complex_number_p(cos(5 - 2 * %i));
273 (%o3) false
274 @end example
276 Véase también @code{isreal_p}.
278 Para hacer uso de esta función, ejecútese @code{load("to_poly_solve")}.
279 @end deffn
286 @deffn {Función} compose_functions (@var{l})
288 La función @code{compose_functions(l)} devuelve una expresión lambda
289 que es la composición de las funciones presentes en la lista @var{l}.
290 Las funciones se aplican de derecha a izquierda.
292 Ejemplo:
294 @example
295 (%i1) compose_functions([cos, exp]);
296 %g151
297 (%o1) lambda([%g151], cos(%e ))
298 (%i2) %(x);
299 x
300 (%o2) cos(%e )
301 @end example
303 Si la lista está vacía devuelve la función identidad:
305 @example
306 (%i3) compose_functions([]);
307 (%o3) lambda([%g152], %g152)
308 (%i4) %(x);
309 (%o4) x
310 @end example
312 @b{Notas}
313 @itemize @bullet
314 @item Cuando Maxima detecta que un miembro de la lista no es un
315 símbolo o expresión lambda, la función
316 @code{funmake} (no @code{compose_functions}) muestra un mensaje de
317 error:
318 @example
319 (%i5) compose_functions([a < b]);
321 funmake: first argument must be a symbol, subscripted symbol,
322 string, or lambda expression; found: a < b
323 #0: compose_functions(l=[a < b])(to_poly_solve.mac line 40)
324 -- an error. To debug this try: debugmode(true);
325 @end example
327 @item Para evitar conflictos de nombres, la variable independiente se determina
328 con la función @code{new_variable}:
329 @example
330 (%i6) compose_functions([%g0]);
331 (%o6) lambda([%g154], %g0(%g154))
332 (%i7) compose_functions([%g0]);
333 (%o7) lambda([%g155], %g0(%g155))
334 @end example
335 Aunque las variables dependientes sean diferentes, Maxima es capaz de
336 determinar que las expresiones lambda son semánticamente equivalentes:
337 @example
338 (%i8) is(equal(%o6,%o7));
339 (%o8) true
340 @end example
341 @end itemize
343 Para hacer uso de esta función, ejecútese @code{load("to_poly_solve")}.
344 @end deffn
351 @deffn {Función} dfloat (@var{x})
353 La función @code{dfloat} es similar a @code{float}, pero @code{dfloat}
354 aplica @code{rectform} cuando @code{float} no puede evaluar a un número
355 decimal de coma flotante de doble precisión. Ejemplo:
357 @example
358 (%i1) float(4.5^(1 + %i));
359 %i + 1
360 (%o1) 4.5
361 (%i2) dfloat(4.5^(1 + %i));
362 (%o2) 4.48998802962884 %i + .3000124893895671
363 @end example
365 @b{Notas}
367 @itemize @bullet
368 @item La forma rectangular de una expresión puede no ser la
369 más adecuada para cálculos numéricos
371 @item El identificador @code{float} es al mismo tiempo una variable opcional,
372 cuyo valor por defecto es @code{false} y el nombre de una función.
373 @end itemize
375 Véanse también @code{float} y @code{bfloat}.
377 Para hacer uso de esta función, ejecútese @code{load("to_poly_solve")}.
379 @end deffn
386 @deffn {Función} elim (@var{l}, @var{x})
388 La función @code{elim} elimina las variables que se indican en el conjunto
389 o lista @code{x} del conjunto o lista de ecuaciones en @code{l}. Cada
390 elemento de @code{x} debe ser un símbolo, mientras que los
391 elementos de @code{l} pueden ser ecuaciones o expresiones que se suponen
392 igualadas a cero.
394 La función @code{elim} devuelve una lista formada por dos listas; la
395 primera está formada por las expresiones con las variables eliminadas y
396 la segunda es la lista de pivotes o, en otras palabras, es la lista de
397 expresiones que @code{elim} ha utilizado para proceder con la eliminación.
399 Ejemplo:
401 Eliminación entre ecuaciones lineales. Eliminando @code{x} e @code{y}
402 se obtiene una única ecuación @code{2 z - 7 = 0}; las ecuaciones
403 @code{y + 7 = 0} y @code{z - z + 1 = 1} se han utilizado como pivotes.
405 @example
406 (%i1) elim(set(x + y + z = 1, x - y - z = 8, x - z = 1),
407 set(x,y));
408 (%o1) [[2 z - 7], [y + 7, z - x + 1]]
409 @end example
411 Eliminando las tres variables de estas ecuaciones se triangulariza el sistema
412 lineal:
414 @example
415 (%i2) elim(set(x + y + z = 1, x - y - z = 8, x - z = 1),
416 set(x,y,z));
417 (%o2) [[], [2 z - 7, y + 7, z - x + 1]]
418 @end example
420 Las ecuaciones no necesitan ser lineales:
422 @example
423 (%i3) elim(set(x^2 - 2 * y^3 = 1, x - y = 5), [x,y]);
424 3 2
425 (%o3) [[], [2 y - y - 10 y - 24, y - x + 5]]
426 @end example
428 El usuario no puede controlar el orden en el que se eliminan las
429 variables. El algoritmo utiliza una heurística con
430 la que intenta escoger el mejor pivote y el mejor orden de eliminación.
432 @b{Notas}
434 @itemize @bullet
436 @item Al contrario que la función relacionada @code{eliminate}, la
437 función @code{elim} no llama a la función @code{solve} cuando el
438 número de ecuaciones iguala al de variables.
440 @item La función @code{elim} trabaja aplicando resultantes; la variable
441 opcional @code{resultant} determina qué algoritmo va a utilizar Maxima.
442 Con @code{sqfr}, Maxima factoriza cada resultante y suprime ceros múltiples.
444 @item @code{elim} triangulariza un conjunto de ecuaciones polinómicas no
445 lineales; el conjunto solución del conjunto triangularizado puede ser mayor
446 que el conjunto de soluciones del conjunto no triangularizado, por lo que
447 las ecuaciones triangularizadas pueden tener soluciones falsas.
449 @end itemize
451 Véanse también @code{elim_allbut}, @code{eliminate_using}, @code{eliminate}
452 y @code{resultant}.
454 Para hacer uso de esta función, ejecútese @code{load("to_poly")}.
456 @end deffn
464 @deffn {Función} elim_allbut (@var{l}, @var{x})
466 Es similar a @code{elim}, excepto por el hecho de que elimina todas las variables
467 que aparecen en la lista de ecuaciones @code{l} que no están en @code{x}.
469 Ejemplo:
471 @example
472 (%i1) elim_allbut([x+y = 1, x - 5*y = 1],[]);
473 (%o1) [[], [y, y + x - 1]]
474 (%i2) elim_allbut([x+y = 1, x - 5*y = 1],[x]);
475 (%o2) [[x - 1], [y + x - 1]]
476 @end example
478 Para hacer uso de esta función, ejecútese @code{load("to_poly")}.
480 Véanse también @code{elim}, @code{eliminate_using}, @code{eliminate}
481 y @code{resultant}.
483 @end deffn
489 @deffn {Función} eliminate_using (@var{l}, @var{e}, @var{x})
491 Elmina el símbolo @code{x} de la lista o conjunto de ecuaciones
492 @code{l} haciendo uso del pivote @code{e}.
494 Ejemplos:
496 @example
497 (%i1) eq : [x^2 - y^2 - z^3 , x*y - z^2 - 5, x - y + z];
498 3 2 2 2
499 (%o1) [- z - y + x , - z + x y - 5, z - y + x]
500 (%i2) eliminate_using(eq,first(eq),z);
501 3 2 2 3 2
502 (%o2) @{y + (1 - 3 x) y + 3 x y - x - x ,
503 4 3 3 2 2 4
504 y - x y + 13 x y - 75 x y + x + 125@}
505 (%i3) eliminate_using(eq,second(eq),z);
506 2 2 4 3 3 2 2 4
507 (%o3) @{y - 3 x y + x + 5, y - x y + 13 x y - 75 x y + x
508 + 125@}
509 (%i4) eliminate_using(eq, third(eq),z);
510 2 2 3 2 2 3 2
511 (%o4) @{y - 3 x y + x + 5, y + (1 - 3 x) y + 3 x y - x - x @}
512 @end example
514 Para hacer uso de esta función, ejecútese @code{load("to_poly")}.
516 Véanse también @code{elim}, @code{elim_allbut}, @code{eliminate}
517 y @code{resultant}.
519 @end deffn
526 @deffn {Función} fourier_elim ([@var{eq1}, @var{eq2}, ...], [@var{var1}, @var{var}, ...])
528 La instrucción @code{fourier_elim([eq1,eq2,...], [var1,var2,...]} aplica el
529 algoritmo de eliminación de Fourier para resolver el sistema de inecuaciones
530 lineales @code{[eq1,eq2,...]} respecto de las variables @code{[var1,var2,...]}.
532 Ejemplos:
534 @example
535 (%i1) fourier_elim([y-x < 5, x - y < 7, 10 < y],[x,y]);
536 (%o1) [y - 5 < x, x < y + 7, 10 < y]
537 (%i2) fourier_elim([y-x < 5, x - y < 7, 10 < y],[y,x]);
538 (%o2) [max(10, x - 7) < y, y < x + 5, 5 < x]
539 @end example
541 Eliminando primero respecto de @math{x} y luego respecto de @math{y},
542 se obtienen límites inferior y superior para @math{x}
543 que dependen de @math{y}, y límites numéricos para @math{y}.
544 Si se eliminan en orden inverso, se obtienen los límites
545 de @math{y} en función de @math{x}, y los de @math{x} son números.
547 De ser necesario, @code{fourier_elim} devuelve una disyunción de listas
548 de ecuaciones:
550 @example
551 (%i3) fourier_elim([x # 6],[x]);
552 (%o3) [x < 6] or [6 < x]
553 @end example
555 Si no existe solución, @code{fourier_elim} devuelve @code{emptyset},
556 y si la solución son todos los reales, @code{fourier_elim} devuelve
557 @code{universalset}:
559 @example
560 (%i4) fourier_elim([x < 1, x > 1],[x]);
561 (%o4) emptyset
562 (%i5) fourier_elim([minf < x, x < inf],[x]);
563 (%o5) universalset
564 @end example
566 En caso de que las inecuaciones no sean lineales, @code{fourier_elim}
567 devuelve una lista de inecuaciones simplificadas:
569 @example
570 (%i6) fourier_elim([x^3 - 1 > 0],[x]);
571 2 2
572 (%o6) [1 < x, x + x + 1 > 0] or [x < 1, - (x + x + 1) > 0]
573 (%i7) fourier_elim([cos(x) < 1/2],[x]);
574 (%o7) [1 - 2 cos(x) > 0]
575 @end example
577 En lugar de una lista de inecuaciones, el primer argumento pasado a
578 @code{fourier_elim} puede ser una conjunción o disyunción lógica.
580 @example
581 (%i8) fourier_elim((x + y < 5) and (x - y >8),[x,y]);
582 3
583 (%o8) [y + 8 < x, x < 5 - y, y < - -]
584 2
585 (%i9) fourier_elim(((x + y < 5) and x < 1) or (x - y >8),[x,y]);
586 (%o9) [y + 8 < x] or [x < min(1, 5 - y)]
587 @end example
589 La función @code{fourier_elim} soporta los operadores de desigualdad
590 @code{<}, @code{<=}, @code{>}, @code{>=}, @code{#} y @code{=}.
592 La rutina de eliminación de Fourier dispone de un preprocesador que
593 convierte algunas inecuaciones no lineales formadas con las funciones
594 del valor absoluto, mínimo y máximo a inecuaciones
595 lineales. Además, el preprocesador admite algunas expresiones
596 que son productos o cocientes de términos lineales:
598 @example
599 (%i10) fourier_elim([max(x,y) > 6, x # 8, abs(y-1) > 12],[x,y]);
600 (%o10) [6 < x, x < 8, y < - 11] or [8 < x, y < - 11]
601 or [x < 8, 13 < y] or [x = y, 13 < y] or [8 < x, x < y, 13 < y]
602 or [y < x, 13 < y]
603 (%i11) fourier_elim([(x+6)/(x-9) <= 6],[x]);
604 (%o11) [x = 12] or [12 < x] or [x < 9]
605 (%i12) fourier_elim([x^2 - 1 # 0],[x]);
606 (%o12) [- 1 < x, x < 1] or [1 < x] or [x < - 1]
607 @end example
609 Para hacer uso de esta función, ejecútese @code{load("fourier_elim")}.
611 @end deffn
619 @deffn {Función} isreal_p (@var{e})
621 El predicado @code{isreal_p} devuelve @code{true} si @code{e} representa un
622 número real y @code{false} si no representa un punto de la recta; en cualquier
623 otro caso devuelve una forma nominal.
625 @example
626 (%i1) map('isreal_p, [-1, 0, %i, %pi]);
627 (%o1) [true, true, false, true]
628 @end example
630 Las variables de Maxima se interpretan como números reales:
632 @example
633 (%i2) isreal_p(x);
634 (%o2) true
635 @end example
637 La función @code{isreal_p} consulta los hechos almacenados en la base de datos:
638 @example
639 (%i3) declare(z,complex)$
641 (%i4) isreal_p(z);
642 (%o4) isreal_p(z)
643 @end example
645 Con frecuencia, @code{isreal_p} devuelve una forma nominal cuando debería
646 devolver @code{false}; por ejemplo, la función logarítmica no toma valores
647 reales en toda la recta real, por lo que @code{isreal_p(log(x))} debería
648 devolver @code{false}, sin embargo:
650 @example
651 (%i5) isreal_p(log(x));
652 (%o5) isreal_p(log(x))
653 @end example
655 Para hacer uso de esta función, ejecútese @code{load("to_poly_solve")}.
657 Véase también @code{complex_number_p}.
659 La función @code{isreal_p} es experimental; sus
660 especificaciones pueden cambiar y su funcionalidad puede incorporarse a otras funciones
661 de Maxima.
662 @end deffn
669 @deffn {Función} new_variable (@var{type})
671 Devuelve un símbolo de la forma @code{%[z,n,r,c,g]k},
672 siendo @code{k} un número entero. Los valores admisibles para @var{type}
673 son @code{integer}, @code{natural_number}, @code{real}, @code{natural_number}
674 y @code{general}. Por número natural se entiende @i{entero negativo}, de
675 manera que el ceero es un número natural.
677 Cuando @var{type} no es de ninguno de los tipos indicados más arriba,
678 @var{type} toma por defecto el valor @code{general}. Para enteros, números
679 naturales y números complejos, Maxima añade esta información a la base de
680 datos de forma automática.
682 @example
683 (%i1) map('new_variable,
684 ['integer, 'natural_number, 'real, 'complex, 'general]);
685 (%o1) [%z144, %n145, %r146, %c147, %g148]
686 (%i2) nicedummies(%);
687 (%o2) [%z0, %n0, %r0, %c0, %g0]
688 (%i3) featurep(%z0, 'integer);
689 (%o3) true
690 (%i4) featurep(%n0, 'integer);
691 (%o4) true
692 (%i5) is(%n0 >= 0);
693 (%o5) true
694 (%i6) featurep(%c0, 'complex);
695 (%o6) true
696 @end example
698 Es recomendable que al argumento de @code{new_variable} se le
699 aplique el operador de comilla simple para evitar su evaluación,
700 de esta manera se evitan errores como el siguiente:
702 @example
703 (%i7) integer : 12$
705 (%i8) new_variable(integer);
706 (%o8) %g149
707 (%i9) new_variable('integer);
708 (%o9) %z150
709 @end example
711 Para hacer uso de esta función, ejecútese @code{load("to_poly_solve")}.
713 Véase también @code{nicedummies}.
715 @end deffn
722 @deffn {Función} nicedummies
724 La función @code{nicedummies} reescribe los índices,
725 comenzando por cero, de las variables de una expresión qua hayan
726 sido introducidas por @code{new_variable}:
728 @example
729 (%i1) new_variable('integer) + 52 * new_variable('integer);
730 (%o1) 52 %z136 + %z135
731 (%i2) new_variable('integer) - new_variable('integer);
732 (%o2) %z137 - %z138
733 (%i3) nicedummies(%);
734 (%o3) %z0 - %z1
735 @end example
737 Para hacer uso de esta función, ejecútese @code{load("to_poly_solve")}.
739 Véase también @code{new_variable}.
741 @end deffn
747 @deffn {Función} parg (@var{x})
749 La función @code{parg} es una versión con capacidades simplificadoras
750 de la función de argumento complejo @code{carg}:
752 @example
753 (%i1) map('parg,[1,1+%i,%i, -1 + %i, -1]);
754 %pi %pi 3 %pi
755 (%o1) [0, ---, ---, -----, %pi]
756 4 2 4
757 @end example
759 Si el argumento pasado a la función @code{parg} no es una constante,
760 se devolverá una forma nominal:
762 @example
763 (%i2) parg(x + %i * sqrt(x));
764 (%o2) parg(x + %i sqrt(x))
765 @end example
767 Si @code{sign} detecta que la entrada es un número real negativo o
768 positivo, @code{parg} devuelve una forma no nominal aunque la entrada
769 no sea una constante:
771 @example
772 (%i3) parg(abs(x));
773 (%o3) 0
774 (%i4) parg(-x^2-1);
775 (%o4) %pi
776 @end example
778 La función @code{sign} suele ignorar las variables declaradas complejas
779 (@code{declare(x,complex)}); en tales casos, @code{parg}
780 puede retornar valores incorrectos:
782 @example
783 (%i1) declare(x,complex)$
785 (%i2) parg(x^2 + 1);
786 (%o2) 0
787 @end example
789 Para hacer uso de esta función, ejecútese @code{load("to_poly_solve")}.
791 Véanse también @code{carg}, @code{isreal_p}.
793 @end deffn
800 @deffn {Función} real_imagpart_to_conjugate (@var{e})
802 La función @code{real_imagpart_to_conjugate} reemplaza todas las
803 llamadas a @code{realpart} y @code{imagpart} presentes en una expresión
804 por llamadas a @code{conjugate}, obteniendo otra expresión equivalente:
806 @example
807 (%i1) declare(x, complex)$
809 (%i2) real_imagpart_to_conjugate(realpart(x) + imagpart(x) = 3);
810 conjugate(x) + x %i (x - conjugate(x))
811 (%o2) ---------------- - --------------------- = 3
812 2 2
813 @end example
815 Para hacer uso de esta función, ejecútese @code{load("to_poly_solve")}.
817 @end deffn
823 @deffn {Función} rectform_log_if_constant (@var{e})
825 La función @code{rectform_log_if_constant} convierte todos los términos
826 de la forma @code{log(c)} a @code{rectform(log(c))}, siendo @code{c}
827 una expresión constante o declarada como tal.
829 @example
830 (%i1) rectform_log_if_constant(log(1-%i) - log(x - %i));
831 log(2) %i %pi
832 (%o1) - log(x - %i) + ------ - ------
833 2 4
834 (%i2) declare(a,constant, b,constant)$
836 (%i3) rectform_log_if_constant(log(a + %i*b));
837 2 2
838 log(b + a )
839 (%o3) ------------ + %i atan2(b, a)
840 2
841 @end example
843 Para hacer uso de esta función, ejecútese @code{load("to_poly_solve")}.
845 @end deffn
851 @deffn {Función} simp_inequality (@var{e})
853 La función @code{simp_inequality} aplica ciertas simplificaciones
854 a conjunciones y disyunciones de inecuaciones.
856 @b{Limitaciones} La función @code{simp_inequality} está limitada en
857 al menos dos aspectos; en primer lugar, las simplificaciones son locales:
859 @example
860 (%i1) simp_inequality((x > minf) %and (x < 0));
861 (%o2) (x>1) %and (x<1)
862 @end example
864 En segundo lugar, @code{simp_inequality} no tiene en cuenta los hechos de la
865 base de datos:
867 @example
868 (%i2) assume(x > 0)$
870 (%i3) simp_inequality(x > 0);
871 (%o3) x > 0
872 @end example
874 Para hacer uso de esta función, ejecútese @code{load("to_poly_solve")}.
876 @end deffn
882 @deffn {Función} standardize_inverse_trig (@var{e})
884 Esta función aplica las identidades @code{cot(x) = atan(1/x)} y
885 @code{acsc(x) = asin(1/x)} y similares con @code{asec}, @code{acoth}
886 y @code{acsch}. Consúltese Abramowitz y Stegun, ecuaciones
887 4.4.6 a 4.4.8 y 4.6.4 a 4.6.6.
889 Para hacer uso de esta función, ejecútese @code{load("to_poly_solve")}.
891 @end deffn
897 @deffn {Función} subst_parallel (@var{l}, @var{e})
899 Dada la ecuación o lista de ecuaciones @var{l} y la expresión
900 @var{e}, sustituye @i{en paralelo} en @var{e} los miembros izquierdos
901 de las ecuaciones por los derechos:
903 @example
904 (%i1) load("to_poly_solve")$
906 (%i2) subst_parallel([x=y,y=x], [x,y]);
907 (%o2) [y, x]
908 @end example
910 Compárese el resultado anterior con las sustituciones hechas en serie:
912 @example
913 (%i3) subst([x=y,y=x],[x,y]);
914 (%o3) [x, x]
915 @end example
917 La función @code{subst_parallel} es similar a @code{sublis}, excepto por
918 el hecho de que @code{subst_parallel} permite la sustitución de expresiones
919 no atómicas:
921 @example
922 (%i4) subst_parallel([x^2 = a, y = b], x^2 * y);
923 (%o4) a b
924 (%i5) sublis([x^2 = a, y = b], x^2 * y);
926 2
927 sublis: left-hand side of equation must be a symbol; found: x
928 -- an error. To debug this try: debugmode(true);
929 @end example
931 Las sustituciones hechas por @code{subst_parallel} son literales, no semánticas,
932 por lo que @code{subst_parallel} no reconoce que @math{x * y} sea una subexpresión
933 de @math{x^2 * y}:
935 @example
936 (%i6) subst_parallel([x * y = a], x^2 * y);
937 2
938 (%o6) x y
939 @end example
941 La función @code{subst_parallel} realiza todas las sustituciones
942 antes de proceder a la simplificación, lo que permite sustituciones
943 en expresiones condicionales que podrín producir
944 errores en caso de simplificar antes de sustituir:
946 @example
947 (%i7) subst_parallel([x = 0], %if(x < 1, 5, log(x)));
948 (%o7) 5
949 (%i8) subst([x = 0], %if(x < 1, 5, log(x)));
951 log: encountered log(0).
952 -- an error. To debug this try: debugmode(true);
953 @end example
955 Para hacer uso de esta función, ejecútese @code{load("to_poly_solve_extra.lisp")}.
957 Véanse también @code{subst}, @code{sublis} y @code{ratsubst}.
959 @end deffn
966 @deffn {Función} to_poly (@var{e}, @var{l})
968 La función @code{to_poly} intenta convertir la ecuación @var{e}
969 en un sistema de polinomios, junto con restricciones en forma de
970 desigualdades. Las soluciones del sistema polinómico que cumplan
971 las restricciones son, a su vez, las soluciones de la ecuación @var{e}.
972 Dicho de manera informal, @code{to_poly} intenta pasar a forma de
973 polinomio la ecuación @var{e}; un ejemplo ayudará a aclarar su
974 comportamiento:
976 @example
977 (%i1) load("to_poly_solve")$
979 (%i2) to_poly(sqrt(x) = 3, [x]);
980 2
981 (%o2) [[%g130 - 3, x = %g130 ],
982 %pi %pi
983 [- --- < parg(%g130), parg(%g130) <= ---], []]
984 2 2
985 @end example
987 Las condiciones @code{-%pi/2<parg(%g130),parg(%g130)<=%pi/2} dicen que
988 @code{%g130} está en el rango de la función radical; cuando eso se
989 cumpla, el conjunto de ecuaciones de @code{sqrt(x) = 3} coincide con
990 el de @code{%g130-3,x=%g130^2}.
992 Para convertir a forma polinómica una expresión trigonométrica,
993 es necesario introducir una sustitución no algebraica; tal sustitución
994 se devuelve en la tercera lista de la respuesta de @code{to_poly}:
996 @example
997 (%i3) to_poly(cos(x),[x]);
998 2 %i x
999 (%o3) [[%g131 + 1], [2 %g131 # 0], [%g131 = %e ]]
1000 @end example
1002 Los términos constantes no se transforman a polinomios a menos que el
1003 número uno se introduzca en la lista de variables:
1005 @example
1006 (%i4) to_poly(x = sqrt(5),[x]);
1007 (%o4) [[x - sqrt(5)], [], []]
1008 (%i5) to_poly(x = sqrt(5),[1,x]);
1009 2
1010 (%o5) [[x - %g132, 5 = %g132 ],
1011 %pi %pi
1012 [- --- < parg(%g132), parg(%g132) <= ---], []]
1013 2 2
1014 @end example
1016 Para generar un polinomio que tenga @math{sqrt(5) + sqrt(7)} como
1017 raíz puede hacerse lo siguiente:
1019 @example
1020 (%i6) first(elim_allbut(first(to_poly(x = sqrt(5) + sqrt(7),
1021 [1,x])), [x]));
1022 4 2
1023 (%o6) [x - 24 x + 4]
1024 @end example
1026 Para hacer uso de esta función, ejecútese @code{load("to_poly")}.
1028 Véase también @code{to_poly_solve}.
1030 @end deffn
1037 @deffn {Función} to_poly_solve (@var{e}, @var{l}, [options])
1039 La función @code{to_poly_solve} intenta resolver las ecuaciones @var{e}
1040 de incógnitas @var{l}. El argumento @var{e} puede ser una única ecuación,
1041 o una lista o conjunto de ecuaciones; de forma similar, @var{l} puede ser un
1042 símbolo o una lista o conjunto de símbolos. Cuando
1043 uno de los elementos de @var{e} no sea una igualdad, como @math{x^2 -1},
1044 se supodrá que es igual a cero.
1046 La estrategia básica de @code{to_poly_solve} consiste en convertir la entrada en un
1047 polinomio y luego invocar a la función @code{algsys}. Internamente, @code{to_poly_solve}
1048 asigna a @code{algexact} el valor @code{true}. Para cambiar el valor de @code{algexact},
1049 debe anñadirse @code{'algexact=false} a la lista de argumentos de @code{to_poly_solve}.
1051 Cuando @code{to_poly_solve} consigue determinar el conjunto de soluciones, cada
1052 miembro del conjunto de soluciones es una lista en un objeto @code{%union}:
1054 @example
1055 (%i1) load("to_poly_solve")$
1057 (%i2) to_poly_solve(x*(x-1) = 0, x);
1058 (%o2) %union([x = 0], [x = 1])
1059 @end example
1061 Cuando @code{to_poly_solve} es incapaz de determinar el conjunto de soluciones,
1062 devuelve una forma nominal de @code{%solve} y muestra un mensaje de aviso:
1064 @example
1065 (%i3) to_poly_solve(x^k + 2* x + 1 = 0, x);
1067 Nonalgebraic argument given to 'to_poly'
1068 unable to solve
1069 k
1070 (%o3) %solve([x + 2 x + 1 = 0], [x])
1071 @end example
1073 A veces se puede obtener la solución haciendo una sustitución en @code{%solve}:
1075 @example
1076 (%i4) subst(k = 2, %);
1077 (%o4) %union([x = - 1])
1078 @end example
1080 Especialmente en el caso de las funciones trigonométricas, los resultados pueden
1081 incorporar números enteros arbitrarios de la forma @code{%zXXX}, siendo @code{XXX}
1082 un índice entero:
1084 @example
1085 (%i5) to_poly_solve(sin(x) = 0, x);
1086 (%o5) %union([x = 2 %pi %z33 + %pi], [x = 2 %pi %z35])
1087 @end example
1089 Para inicializar los índices, hágase uso de @code{nicedummies}:
1091 @example
1092 (%i6) nicedummies(%);
1093 (%o6) %union([x = 2 %pi %z0 + %pi], [x = 2 %pi %z1])
1094 @end example
1096 En ocasiones, se introducen números complejos arbitrarios de la forma
1097 @code{%cXXX}, o reales de la forma @code{%rXXX}. La función @code{nicedummies}
1098 inicializa estos identificadores a cero.
1100 También a veces, la solución incorpora versiones simplificadas de los
1101 operadores lógicos @code{%and}, @code{%or} y @code{%if}, que representan, respectivamente,
1102 la conjunción, la disyunción y la implicación:
1104 @example
1105 (%i7) sol : to_poly_solve(abs(x) = a, x);
1106 (%o7) %union(%if(isnonnegative_p(a), [x = - a], %union()),
1107 %if(isnonnegative_p(a), [x = a], %union()))
1108 (%i8) subst(a = 42, sol);
1109 (%o8) %union([x = - 42], [x = 42])
1110 (%i9) subst(a = -42, sol);
1111 (%o9) %union()
1112 @end example
1114 El conjunto vacío se representa por @code{%union}.
1116 La función @code{to_poly_solve} es capaz de resolver algunas ecuaciones
1117 con potencias racionales, potencias no racionales, valores absolutos, funciones
1118 trigonométricas y funciones del mínimo y del máximo.
1119 También puede resolver algunas ecuaciones resolubles en términos de la
1120 función W de Lambert:
1122 @example
1123 (%i1) load("to_poly_solve")$
1125 (%i2) to_poly_solve(set(max(x,y) = 5, x+y = 2), set(x,y));
1126 (%o2) %union([x = - 3, y = 5], [x = 5, y = - 3])
1127 (%i3) to_poly_solve(abs(1-abs(1-x)) = 10,x);
1128 (%o3) %union([x = - 10], [x = 12])
1129 (%i4) to_poly_solve(set(sqrt(x) + sqrt(y) = 5, x + y = 10),
1130 set(x,y));
1131 3/2 3/2
1132 5 %i - 10 5 %i + 10
1133 (%o4) %union([x = - ------------, y = ------------],
1134 2 2
1135 3/2 3/2
1136 5 %i + 10 5 %i - 10
1137 [x = ------------, y = - ------------])
1138 2 2
1139 (%i5) to_poly_solve(cos(x) * sin(x) = 1/2,x,
1140 'simpfuncs = ['expand, 'nicedummies]);
1141 %pi
1142 (%o5) %union([x = %pi %z0 + ---])
1143 4
1144 (%i6) to_poly_solve(x^(2*a) + x^a + 1,x);
1145 2 %i %pi %z81
1146 -------------
1147 1/a a
1148 (sqrt(3) %i - 1) %e
1149 (%o6) %union([x = -----------------------------------],
1150 1/a
1151 2
1152 2 %i %pi %z83
1153 -------------
1154 1/a a
1155 (- sqrt(3) %i - 1) %e
1156 [x = -------------------------------------])
1157 1/a
1158 2
1159 (%i7) to_poly_solve(x * exp(x) = a, x);
1160 (%o7) %union([x = lambert_w(a)])
1161 @end example
1163 En el caso de inecuaciones lineales, @code{to_poly_solve} aplica automáticamente
1164 la eliminación de Fourier:
1166 @example
1167 (%i8) to_poly_solve([x + y < 1, x - y >= 8], [x,y]);
1168 7
1169 (%o8) %union([x = y + 8, y < - -],
1170 2
1171 7
1172 [y + 8 < x, x < 1 - y, y < - -])
1173 2
1174 @end example
1176 Los argumentos opcionales deben tener forma de ecuación; generalmente, el orden
1177 de estas opciones no reviste importancia.
1179 @itemize
1181 @item @code{simpfuncs = l}, siendo @code{l} una lista de funciones,
1182 aplica la composición de los elementos de @code{l} a cada solución:
1183 @example
1184 (%i1) to_poly_solve(x^2=%i,x);
1185 1/4 1/4
1186 (%o1) %union([x = - (- 1) ], [x = (- 1) ])
1187 (%i2) to_poly_solve(x^2= %i,x, 'simpfuncs = ['rectform]);
1188 %i 1 %i 1
1189 (%o2) %union([x = - ------- - -------], [x = ------- + -------])
1190 sqrt(2) sqrt(2) sqrt(2) sqrt(2)
1191 @end example
1193 A veces, una simplificación puede anular una simplificación anterior:
1194 @example
1195 (%i3) to_poly_solve(x^2=1,x);
1196 (%o3) %union([x = - 1], [x = 1])
1197 (%i4) to_poly_solve(x^2= 1,x, 'simpfuncs = [polarform]);
1198 %i %pi
1199 (%o4) %union([x = 1], [x = %e ]
1200 @end example
1202 Maxima no comprueba que los elementos de la lista de funciones @code{l} sean
1203 todos simplificaciones:
1204 @example
1205 (%i5) to_poly_solve(x^2 = %i,x, 'simpfuncs = [lambda([s],s^2)]);
1206 (%o5) %union([x = %i])
1207 @end example
1209 Para convertir cada solución a real de doble precisión hágase uso de
1210 @code{simpfunc = ['dfloat]}:
1211 @example
1212 (%i6) to_poly_solve(x^3 +x + 1 = 0,x,
1213 'simpfuncs = ['dfloat]), algexact : true;
1214 (%o6) %union([x = - .6823278038280178],
1215 [x = .3411639019140089 - 1.161541399997251 %i],
1216 [x = 1.161541399997251 %i + .3411639019140089])
1217 @end example
1219 @item Con la opción @code{use_grobner = true} se aplica la función
1220 @code{poly_reduced_grobner} a las ecuaciones antes de intentar resolverlas.
1221 En primer lugar, esta opción proporciona una manera de soslayar algunas
1222 debilidades de la función @code{algsys}:
1224 @example
1225 (%i7) to_poly_solve([x^2+y^2=2^2,(x-1)^2+(y-1)^2=2^2],[x,y],
1226 'use_grobner = true);
1227 sqrt(7) - 1 sqrt(7) + 1
1228 (%o7) %union([x = - -----------, y = -----------],
1229 2 2
1230 sqrt(7) + 1 sqrt(7) - 1
1231 [x = -----------, y = - -----------])
1232 2 2
1233 (%i8) to_poly_solve([x^2+y^2=2^2,(x-1)^2+(y-1)^2=2^2],[x,y]);
1234 (%o8) %union()
1235 @end example
1237 @item @code{maxdepth = k}, siendo @code{k} un positivo entero, controla el nivel
1238 de recursión. El valor por defecto es cinco. Cuando se excede el nivel de recursión
1239 se obtiene un mensaje de error:
1240 @example
1241 (%i9) to_poly_solve(cos(x) = x,x, 'maxdepth = 2);
1243 Unable to solve
1244 Unable to solve
1245 (%o9) %solve([cos(x) = x], [x], maxdepth = 2)
1246 @end example
1248 @item Con @code{parameters = l}, siendo @code{l} una lista de símbolos,
1249 el programa intenta encontrar una solución válida para todos los miembros de la
1250 lista @code{l}:
1251 @example
1252 (%i10) to_poly_solve(a * x = x, x);
1253 (%o10) %union([x = 0])
1254 (%i11) to_poly_solve(a * x = x, x, 'parameters = [a]);
1255 (%o11) %union(%if(a - 1 = 0, [x = %c111], %union()),
1256 %if(a - 1 # 0, [x = 0], %union()))
1257 @end example
1258 En @code{(%o2)}, el programa introduce una variable ficticia; para reinicializarla,
1259 úsese la función @code{nicedummies}:
1260 @example
1261 (%i12) nicedummies(%);
1262 (%o12) %union(%if(a - 1 = 0, [x = %c0], %union()),
1263 %if(a - 1 # 0, [x = 0], %union()))
1264 @end example
1265 @end itemize
1267 @code{to_poly_solve} utiliza información almacenada en el array @code{one_to_one_reduce}
1268 para resolver ecuaciones de la forma @math{f(a) = f(b)}. La asignación
1269 @code{one_to_one_reduce['f,'f] : lambda([a,b], a=b)} le dice a @code{to_poly_solve}
1270 que el conjunto de soluciones de @math{f(a) = f(b)} es igual al conjunto de soluciones
1271 de @math{a=b}:
1272 @example
1273 (%i13) one_to_one_reduce['f,'f] : lambda([a,b], a=b)$
1275 (%i14) to_poly_solve(f(x^2-1) = f(0),x);
1276 (%o14) %union([x = - 1], [x = 1])
1277 @end example
1279 De forma más general, la asignación
1280 @code{one_to_one_reduce['f,'g] : lambda([a,b], w(a,b)=0} le indica a
1281 @code{to_poly_solve} que el cojunto de soluciones de @math{f(a) = f(b)}
1282 es igual al conjunto de soluciones de @math{w(a,b) = 0}:
1283 @example
1284 (%i15) one_to_one_reduce['f,'g] : lambda([a,b], a = 1 + b/2)$
1286 (%i16) to_poly_solve(f(x) - g(x),x);
1287 (%o16) %union([x = 2])
1288 @end example
1290 Además, @code{to_poly_solve} utiliza información almacenada en el array
1291 @code{function_inverse} para resolver ecuaciones de la forma @math{f(a) = b}.
1292 La asignación @code{function_inverse['f] : lambda([s], g(s))} le dice a
1293 @code{to_poly_solve} que el conjunto de soluciones de @math{f(x) = b} es
1294 igual al conjunto de soluciones de @math{x = g(b)}:
1295 @example
1296 (%i17) function_inverse['Q] : lambda([s], P(s))$
1298 (%i18) to_poly_solve(Q(x-1) = 2009,x);
1299 (%o18) %union([x = P(2009) + 1])
1300 (%i19) function_inverse['G] : lambda([s], s+new_variable(integer));
1301 (%o19) lambda([s], s + new_variable(integer))
1302 (%i20) to_poly_solve(G(x - a) = b,x);
1303 (%o20) %union([x = b + a + %z125])
1304 @end example
1306 @b{Notas}
1308 @itemize
1310 @item Las incógnitas a resolver no necesitan ser símbolos, lo cual es
1311 cierto cuando @code{fullratsubst} es capaz de hacer las sustituciones de forma apropiadas:
1312 @example
1313 (%i1) to_poly_solve([x^2 + y^2 + x * y = 5, x * y = 8],
1314 [x^2 + y^2, x * y]);
1315 2 2
1316 (%o1) %union([x y = 8, y + x = - 3])
1317 @end example
1319 @item Cuando las ecuaciones involucran conjugados de complejos, el programa
1320 añade automáticamente las ecuaciones conjugadas:
1321 @example
1322 (%i1) declare(x,complex)$
1324 (%i2) to_poly_solve(x + (5 + %i) * conjugate(x) = 1, x);
1325 %i + 21
1326 (%o2) %union([x = - -----------])
1327 25 %i - 125
1328 (%i3) declare(y,complex)$
1330 (%i4) to_poly_solve(set(conjugate(x) - y = 42 + %i,
1331 x + conjugate(y) = 0), set(x,y));
1332 %i - 42 %i + 42
1333 (%o4) %union([x = - -------, y = - -------])
1334 2 2
1335 @end example
1337 @item Cuando las funciones involucran valores absolutos, @code{to_poly_solve}
1338 consulta los hechos de la base de datos para decidir si los argumentos de los valores
1339 absolutos son números complejos:
1340 @example
1341 (%i1) to_poly_solve(abs(x) = 6, x);
1342 (%o1) %union([x = - 6], [x = 6])
1343 (%i2) declare(z,complex)$
1345 (%i3) to_poly_solve(abs(z) = 6, z);
1346 (%o3) %union(%if((%c11 # 0) %and (%c11 conjugate(%c11) - 36 =
1347 0), [z = %c11], %union()))
1348 @end example
1350 Esta es la única situación en la que @code{to_poly_solve} consulta la base de
1351 datos; si una incógnita se declara, por ejemplo, como entero, @code{to_poly_solve} lo ignora.
1352 @end itemize
1354 Para hacer uso de esta función, ejecútese @code{load("to_poly_solve")}.
1356 Véase también @code{algexact}, @code{resultant}, @code{algebraic} y @code{to_poly}.
1358 @end deffn