Siguiente: Funciones Especiales, Anterior: Lectura y escritura [Índice general][Índice]
Siguiente: Funciones y variables para polinomios, Anterior: Polinomios, Subir: Polinomios [Índice general][Índice]
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 factor, ratsimp y demás.
Las Expresiones Racionales Canónicas (CRE) constituyen un tipo de representación
que es especialmente apropiado para expandir polinomios y funciones racionales
(así como para polinomios parcialmente factorizados y funciones racionales cuando a la variable ratfac se le asigna el valor 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,
una por cada término del polinomio. El primer miembro
de cada par es el exponente de la variable principal en ese término y el
segundo miembro es el coeficiente de ese término, el cual puede ser un número o
un polinomio en otra variable representado también de esta forma. Así,
la parte principal de la forma CRE de 3*X^2-1 es (X 2 3 0 -1) y la de
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.
Las "variables" de la expresión CRE no son necesariamente atómicas. De hecho
cualquier subexpresión cuyo operador principal no es + - * / ni ^ con potencia entera
puede ser considerada como una "variable" de la expresión (en forma CRE) en
el cual aparezca. Por ejemplo las variables CRE de la expresión
X+SIN(X+1)+2*SQRT(X)+1 son X, SQRT(X) y SIN(X+1). Si el usuario no
especifica una ordenación de las variables mediante la función ratvars
Maxima escogerá una alfabéticamente. En general, laa CRE representan expresiones
racionales, esto es, fracciones de polinomios, donde el numerador y
el denominador no tienen factores comunes, siendo el denominador es
positivo. La forma interna es esencialmente un par de polinomios (el
numerador y el denominador) precedida por la lista de variables ordenadas. Si
una expresión a ser mostrada está en la forma CRE o contiene alguna
subexpresión en forma de CRE, el simbolo /R/ será seguido por la etiqueta de la línea de comando.
Véase la función rat para convertir una expresión a la forma CRE. Una
extensión de la forma CRE se utiliza para la representación de las series de Taylor. La
noción de una expresión racional se extiende de manera que los exponentes de las
variables pueden ser números racionales positivos o negativos y no sólo
enteros positivos y los coeficientes pueden ser también expresiones
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.
Anterior: Introducción a los polinomios, Subir: Polinomios [Índice general][Índice]
Valor por defecto: false
La variable algebraic debe valer true para que se pueda hacer la simplificación de enteros algebraicos.
Valor por defecto: true
Si berlefact vale 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.
Es una alternativa a la función resultant. Devuelve una matriz.
(%i1) bezout(a*x+b, c*x^2+d, x);
[ b c - a d ]
(%o1) [ ]
[ a b ]
(%i2) determinant(%);
2 2
(%o2) a d + b c
(%i3) resultant(a*x+b, c*x^2+d, x);
2 2
(%o3) a d + b c
Devuelve una lista cuyo primer miembro es el coeficiente de x en expr (que coincide con el que devuelve ratcoef si expr está en formato CRE, o el que devuelve coeff si no está en este formato) y cuyo segundo miembro es la parte restante de expr. Esto es, [A, B] donde expr = A*x + B.
Ejemplo:
(%i1) islinear (expr, x) := block ([c],
c: bothcoef (rat (expr, x), x),
is (freeof (x, c) and c[1] # 0))$
(%i2) islinear ((r^2 - (x - r)^2)/x, x);
(%o2) true
Devuelve el coeficiente de x^n en expr,
donde expr es un polinomio o monomio en x.
coeff(expr, x^n) es equivalente a
coeff(expr, x, n).
coeff(expr, x, 0) devuelve el resto de expr,
el cual no contiene a x. En caso de omisión, se entiende
que n es igual a 1.
x puede ser tanto el nombre de una variable simple como el de una variable con subíndice, o también una subexpresión de expr que contenga un operador junto con todos sus argumentos.
En ocasiones, es posible calcular los coeficientes de expresiones
equivalentes a expr aplicando expand o factor.
coeff no aplica ni expand, ni factor, ni ninguna otra
función.
coeff se distribuye sobre listas, matrices y ecuaciones.
Ejemplos:
coeff devuelve el coeficiente de x^n en expr.
(%i1) coeff (b^3*a^3 + b^2*a^2 + b*a + 1, a^3);
3
(%o1) b
coeff(expr, x^n) es equivalente
a coeff(expr, x, n).
(%i1) coeff (c[4]*z^4 - c[3]*z^3 - c[2]*z^2 + c[1]*z, z, 3);
(%o1) - c
3
(%i2) coeff (c[4]*z^4 - c[3]*z^3 - c[2]*z^2 + c[1]*z, z^3);
(%o2) - c
3
coeff(expr, x, 0) devuelve el resto de expr,
el cual no contiene a x.
(%i1) coeff (a*u + b^2*u^2 + c^3*u^3, b, 0);
3 3
(%o1) c u + a u
x puede ser tanto el nombre de una variable simple como el de una variable con subíndice, o también una subexpresión de expr que contenga un operador junto con todos sus argumentos.
(%i1) coeff (h^4 - 2*%pi*h^2 + 1, h, 2);
(%o1) - 2 %pi
(%i2) coeff (v[1]^4 - 2*%pi*v[1]^2 + 1, v[1], 2);
(%o2) - 2 %pi
(%i3) coeff (sin(1 + x)*sin(x) + sin(1 + x)^3*sin(x)^3, sin(1 + x)^3);
3
(%o3) sin (x)
(%i4) coeff ((d - a)^2*(b + c)^3 + (a + b)^4*(c - d), a + b, 4);
(%o4) c - d
coeff no aplica ni expand, ni factor, ni ninguna otra
función.
(%i1) coeff (c*(a + b)^3, a);
(%o1) 0
(%i2) expand (c*(a + b)^3);
3 2 2 3
(%o2) b c + 3 a b c + 3 a b c + a c
(%i3) coeff (%, a);
2
(%o3) 3 b c
(%i4) coeff (b^3*c + 3*a*b^2*c + 3*a^2*b*c + a^3*c, (a + b)^3);
(%o4) 0
(%i5) factor (b^3*c + 3*a*b^2*c + 3*a^2*b*c + a^3*c);
3
(%o5) (b + a) c
(%i6) coeff (%, (a + b)^3);
(%o6) c
coeff se distribuye sobre listas, matrices y ecuaciones.
(%i1) coeff ([4*a, -3*a, 2*a], a); (%o1) [4, - 3, 2] (%i2) coeff (matrix ([a*x, b*x], [-c*x, -d*x]), x);
[ a b ]
(%o2) [ ]
[ - c - d ]
(%i3) coeff (a*u - b*v = 7*u + 3*v, u); (%o3) a = 7
Devuelve una lista cuyo primer miembro es el máximo común divisor de los coeficientes de los términos del polinomio p_1 de variable x_n (este es el contenido) y cuyo segundo miembro es el polinomio p_1 dividido por el contenido.
Ejemplos:
(%i1) content (2*x*y + 4*x^2*y^2, y);
2
(%o1) [2 x, 2 x y + y]
Devuelve el denominador de la expresión racional expr.
Calcula el cociente y el resto del polinomio p_1 dividido por el polinomio p_2, siendo la variable principal x_n.
Las otras funciones son como en la función ratvars. El resultado es una lista cuyo primer miembro es el cociente y el segundo miembro el resto.
Ejemplos:
(%i1) divide (x + y, x - y, x); (%o1) [1, 2 y] (%i2) divide (x + y, x - y); (%o2) [- 1, 2 x]
Nótese que y es la variable principal en el segundo ejemplo.
Elimina variables de ecuaciones (o de expresiones que se supone valen cero) tomando resultantes sucesivas. Devuelve una lista con n - k expresiones y k variables x_1, ..., x_k eliminadas. Primero se elimina x_1 dando n - 1 expresiones, después se elimina x_2, etc. Si k = n entonces se devuelve una lista con una única expresión, libre de las variables x_1, ..., x_k. En este caso se llama a solve para resolver la última resultante para la última variable.
Ejemplo:
(%i1) expr1: 2*x^2 + y*x + z;
2
(%o1) z + x y + 2 x
(%i2) expr2: 3*x + 5*y - z - 1;
(%o2) - z + 5 y + 3 x - 1
(%i3) expr3: z^2 + x - y^2 + 5;
2 2
(%o3) z - y + x + 5
(%i4) eliminate ([expr3, expr2, expr1], [y, z]);
8 7 6 5 4
(%o4) [7425 x - 1170 x + 1299 x + 12076 x + 22887 x
3 2
- 5154 x - 1291 x + 7688 x + 15376]
Devuelve una lista cuyo primer elemento es el máximo común divisor (mcd)
de los polinomios p_1, p_2, p_3, …, siendo los
miembros restantes los mismos polinomios divididos por el mcd.
Se utiliza siempre el algoritmo ezgcd.
Véanse también gcd, gcdex, gcdivide y poly_gcd.
Ejemplos:
Los tres polinomios tiene como máximo común divisor 2*x-3,
el cual se calcula primero con la función gcd y luego con
ezgcd.
(%i1) p1 : 6*x^3-17*x^2+14*x-3;
3 2
(%o1) 6 x - 17 x + 14 x - 3
(%i2) p2 : 4*x^4-14*x^3+12*x^2+2*x-3;
4 3 2
(%o2) 4 x - 14 x + 12 x + 2 x - 3
(%i3) p3 : -8*x^3+14*x^2-x-3;
3 2
(%o3) - 8 x + 14 x - x - 3
(%i4) gcd(p1, gcd(p2, p3));
(%o4) 2 x - 3
(%i5) ezgcd(p1, p2, p3);
2 3 2 2
(%o5) [2 x - 3, 3 x - 4 x + 1, 2 x - 4 x + 1, - 4 x + x + 1]
Valor por defecto: true
La variable facexpand controla si los factores irreducibles devueltos por factor están en formato expandido (por defecto) o recursivo (CRE normal).
Factoriza la expresión expr, que puede contener
cualquier número de variables o funciones, en factores
irreducibles respecto de los enteros. La llamada
factor (expr, p) factoriza expr
en el campo de los racionales con un elemento añadido cuyo
polinomio mínimo es p.
La función factor utiliza a ifactors
para factorizar enteros.
Si la variable factorflag vale false suprime
la factorización de los factores enteros en las expresiones racionales.
La variable dontfactor puede contener una lista
de variables con respecto a las cuales no se factorizará
(inicialmente está vacía). Tampoco se
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 dontfactor.
Si la variable savefactors vale true, los
factores de una expresión en forma de producto se guardarán
por ciertas funciones a fin de acelerar posteriores factorizaciones
de expresiones que contengan algunos de estos mismos factores.
Si berlefact vale 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.
Si la variable intfaclim vale true, Maxima desistirá de
factorizar enteros si no encuentra ningún factor después de las
divisiones tentativas y de aplicar el método rho de Pollard. Si vale
false (este es el caso cuando el usuario invoca explícitamente
a factor), se intentará la factorización completa del entero. El valor
asignado a intfaclim se utiliza en llamadas internas a factor. Así,
se puede cambiar el valor de intfaclim para evitar que Maxima dedique
un tiempo prohibitivo a factorizar números enteros grandes.
Ejemplos:
(%i1) factor (2^63 - 1);
2
(%o1) 7 73 127 337 92737 649657
(%i2) factor (-8*y - 4*x + z^2*(2*y + x));
(%o2) (2 y + x) (z - 2) (z + 2)
(%i3) -1 - 2*x - x^2 + y^2 + 2*x*y^2 + x^2*y^2;
2 2 2 2 2
(%o3) x y + 2 x y + y - x - 2 x - 1
(%i4) block ([dontfactor: [x]], factor (%/36/(1 + 2*y + y^2)));
2
(x + 2 x + 1) (y - 1)
(%o4) ----------------------
36 (y + 1)
(%i5) factor (1 + %e^(3*x));
x 2 x x
(%o5) (%e + 1) (%e - %e + 1)
(%i6) factor (1 + x^4, a^2 - 2);
2 2
(%o6) (x - a x + 1) (x + a x + 1)
(%i7) factor (-y^2*z^2 - x*z^2 + x^2*y^2 + x^3);
2
(%o7) - (y + x) (z - x) (z + x)
(%i8) (2 + x)/(3 + x)/(b + x)/(c + x)^2;
x + 2
(%o8) ------------------------
2
(x + 3) (x + b) (x + c)
(%i9) ratsimp (%);
4 3
(%o9) (x + 2)/(x + (2 c + b + 3) x
2 2 2 2
+ (c + (2 b + 6) c + 3 b) x + ((b + 3) c + 6 b c) x + 3 b c )
(%i10) partfrac (%, x);
2 4 3
(%o10) - (c - 4 c - b + 6)/((c + (- 2 b - 6) c
2 2 2 2
+ (b + 12 b + 9) c + (- 6 b - 18 b) c + 9 b ) (x + c))
c - 2
- ---------------------------------
2 2
(c + (- b - 3) c + 3 b) (x + c)
b - 2
+ -------------------------------------------------
2 2 3 2
((b - 3) c + (6 b - 2 b ) c + b - 3 b ) (x + b)
1
- ----------------------------------------------
2
((b - 3) c + (18 - 6 b) c + 9 b - 27) (x + 3)
(%i11) map ('factor, %);
2
c - 4 c - b + 6 c - 2
(%o11) - ------------------------- - ------------------------
2 2 2
(c - 3) (c - b) (x + c) (c - 3) (c - b) (x + c)
b - 2 1
+ ------------------------ - ------------------------
2 2
(b - 3) (c - b) (x + b) (b - 3) (c - 3) (x + 3)
(%i12) ratsimp ((x^5 - 1)/(x - 1));
4 3 2
(%o12) x + x + x + x + 1
(%i13) subst (a, x, %);
4 3 2
(%o13) a + a + a + a + 1
(%i14) factor (%th(2), %);
2 3 3 2
(%o14) (x - a) (x - a ) (x - a ) (x + a + a + a + 1)
(%i15) factor (1 + x^12);
4 8 4
(%o15) (x + 1) (x - x + 1)
(%i16) factor (1 + x^99);
2 6 3
(%o16) (x + 1) (x - x + 1) (x - x + 1)
10 9 8 7 6 5 4 3 2
(x - x + x - x + x - x + x - x + x - x + 1)
20 19 17 16 14 13 11 10 9 7 6
(x + x - x - x + x + x - x - x - x + x + x
4 3 60 57 51 48 42 39 33
- x - x + x + 1) (x + x - x - x + x + x - x
30 27 21 18 12 9 3
- x - x + x + x - x - x + x + 1)
Valor por defecto: false
Si factorflag vale false se evita la factorización de factores enteros de expresiones racionales.
Reorganiza la suma expr como una suma de términos de la forma
f (x_1, x_2, ...)*g, donde g es un producto
de expresiones que no contienen ningún x_i y f se factoriza.
Nótese que factorout ignora la variable opcional keepfloat.
Ejemplo:
(%i1) expand (a*(x+1)*(x-1)*(u+1)^2);
2 2 2 2 2
(%o1) a u x + 2 a u x + a x - a u - 2 a u - a
(%i2) factorout(%,x);
2
(%o2) a u (x - 1) (x + 1) + 2 a u (x - 1) (x + 1)
+ a (x - 1) (x + 1)
Intenta agrupar términos en los factores de expr que son sumas en grupos de términos tales que su suma sea factorizable. La función factorsum puede restablecer el recuperar de expand ((x + y)^2 + (z + w)^2) pero no puede recuperar expand ((x + 1)^2 + (x + y)^2) porque los términos tienen variables comunes.
Ejemplo:
(%i1) expand ((x + 1)*((u + v)^2 + a*(w + z)^2));
2 2 2 2
(%o1) a x z + a z + 2 a w x z + 2 a w z + a w x + v x
2 2 2 2
+ 2 u v x + u x + a w + v + 2 u v + u
(%i2) factorsum (%);
2 2
(%o2) (x + 1) (a (z + w) + (v + u) )
Calcula el producto de los polinomios p_1 y p_2 utilizando un algoritmo especial. Los polinomios p_1 y p_2 deben ser multivariantes, densos y aproximadamente del mismo tamaño. La multiplicación clásica es de orden n_1 n_2 donde n_1 es el grado de p_1 y n_2 el grado de p_2. La función fasttimes es de orden max (n_1, n_2)^1.585.
Aplica repetidamente ratsimp a una expresión, seguida de simplificaciones no racionales, hasta que no se obtienen más transformaciones; entonces devuelve el resultado.
En presencia de expresiones no racionales, una llamada a 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 ratsimp, que es lo que hace precisamente fullratsimp.
Ejemplo:
(%i1) expr: (x^(a/2) + 1)^2*(x^(a/2) - 1)^2/(x^a - 1);
a/2 2 a/2 2
(x - 1) (x + 1)
(%o1) -----------------------
a
x - 1
(%i2) ratsimp (expr);
2 a a
x - 2 x + 1
(%o2) ---------------
a
x - 1
(%i3) fullratsimp (expr);
a
(%o3) x - 1
(%i4) rat (expr);
a/2 4 a/2 2
(x ) - 2 (x ) + 1
(%o4)/R/ -----------------------
a
x - 1
Similar a 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.
La función fullratsubst también acepta sus argumentos en el formato de lratsubst.
Es necesario ejecutar load ("lrats") para cargar fullratsubst y lratsubst.
Ejemplos:
(%i1) load ("lrats")$
subst puede hacer sustituciones múltiples;
lratsubst es análoga a subst.
(%i2) subst ([a = b, c = d], a + c); (%o2) d + b (%i3) lratsubst ([a^2 = b, c^2 = d], (a + e)*c*(a + c)); (%o3) (d + a c) e + a d + b c
(%i4) lratsubst (a^2 = b, a^3); (%o4) a b
fullratsubst equivale a ratsubst,
excepto por el hecho de que se llama a í misma recursivamente hasta que el resultado deja de cambiar.
(%i5) ratsubst (b*a, a^2, a^3);
2
(%o5) a b
(%i6) fullratsubst (b*a, a^2, a^3);
2
(%o6) a b
fullratsubst también acepta una lista de ecuaciones o una sóla ecuación como primer argumento.
(%i7) fullratsubst ([a^2 = b, b^2 = c, c^2 = a], a^3*b*c);
(%o7) b
(%i8) fullratsubst (a^2 = b*a, a^3);
2
(%o8) a b
fullratsubst puede caer en una recursión infinita.
(%i9) errcatch (fullratsubst (b*a^2, a^2, a^3)); *** - Lisp stack overflow. RESET
Devuelve el máximo común divisor de p_1 y p_2.
La variable gcd determiona qué algoritmo se va a utilizar.
Asignándole a gcd los valores ez, subres, red
o spmod, se seleccionan los algoritmos ezgcd,
subresultante prs, reducido o modular, respectivamente.
Si gcd vale false entonces gcd(p_1,
p_2, x) devolverá siempre 1 para cualquier x.
Muchas funciones (por ejemplo, ratsimp, factor, etc.)
hacen uso de gcd implícitamente.
En caso de polinomios homogéneos se recomienda darle a
gcd el valor subres. Para calcular un máximo
común divisor en presencia de raíces, como en
gcd (x^2 - 2*sqrt(2)*x + 2, x - sqrt(2)),
la variable algebraic debe igualarse
a true y gcd no puede ser ez.
Se recomienda utilizar el algoritmo subres en lugar de red,
por ser aquél más moderno.
Si la variable gcd, cuyo valor por defecto es spmod,
vale false, no se calculará el máximo común divisor
cuando las expresiones se conviertan a su forma canónica (CRE),
lo que redundará en ocasiones en mayor rapidez de cálculo.
Devuelve una lista [a, b, u] en la que u es el máximo común divisor (mcd) de f y g, e igual a a f + b g.
Los argumentos f y g deben ser polinomios univariantes, o indicarles la variable principal x en caso de ser multivariantes.
La función gcdex implementa el algoritmo de Euclides, en el que tenemos una secuencia de L[i]: [a[i], b[i], r[i]] todos ellos ortogonales a [f, g, -1] siendo el siguiente calculado a partir de q = quotient(r[i]/r[i+1]) y L[i+2]: L[i] - q L[i+1]; el proceso termina en L[i+1] cuando el resto r[i+2] se anula.
(%i1) gcdex (x^2 + 1, x^3 + 4);
2
x + 4 x - 1 x + 4
(%o1)/R/ [- ------------, -----, 1]
17 17
(%i2) % . [x^2 + 1, x^3 + 4, -1];
(%o2)/R/ 0
Factoriza el entero gaussiano n como producto, a su vez, de enteros gaussianos, (un entero gaussiano es de la formaa + b donde a y b son números enteros). Los factores se normalizan de manera que tanto la parte real como imaginaria sean no negativas.
%i
Factoriza el polinomio expr sobre los enteros gaussianos (un entero gaussiano es de la formaa + b donde a y b son números enteros).
Es como %ifactor (expr, a^2+1) donde a vale %i.
Ejemplo:
(%i1) gfactor (x^4 - 1); (%o1) (x - 1) (x + 1) (x - %i) (x + %i)
Esta función es similar a factorsum pero aplica gfactor en lugar de factor.
Devuelve el mayor exponente explícito de x en expr.
El argumentox puede ser una variable o una expresión general.
Si x no aparece en expr, hipow devuelve 0.
La función hipow no tiene en cuenta expresiones equivalentes a expr.
En particular, hipow no expande expr, de manera que hipow (expr, x) y hipow (expand (expr, x)) pueden dar resultados diferentes.
Ejemplos:
(%i1) hipow (y^3 * x^2 + x * y^4, x); (%o1) 2 (%i2) hipow ((x + y)^5, x); (%o2) 1 (%i3) hipow (expand ((x + y)^5), x); (%o3) 5 (%i4) hipow ((x + y)^5, x + y); (%o4) 5 (%i5) hipow (expand ((x + y)^5), x + y); (%o5) 0
Valor por defecto: true
Si vale true, Maxima desistirá de
factorizar enteros si no encuentra ningún factor después de las
divisiones tentativas y de aplicar el método rho de Pollard, por lo que
la factorización puede quedar incompleta.
Si vale false (este es el caso cuando el usuario invoca explícitamente
a factor), se intentará la factorización completa del entero. El valor
asignado a intfaclim se utiliza en llamadas internas a factor. A la variable
intfaclim se le asigna el valor false cuando se calculan factores desde las
funciones divisors, divsum y totient.
Las llamadas internas a factor respetan el valor dado por el usuario a intfaclim.
Asignando a intfaclim el valor true se puede reducir el tiempo que Maxima dedica a
factorizar enteros grandes.
Valor por defecto: false
Si keepfloat vale 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).
Nótese que la función solve y todas aquellas otras que la
invocan (por ejemplo, eigenvalues) ignoran esta variable, por
lo que hacen la conversión de los números decimales.
Ejemplos:
(%i1) rat(x/2.0);
`rat' replaced 0.5 by 1/2 = 0.5
x
(%o1)/R/ -
2
(%i2) rat(x/2.0), keepfloat;
(%o2)/R/ 0.5 x
solve ignora keepfloat:
(%i3) solve(1.0-x,x), keepfloat; `rat' replaced 1.0 by 1/1 = 1.0 (%o3) [x = 1]
Devuelve el menor exponente de x que aparece explícitamente en expr.
(%i1) lopow ((x+y)^2 + (x+y)^a, x+y); (%o1) min(a, 2)
Esta función es similar a subst (L, expr), excepto por el hecho de que utiliza ratsubst en lugar de subst.
El primer argumento de lratsubst es una ecuación o lista de ecuaciones idénticas en formato a las aceptadas por subst. Las sustituciones se hacen en el orden dado por la lista de ecuaciones, esto es, de izquierda a derecha.
La instrucción load ("lrats") carga fullratsubst y lratsubst.
Ejemplos:
(%i1) load ("lrats")$
subst can carry out multiple substitutions.
lratsubst is analogous to subst.
(%i2) subst ([a = b, c = d], a + c); (%o2) d + b (%i3) lratsubst ([a^2 = b, c^2 = d], (a + e)*c*(a + c)); (%o3) (d + a c) e + a d + b c
(%i4) lratsubst (a^2 = b, a^3); (%o4) a b
Valor por defecto: false
Si modulus es un número positivo p, las operaciones con números racionales
(como los devueltos por rat y funciones relacionadas) se realizan módulo p,
utilizando el llamado sistema de módulo balanceado, en el que n módulo p
se define como un entero k de [-(p-1)/2, ..., 0, ..., (p-1)/2]
si p es impar, o de [-(p/2 - 1), ..., 0, ...., p/2] si p es par,
de tal manera que a p + k es igual a n para algún entero a.
Normalmente a modulus se le asigna un número primo. Se acepta que a modulus
se le asigne un entero positivo no primo, pero se obtendrá un mensaje de aviso. Maxima
responderá con un mensaje de error cuando se le asigne a modulus cero o un número
negativo.
Ejemplos:
(%i1) modulus:7;
(%o1) 7
(%i2) polymod([0,1,2,3,4,5,6,7]);
(%o2) [0, 1, 2, 3, - 3, - 2, - 1, 0]
(%i3) modulus:false;
(%o3) false
(%i4) poly:x^6+x^2+1;
6 2
(%o4) x + x + 1
(%i5) factor(poly);
6 2
(%o5) x + x + 1
(%i6) modulus:13;
(%o6) 13
(%i7) factor(poly);
2 4 2
(%o7) (x + 6) (x - 6 x - 2)
(%i8) polymod(%);
6 2
(%o8) x + x + 1
Devuelve el numerador de expr si se trata de una fracción. Si expr no es una fracción, se devuelve expr.
La función num evalúa su argumento.
Descompone el polinomio p de variable x en una composición funcional de polinomios en x.
La función polydecomp devuelve una lista [p_1, ..., p_n] tal que
lambda([x],p_1)(lambda ([x],p_2)(...(lambda([x],p_n)(x))...))
es igual a p. El grado de p_i es mayor que 1 para i menor que n.
Esta descomposición no es única.
Ejemplos:
(%i1) polydecomp (x^210, x);
7 5 3 2
(%o1) [x , x , x , x ]
(%i2) p : expand (subst (x^3 - x - 1, x, x^2 - a));
6 4 3 2
(%o2) x - 2 x - 2 x + x + 2 x - a + 1
(%i3) polydecomp (p, x);
2 3
(%o3) [x - a, x - x - 1]
La siguiente función compone L = [e_1, ..., e_n] como funciones de x;
se trata de la inversa de polydecomp:
compose (L, x) := block ([r : x], for e in L do r : subst (e, x, r), r) $
Se vuelve a obtener el resultado del ejemplo de más arriba haciendo uso de compose:
(%i3) polydecomp (compose ([x^2 - a, x^3 - x - 1], x), x);
2 3
(%o3) [x - a, x - x - 1]
Nótese que aunque compose (polydecomp (p, x), x)
devuelve siempre p (sin expandir),
polydecomp (compose ([p_1, ..., p_n], x), x) no
devuelve necesariamente [p_1, ..., p_n]:
(%i4) polydecomp (compose ([x^2 + 2*x + 3, x^2], x), x);
2 2
(%o4) [x + 2, x + 1]
(%i5) polydecomp (compose ([x^2 + x + 1, x^2 + x + 1], x), x);
2 2
x + 3 x + 5
(%o5) [------, ------, 2 x + 1]
4 2
Convierte el polinomio p a una representación modular respecto del módulo actual, que es el valor almacenado en la variable modulus.
La llamada polymod (p, m) especifica un módulo m para ser utilizado en lugar de valor almacenado en modulus.
Véase modulus.
Devuelve las potencias de x dentro de expr.
La instrucción load ("powers") carga esta función.
Devuelve el polinomio p_1 dividido por el polinomio p_2. Los argumentos x_1, ..., x_n se interpretan como en la función ratvars.
La función quotient devuelve el primer elemento de la lista devuelta por divide.
Convierte 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 ratepsilon. Las variables se ordenan de acuerdo a x_1, ..., x_n si se han especificado, como en la función ratvars.
En general, rat no simplifica otras funciones que no sean la suma +, resta -, multiplicación *, división / y exponenciación de exponente entero, mientras que ratsimp sí lo hace.
Nótese que los átomos (números y variables) en expresiones en formato CRE no son los mismos que en el formato general.
Por ejemplo, rat(x)- x devuelve rat(0), que tiene una representación interna diferente de 0.
Si ratprint vale false no aparecerán mensajes informando al usuario sobre la conversión de números decimales en coma flotante a números racionales.
Si keepfloat vale true no se convertirán números decimales en coma flotante a números racionales.
Véanse también ratexpand y ratsimp.
Ejemplos:
(%i1) ((x - 2*y)^4/(x^2 - 4*y^2)^2 + 1)*(y + a)*(2*y + x)
/ (4*y^2 + x^2);
4
(x - 2 y)
(y + a) (2 y + x) (------------ + 1)
2 2 2
(x - 4 y )
(%o1) ------------------------------------
2 2
4 y + x
(%i2) rat (%, y, a, x);
2 a + 2 y
(%o2)/R/ ---------
x + 2 y
Valor por defecto: true
Si ratalgdenom vale true, se permite la racionalización de denominadores eliminando radicales.
La variable ratalgdenom sólo tiene efecto cuando expresiones en formato canónico (CRE) están siendo utilizadas en modo algebraico.
Devuelve el coeficiente de la expresión x^n dentro de la expresión expr. Si se omite, n se considera igual a 1.
El valor devuelto está libre de las variables en x, excepto quizás en un sentido no racional. Si no existe un coeficiente de este tipo se devuelve 0.
La función ratcoef expande y simplifica racionalmente su primer argumento, por lo que puede dar una respuesta diferente a la dada por la función coeff, la cual tiene un carácter puramente sintáctico.
Así, ratcoef ((x + 1)/y + x, x) devuelve (y + 1)/y,
mientras que coeff devuelve 1.
La llamada ratcoef (expr, x, 0), siendo expr una suma, devuelve una suma formada por los términos que no contienen x.
Puesto que expr se simplifica racionalmente antes de ser examinada, algunos coeficientes puede que no aparezcan como en la expresión original.
Ejemplo:
(%i1) s: a*x + b*x + 5$ (%i2) ratcoef (s, a + b); (%o2) x
Devuelve el denominador de expr, después de transformar expr al formato canónico (CRE). El valor retornado está también en formato CRE.
El argumento expr se transforma al formato CRE por la función rat, a menos que ya esté en este formato.
Esta conversión puede cambiar la forma de expr colocando todos sus términos sobre un denominador común.
La función denom es parecida, pero devuelve una expresión general en lugar de una CRE. Tampoco denom intenta colocar todos sus términos sobre un denominador común, de manera que algunas expresiones que son consideradas como divisiones por ratdenom, no son tales para denom.
Valor por defecto: true
Si ratdenomdivide vale true, la función ratexpand expande una fracción en la que el numerador es una suma en una suma de divisiones. En otro caso, ratexpand reduce una suma de divisiones a una única fracción, cuyo numerador es la suma de los denominadores de cada fracción.
Ejemplos:
(%i1) expr: (x^2 + x + 1)/(y^2 + 7);
2
x + x + 1
(%o1) ----------
2
y + 7
(%i2) ratdenomdivide: true$
(%i3) ratexpand (expr);
2
x x 1
(%o3) ------ + ------ + ------
2 2 2
y + 7 y + 7 y + 7
(%i4) ratdenomdivide: false$
(%i5) ratexpand (expr);
2
x + x + 1
(%o5) ----------
2
y + 7
(%i6) expr2: a^2/(b^2 + 3) + b/(b^2 + 3);
2
b a
(%o6) ------ + ------
2 2
b + 3 b + 3
(%i7) ratexpand (expr2);
2
b + a
(%o7) ------
2
b + 3
Deriva la expresión racional expr con respecto a x. El argumento expr debe ser una fracción algebraica o un polinomio en x. El argumento x puede ser una variable o una subexpresión de expr.
El resultado equivale al devuelto por diff, aunque es posible que se obtenga en una forma diferente.
La función ratdiff puede ser más rápida que diff en expresiones racionales.
La función ratdiff devuelve una expresión en formato canónico o CRE si expr es también una expresión CRE. En otro caso, ratdiff devuelve una expresión general.
La función ratdiff considera únicamente la dependencia de expr respecto de x, ignorando cualquier dependencia establecida por depends.
Ejemplo:
(%i1) expr: (4*x^3 + 10*x - 11)/(x^5 + 5);
3
4 x + 10 x - 11
(%o1) ----------------
5
x + 5
(%i2) ratdiff (expr, x);
7 5 4 2
8 x + 40 x - 55 x - 60 x - 50
(%o2) - ---------------------------------
10 5
x + 10 x + 25
(%i3) expr: f(x)^3 - f(x)^2 + 7;
3 2
(%o3) f (x) - f (x) + 7
(%i4) ratdiff (expr, f(x));
2
(%o4) 3 f (x) - 2 f(x)
(%i5) expr: (a + b)^3 + (a + b)^2;
3 2
(%o5) (b + a) + (b + a)
(%i6) ratdiff (expr, a + b);
2 2
(%o6) 3 b + (6 a + 2) b + 3 a + 2 a
Devuelve su argumento como una expresión general. Si expr es una expresión general, se devuelve sin cambios.
Normalmente se invoca a 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.
Véase también totaldisrep.
Expande 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.
El valor que devuelve ratexpand es una expresión general, incluso cuando expr está en formato canónico o CRE.
Si la variable ratexpand vale 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 false se mostrarán de forma recursiva. Véase también ratsimp.
Si ratdenomdivide vale true,
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, ratexpand reduce una suma de fracciones en una única fracción, cuyo numerador es la suma de los numeradores de cada fracción.
Si keepfloat vale 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).
Ejemplos:
(%i1) ratexpand ((2*x - 3*y)^3);
3 2 2 3
(%o1) - 27 y + 54 x y - 36 x y + 8 x
(%i2) expr: (x - 1)/(x + 1)^2 + 1/(x - 1);
x - 1 1
(%o2) -------- + -----
2 x - 1
(x + 1)
(%i3) expand (expr);
x 1 1
(%o3) ------------ - ------------ + -----
2 2 x - 1
x + 2 x + 1 x + 2 x + 1
(%i4) ratexpand (expr);
2
2 x 2
(%o4) --------------- + ---------------
3 2 3 2
x + x - x - 1 x + x - x - 1
Valor por defecto: false
Si ratfac vale true, las expresiones canónicas (CRE) se manipulan en una forma parcialmente factorizada.
Durante las operaciones racionales, las expresiones se mantienen completamente factorizadas tanto como sea posible sin llamar a factor. Esto debería ahorrar espacio y tiempo en algunos cálculos. El numerador y denominador se hacen primos relativos, por ejemplo rat ((x^2 - 1)^4/(x + 1)^2) devuelve (x - 1)^4 (x + 1)^2), pero los factores dentro de cada parte pueden no ser primos relativos.
En el paquete 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 ratfac vale true;
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.
Nota: Los esquemas de comportamiento basados en ratfac y ratweight son incompatibles y no se debe pretender usarlos al mismo tiempo.
Devuelve el numerador de expr, después de reducir expr a su forma canónica (CRE). El valor retornado está también en formato CRE.
El argumento expr se transforma al formato CRE por la función rat, a menos que ya esté en este formato.
Esta conversión puede cambiar la forma de expr colocando todos sus términos sobre un denominador común.
Es parecida a la función num, pero devuelve una expresión general en lugar de una CRE.
Además, num no intenta colocar todos los términos sobre un denominador común, de manera que algunas expresiones que son consideradas fracciones por ratnumer no se consideran como tales por num.
Devuelve true si expr es una expresión canónica racional (canonical rational expression o CRE) o una CRE extendida, en caso contrario devuelve false.
Las expresiones CRE son creadas por rat y funciones asociadas. Las CRE extendidas son creadas por taylor y funciones asociadas.
Valor por defecto: true
Si ratprint vale true, se muestra al usuario un mensaje dando cuenta de la conversión de números decimales en coma flotante a formato racional.
Simplifica la expresión 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 sin (x^2 + 1), y los argumentos de tales funciones son también racionalmente simplificados.
La llamada ratsimp (expr, x_1, ..., x_n) permite la simplificación racional con la especificación del orden de las variables, como en ratvars.
Si ratsimpexpons vale true, ratsimp se aplica a los exponentes de las expresiones durante la simplificación.
Véase también ratexpand. Nótese que ratsimp se ve afectada por algunas de las variables globales que controlan a ratexpand.
Ejemplos:
(%i1) sin (x/(x^2 + x)) = exp ((log(x) + 1)^2 - log(x)^2);
2 2
x (log(x) + 1) - log (x)
(%o1) sin(------) = %e
2
x + x
(%i2) ratsimp (%);
1 2
(%o2) sin(-----) = %e x
x + 1
(%i3) ((x - 1)^(3/2) - (x + 1)*sqrt(x - 1))/sqrt((x - 1)*(x + 1));
3/2
(x - 1) - sqrt(x - 1) (x + 1)
(%o3) --------------------------------
sqrt((x - 1) (x + 1))
(%i4) ratsimp (%);
2 sqrt(x - 1)
(%o4) - -------------
2
sqrt(x - 1)
(%i5) x^(a + 1/a), ratsimpexpons: true;
2
a + 1
------
a
(%o5) x
Valor por defecto: false
Si ratsimpexpons vale true, ratsimp se aplica a los exponentes de las expresiones durante la simplificación.
Valor por defecto: false
Si radsubstflag vale true se permite a ratsubst hacer la sustitución u por sqrt (x) in x.
Sustituye b por a en c y devuelve la expresión resultante. El argumento b puede ser una suma, un producto, una potencia, etc.
La función ratsubst reconoce el significado de las expresiones, mientras que subst tan solo realiza sustituciones sintácticas. Así por ejemplo, subst (a, x + y, x + y + z) devuelve x + y + z
cuando ratsubst devuelve z + a.
Si radsubstflag vale true,
ratsubst sustituye radicales en expresiones que no los contienen explícitamente.
ratsubst ignora el valor true de la variable
opcional keepfloat.
Ejemplos:
(%i1) ratsubst (a, x*y^2, x^4*y^3 + x^4*y^8);
3 4
(%o1) a x y + a
(%i2) cos(x)^4 + cos(x)^3 + cos(x)^2 + cos(x) + 1;
4 3 2
(%o2) cos (x) + cos (x) + cos (x) + cos(x) + 1
(%i3) ratsubst (1 - sin(x)^2, cos(x)^2, %);
4 2 2
(%o3) sin (x) - 3 sin (x) + cos(x) (2 - sin (x)) + 3
(%i4) ratsubst (1 - cos(x)^2, sin(x)^2, sin(x)^4);
4 2
(%o4) cos (x) - 2 cos (x) + 1
(%i5) radsubstflag: false$
(%i6) ratsubst (u, sqrt(x), x);
(%o6) x
(%i7) radsubstflag: true$
(%i8) ratsubst (u, sqrt(x), x);
2
(%o8) u
Declara como variables principales x_1, ..., x_n en expresiones racionales. Si 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 x_[n-1] si aparece en la expresión, se continúa así hasta x_1, que se considerará como variable principal sólo si ninguna de las variables que le siguen está presente en la expresión.
Si una variable de la expresión racional no está presente en la lista ratvars, se le dará una prioridad inferior a la de x_1.
Los argumentos de ratvars pueden ser tanto variables como funciones no racionales como sin(x).
La variable ratvars es una lista que contiene los argumentos pasados a la función ratvars la última vez que fue invocada. Cada llamada a la función ratvars reinicializa la lista. La llamada ratvars () vacía la lista.
Valor por defecto: true
Maxima almacena una lista interna en la variable Lisp VARLIST cuyo
contenido son las variables principales de las expresiones racionales. Cuando ratvarswitch
vale true, su valor por defecto, cada evaluación comienza con la lista
VARLIST vacía. En caso contrario, las variables principales
de las expresiones anteriores se mantienen en la lista VARLIST.
Las variables principales declaradas con la función ratvars no se
ven afectadas por la opción ratvarswitch.
Ejemplos:
Cuando ratvarswitch vale true, su valor por defecto, cada
evaluación comienza con la lista VARLIST vacía.
(%i1) ratvarswitch:true$
(%i2) rat(2*x+y^2);
2
(%o2)/R/ y + 2 x
(%i3) :lisp varlist
($X $Y)
(%i3) rat(2*a+b^2);
2
(%o3)/R/ b + 2 a
(%i4) :lisp varlist
($A $B)
Cuando ratvarswitch vale false, las variables principales
de las expresiones anteriores se mantienen en lista VARLIST.
(%i4) ratvarswitch:false$
(%i5) rat(2*x+y^2);
2
(%o5)/R/ y + 2 x
(%i6) :lisp varlist
($X $Y)
(%i6) rat(2*a+b^2);
2
(%o6)/R/ b + 2 a
(%i7) :lisp varlist
($A $B $X $Y)
Asigna un peso w_i a la variable x_i. Un término será reemplazado por 0 si su peso excede el valor de la variable 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 3 x_1^2 x_2 es 2 w_1 + w_2. El truncamiento basado en ratwtlvl solamente se lleva a cabo cuando se multiplican o se elevan a potencias expresiones canónicas (CRE).
La llamada ratweight () devuelve la lista acumulada de asignaciones de pesos.
Nota: Los esquemas de comportamiento basados en ratfac y ratweight son incompatibles y no se debe pretender usarlos al mismo tiempo.
Ejemplos:
(%i1) ratweight (a, 1, b, 1);
(%o1) [a, 1, b, 1]
(%i2) expr1: rat(a + b + 1)$
(%i3) expr1^2;
2 2
(%o3)/R/ b + (2 a + 2) b + a + 2 a + 1
(%i4) ratwtlvl: 1$
(%i5) expr1^2;
(%o5)/R/ 2 b + 2 a + 1
Valor por defecto: []
La variable ratweights es una lista que contiene los pesos asignados por ratweight.
Las lista es acumulativa, en el sentido de que cada llamada a ratweight añade nuevos elementos a la lista.
Valor por defecto: false
La variable ratwtlvl se utiliza en combinación con la función ratweight para controlar el truncamiento de expresiones racionales canónicas (CRE). Con el valor por defecto, false, no se produce truncamiento alguno.
Devuelve el resto de la división del polinomio p_1 entre p_2. Los argumentos x_1, ..., x_n se interpretan como en ratvars.
La función remainder devuelve el segundo elemento de la lista retornada por divide.
Calcula la resultante de los dos polinomios p_1 y p_2, eliminando la variable x. La resultante es un determinante de los coeficientes de x en p_1 y p_2, que es igual a cero si sólo si p_1 y p_2 tienen un factor común no constante.
Si p_1 o p_2 pueden ser factorizados, puede ser necesario llamar a
factor antes que invocar a resultant.
La variable opcional resultant controla qué algoritmo será utilizado para calcular la resultante.
Véanse option_resultant y resultant.
La función bezout toma los mismos argumentos que resultant y devuelve una matriz.
El determinante del valor retornado es la resultante buscada.
Ejemplos:
(%i1) resultant(2*x^2+3*x+1, 2*x^2+x+1, x);
(%o1) 8
(%i2) resultant(x+1, x+1, x);
(%o2) 0
(%i3) resultant((x+1)*x, (x+1), x);
(%o3) 0
(%i4) resultant(a*x^2+b*x+1, c*x + 2, x);
2
(%o4) c - 2 b c + 4 a
(%i5) bezout(a*x^2+b*x+1, c*x+2, x);
[ 2 a 2 b - c ]
(%o5) [ ]
[ c 2 ]
(%i6) determinant(%); (%o6) 4 a - (2 b - c) c
Valor por defecto: subres
La variable opcional resultant controla qué algoritmo será utilizado para
calcular la resultante con la función resultant. Los valores posibles son:
subrespara el algoritmo PRS (polynomial remainder sequence) subresultante,
modpara el algoritmo resultante modular y
redpara el algoritmo PRS (polynomial remainder sequence) reducido.
En la mayor parte de problemas, el valor por defecto, subres, es el
más apropiado. Pero en el caso de problemas bivariantes o univariantes
de grado alto, puede ser mejor utilizar mod.
Valor por defecto: false
Si savefactors vale 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.
Devuelve una lista de las variables de expresiones canónicas racionales (CRE) en la expresión expr.
Véase también ratvars.
Añade al anillo de enteros algebraicos conocidos por Maxima los elementos que son soluciones de los polinomios p_1, ..., p_n. Cada argumento p_i es un polinomio de coeficientes enteros.
La llamada tellrat (x) hace que se sustituya 0 por x en las funciones racionales.
La llamada tellrat () devuelve una lista con las sustituciones actuales.
A la variable algebraic se le debe asignar el valor true a fin de poder realizar la simplificación de enteros algebraicos.
Maxima reconoce la unidad imaginaria %i y todas las raíces de los enteros.
La instrucción untellrat borra todas las propiedades de tellrat.
Es ambiguo aplicar tellrat a un polinomio multivariante tal como tellrat (x^2 - y^2), pues no se sabe si sustituir y^2 por 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 tellrat (y^2 = x^2), que indica que se ponga x^2 en lugar de y^2.
Ejemplos:
(%i1) 10*(%i + 1)/(%i + 3^(1/3));
10 (%i + 1)
(%o1) -----------
1/3
%i + 3
(%i2) ev (ratdisrep (rat(%)), algebraic);
2/3 1/3 2/3 1/3
(%o2) (4 3 - 2 3 - 4) %i + 2 3 + 4 3 - 2
(%i3) tellrat (1 + a + a^2);
2
(%o3) [a + a + 1]
(%i4) 1/(a*sqrt(2) - 1) + a/(sqrt(3) + sqrt(2));
1 a
(%o4) ------------- + -----------------
sqrt(2) a - 1 sqrt(3) + sqrt(2)
(%i5) ev (ratdisrep (rat(%)), algebraic);
(7 sqrt(3) - 10 sqrt(2) + 2) a - 2 sqrt(2) - 1
(%o5) ----------------------------------------------
7
(%i6) tellrat (y^2 = x^2);
2 2 2
(%o6) [y - x , a + a + 1]
Convierte cada subexpresión de expr del formato canónico (CRE) al general y devuelve el resultado.
Si expr está en formato CRE entonces totaldisrep es idéntico a ratdisrep.
La función totaldisrep puede ser útil para modificar expresiones como las ecuaciones, listas, matrices, etc., que tienen algunas subexpresiones en formato CRE.
Elimina de x_1, ..., x_n las propiedades relacionadas con tellrat.
Siguiente: Funciones Especiales, Anterior: Lectura y escritura [Índice general][Índice]