| blob | 3ec8248706aa73e9d79cfc4a67bff8d29a831f7a |
1 @c English version 2011-08-04
2 @menu
3 * Introducción a los polinomios::
4 * Funciones y variables para polinomios::
5 @end menu
7 @node Introducción a los polinomios, Funciones y variables para polinomios, Polinomios, Polinomios
8 @section Introducción a los polinomios
10 Los polinomios se almacenan en Maxima, bien en un formato general, bien en una forma conocida como canónica (Cannonical Rational Expressions, CRE). La última corresponde al formato estándar y se utiliza internamente para realizar operaciones como @code{factor}, @code{ratsimp} y demás.
12 Las Expresiones Racionales Canónicas (CRE) constituyen un tipo de representación
13 que es especialmente apropiado para expandir polinomios y funciones racionales
14 (así como para polinomios parcialmente factorizados y funciones racionales cuando a la variable @code{ratfac} se le asigna el valor @code{true}). En esta forma CRE las variables se ordenan de mayor a menor. Los polinomios se representan recursivamente como una lista compuesta por la variable principal seguida por una serie de pares de expresiones,
15 una por cada término del polinomio. El primer miembro
16 de cada par es el exponente de la variable principal en ese término y el
17 segundo miembro es el coeficiente de ese término, el cual puede ser un número o
18 un polinomio en otra variable representado también de esta forma. Así,
19 la parte principal de la forma CRE de 3*X^2-1 es (X 2 3 0 -1) y la de
20 2*X*Y+X-3 es (Y 1 (X 1 2) 0 (X 1 1 0 -3)) asumiendo que Y es la variable principal, y será (X 1 (Y 1 2 0 1) 0 -3) si se asume que la variable principal es X. Qué variable se considera "principal" se determinada en orden alfabético inverso.
21 Las "variables" de la expresión CRE no son necesariamente atómicas. De hecho
22 cualquier subexpresión cuyo operador principal no es + - * / ni ^ con potencia entera
23 puede ser considerada como una "variable" de la expresión (en forma CRE) en
24 el cual aparezca. Por ejemplo las variables CRE de la expresión
25 X+SIN(X+1)+2*SQRT(X)+1 son X, SQRT(X) y SIN(X+1). Si el usuario no
26 especifica una ordenación de las variables mediante la función @code{ratvars}
27 Maxima escogerá una alfabéticamente. En general, laa CRE representan expresiones
28 racionales, esto es, fracciones de polinomios, donde el numerador y
29 el denominador no tienen factores comunes, siendo el denominador es
30 positivo. La forma interna es esencialmente un par de polinomios (el
31 numerador y el denominador) precedida por la lista de variables ordenadas. Si
32 una expresión a ser mostrada está en la forma CRE o contiene alguna
33 subexpresión en forma de CRE, el simbolo /R/ será seguido por la etiqueta de la línea de comando.
34 Véase la función @code{rat} para convertir una expresión a la forma CRE. Una
35 extensión de la forma CRE se utiliza para la representación de las series de Taylor. La
36 noción de una expresión racional se extiende de manera que los exponentes de las
37 variables pueden ser números racionales positivos o negativos y no sólo
38 enteros positivos y los coeficientes pueden ser también expresiones
39 racionales y no sólo polinomios. Estas expresiones se representan internamente por una forma polinomial recursiva que es similar a la forma CRE, pero que la generaliza, aportando información adicional como el grado de truncamiento. Como con la forma CRE, el símbolo /T/ sigue la etiqueta de línea de comando en la que se encuentra dicha expresión.
48 @node Funciones y variables para polinomios, , Introducción a los polinomios, Polinomios
49 @section Funciones y variables para polinomios
51 @defvr {Variable opcional} algebraic
52 Valor por defecto: @code{false}
54 La variable @code{algebraic} debe valer @code{true} para que se pueda hacer la simplificación de enteros algebraicos.
56 @end defvr
58 @defvr {Variable opcional} berlefact
59 Valor por defecto: @code{true}
61 Si @code{berlefact} vale @code{false} entonces se utiliza el algoritmo de factorización de Kronecker, en caso contrario se utilizará el algoritmo de Berlekamp, que es el que se aplica por defecto.
63 @end defvr
65 @deffn {Función} bezout (@var{p1}, @var{p2}, @var{x})
66 Es una alternativa a la función @code{resultant}. Devuelve una matriz.
68 @example
69 (%i1) bezout(a*x+b, c*x^2+d, x);
70 [ b c - a d ]
71 (%o1) [ ]
72 [ a b ]
73 (%i2) determinant(%);
74 2 2
75 (%o2) a d + b c
76 (%i3) resultant(a*x+b, c*x^2+d, x);
77 2 2
78 (%o3) a d + b c
79 @end example
80 @end deffn
82 @deffn {Función} bothcoef (@var{expr}, @var{x})
83 Devuelve una lista cuyo primer miembro es el coeficiente de @var{x} en @var{expr} (que coincide con el que devuelve @code{ratcoef} si @var{expr} está en formato CRE, o el que devuelve @code{coeff} si no está en este formato) y cuyo segundo miembro es la parte restante de @var{expr}. Esto es, @code{[A, B]} donde @code{@var{expr} = A*@var{x} + B}.
85 Ejemplo:
86 @c FOLLOWING GENERATED FROM THESE EXPRESSIONS
87 @c islinear (expr, x) := block ([c],
88 @c c: bothcoef (rat (expr, x), x),
89 @c is (freeof (x, c) and c[1] # 0))$
90 @c islinear ((r^2 - (x - r)^2)/x, x);
92 @example
93 (%i1) islinear (expr, x) := block ([c],
94 c: bothcoef (rat (expr, x), x),
95 is (freeof (x, c) and c[1] # 0))$
96 (%i2) islinear ((r^2 - (x - r)^2)/x, x);
97 (%o2) true
98 @end example
100 @end deffn
102 @deffn {Función} coeff (@var{expr}, @var{x}, @var{n})
103 @deffnx {Función} coeff (@var{expr}, @var{x})
104 Devuelve el coeficiente de @code{@var{x}^@var{n}} en @var{expr},
105 donde @var{expr} es un polinomio o monomio en @var{x}.
107 @code{coeff(@var{expr}, @var{x}^@var{n})} es equivalente a
108 @code{coeff(@var{expr}, @var{x}, @var{n})}.
109 @code{coeff(@var{expr}, @var{x}, 0)} devuelve el resto de @var{expr},
110 el cual no contiene a @var{x}. En caso de omisión, se entiende
111 que @var{n} es igual a 1.
113 @var{x} puede ser tanto el nombre de una variable simple como el
114 de una variable con subíndice, o también una
115 subexpresión de @var{expr} que contenga un operador junto con
116 todos sus argumentos.
118 En ocasiones, es posible calcular los coeficientes de expresiones
119 equivalentes a @var{expr} aplicando @code{expand} o @code{factor}.
120 @code{coeff} no aplica ni @code{expand}, ni @code{factor}, ni ninguna otra
121 función.
123 @code{coeff} se distribuye sobre listas, matrices y ecuaciones.
125 Ejemplos:
127 @code{coeff} devuelve el coeficiente de @code{@var{x}^@var{n}} en @var{expr}.
129 @c ===beg===
130 @c coeff (b^3*a^3 + b^2*a^2 + b*a + 1, a^3);
131 @c ===end===
132 @example
133 (%i1) coeff (b^3*a^3 + b^2*a^2 + b*a + 1, a^3);
134 3
135 (%o1) b
136 @end example
138 @code{coeff(@var{expr}, @var{x}^@var{n})} es equivalente
139 a @code{coeff(@var{expr}, @var{x}, @var{n})}.
141 @c ===beg===
142 @c coeff (c[4]*z^4 - c[3]*z^3 - c[2]*z^2 + c[1]*z, z, 3);
143 @c coeff (c[4]*z^4 - c[3]*z^3 - c[2]*z^2 + c[1]*z, z^3);
144 @c ===end===
145 @example
146 (%i1) coeff (c[4]*z^4 - c[3]*z^3 - c[2]*z^2 + c[1]*z, z, 3);
147 (%o1) - c
148 3
149 (%i2) coeff (c[4]*z^4 - c[3]*z^3 - c[2]*z^2 + c[1]*z, z^3);
150 (%o2) - c
151 3
152 @end example
154 @code{coeff(@var{expr}, @var{x}, 0)} devuelve el resto de @var{expr},
155 el cual no contiene a @var{x}.
157 @c ===beg===
158 @c coeff (a*u + b^2*u^2 + c^3*u^3, b, 0);
159 @c ===end===
160 @example
161 (%i1) coeff (a*u + b^2*u^2 + c^3*u^3, b, 0);
162 3 3
163 (%o1) c u + a u
164 @end example
166 @var{x} puede ser tanto el nombre de una variable simple como el
167 de una variable con subíndice, o también una
168 subexpresión de @var{expr} que contenga un operador junto con
169 todos sus argumentos.
171 @c ===beg===
172 @c coeff (h^4 - 2*%pi*h^2 + 1, h, 2);
173 @c coeff (v[1]^4 - 2*%pi*v[1]^2 + 1, v[1], 2);
174 @c coeff (sin(1 + x)*sin(x) + sin(1 + x)^3*sin(x)^3, sin(1 + x)^3);
175 @c coeff ((d - a)^2*(b + c)^3 + (a + b)^4*(c - d), a + b, 4);
176 @c ===end===
177 @example
178 (%i1) coeff (h^4 - 2*%pi*h^2 + 1, h, 2);
179 (%o1) - 2 %pi
180 (%i2) coeff (v[1]^4 - 2*%pi*v[1]^2 + 1, v[1], 2);
181 (%o2) - 2 %pi
182 (%i3) coeff (sin(1 + x)*sin(x) + sin(1 + x)^3*sin(x)^3, sin(1 + x)^3);
183 3
184 (%o3) sin (x)
185 (%i4) coeff ((d - a)^2*(b + c)^3 + (a + b)^4*(c - d), a + b, 4);
186 (%o4) c - d
187 @end example
189 @code{coeff} no aplica ni @code{expand}, ni @code{factor}, ni ninguna otra
190 función.
192 @c ===beg===
193 @c coeff (c*(a + b)^3, a);
194 @c expand (c*(a + b)^3);
195 @c coeff (%, a);
196 @c coeff (b^3*c + 3*a*b^2*c + 3*a^2*b*c + a^3*c, (a + b)^3);
197 @c factor (b^3*c + 3*a*b^2*c + 3*a^2*b*c + a^3*c);
198 @c coeff (%, (a + b)^3);
199 @c ===end===
200 @example
201 (%i1) coeff (c*(a + b)^3, a);
202 (%o1) 0
203 (%i2) expand (c*(a + b)^3);
204 3 2 2 3
205 (%o2) b c + 3 a b c + 3 a b c + a c
206 (%i3) coeff (%, a);
207 2
208 (%o3) 3 b c
209 (%i4) coeff (b^3*c + 3*a*b^2*c + 3*a^2*b*c + a^3*c, (a + b)^3);
210 (%o4) 0
211 (%i5) factor (b^3*c + 3*a*b^2*c + 3*a^2*b*c + a^3*c);
212 3
213 (%o5) (b + a) c
214 (%i6) coeff (%, (a + b)^3);
215 (%o6) c
216 @end example
218 @code{coeff} se distribuye sobre listas, matrices y ecuaciones.
220 @c ===beg===
221 @c coeff ([4*a, -3*a, 2*a], a);
222 @c coeff (matrix ([a*x, b*x], [-c*x, -d*x]), x);
223 @c coeff (a*u - b*v = 7*u + 3*v, u);
224 @c ===end===
225 @example
226 (%i1) coeff ([4*a, -3*a, 2*a], a);
227 (%o1) [4, - 3, 2]
228 (%i2) coeff (matrix ([a*x, b*x], [-c*x, -d*x]), x);
229 @group
230 [ a b ]
231 (%o2) [ ]
232 [ - c - d ]
233 @end group
234 (%i3) coeff (a*u - b*v = 7*u + 3*v, u);
235 (%o3) a = 7
236 @end example
237 @end deffn
241 @deffn {Función} content (@var{p_1}, @var{x_1}, ..., @var{x_n})
242 Devuelve una lista cuyo primer miembro es el máximo común divisor de los coeficientes de los términos del polinomio @var{p_1} de variable @var{x_n} (este es el contenido) y cuyo segundo miembro es el polinomio @var{p_1} dividido por el contenido.
243 @c APPEARS TO WORK AS ADVERTISED -- ONLY x_n HAS ANY EFFECT ON THE RESULT
244 @c WHAT ARE THE OTHER VARIABLES x_1 THROUGH x_{n-1} FOR ??
246 Ejemplos:
247 @c FOLLOWING GENERATED FROM THESE EXPRESSIONS
248 @c content (2*x*y + 4*x^2*y^2, y);
250 @example
251 (%i1) content (2*x*y + 4*x^2*y^2, y);
252 2
253 (%o1) [2 x, 2 x y + y]
254 @end example
256 @end deffn
258 @deffn {Función} denom (@var{expr})
259 Devuelve el denominador de la expresión racional @var{expr}.
261 @end deffn
263 @deffn {Función} divide (@var{p_1}, @var{p_2}, @var{x_1}, ..., @var{x_n})
264 Calcula el cociente y el resto del polinomio @var{p_1} dividido por el polinomio @var{p_2}, siendo la variable principal @var{x_n}.
265 @c SPELL OUT THE PURPOSE OF THE OTHER VARIABLES
266 Las otras funciones son como en la función @code{ratvars}. El resultado es una lista cuyo primer miembro es el cociente y el segundo miembro el resto.
268 Ejemplos:
269 @c FOLLOWING GENERATED FROM THESE EXPRESSIONS
270 @c divide (x + y, x - y, x);
271 @c divide (x + y, x - y);
273 @example
274 (%i1) divide (x + y, x - y, x);
275 (%o1) [1, 2 y]
276 (%i2) divide (x + y, x - y);
277 (%o2) [- 1, 2 x]
278 @end example
280 @noindent
281 Nótese que @code{y} es la variable principal en el segundo ejemplo.
283 @end deffn
285 @deffn {Función} eliminate ([@var{eqn_1}, ..., @var{eqn_n}], [@var{x_1}, ..., @var{x_k}])
286 Elimina variables de ecuaciones (o de expresiones que se supone valen cero) tomando resultantes sucesivas. Devuelve una lista con @code{@var{n} - @var{k}} expresiones y @var{k} variables @var{x_1}, ..., @var{x_k} eliminadas. Primero se elimina @var{x_1} dando @code{@var{n} - 1} expresiones, después se elimina @code{x_2}, etc. Si @code{@var{k} = @var{n}} entonces se devuelve una lista con una única expresión, libre de las variables @var{x_1}, ..., @var{x_k}. En este caso se llama a @code{solve} para resolver la última resultante para la última variable.
288 Ejemplo:
289 @c FOLLOWING GENERATED FROM THESE EXPRESSIONS
290 @c expr1: 2*x^2 + y*x + z;
291 @c expr2: 3*x + 5*y - z - 1;
292 @c expr3: z^2 + x - y^2 + 5;
293 @c eliminate ([expr3, expr2, expr1], [y, z]);
295 @example
296 (%i1) expr1: 2*x^2 + y*x + z;
297 2
298 (%o1) z + x y + 2 x
299 (%i2) expr2: 3*x + 5*y - z - 1;
300 (%o2) - z + 5 y + 3 x - 1
301 (%i3) expr3: z^2 + x - y^2 + 5;
302 2 2
303 (%o3) z - y + x + 5
304 (%i4) eliminate ([expr3, expr2, expr1], [y, z]);
305 8 7 6 5 4
306 (%o4) [7425 x - 1170 x + 1299 x + 12076 x + 22887 x
308 3 2
309 - 5154 x - 1291 x + 7688 x + 15376]
310 @end example
312 @end deffn
314 @deffn {Función} ezgcd (@var{p_1}, @var{p_2}, @var{p_3}, ...)
315 Devuelve una lista cuyo primer elemento es el máximo común divisor (mcd)
316 de los polinomios @var{p_1}, @var{p_2}, @var{p_3}, @dots{}, siendo los
317 miembros restantes los mismos polinomios divididos por el mcd.
318 Se utiliza siempre el algoritmo @code{ezgcd}.
320 Véanse también @code{gcd}, @code{gcdex}, @code{gcdivide} y @code{poly_gcd}.
322 Ejemplos:
324 Los tres polinomios tiene como máximo común divisor @code{2*x-3},
325 el cual se calcula primero con la función @code{gcd} y luego con
326 @code{ezgcd}.
328 @example
329 (%i1) p1 : 6*x^3-17*x^2+14*x-3;
330 3 2
331 (%o1) 6 x - 17 x + 14 x - 3
332 (%i2) p2 : 4*x^4-14*x^3+12*x^2+2*x-3;
333 4 3 2
334 (%o2) 4 x - 14 x + 12 x + 2 x - 3
335 (%i3) p3 : -8*x^3+14*x^2-x-3;
336 3 2
337 (%o3) - 8 x + 14 x - x - 3
339 (%i4) gcd(p1, gcd(p2, p3));
340 (%o4) 2 x - 3
342 (%i5) ezgcd(p1, p2, p3);
343 2 3 2 2
344 (%o5) [2 x - 3, 3 x - 4 x + 1, 2 x - 4 x + 1, - 4 x + x + 1]
345 @end example
349 @end deffn
351 @defvr {Variable opcional} facexpand
352 Valor por defecto: @code{true}
354 La variable @code{facexpand} controla si los factores irreducibles devueltos por @code{factor} están en formato expandido (por defecto) o recursivo (CRE normal).
356 @end defvr
360 @deffn {Función} factor (@var{expr})
361 @deffnx {Función} factor (@var{expr}, @var{p})
363 Factoriza la expresión @var{expr}, que puede contener
364 cualquier número de variables o funciones, en factores
365 irreducibles respecto de los enteros. La llamada
366 @code{factor (@var{expr}, @var{p})} factoriza @var{expr}
367 en el campo de los racionales con un elemento añadido cuyo
368 polinomio mínimo es @var{p}.
370 La función @code{factor} utiliza a @code{ifactors}
371 para factorizar enteros.
373 Si la variable @code{factorflag} vale @code{false} suprime
374 la factorización de los factores enteros en las expresiones racionales.
376 La variable @code{dontfactor} puede contener una lista
377 de variables con respecto a las cuales no se factorizará
378 (inicialmente está vacía). Tampoco se
379 factorizará respecto de cualesquiera otra variables que sean menos importantes (según la ordenación que se sigue en el formato CRE) que aquellas que se encuentran en la lista @code{dontfactor}.
381 Si la variable @code{savefactors} vale @code{true}, los
382 factores de una expresión en forma de producto se guardarán
383 por ciertas funciones a fin de acelerar posteriores factorizaciones
384 de expresiones que contengan algunos de estos mismos factores.
386 Si @code{berlefact} vale @code{false} entonces se utiliza el
387 algoritmo de factorización de Kronecker, en caso contrario se
388 utilizará el algoritmo de Berlekamp, que es el que se aplica por defecto.
390 Si la variable @code{intfaclim} vale @code{true}, Maxima desistirá de
391 factorizar enteros si no encuentra ningún factor después de las
392 divisiones tentativas y de aplicar el método rho de Pollard. Si vale
393 @code{false} (este es el caso cuando el usuario invoca explícitamente
394 a @code{factor}), se intentará la factorización completa del entero. El valor
395 asignado a @code{intfaclim} se utiliza en llamadas internas a @code{factor}. Así,
396 se puede cambiar el valor de @code{intfaclim} para evitar que Maxima dedique
397 un tiempo prohibitivo a factorizar números enteros grandes.
399 Ejemplos:
400 @c EXAMPLES BELOW ADAPTED FROM examples (factor)
401 @c factor (2^63 - 1);
402 @c factor (-8*y - 4*x + z^2*(2*y + x));
403 @c -1 - 2*x - x^2 + y^2 + 2*x*y^2 + x^2*y^2;
404 @c block ([dontfactor: [x]], factor (%/36/(1 + 2*y + y^2)));
405 @c factor (1 + %e^(3*x));
406 @c factor (1 + x^4, a^2 - 2);
407 @c factor (-y^2*z^2 - x*z^2 + x^2*y^2 + x^3);
408 @c (2 + x)/(3 + x)/(b + x)/(c + x)^2;
409 @c ratsimp (%);
410 @c partfrac (%, x);
411 @c map ('factor, %);
412 @c ratsimp ((x^5 - 1)/(x - 1));
413 @c subst (a, x, %);
414 @c factor (%th(2), %);
415 @c factor (1 + x^12);
416 @c factor (1 + x^99);
418 @example
419 (%i1) factor (2^63 - 1);
420 2
421 (%o1) 7 73 127 337 92737 649657
422 (%i2) factor (-8*y - 4*x + z^2*(2*y + x));
423 (%o2) (2 y + x) (z - 2) (z + 2)
424 (%i3) -1 - 2*x - x^2 + y^2 + 2*x*y^2 + x^2*y^2;
425 2 2 2 2 2
426 (%o3) x y + 2 x y + y - x - 2 x - 1
427 (%i4) block ([dontfactor: [x]], factor (%/36/(1 + 2*y + y^2)));
428 2
429 (x + 2 x + 1) (y - 1)
430 (%o4) ----------------------
431 36 (y + 1)
432 (%i5) factor (1 + %e^(3*x));
433 x 2 x x
434 (%o5) (%e + 1) (%e - %e + 1)
435 (%i6) factor (1 + x^4, a^2 - 2);
436 2 2
437 (%o6) (x - a x + 1) (x + a x + 1)
438 (%i7) factor (-y^2*z^2 - x*z^2 + x^2*y^2 + x^3);
439 2
440 (%o7) - (y + x) (z - x) (z + x)
441 (%i8) (2 + x)/(3 + x)/(b + x)/(c + x)^2;
442 x + 2
443 (%o8) ------------------------
444 2
445 (x + 3) (x + b) (x + c)
446 (%i9) ratsimp (%);
447 4 3
448 (%o9) (x + 2)/(x + (2 c + b + 3) x
450 2 2 2 2
451 + (c + (2 b + 6) c + 3 b) x + ((b + 3) c + 6 b c) x + 3 b c )
452 (%i10) partfrac (%, x);
453 2 4 3
454 (%o10) - (c - 4 c - b + 6)/((c + (- 2 b - 6) c
456 2 2 2 2
457 + (b + 12 b + 9) c + (- 6 b - 18 b) c + 9 b ) (x + c))
459 c - 2
460 - ---------------------------------
461 2 2
462 (c + (- b - 3) c + 3 b) (x + c)
464 b - 2
465 + -------------------------------------------------
466 2 2 3 2
467 ((b - 3) c + (6 b - 2 b ) c + b - 3 b ) (x + b)
469 1
470 - ----------------------------------------------
471 2
472 ((b - 3) c + (18 - 6 b) c + 9 b - 27) (x + 3)
473 (%i11) map ('factor, %);
474 2
475 c - 4 c - b + 6 c - 2
476 (%o11) - ------------------------- - ------------------------
477 2 2 2
478 (c - 3) (c - b) (x + c) (c - 3) (c - b) (x + c)
480 b - 2 1
481 + ------------------------ - ------------------------
482 2 2
483 (b - 3) (c - b) (x + b) (b - 3) (c - 3) (x + 3)
484 (%i12) ratsimp ((x^5 - 1)/(x - 1));
485 4 3 2
486 (%o12) x + x + x + x + 1
487 (%i13) subst (a, x, %);
488 4 3 2
489 (%o13) a + a + a + a + 1
490 (%i14) factor (%th(2), %);
491 2 3 3 2
492 (%o14) (x - a) (x - a ) (x - a ) (x + a + a + a + 1)
493 (%i15) factor (1 + x^12);
494 4 8 4
495 (%o15) (x + 1) (x - x + 1)
496 (%i16) factor (1 + x^99);
497 2 6 3
498 (%o16) (x + 1) (x - x + 1) (x - x + 1)
500 10 9 8 7 6 5 4 3 2
501 (x - x + x - x + x - x + x - x + x - x + 1)
503 20 19 17 16 14 13 11 10 9 7 6
504 (x + x - x - x + x + x - x - x - x + x + x
506 4 3 60 57 51 48 42 39 33
507 - x - x + x + 1) (x + x - x - x + x + x - x
509 30 27 21 18 12 9 3
510 - x - x + x + x - x - x + x + 1)
511 @end example
513 @end deffn
518 @defvr {Variable opcional} factorflag
519 Valor por defecto: @code{false}
521 @c WHAT IS THIS ABOUT EXACTLY ??
522 Si @code{factorflag} vale @code{false} se evita la factorización de factores enteros de expresiones racionales.
523 @end defvr
528 @deffn {Función} factorout (@var{expr}, @var{x_1}, @var{x_2}, ...)
529 Reorganiza la suma @var{expr} como una suma de términos de la forma
530 @code{f (@var{x_1}, @var{x_2}, ...)*g}, donde @code{g} es un producto
531 de expresiones que no contienen ningún @var{x_i} y @code{f} se factoriza.
533 Nótese que @code{factorout} ignora la variable opcional @code{keepfloat}.
535 Ejemplo:
537 @c ===beg===
538 @c expand (a*(x+1)*(x-1)*(u+1)^2);
539 @c factorout(%,x);
540 @c ===end===
541 @example
542 (%i1) expand (a*(x+1)*(x-1)*(u+1)^2);
543 2 2 2 2 2
544 (%o1) a u x + 2 a u x + a x - a u - 2 a u - a
545 (%i2) factorout(%,x);
546 2
547 (%o2) a u (x - 1) (x + 1) + 2 a u (x - 1) (x + 1)
548 + a (x - 1) (x + 1)
549 @end example
550 @end deffn
555 @deffn {Función} factorsum (@var{expr})
556 Intenta agrupar términos en los factores de @var{expr} que son sumas en grupos de términos tales que su suma sea factorizable. La función @code{factorsum} puede restablecer el recuperar de @code{expand ((x + y)^2 + (z + w)^2)} pero no puede recuperar @code{expand ((x + 1)^2 + (x + y)^2)} porque los términos tienen variables comunes.
558 Ejemplo:
559 @c FOLLOWING GENERATED FROM THESE EXPRESSIONS
560 @c expand ((x + 1)*((u + v)^2 + a*(w + z)^2));
561 @c factorsum (%);
563 @example
564 (%i1) expand ((x + 1)*((u + v)^2 + a*(w + z)^2));
565 2 2 2 2
566 (%o1) a x z + a z + 2 a w x z + 2 a w z + a w x + v x
568 2 2 2 2
569 + 2 u v x + u x + a w + v + 2 u v + u
570 (%i2) factorsum (%);
571 2 2
572 (%o2) (x + 1) (a (z + w) + (v + u) )
573 @end example
575 @end deffn
577 @deffn {Función} fasttimes (@var{p_1}, @var{p_2})
578 Calcula el producto de los polinomios @var{p_1} y @var{p_2} utilizando un algoritmo especial. Los polinomios @code{p_1} y @code{p_2} deben ser multivariantes, densos y aproximadamente del mismo tamaño. La multiplicación clásica es de orden @code{n_1 n_2} donde @code{n_1} es el grado de @code{p_1} y @code{n_2} el grado de @code{p_2}. La función @code{fasttimes} es de orden @code{max (n_1, n_2)^1.585}.
580 @end deffn
582 @deffn {Función} fullratsimp (@var{expr})
583 Aplica repetidamente @code{ratsimp} a una expresión, seguida de simplificaciones no racionales, hasta que no se obtienen más transformaciones; entonces devuelve el resultado.
585 En presencia de expresiones no racionales, una llamada a @code{ratsimp} seguida de una simplificación no racional ("general") puede no ser suficiente para conseguir un resultado simplificado. En ocasiones serán necesarias más de una llamada a @code{ratsimp}, que es lo que hace precisamente @code{fullratsimp}.
587 Ejemplo:
588 @c FOLLOWING GENERATED FROM THESE EXPRESSIONS
589 @c expr: (x^(a/2) + 1)^2*(x^(a/2) - 1)^2/(x^a - 1);
590 @c ratsimp (expr);
591 @c fullratsimp (expr);
592 @c rat (expr);
594 @example
595 (%i1) expr: (x^(a/2) + 1)^2*(x^(a/2) - 1)^2/(x^a - 1);
596 a/2 2 a/2 2
597 (x - 1) (x + 1)
598 (%o1) -----------------------
599 a
600 x - 1
601 (%i2) ratsimp (expr);
602 2 a a
603 x - 2 x + 1
604 (%o2) ---------------
605 a
606 x - 1
607 (%i3) fullratsimp (expr);
608 a
609 (%o3) x - 1
610 (%i4) rat (expr);
611 a/2 4 a/2 2
612 (x ) - 2 (x ) + 1
613 (%o4)/R/ -----------------------
614 a
615 x - 1
616 @end example
618 @end deffn
620 @deffn {Función} fullratsubst (@var{a}, @var{b}, @var{c})
621 Similar a @code{ratsubst} excepto por el hecho de que se llama a í misma recursivamente hasta que el resultado deja de cambiar. Esta función es útil cuando la expresión a sustituir y la que la sustituye tienen variables comunes.
623 La función @code{fullratsubst} también acepta sus argumentos en el formato de @code{lratsubst}.
625 Es necesario ejecutar @code{load ("lrats")} para cargar @code{fullratsubst} y @code{lratsubst}.
627 Ejemplos:
628 @c EXPRESSIONS ADAPTED FROM demo ("lrats")
629 @c CAN PROBABLY CUT OUT THE lratsubst STUFF (lratsubst HAS ITS OWN DESCRIPTION)
630 @c load ("lrats")$
631 @c subst ([a = b, c = d], a + c);
632 @c lratsubst ([a^2 = b, c^2 = d], (a + e)*c*(a + c));
633 @c lratsubst (a^2 = b, a^3);
634 @c ratsubst (b*a, a^2, a^3);
635 @c fullratsubst (b*a, a^2, a^3);
636 @c fullratsubst ([a^2 = b, b^2 = c, c^2 = a], a^3*b*c);
637 @c fullratsubst (a^2 = b*a, a^3);
638 @c errcatch (fullratsubst (b*a^2, a^2, a^3));
640 @example
641 (%i1) load ("lrats")$
642 @end example
643 @itemize @bullet
644 @item
645 @code{subst} puede hacer sustituciones múltiples;
646 @code{lratsubst} es análoga a @code{subst}.
647 @end itemize
648 @example
649 (%i2) subst ([a = b, c = d], a + c);
650 (%o2) d + b
651 (%i3) lratsubst ([a^2 = b, c^2 = d], (a + e)*c*(a + c));
652 (%o3) (d + a c) e + a d + b c
653 @end example
654 @itemize @bullet
655 @item
656 Si sólo se quiere una sustitución, entonces se puede dar una única ecuación como primer argumento.
657 @end itemize
658 @example
659 (%i4) lratsubst (a^2 = b, a^3);
660 (%o4) a b
661 @end example
662 @itemize @bullet
663 @item
664 @code{fullratsubst} equivale a @code{ratsubst},
665 excepto por el hecho de que se llama a í misma recursivamente hasta que el resultado deja de cambiar.
666 @end itemize
667 @example
668 (%i5) ratsubst (b*a, a^2, a^3);
669 2
670 (%o5) a b
671 (%i6) fullratsubst (b*a, a^2, a^3);
672 2
673 (%o6) a b
674 @end example
675 @itemize @bullet
676 @item
677 @code{fullratsubst} también acepta una lista de ecuaciones o una sóla ecuación como primer argumento.
678 @end itemize
679 @example
680 (%i7) fullratsubst ([a^2 = b, b^2 = c, c^2 = a], a^3*b*c);
681 (%o7) b
682 (%i8) fullratsubst (a^2 = b*a, a^3);
683 2
684 (%o8) a b
685 @end example
686 @itemize @bullet
687 @item
688 @c REWORD THIS SENTENCE
689 @code{fullratsubst} puede caer en una recursión infinita.
690 @end itemize
691 @example
692 (%i9) errcatch (fullratsubst (b*a^2, a^2, a^3));
694 *** - Lisp stack overflow. RESET
695 @end example
697 @end deffn
699 @deffn {Función} gcd (@var{p_1}, @var{p_2}, @var{x_1}, ...)
700 Devuelve el máximo común divisor de @var{p_1} y @var{p_2}.
701 La variable @code{gcd} determiona qué algoritmo se va a utilizar.
702 Asignándole a @code{gcd} los valores @code{ez}, @code{subres}, @code{red}
703 o @code{spmod}, se seleccionan los algoritmos @code{ezgcd},
704 subresultante @code{prs}, reducido o modular, respectivamente.
705 Si @code{gcd} vale @code{false} entonces @code{gcd(@var{p_1},
706 @var{p_2}, @var{x})} devolverá siempre 1 para cualquier @var{x}.
707 Muchas funciones (por ejemplo, @code{ratsimp}, @code{factor}, etc.)
708 hacen uso de @code{gcd} implícitamente.
709 En caso de polinomios homogéneos se recomienda darle a
710 @code{gcd} el valor @code{subres}. Para calcular un máximo
711 común divisor en presencia de raíces, como en
712 @code{gcd (@var{x}^2 - 2*sqrt(2)*@var{x} + 2, @var{x} - sqrt(2))},
713 la variable @code{algebraic} debe igualarse
714 a @code{true} y @code{gcd} no puede ser @code{ez}.
716 Se recomienda utilizar el algoritmo @code{subres} en lugar de @code{red},
717 por ser aquél más moderno.
719 Si la variable @code{gcd}, cuyo valor por defecto es @code{spmod},
720 vale @code{false}, no se calculará el máximo común divisor
721 cuando las expresiones se conviertan a su forma canónica (CRE),
722 lo que redundará en ocasiones en mayor rapidez de cálculo.
725 @end deffn
727 @deffn {Función} gcdex (@var{f}, @var{g})
728 @deffnx {Función} gcdex (@var{f}, @var{g}, @var{x})
729 Devuelve una lista @code{[@var{a}, @var{b}, @var{u}]} en la que @var{u} es el máximo común divisor (mcd) de @var{f} y @var{g}, e igual a @code{@var{a} @var{f} + @var{b} @var{g}}.
730 Los argumentos @var{f} y @var{g} deben ser polinomios univariantes, o indicarles la variable principal @var{x} en caso de ser multivariantes.
732 La función @code{gcdex} implementa el algoritmo de Euclides, en el que tenemos una secuencia de @code{L[i]: [a[i], b[i], r[i]]} todos ellos ortogonales a @code{[f, g, -1]} siendo el siguiente calculado a partir de @code{q = quotient(r[i]/r[i+1])} y @code{L[i+2]: L[i] - q L[i+1]}; el proceso termina en @code{L[i+1]} cuando el resto @code{r[i+2]} se anula.
734 @c FOLLOWING GENERATED FROM THESE EXPRESSIONS
735 @c gcdex (x^2 + 1, x^3 + 4);
736 @c % . [x^2 + 1, x^3 + 4, -1];
738 @example
739 (%i1) gcdex (x^2 + 1, x^3 + 4);
740 2
741 x + 4 x - 1 x + 4
742 (%o1)/R/ [- ------------, -----, 1]
743 17 17
744 (%i2) % . [x^2 + 1, x^3 + 4, -1];
745 (%o2)/R/ 0
746 @end example
748 @c AQUI FALTA PARRAFO
750 @end deffn
753 @c CHOOSE ONE CHARACTERIZATION OF "GAUSSIAN INTEGERS" AND USE IT WHERE GAUSSIAN INTEGERS ARE REFERENCED
754 @deffn {Función} gcfactor (@var{n})
755 Factoriza el entero gaussiano @var{n} como producto, a su vez, de enteros gaussianos, (un entero gaussiano es de la forma@code{@var{a} + @var{b} @code{%i}} donde @var{a} y @var{b} son números enteros). Los factores se normalizan de manera que tanto la parte real como imaginaria sean no negativas.
756 @c NEED EXAMPLES HERE
758 @end deffn
760 @c CHOOSE ONE CHARACTERIZATION OF "GAUSSIAN INTEGERS" AND USE IT WHERE GAUSSIAN INTEGERS ARE REFERENCED
761 @deffn {Función} gfactor (@var{expr})
762 Factoriza el polinomio @var{expr} sobre los enteros gaussianos (un entero gaussiano es de la forma@code{@var{a} + @var{b} @code{%i}} donde @var{a} y @var{b} son números enteros).
763 @c "This is like" -- IS IT THE SAME OR NOT ??
764 Es como @code{factor (@var{expr}, @var{a}^2+1)} donde @var{a} vale @code{%i}.
766 Ejemplo:
767 @c FOLLOWING GENERATED FROM THESE EXPRESSIONS
768 @c gfactor (x^4 - 1);
770 @example
771 (%i1) gfactor (x^4 - 1);
772 (%o1) (x - 1) (x + 1) (x - %i) (x + %i)
773 @end example
775 @end deffn
777 @deffn {Función} gfactorsum (@var{expr})
778 Esta función es similar a @code{factorsum} pero aplica @code{gfactor} en lugar de @code{factor}.
780 @end deffn
782 @deffn {Función} hipow (@var{expr}, @var{x})
783 Devuelve el mayor exponente explícito de @var{x} en @var{expr}.
784 El argumento@var{x} puede ser una variable o una expresión general.
785 Si @var{x} no aparece en @var{expr}, @code{hipow} devuelve @code{0}.
787 La función @code{hipow} no tiene en cuenta expresiones equivalentes a @code{expr}.
788 En particular, @code{hipow} no expande @code{expr}, de manera que @code{hipow (@var{expr}, @var{x})} y @code{hipow (expand (@var{expr}, @var{x}))} pueden dar resultados diferentes.
790 Ejemplos:
792 @example
793 (%i1) hipow (y^3 * x^2 + x * y^4, x);
794 (%o1) 2
795 (%i2) hipow ((x + y)^5, x);
796 (%o2) 1
797 (%i3) hipow (expand ((x + y)^5), x);
798 (%o3) 5
799 (%i4) hipow ((x + y)^5, x + y);
800 (%o4) 5
801 (%i5) hipow (expand ((x + y)^5), x + y);
802 (%o5) 0
803 @end example
805 @end deffn
807 @defvr {Variable opcional} intfaclim
808 Valor por defecto: @code{true}
810 Si vale @code{true}, Maxima desistirá de
811 factorizar enteros si no encuentra ningún factor después de las
812 divisiones tentativas y de aplicar el método rho de Pollard, por lo que
813 la factorización puede quedar incompleta.
815 Si vale @code{false} (este es el caso cuando el usuario invoca explícitamente
816 a @code{factor}), se intentará la factorización completa del entero. El valor
817 asignado a @code{intfaclim} se utiliza en llamadas internas a @code{factor}. A la variable
818 @code{intfaclim} se le asigna el valor @code{false} cuando se calculan factores desde las
819 funciones @code{divisors}, @code{divsum} y @code{totient}.
820 @c ANY OTHERS ??
822 @c WHAT ARE THESE MYSTERIOUS INTERNAL CALLS ?? (LET'S JUST LIST THE FUNCTIONS INVOLVED)
823 Las llamadas internas a @code{factor} respetan el valor dado por el usuario a @code{intfaclim}.
824 Asignando a @code{intfaclim} el valor @code{true} se puede reducir el tiempo que Maxima dedica a
825 factorizar enteros grandes.
826 @c NEED EXAMPLES HERE
828 @end defvr
833 @defvr {Variable opcional} keepfloat
834 Valor por defecto: @code{false}
836 Si @code{keepfloat} vale @code{true}, los números decimales en coma flotante no se racionalizan cuando las expresiones que los contienen se convierten al formato canónico racional (CRE).
838 Nótese que la función @code{solve} y todas aquellas otras que la
839 invocan (por ejemplo, @code{eigenvalues}) ignoran esta variable, por
840 lo que hacen la conversión de los números decimales.
842 Ejemplos:
844 @c ===beg===
845 @c rat(x/2.0);
846 @c rat(x/2.0), keepfloat;
847 @c ===end===
848 @example
849 (%i1) rat(x/2.0);
851 `rat' replaced 0.5 by 1/2 = 0.5
852 x
853 (%o1)/R/ -
854 2
855 (%i2) rat(x/2.0), keepfloat;
857 (%o2)/R/ 0.5 x
858 @end example
860 @code{solve} ignora @code{keepfloat}:
862 @c ===beg===
863 @c solve(1.0-x,x), keepfloat;
864 @c ===end===
865 @example
866 (%i3) solve(1.0-x,x), keepfloat;
868 `rat' replaced 1.0 by 1/1 = 1.0
869 (%o3) [x = 1]
870 @end example
871 @end defvr
875 @deffn {Función} lopow (@var{expr}, @var{x})
877 Devuelve el menor exponente de @var{x} que aparece explícitamente
878 en @var{expr}.
880 @example
881 (%i1) lopow ((x+y)^2 + (x+y)^a, x+y);
882 (%o1) min(a, 2)
883 @end example
885 @end deffn
889 @deffn {Función} lratsubst (@var{L}, @var{expr})
890 Esta función es similar a @code{subst (@var{L}, @var{expr})}, excepto por el hecho de que utiliza @code{ratsubst} en lugar de @code{subst}.
892 El primer argumento de @code{lratsubst} es una ecuación o lista de ecuaciones idénticas en formato a las aceptadas por @code{subst}. Las sustituciones se hacen en el orden dado por la lista de ecuaciones, esto es, de izquierda a derecha.
894 La instrucción @code{load ("lrats")} carga @code{fullratsubst} y @code{lratsubst}.
896 Ejemplos:
897 @c EXPRESSIONS ADAPTED FROM demo ("lrats")
898 @c THIS STUFF CAN PROBABLY STAND REVISION -- EXAMPLES DON'T SEEM VERY ENLIGHTENING
899 @c load ("lrats")$
900 @c subst ([a = b, c = d], a + c);
901 @c lratsubst ([a^2 = b, c^2 = d], (a + e)*c*(a + c));
902 @c lratsubst (a^2 = b, a^3);
904 @example
905 (%i1) load ("lrats")$
906 @end example
907 @itemize @bullet
908 @item
909 @code{subst} can carry out multiple substitutions.
910 @code{lratsubst} is analogous to @code{subst}.
911 @end itemize
912 @example
913 (%i2) subst ([a = b, c = d], a + c);
914 (%o2) d + b
915 (%i3) lratsubst ([a^2 = b, c^2 = d], (a + e)*c*(a + c));
916 (%o3) (d + a c) e + a d + b c
917 @end example
918 @itemize @bullet
919 @item
920 If only one substitution is desired, then a single
921 equation may be given as first argument.
922 @end itemize
923 @example
924 (%i4) lratsubst (a^2 = b, a^3);
925 (%o4) a b
926 @end example
928 @end deffn
931 @defvr {Variable opcional} modulus
932 Valor por defecto: @code{false}
934 Si @code{modulus} es un número positivo @var{p}, las operaciones con números racionales
935 (como los devueltos por @code{rat} y funciones relacionadas) se realizan módulo @var{p},
936 utilizando el llamado sistema de módulo balanceado, en el que @code{@var{n} módulo @var{p}}
937 se define como un entero @var{k} de @code{[-(@var{p}-1)/2, ..., 0, ..., (@var{p}-1)/2]}
938 si @var{p} es impar, o de @code{[-(@var{p}/2 - 1), ..., 0, ...., @var{p}/2]} si @var{p} es par,
939 de tal manera que @code{@var{a} @var{p} + @var{k}} es igual a @var{n} para algún entero @var{a}.
941 Normalmente a @code{modulus} se le asigna un número primo. Se acepta que a @code{modulus}
942 se le asigne un entero positivo no primo, pero se obtendrá un mensaje de aviso. Maxima
943 responderá con un mensaje de error cuando se le asigne a @code{modulus} cero o un número
944 negativo.
946 Ejemplos:
948 @example
949 (%i1) modulus:7;
950 (%o1) 7
951 (%i2) polymod([0,1,2,3,4,5,6,7]);
952 (%o2) [0, 1, 2, 3, - 3, - 2, - 1, 0]
953 (%i3) modulus:false;
954 (%o3) false
955 (%i4) poly:x^6+x^2+1;
956 6 2
957 (%o4) x + x + 1
958 (%i5) factor(poly);
959 6 2
960 (%o5) x + x + 1
961 (%i6) modulus:13;
962 (%o6) 13
963 (%i7) factor(poly);
964 2 4 2
965 (%o7) (x + 6) (x - 6 x - 2)
966 (%i8) polymod(%);
967 6 2
968 (%o8) x + x + 1
969 @end example
970 @end defvr
974 @deffn {Función} num (@var{expr})
975 Devuelve el numerador de @var{expr} si se trata de una fracción. Si @var{expr} no es una fracción, se devuelve @var{expr}.
977 La función @code{num} evalúa su argumento.
979 @c NEED SOME EXAMPLES HERE
980 @end deffn
982 @deffn {Función} polydecomp (@var{p}, @var{x})
984 Descompone el polinomio @var{p} de variable @var{x} en una composición funcional de polinomios en @var{x}.
985 La función @code{polydecomp} devuelve una lista @code{[@var{p_1}, ..., @var{p_n}]} tal que
987 @example
988 lambda([x],p_1)(lambda ([x],p_2)(...(lambda([x],p_n)(x))...))
989 @end example
991 es igual a @var{p}.
992 El grado de @var{p_i} es mayor que 1 para @var{i} menor que @var{n}.
994 Esta descomposición no es única.
996 Ejemplos:
998 @c ===beg===
999 @c polydecomp (x^210, x);
1000 @c p : expand (subst (x^3 - x - 1, x, x^2 - a));
1001 @c polydecomp (p, x);
1002 @c ===end===
1003 @example
1004 (%i1) polydecomp (x^210, x);
1005 7 5 3 2
1006 (%o1) [x , x , x , x ]
1007 (%i2) p : expand (subst (x^3 - x - 1, x, x^2 - a));
1008 6 4 3 2
1009 (%o2) x - 2 x - 2 x + x + 2 x - a + 1
1010 (%i3) polydecomp (p, x);
1011 2 3
1012 (%o3) [x - a, x - x - 1]
1013 @end example
1015 La siguiente función compone @code{L = [e_1, ..., e_n]} como funciones de @code{x};
1016 se trata de la inversa de @code{polydecomp}:
1018 @c ===beg===
1019 @c compose (L, x) :=
1020 @c block ([r : x], for e in L do r : subst (e, x, r), r) $
1021 @c ===end===
1022 @example
1023 compose (L, x) :=
1024 block ([r : x], for e in L do r : subst (e, x, r), r) $
1025 @end example
1027 Se vuelve a obtener el resultado del ejemplo de más arriba haciendo uso de @code{compose}:
1029 @c ===beg===
1030 @c polydecomp (compose ([x^2 - a, x^3 - x - 1], x), x);
1031 @c ===end===
1032 @example
1033 (%i3) polydecomp (compose ([x^2 - a, x^3 - x - 1], x), x);
1034 2 3
1035 (%o3) [x - a, x - x - 1]
1036 @end example
1038 Nótese que aunque @code{compose (polydecomp (@var{p}, @var{x}), @var{x})}
1039 devuelve siempre @var{p} (sin expandir),
1040 @code{polydecomp (compose ([@var{p_1}, ..., @var{p_n}], @var{x}), @var{x})} @i{no}
1041 devuelve necesariamente @code{[@var{p_1}, ..., @var{p_n}]}:
1043 @c ===beg===
1044 @c polydecomp (compose ([x^2 + 2*x + 3, x^2], x), x);
1045 @c polydecomp (compose ([x^2 + x + 1, x^2 + x + 1], x), x);
1046 @c ===end===
1047 @example
1048 (%i4) polydecomp (compose ([x^2 + 2*x + 3, x^2], x), x);
1049 2 2
1050 (%o4) [x + 2, x + 1]
1051 (%i5) polydecomp (compose ([x^2 + x + 1, x^2 + x + 1], x), x);
1052 2 2
1053 x + 3 x + 5
1054 (%o5) [------, ------, 2 x + 1]
1055 4 2
1056 @end example
1058 @end deffn
1062 @deffn {Función} polymod (@var{p})
1063 @deffnx {Función} polymod (@var{p}, @var{m})
1064 Convierte el polinomio @var{p} a una representación modular respecto del módulo actual, que es el valor almacenado en la variable @code{modulus}.
1066 La llamada @code{polymod (@var{p}, @var{m})} especifica un módulo @var{m} para ser utilizado en lugar de valor almacenado en @code{modulus}.
1068 Véase @code{modulus}.
1069 @end deffn
1073 @c ISN'T THERE AN EQUIVALENT FUNCTION SOMEWHERE ??
1074 @c NEEDS WORK (IF KEPT)
1075 @deffn {Función} powers (@var{expr}, @var{x})
1076 Devuelve las potencias de @var{x} dentro de @var{expr}.
1078 La instrucción @code{load ("powers")} carga esta función.
1079 @c HMM, THERE'S A BUNCH OF MAXIMA FUNCTIONS IN src/powers.lisp ...
1080 @c FOR SOME REASON src/powers.lisp IS NOT PART OF THE USUAL BUILD -- STRANGE
1082 @c HERE IS THE TEXT FROM archive/share/unknown/powers.usg -- MERGE !!!
1083 @c THIS FUNCTION IS A GENERALISATION OF "HIPOW" AND "LOPOW"
1084 @c IN THAT IT RETURNS A LIST OF ALL THE POWERS OF VAR OCCURING
1085 @c IN EXPR. IT IS STILL NECESSARY TO EXPAND EXPR BEFORE APPLYING
1086 @c POWERS (ON PAIN OF GETTING THE WRONG ANSWER).
1087 @c
1088 @c THIS FUNCTION HAS MANY USES, E.G. IF YOU WANT TO FIND ALL
1089 @c THE COEFFICIENTS OF X IN A POLYNOMIAL POLY YOU CAN USE
1090 @c MAP(LAMBDA([POW],COEFF(POLY,X,POW)),POWERS(POLY,X));
1091 @c AND MANY OTHER SIMILAR USEFUL HACKS.
1093 @end deffn
1097 @deffn {Función} quotient (@var{p_1}, @var{p_2})
1098 @deffnx {Función} quotient (@var{p_1}, @var{p_2}, @var{x_1}, ..., @var{x_n})
1099 Devuelve el polinomio @var{p_1} dividido por el polinomio @var{p_2}. Los argumentos @var{x_1}, ..., @var{x_n} se interpretan como en la función @code{ratvars}.
1101 La función @code{quotient} devuelve el primer elemento de la lista devuelta por @code{divide}.
1103 @c NEED SOME EXAMPLES HERE
1104 @end deffn
1107 @deffn {Función} rat (@var{expr})
1108 @deffnx {Función} rat (@var{expr}, @var{x_1}, ..., @var{x_n})
1109 Convierte @var{expr} al formato canónico racional (canonical rational expression o CRE) expandiendo y combinando todos los términos sobre un denominador común y cancelando el máximo común divisor del numerador y denominador, así como convirtiendo números decimales en coma flotante a números racionales dentro de la tolerancia indicada por @code{ratepsilon}. Las variables se ordenan de acuerdo a @var{x_1}, ..., @var{x_n} si se han especificado, como en la función @code{ratvars}.
1111 En general, @code{rat} no simplifica otras funciones que no sean la suma @code{+}, resta @code{-}, multiplicación @code{*}, división @code{/} y exponenciación de exponente entero, mientras que @code{ratsimp} sí lo hace.
1112 Nótese que los átomos (números y variables) en expresiones en formato CRE no son los mismos que en el formato general.
1113 Por ejemplo, @code{rat(x)- x} devuelve @code{rat(0)}, que tiene una representación interna diferente de 0.
1115 @c FALTA PARRAFO QUE NECESITA CLARIFICACION EN VERSION INGLESA
1117 Si @code{ratprint} vale @code{false} no aparecerán mensajes informando al usuario sobre la conversión de números decimales en coma flotante a números racionales.
1119 Si @code{keepfloat} vale @code{true} no se convertirán números decimales en coma flotante a números racionales.
1121 Véanse también @code{ratexpand} y @code{ratsimp}.
1123 Ejemplos:
1124 @c ===beg===
1125 @c ((x - 2*y)^4/(x^2 - 4*y^2)^2 + 1)*(y + a)*(2*y + x)
1126 @c / (4*y^2 + x^2);
1127 @c rat (%, y, a, x);
1128 @c ===end===
1129 @example
1130 (%i1) ((x - 2*y)^4/(x^2 - 4*y^2)^2 + 1)*(y + a)*(2*y + x)
1131 / (4*y^2 + x^2);
1132 4
1133 (x - 2 y)
1134 (y + a) (2 y + x) (------------ + 1)
1135 2 2 2
1136 (x - 4 y )
1137 (%o1) ------------------------------------
1138 2 2
1139 4 y + x
1140 (%i2) rat (%, y, a, x);
1141 2 a + 2 y
1142 (%o2)/R/ ---------
1143 x + 2 y
1144 @end example
1146 @end deffn
1148 @defvr {Variable opcional} ratalgdenom
1149 Valor por defecto: @code{true}
1151 Si @code{ratalgdenom} vale @code{true}, se permite la racionalización de denominadores eliminando radicales.
1152 La variable @code{ratalgdenom} sólo tiene efecto cuando expresiones en formato canónico (CRE) están siendo utilizadas en modo algebraico.
1154 @end defvr
1156 @deffn {Función} ratcoef (@var{expr}, @var{x}, @var{n})
1157 @deffnx {Función} ratcoef (@var{expr}, @var{x})
1158 Devuelve el coeficiente de la expresión @code{@var{x}^@var{n}} dentro de la expresión @var{expr}. Si se omite, @var{n} se considera igual a 1.
1160 El valor devuelto está libre de las variables en @var{x}, excepto quizás en un sentido no racional. Si no existe un coeficiente de este tipo se devuelve 0.
1162 La función @code{ratcoef} expande y simplifica racionalmente su primer argumento, por lo que puede dar una respuesta diferente a la dada por la función @code{coeff}, la cual tiene un carácter puramente sintáctico.
1163 Así, @code{ratcoef ((x + 1)/y + x, x)} devuelve @code{(y + 1)/y},
1164 mientras que @code{coeff} devuelve 1.
1166 La llamada @code{ratcoef (@var{expr}, @var{x}, 0)}, siendo @var{expr} una suma, devuelve una suma formada por los términos que no contienen @var{x}.
1168 Puesto que @var{expr} se simplifica racionalmente antes de ser examinada, algunos coeficientes puede que no aparezcan como en la expresión original.
1170 Ejemplo:
1171 @c FOLLOWING GENERATED FROM THESE EXPRESSIONS
1172 @c s: a*x + b*x + 5$
1173 @c ratcoef (s, a + b);
1175 @example
1176 (%i1) s: a*x + b*x + 5$
1177 (%i2) ratcoef (s, a + b);
1178 (%o2) x
1179 @end example
1180 @c NEED MORE EXAMPLES HERE
1182 @end deffn
1184 @deffn {Función} ratdenom (@var{expr})
1185 Devuelve el denominador de @var{expr}, después de transformar @var{expr} al formato canónico (CRE). El valor retornado está también en formato CRE.
1187 @c ACTUALLY THE CONVERSION IS CARRIED OUT BY ratf BUT THAT'S WHAT $rat CALLS
1188 El argumento @var{expr} se transforma al formato CRE por la función @code{rat}, a menos que ya esté en este formato.
1189 Esta conversión puede cambiar la forma de @var{expr} colocando todos sus términos sobre un denominador común.
1191 La función @code{denom} es parecida, pero devuelve una expresión general en lugar de una CRE. Tampoco @code{denom} intenta colocar todos sus términos sobre un denominador común, de manera que algunas expresiones que son consideradas como divisiones por @code{ratdenom}, no son tales para @code{denom}.
1193 @c NEEDS AN EXAMPLE HERE
1194 @end deffn
1196 @defvr {Variable opcional} ratdenomdivide
1197 Valor por defecto: @code{true}
1199 Si @code{ratdenomdivide} vale @code{true}, la función @code{ratexpand} expande una fracción en la que el numerador es una suma en una suma de divisiones. En otro caso, @code{ratexpand} reduce una suma de divisiones a una única fracción, cuyo numerador es la suma de los denominadores de cada fracción.
1201 Ejemplos:
1203 @example
1204 (%i1) expr: (x^2 + x + 1)/(y^2 + 7);
1205 2
1206 x + x + 1
1207 (%o1) ----------
1208 2
1209 y + 7
1210 (%i2) ratdenomdivide: true$
1211 (%i3) ratexpand (expr);
1212 2
1213 x x 1
1214 (%o3) ------ + ------ + ------
1215 2 2 2
1216 y + 7 y + 7 y + 7
1217 (%i4) ratdenomdivide: false$
1218 (%i5) ratexpand (expr);
1219 @group
1220 2
1221 x + x + 1
1222 (%o5) ----------
1223 2
1224 y + 7
1225 @end group
1226 (%i6) expr2: a^2/(b^2 + 3) + b/(b^2 + 3);
1227 2
1228 b a
1229 (%o6) ------ + ------
1230 2 2
1231 b + 3 b + 3
1232 (%i7) ratexpand (expr2);
1233 2
1234 b + a
1235 (%o7) ------
1236 2
1237 b + 3
1238 @end example
1240 @end defvr
1243 @deffn {Función} ratdiff (@var{expr}, @var{x})
1244 Deriva la expresión racional @var{expr} con respecto a @var{x}.
1245 El argumento @var{expr} debe ser una fracción algebraica o un polinomio en @var{x}.
1246 El argumento @var{x} puede ser una variable o una subexpresión de @var{expr}.
1247 @c NOT CLEAR (FROM READING CODE) HOW x OTHER THAN A VARIABLE IS HANDLED --
1248 @c LOOKS LIKE (a+b), 10*(a+b), (a+b)^2 ARE ALL TREATED LIKE (a+b);
1249 @c HOW TO DESCRIBE THAT ??
1251 El resultado equivale al devuelto por @code{diff}, aunque es posible que se obtenga en una forma diferente.
1252 La función @code{ratdiff} puede ser más rápida que @code{diff} en expresiones racionales.
1254 La función @code{ratdiff} devuelve una expresión en formato canónico o CRE si @code{expr} es también una expresión CRE. En otro caso, @code{ratdiff} devuelve una expresión general.
1256 La función @code{ratdiff} considera únicamente la dependencia de @var{expr} respecto de @var{x}, ignorando cualquier dependencia establecida por @code{depends}.
1258 Ejemplo:
1259 @c FOLLOWING GENERATED FROM THESE EXPRESSIONS
1260 @c expr: (4*x^3 + 10*x - 11)/(x^5 + 5);
1261 @c ratdiff (expr, x);
1262 @c expr: f(x)^3 - f(x)^2 + 7;
1263 @c ratdiff (expr, f(x));
1264 @c expr: (a + b)^3 + (a + b)^2;
1265 @c ratdiff (expr, a + b);
1267 @example
1268 (%i1) expr: (4*x^3 + 10*x - 11)/(x^5 + 5);
1269 3
1270 4 x + 10 x - 11
1271 (%o1) ----------------
1272 5
1273 x + 5
1274 (%i2) ratdiff (expr, x);
1275 7 5 4 2
1276 8 x + 40 x - 55 x - 60 x - 50
1277 (%o2) - ---------------------------------
1278 10 5
1279 x + 10 x + 25
1280 (%i3) expr: f(x)^3 - f(x)^2 + 7;
1281 3 2
1282 (%o3) f (x) - f (x) + 7
1283 (%i4) ratdiff (expr, f(x));
1284 2
1285 (%o4) 3 f (x) - 2 f(x)
1286 (%i5) expr: (a + b)^3 + (a + b)^2;
1287 3 2
1288 (%o5) (b + a) + (b + a)
1289 (%i6) ratdiff (expr, a + b);
1290 2 2
1291 (%o6) 3 b + (6 a + 2) b + 3 a + 2 a
1292 @end example
1294 @end deffn
1296 @deffn {Función} ratdisrep (@var{expr})
1297 Devuelve su argumento como una expresión general.
1298 Si @var{expr} es una expresión general, se devuelve sin cambios.
1300 Normalmente se invoca a @code{ratdisrep} a fin de convertir una expresión en formato canónico (CRE) al formato general, lo que puede ser utilizado si se quiere parar el contagio que produce el formato CRE, o para utilizar funciones racionales en contextos no racionales.
1302 Véase también @code{totaldisrep}.
1304 @end deffn
1307 @deffn {Función} ratexpand (@var{expr})
1308 @deffnx {Variable opcional} ratexpand
1309 Expande @var{expr} multiplicando productos de sumas y sumas con exponentes, combinando fracciones con común denominador, cancelando el máximo común divisor del numerador y del denominador y luego dividiendo los sumandos del numerador por el denominador.
1311 El valor que devuelve @code{ratexpand} es una expresión general, incluso cuando @var{expr} está en formato canónico o CRE.
1313 Si la variable @code{ratexpand} vale @code{true} hará que las expresiones CRE se expandan completamente cuando se conviertan al formato general o se muestren en el terminal, mientras que si vale @code{false} se mostrarán de forma recursiva. Véase también @code{ratsimp}.
1315 Si @code{ratdenomdivide} vale @code{true},
1316 @code{ratexpand} expande una fracción en la que el numerador es una suma en una suma de fracciones, todas ellas con denominador común. En otro caso, @code{ratexpand} reduce una suma de fracciones en una única fracción, cuyo numerador es la suma de los numeradores de cada fracción.
1318 Si @code{keepfloat} vale @code{true}, los números decimales en coma flotante no se racionalizan cuando las expresiones que los contienen se convierten al formato canónico racional (CRE).
1320 Ejemplos:
1321 @c FOLLOWING GENERATED FROM THESE EXPRESSIONS
1322 @c ratexpand ((2*x - 3*y)^3);
1323 @c expr: (x - 1)/(x + 1)^2 + 1/(x - 1);
1324 @c expand (expr);
1325 @c ratexpand (expr);
1327 @example
1328 (%i1) ratexpand ((2*x - 3*y)^3);
1329 3 2 2 3
1330 (%o1) - 27 y + 54 x y - 36 x y + 8 x
1331 (%i2) expr: (x - 1)/(x + 1)^2 + 1/(x - 1);
1332 x - 1 1
1333 (%o2) -------- + -----
1334 2 x - 1
1335 (x + 1)
1336 (%i3) expand (expr);
1337 x 1 1
1338 (%o3) ------------ - ------------ + -----
1339 2 2 x - 1
1340 x + 2 x + 1 x + 2 x + 1
1341 (%i4) ratexpand (expr);
1342 2
1343 2 x 2
1344 (%o4) --------------- + ---------------
1345 3 2 3 2
1346 x + x - x - 1 x + x - x - 1
1347 @end example
1349 @end deffn
1353 @defvr {Variable opcional} ratfac
1354 Valor por defecto: @code{false}
1356 Si @code{ratfac} vale @code{true}, las expresiones canónicas (CRE) se manipulan en una forma parcialmente factorizada.
1358 Durante las operaciones racionales, las expresiones se mantienen completamente factorizadas tanto como sea posible sin llamar a @code{factor}. Esto debería ahorrar espacio y tiempo en algunos cálculos. El numerador y denominador se hacen primos relativos, por ejemplo @code{rat ((x^2 - 1)^4/(x + 1)^2)} devuelve @code{(x - 1)^4 (x + 1)^2)}, pero los factores dentro de cada parte pueden no ser primos relativos.
1360 En el paquete @code{ctensr} sobre manipulación de tensores por componentes, los tensores de Ricci, Einstein, Riemann y Weyl y la curvatura escalar se factorizan automáticamente si @code{ratfac} vale @code{true};
1361 @i{@code{ratfac} debe activarse únicamente en aquellos casos en los que se sabe que el número de términos de las componentes tensoriales es pequño.}
1363 Nota: Los esquemas de comportamiento basados en @code{ratfac} y @code{ratweight} son incompatibles y no se debe pretender usarlos al mismo tiempo.
1365 @c NEED EXAMPLES HERE
1366 @end defvr
1368 @deffn {Función} ratnumer (@var{expr})
1369 Devuelve el numerador de @var{expr}, después de reducir @var{expr} a su forma canónica (CRE).
1370 El valor retornado está también en formato CRE.
1372 @c ACTUALLY THE CONVERSION IS CARRIED OUT BY ratf BUT THAT'S WHAT $rat CALLS
1373 El argumento @var{expr} se transforma al formato CRE por la función @code{rat}, a menos que ya esté en este formato.
1374 Esta conversión puede cambiar la forma de @var{expr} colocando todos sus términos sobre un denominador común.
1376 Es parecida a la función @code{num}, pero devuelve una expresión general en lugar de una CRE.
1377 Además, @code{num} no intenta colocar todos los términos sobre un denominador común, de manera que algunas expresiones que son consideradas fracciones por @code{ratnumer} no se consideran como tales por @code{num}.
1378 @end deffn
1381 @deffn {Función} ratp (@var{expr})
1382 Devuelve @code{true} si @var{expr} es una expresión canónica racional (canonical rational expression o CRE) o una CRE extendida, en caso contrario devuelve @code{false}.
1384 Las expresiones CRE son creadas por @code{rat} y funciones asociadas. Las CRE extendidas son creadas por @code{taylor} y funciones asociadas.
1386 @end deffn
1388 @defvr {Variable opcional} ratprint
1389 Valor por defecto: @code{true}
1391 Si @code{ratprint} vale @code{true}, se muestra al usuario un mensaje dando cuenta de la conversión de números decimales en coma flotante a formato racional.
1393 @end defvr
1395 @deffn {Función} ratsimp (@var{expr})
1396 @deffnx {Función} ratsimp (@var{expr}, @var{x_1}, ..., @var{x_n})
1397 Simplifica la expresión @var{expr} y todas sus subexpresiones, incluyendo los argumentos de funciones no racionales. El resultado es un cociente de dos polinomios en una forma recursiva, esto es, los coeficientes de la variable principal son polinomios respecto de las otras variables. Las variables pueden incluir funciones no racionales, como @code{sin (x^2 + 1)}, y los argumentos de tales funciones son también racionalmente simplificados.
1399 La llamada @code{ratsimp (@var{expr}, @var{x_1}, ..., @var{x_n})} permite la simplificación racional con la especificación del orden de las variables, como en @code{ratvars}.
1401 Si @code{ratsimpexpons} vale @code{true}, @code{ratsimp} se aplica a los exponentes de las expresiones durante la simplificación.
1403 Véase también @code{ratexpand}. Nótese que @code{ratsimp} se ve afectada por algunas de las variables globales que controlan a @code{ratexpand}.
1405 Ejemplos:
1406 @c FOLLOWING GENERATED FROM THESE EXPRESSIONS
1407 @c sin (x/(x^2 + x)) = exp ((log(x) + 1)^2 - log(x)^2);
1408 @c ratsimp (%);
1409 @c ((x - 1)^(3/2) - (x + 1)*sqrt(x - 1))/sqrt((x - 1)*(x + 1));
1410 @c ratsimp (%);
1411 @c x^(a + 1/a), ratsimpexpons: true;
1413 @example
1414 (%i1) sin (x/(x^2 + x)) = exp ((log(x) + 1)^2 - log(x)^2);
1415 2 2
1416 x (log(x) + 1) - log (x)
1417 (%o1) sin(------) = %e
1418 2
1419 x + x
1420 (%i2) ratsimp (%);
1421 1 2
1422 (%o2) sin(-----) = %e x
1423 x + 1
1424 (%i3) ((x - 1)^(3/2) - (x + 1)*sqrt(x - 1))/sqrt((x - 1)*(x + 1));
1425 3/2
1426 (x - 1) - sqrt(x - 1) (x + 1)
1427 (%o3) --------------------------------
1428 sqrt((x - 1) (x + 1))
1429 (%i4) ratsimp (%);
1430 2 sqrt(x - 1)
1431 (%o4) - -------------
1432 2
1433 sqrt(x - 1)
1434 (%i5) x^(a + 1/a), ratsimpexpons: true;
1435 2
1436 a + 1
1437 ------
1438 a
1439 (%o5) x
1440 @end example
1442 @end deffn
1446 @defvr {Variable opcional} ratsimpexpons
1447 Valor por defecto: @code{false}
1449 Si @code{ratsimpexpons} vale @code{true}, @code{ratsimp} se aplica a los exponentes de las expresiones durante la simplificación.
1450 @end defvr
1453 @defvr {Variable opcional} radsubstflag
1454 Valor por defecto: @code{false}
1456 Si @code{radsubstflag} vale @code{true} se permite a @code{ratsubst} hacer la sustitución @code{u} por @code{sqrt (x)} in @code{x}.
1458 @end defvr
1462 @deffn {Función} ratsubst (@var{a}, @var{b}, @var{c})
1464 Sustituye @var{b} por @var{a} en @var{c} y devuelve la expresión resultante.
1465 @c "ETC" SUGGESTS THE READER KNOWS WHAT ELSE GOES THERE -- NOT LIKELY THE CASE
1466 El argumento @var{b} puede ser una suma, un producto, una potencia, etc.
1468 @c WHAT, EXACTLY, DOES ratsubst KNOW ??
1469 La función @code{ratsubst} reconoce el significado de las expresiones, mientras que @code{subst} tan solo realiza sustituciones sintácticas. Así por ejemplo, @code{subst (a, x + y, x + y + z)} devuelve @code{x + y + z}
1470 cuando @code{ratsubst} devuelve @code{z + a}.
1472 Si @code{radsubstflag} vale @code{true},
1473 @code{ratsubst} sustituye radicales en expresiones que no los contienen explícitamente.
1475 @code{ratsubst} ignora el valor @code{true} de la variable
1476 opcional @code{keepfloat}.
1478 Ejemplos:
1480 @c ===beg===
1481 @c ratsubst (a, x*y^2, x^4*y^3 + x^4*y^8);
1482 @c cos(x)^4 + cos(x)^3 + cos(x)^2 + cos(x) + 1;
1483 @c ratsubst (1 - sin(x)^2, cos(x)^2, %);
1484 @c ratsubst (1 - cos(x)^2, sin(x)^2, sin(x)^4);
1485 @c radsubstflag: false$
1486 @c ratsubst (u, sqrt(x), x);
1487 @c radsubstflag: true$
1488 @c ratsubst (u, sqrt(x), x);
1489 @c ===end===
1490 @example
1491 (%i1) ratsubst (a, x*y^2, x^4*y^3 + x^4*y^8);
1492 3 4
1493 (%o1) a x y + a
1494 (%i2) cos(x)^4 + cos(x)^3 + cos(x)^2 + cos(x) + 1;
1495 4 3 2
1496 (%o2) cos (x) + cos (x) + cos (x) + cos(x) + 1
1497 (%i3) ratsubst (1 - sin(x)^2, cos(x)^2, %);
1498 4 2 2
1499 (%o3) sin (x) - 3 sin (x) + cos(x) (2 - sin (x)) + 3
1500 (%i4) ratsubst (1 - cos(x)^2, sin(x)^2, sin(x)^4);
1501 4 2
1502 (%o4) cos (x) - 2 cos (x) + 1
1503 (%i5) radsubstflag: false$
1504 (%i6) ratsubst (u, sqrt(x), x);
1505 (%o6) x
1506 (%i7) radsubstflag: true$
1507 (%i8) ratsubst (u, sqrt(x), x);
1508 2
1509 (%o8) u
1510 @end example
1511 @end deffn
1515 @deffn {Función} ratvars (@var{x_1}, ..., @var{x_n})
1516 @deffnx {Función} ratvars ()
1517 @deffnx {Variable del sistema} ratvars
1518 Declara como variables principales @var{x_1}, ..., @var{x_n} en expresiones racionales. Si @var{x_n} está presente en una expresión racional, se considerará como variable principal. Si no está presente, entonces se considerará principal a la variable @var{x_[n-1]} si aparece en la expresión, se continúa así hasta @var{x_1}, que se considerará como variable principal sólo si ninguna de las variables que le siguen está presente en la expresión.
1520 Si una variable de la expresión racional no está presente en la lista @code{ratvars}, se le dará una prioridad inferior a la de @var{x_1}.
1522 Los argumentos de @code{ratvars} pueden ser tanto variables como funciones no racionales como @code{sin(x)}.
1524 La variable @code{ratvars} es una lista que contiene los argumentos pasados a la función @code{ratvars} la última vez que fue invocada. Cada llamada a la función @code{ratvars} reinicializa la lista. La llamada @code{ratvars ()} vacía la lista.
1526 @end deffn
1530 @defvr {Variable opcional} ratvarswitch
1531 Valor por defecto: @code{true}
1533 Maxima almacena una lista interna en la variable Lisp @code{VARLIST} cuyo
1534 contenido son las variables principales de las expresiones racionales. Cuando @code{ratvarswitch}
1535 vale @code{true}, su valor por defecto, cada evaluación comienza con la lista
1536 @code{VARLIST} vacía. En caso contrario, las variables principales
1537 de las expresiones anteriores se mantienen en la lista @code{VARLIST}.
1539 Las variables principales declaradas con la función @code{ratvars} no se
1540 ven afectadas por la opción @code{ratvarswitch}.
1542 Ejemplos:
1544 Cuando @code{ratvarswitch} vale @code{true}, su valor por defecto, cada
1545 evaluación comienza con la lista @code{VARLIST} vacía.
1547 @c ===beg===
1548 @c ratvarswitch:true$
1549 @c rat(2*x+y^2);
1550 @c :lisp varlist
1551 @c rat(2*a+b^2);
1552 @c :lisp varlist
1553 @c ===end===
1554 @example
1555 (%i1) ratvarswitch:true$
1557 (%i2) rat(2*x+y^2);
1558 2
1559 (%o2)/R/ y + 2 x
1560 (%i3) :lisp varlist
1561 ($X $Y)
1563 (%i3) rat(2*a+b^2);
1564 2
1565 (%o3)/R/ b + 2 a
1567 (%i4) :lisp varlist
1568 ($A $B)
1569 @end example
1571 Cuando @code{ratvarswitch} vale @code{false}, las variables principales
1572 de las expresiones anteriores se mantienen en lista @code{VARLIST}.
1574 @c ===beg===
1575 @c ratvarswitch:false$
1576 @c rat(2*x+y^2);
1577 @c :lisp varlist
1578 @c rat(2*a+b^2);
1579 @c :lisp varlist
1580 @c ===end===
1581 @example
1582 (%i4) ratvarswitch:false$
1584 (%i5) rat(2*x+y^2);
1585 2
1586 (%o5)/R/ y + 2 x
1587 (%i6) :lisp varlist
1588 ($X $Y)
1590 (%i6) rat(2*a+b^2);
1591 2
1592 (%o6)/R/ b + 2 a
1594 (%i7) :lisp varlist
1595 ($A $B $X $Y)
1596 @end example
1598 @end defvr
1604 @deffn {Función} ratweight (@var{x_1}, @var{w_1}, ..., @var{x_n}, @var{w_n})
1605 @deffnx {Función} ratweight ()
1606 Asigna un peso @var{w_i} a la variable @var{x_i}. Un término será reemplazado por 0 si su peso excede el valor de la variable @code{ratwtlvl} (por defecto no se realiza el truncamiento). El peso de un término es la suma de los productos de los pesos de las variables que lo forman multiplicados por sus exponentes. Por ejemplo, el peso de @code{3 x_1^2 x_2} es @code{2 w_1 + w_2}. El truncamiento basado en @code{ratwtlvl} solamente se lleva a cabo cuando se multiplican o se elevan a potencias expresiones canónicas (CRE).
1608 La llamada @code{ratweight ()} devuelve la lista acumulada de asignaciones de pesos.
1610 Nota: Los esquemas de comportamiento basados en @code{ratfac} y @code{ratweight} son incompatibles y no se debe pretender usarlos al mismo tiempo.
1612 Ejemplos:
1613 @c FOLLOWING GENERATED FROM THESE EXPRESSIONS
1614 @c ratweight (a, 1, b, 1);
1615 @c expr1: rat(a + b + 1)$
1616 @c expr1^2;
1617 @c ratwtlvl: 1$
1618 @c expr1^2;
1620 @example
1621 (%i1) ratweight (a, 1, b, 1);
1622 (%o1) [a, 1, b, 1]
1623 (%i2) expr1: rat(a + b + 1)$
1624 (%i3) expr1^2;
1625 2 2
1626 (%o3)/R/ b + (2 a + 2) b + a + 2 a + 1
1627 (%i4) ratwtlvl: 1$
1628 (%i5) expr1^2;
1629 (%o5)/R/ 2 b + 2 a + 1
1630 @end example
1632 @end deffn
1634 @defvr {Variable del sistema} ratweights
1635 Valor por defecto: @code{[]}
1637 La variable @code{ratweights} es una lista que contiene los pesos asignados por @code{ratweight}.
1638 Las lista es acumulativa, en el sentido de que cada llamada a @code{ratweight} añade nuevos elementos a la lista.
1640 @end defvr
1642 @defvr {Variable opcional} ratwtlvl
1643 Valor por defecto: @code{false}
1645 La variable @code{ratwtlvl} se utiliza en combinación con la función @code{ratweight} para controlar el truncamiento de expresiones racionales canónicas (CRE). Con el valor por defecto, @code{false}, no se produce truncamiento alguno.
1647 @end defvr
1649 @deffn {Función} remainder (@var{p_1}, @var{p_2})
1650 @deffnx {Función} remainder (@var{p_1}, @var{p_2}, @var{x_1}, ..., @var{x_n})
1651 Devuelve el resto de la división del polinomio @var{p_1} entre @var{p_2}. Los argumentos @var{x_1}, ..., @var{x_n} se interpretan como en @code{ratvars}.
1653 La función @code{remainder} devuelve el segundo elemento de la lista retornada por @code{divide}.
1655 @c NEED SOME EXAMPLES HERE
1656 @end deffn
1658 @deffn {Función} resultant (@var{p_1}, @var{p_2}, @var{x})
1659 Calcula la resultante de los dos polinomios @var{p_1} y @var{p_2}, eliminando
1660 la variable @var{x}. La resultante es un determinante de los coeficientes de @var{x}
1661 en @var{p_1} y @var{p_2}, que es igual a cero si sólo si @var{p_1} y @var{p_2}
1662 tienen un factor común no constante.
1664 Si @var{p_1} o @var{p_2} pueden ser factorizados, puede ser necesario llamar a
1665 @code{factor} antes que invocar a @code{resultant}.
1667 La variable opcional @code{resultant} controla qué algoritmo será utilizado para calcular la resultante.
1668 Véanse @code{option_resultant} y @code{resultant}.
1670 La función @code{bezout} toma los mismos argumentos que @code{resultant} y devuelve una matriz.
1671 El determinante del valor retornado es la resultante buscada.
1673 Ejemplos:
1675 @example
1676 (%i1) resultant(2*x^2+3*x+1, 2*x^2+x+1, x);
1677 (%o1) 8
1678 (%i2) resultant(x+1, x+1, x);
1679 (%o2) 0
1680 (%i3) resultant((x+1)*x, (x+1), x);
1681 (%o3) 0
1682 (%i4) resultant(a*x^2+b*x+1, c*x + 2, x);
1683 2
1684 (%o4) c - 2 b c + 4 a
1686 (%i5) bezout(a*x^2+b*x+1, c*x+2, x);
1687 @group
1688 [ 2 a 2 b - c ]
1689 (%o5) [ ]
1690 [ c 2 ]
1691 @end group
1692 (%i6) determinant(%);
1693 (%o6) 4 a - (2 b - c) c
1694 @end example
1695 @end deffn
1699 @defvr {Variable opcional} resultant
1700 Valor por defecto: @code{subres}
1702 La variable opcional @code{resultant} controla qué algoritmo será utilizado para
1703 calcular la resultante con la función @code{resultant}. Los valores posibles son:
1705 @table @code
1706 @item subres
1707 para el algoritmo PRS (@i{polynomial remainder sequence}) subresultante,
1708 @item mod
1709 para el algoritmo resultante modular y
1710 @item red
1711 para el algoritmo PRS (@i{polynomial remainder sequence}) reducido.
1712 @end table
1714 En la mayor parte de problemas, el valor por defecto, @code{subres}, es el
1715 más apropiado. Pero en el caso de problemas bivariantes o univariantes
1716 de grado alto, puede ser mejor utilizar @code{mod}.
1717 @end defvr
1721 @defvr {Variable opcional} savefactors
1722 Valor por defecto: @code{false}
1724 @c "certain functions" -- WHICH ONES ??
1725 Si @code{savefactors} vale @code{true}, los factores de una expresión producto se almacenan por ciertas funciones a fin de acelerar posteriores factorizaciones de expresiones que contengan algunos de estos factores.
1727 @end defvr
1730 @deffn {Función} showratvars (@var{expr})
1731 Devuelve una lista de las variables de expresiones canónicas racionales (CRE) en la expresión @code{expr}.
1733 Véase también @code{ratvars}.
1735 @end deffn
1739 @c FALTA DEFINICION DE sqfr
1742 @deffn {Función} tellrat (@var{p_1}, ..., @var{p_n})
1743 @deffnx {Función} tellrat ()
1744 Añade al anillo de enteros algebraicos conocidos por Maxima los elementos que son soluciones de los polinomios @var{p_1}, ..., @var{p_n}. Cada argumento @var{p_i} es un polinomio de coeficientes enteros.
1746 La llamada @code{tellrat (@var{x})} hace que se sustituya 0 por @var{x} en las funciones racionales.
1748 La llamada @code{tellrat ()} devuelve una lista con las sustituciones actuales.
1750 A la variable @code{algebraic} se le debe asignar el valor @code{true} a fin de poder realizar la simplificación de enteros algebraicos.
1752 Maxima reconoce la unidad imaginaria @code{%i} y todas las raíces de los enteros.
1754 La instrucción @code{untellrat} borra todas las propiedades de @code{tellrat}.
1756 Es ambiguo aplicar @code{tellrat} a un polinomio multivariante tal como @code{tellrat (x^2 - y^2)}, pues no se sabe si sustituir @code{@var{y}^2} por @code{@var{x}^2} o al revés. Maxima sigue un cierto orden, pero si el usuario quiere especificar uno en concreto, puede hacerlo mediante la sintaxis @code{tellrat (y^2 = x^2)}, que indica que se ponga @code{@var{x}^2} en lugar de @code{@var{y}^2}.
1758 Ejemplos:
1759 @c EXAMPLE ADAPTED FROM example (tellrat)
1760 @c 10*(%i + 1)/(%i + 3^(1/3));
1761 @c ev (ratdisrep (rat(%)), algebraic);
1762 @c tellrat (1 + a + a^2);
1763 @c 1/(a*sqrt(2) - 1) + a/(sqrt(3) + sqrt(2));
1764 @c ev (ratdisrep (rat(%)), algebraic);
1765 @c tellrat (y^2 = x^2);
1767 @example
1768 (%i1) 10*(%i + 1)/(%i + 3^(1/3));
1769 10 (%i + 1)
1770 (%o1) -----------
1771 1/3
1772 %i + 3
1773 (%i2) ev (ratdisrep (rat(%)), algebraic);
1774 2/3 1/3 2/3 1/3
1775 (%o2) (4 3 - 2 3 - 4) %i + 2 3 + 4 3 - 2
1776 (%i3) tellrat (1 + a + a^2);
1777 2
1778 (%o3) [a + a + 1]
1779 (%i4) 1/(a*sqrt(2) - 1) + a/(sqrt(3) + sqrt(2));
1780 1 a
1781 (%o4) ------------- + -----------------
1782 sqrt(2) a - 1 sqrt(3) + sqrt(2)
1783 (%i5) ev (ratdisrep (rat(%)), algebraic);
1784 (7 sqrt(3) - 10 sqrt(2) + 2) a - 2 sqrt(2) - 1
1785 (%o5) ----------------------------------------------
1786 7
1787 (%i6) tellrat (y^2 = x^2);
1788 2 2 2
1789 (%o6) [y - x , a + a + 1]
1790 @end example
1792 @end deffn
1794 @deffn {Función} totaldisrep (@var{expr})
1795 Convierte cada subexpresión de @var{expr} del formato canónico (CRE) al general y devuelve el resultado.
1796 Si @var{expr} está en formato CRE entonces @code{totaldisrep} es idéntico a @code{ratdisrep}.
1798 La función @code{totaldisrep} puede ser útil para modificar expresiones como las ecuaciones, listas, matrices, etc., que tienen algunas subexpresiones en formato CRE.
1800 @c NEED EXAMPLES HERE
1801 @end deffn
1803 @deffn {Función} untellrat (@var{x_1}, ..., @var{x_n})
1804 Elimina de @var{x_1}, ..., @var{x_n} las propiedades relacionadas con @code{tellrat}.
1806 @c NEED EXAMPLES HERE
1807 @end deffn