Introducción a los polinomios
=============================

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.

Funciones y variables para polinomios
=====================================

 -- Variable opcional: algebraic
     Valor por defecto: false

     La variable algebraic debe valer true para que se pueda hacer la simplificación de enteros algebraicos.

 -- Variable opcional: berlefact
     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.

 -- Función: bezout (P1, P2, X)
     Es una alternativa a la función resultant.  Devuelve una matriz.

 -- Función: bothcoef (EXPR, X)
     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

 -- Función: coeff (EXPR, X, N)
     Devuelve el coeficiente de X^N en EXPR. El argumento N puede omitirse si es igual a la unidad. El argumento X puede ser un átomo  o una subexpresión completa de EXPR, por ejemplo sin(x), a[i+1], x + y, etc. (En este último caso, la expresión (x + y) debe aparecer en EXPR).  En ocasiones puede ser necesario expandir o factorizar EXPR para hacer X^N explícito, lo cual no hace coeff automáticamente.

     Ejemplos:

          (%i1) coeff (2*a*tan(x) + tan(x) + b = 5*tan(x) + 3, tan(x));
          (%o1)                      2 a + 1 = 5
          (%i2) coeff (y + x*%e^x + 1, x, 0);
          (%o2)                         y + 1

 -- Función: combine (EXPR)
     Simplifica la suma EXPR combinando términos de con igual denominador reduciéndolos a un único término.

 -- Función: content (P_1, X_1, ..., X_N)
     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]

 -- Función: denom (EXPR)
     Devuelve el denominador de la expresión racional EXPR.

 -- Función: divide (P_1, P_2, X_1, ..., X_N)
     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.

 -- Función: eliminate ([EQN_1, ..., EQN_N], [X_1, ..., X_K])
     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]

 -- Función: ezgcd (P_1, P_2, P_3, ...)
     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.

 -- Variable opcional: facexpand
     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).

 -- Función: factcomb (EXPR)
     Trata de combinar los coeficientes de los factoriales de EXPR con los mismos factoriales, convirtiendo, por ejemplo, (n + 1)*n! en (n + 1)!.

     Si la variable sumsplitfact vale false hará que minfactorial se aplique después de factcomb.

 -- Función: factor (EXPR)
     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 enteros 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)

 -- Variable opcional: factorflag
     Valor por defecto: false

     Si factorflag vale false se evita la factorización de factores enteros de expresiones racionales.

 -- Función: factorout (EXPR, X_1, X_2, ...)
     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.

 -- Función: factorsum (EXPR)
     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) )

 -- Función: fasttimes (P_1, P_2)
     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.

 -- Función: fullratsimp (EXPR)
     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

 -- Función: fullratsubst (A, B, C)
     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

       * Si sólo se quiere una sustitución, entonces se puede dar una única ecuación como primer argumento.

          (%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

 -- Función: gcd (P_1, P_2, X_1, ...)
     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 previamente a true y gcd no puede ser ez. Se recomienda utilizar el algoritmo subres en lugar de red, por ser aquél más nuevo.

     Cuando la variable gcd, cuyo valor por defecto es subres, 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.

 -- Función: gcdex (F, G)
 -- Función: gcdex (F, G, X)
     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

 -- Función: gcfactor (N)
     Factoriza el entero gaussiano N como producto, a su vez, de enteros gaussianos, (un entero gaussiano es de la formaA + B %i donde A y B son números enteros). Los factores se normalizan de manera que tanto la parte real como imaginaria sean no negativas.

 -- Función: gfactor (EXPR)
     Factoriza el polinomio EXPR sobre los enteros gaussianos (un entero gaussiano es de la formaA + B %i donde A y B son números enteros). Es como factor (EXPR, A^2+1) donde A vale %i.

     Ejemplo:

          (%i1) gfactor (x^4 - 1);
          (%o1)           (x - 1) (x + 1) (x - %i) (x + %i)

 -- Función: gfactorsum (EXPR)
     Esta función es similar a factorsum pero aplica gfactor en lugar de factor.

 -- Función: hipow (EXPR, X)
     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

 -- Variable opcional: intfaclim
     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.

 -- Variable opcional: keepfloat
     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).

 -- Función: lratsubst (L, EXPR)
     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

       * If only one substitution is desired, then a single equation may be given as first argument.

          (%i4) lratsubst (a^2 = b, a^3);
          (%o4)                          a b

 -- Variable opcional: modulus
     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 asociadas) 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 permitirá que a modulus se le asigne cero o un entero negativo, aunque no esté clara su utilidad.

 -- Función: num (EXPR)
     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.

 -- Función: polydecomp (P, X)

     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

 -- Función: quotient (P_1, P_2)
 -- Función: quotient (P_1, P_2, X_1, ..., X_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.

 -- Función: rat (EXPR)
 -- Función: rat (EXPR, X_1, ..., X_N)
     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

 -- Variable opcional: ratalgdenom
     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.

 -- Función: ratcoef (EXPR, X, N)
 -- Función: ratcoef (EXPR, X)
     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

 -- Función: ratdenom (EXPR)
     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.

 -- Variable opcional: ratdenomdivide
     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.

     Examples:

          (%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

 -- Función: ratdiff (EXPR, X)
     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

 -- Función: ratdisrep (EXPR)
     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.

 -- Variable opcional: ratepsilon
     Valor por defecto: 2.0e-8

     La variable ratepsilon guarda la tolerancia utilizada en la conversión de números decimales en coma flotante a números racionales.

 -- Función: ratexpand (EXPR)
 -- Variable opcional: ratexpand
     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

 -- Variable opcional: ratfac
     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.

 -- Función: ratnumer (EXPR)
     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.

 -- Función: ratnump (EXPR)
     Devuelve true si EXPR es un entero literal o una fracción de enteros literales, en caso contrario devuelve false.

 -- Función: ratp (EXPR)
     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.

 -- Variable opcional: ratprint
     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.

 -- Función: ratsimp (EXPR)
 -- Función: ratsimp (EXPR, X_1, ..., X_N)
     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

 -- Variable opcional: ratsimpexpons
     Valor por defecto: false

     Si ratsimpexpons vale true, ratsimp se aplica a los exponentes de las expresiones durante la simplificación.

 -- Función: ratsubst (A, B, C)
     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.

     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

 -- Función: ratvars (X_1, ..., X_N)
 -- Función: ratvars ()
 -- Variable del sistema: ratvars
     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.

 -- Función: ratweight (X_1, W_1, ..., X_N, W_N)
 -- Función: ratweight ()
     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

 -- Variable del sistema: ratweights
     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.

 -- Variable opcional: ratwtlvl
     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.

 -- Función: remainder (P_1, P_2)
 -- Función: remainder (P_1, P_2, X_1, ..., X_N)
     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.

 -- Función: resultant (P_1, P_2, X)
 -- Variable: resultant
     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 resultant controla qué algoritmo será utilizado para calcular la resultante.

     La función bezout toma los mismos argumentos que resultant y devuelve una matriz. El determinante del valor retornado es la resultante buscada.

 -- Variable opcional: savefactors
     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.

 -- Función: tellrat (P_1, ..., P_N)
 -- Función: tellrat ()
     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]

 -- Función: totaldisrep (EXPR)
     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.

 -- Función: untellrat (X_1, ..., X_N)
     Elimina de X_1, ..., X_N las propiedades relacionadas con tellrat.