Introducedilhaão a Polinômios
=============================

Polinômios são armazenados no Maxima ou na forma geral ou na forma de Expressões Racionais Canônicas (CRE).  Essa última é uma forma padrão, e é usada internamente por operacedilhaões tais como factor, ratsimp, e assim por diante.

Expressões Racionais Canônicas constituem um tipo de representacedilhaão que é especialmente adequado para polinômios expandidos e funcedilhaões racionais (também para polinômios parcialmente fatorados e funcedilhaões racionais quando RATFAC for escolhida para true).  Nessa forma CRE uma ordenacedilhaão de variáveis (da mais para a menos importante) é assumida para cada expressão.  Polinômios são representados recursivamente por uma lista consistindo da variável principal seguida por uma série de pares de expressões, uma para cada termo do polinômio.  O primeiro membro de cada par é o expoente da variável principal naquele termo e o segundo membro é o coeficiente daquele termo que pode ser um número ou um polinômio em outra variável novamente respresentado nessa forma.  Sendo assim a parte principal da forma CRE de 3*X^2-1 é (X 2 3 0 -1) e que a parte principal da forma CRE de 2*X*Y+X-3 é (Y 1 (X 1 2) 0 (X 1 1 0 -3)) assumindo Y como sendo a variável principal, e é (X 1 (Y 1 2 0 1) 0 -3) assumindo X como sendo a variável principal. A variável principal é usualmente determineda pela ordem alfabética reversa.  As "variáveis" de uma expressão CRE não necessariamente devem ser atômicas.  De fato qualquer subexpressão cujo principal operador não for + - * / or ^ com expoente inteiro será considerado uma "variável" da expressão (na forma CRE) na qual essa ocorrer.  Por exemplo as variáveis CRE da expressão X+SIN(X+1)+2*SQRT(X)+1 são X, SQRT(X), e SIN(X+1).  Se o usuário não especifica uma ordem de variáveis pelo uso da funcedilhaão RATVARS Maxima escolherá a alfabética por conta própria.  Em geral, CREs representam expressões racionais, isto é, razões de polinômios, onde o numerador e o denominador não possuem fatores comuns, e o denominador for positivo.  A forma interna é essencialmente um par de polinômios (o numerador e o denominador) precedidos pela lista de ordenacedilhaão de variável.  Se uma expressão a ser mostrada estiver na forma CRE ou se contiver quaisquer subexpressões na forma CRE, o símbolo /R/ seguirá o rótulo da linha. Veja a funcedilhaão RAT para saber como converter uma expressão para a forma CRE.  Uma forma CRE extendida é usada para a representacedilhaão de séries de Taylor.  A nocedilhaão de uma expressão racional é extendida de modo que os expoentes das variáveis podem ser números racionais positivos ou negativos em lugar de apenas inteiros positivos e os coeficientes podem eles mesmos serem expressões racionais como descrito acima em lugar de apenas polinômios.  Estes são representados internamente por uma forma polinomial recursiva que é similar à forma CRE e é a generalizacedilhaão dessa mesma forma CRE, mas carrega informacedilhaão adicional tal com o grau de truncacedilhaão.  Do mesmo modo que na forma CRE, o símbolo /T/ segue o rótulo de linha que contém as tais expressões.

Funcedilhaões e Variáveis Definidas para Polinômios
===================================================

 -- Variável de opcedilhaão: algebraic
     Valor Padrão: false

     algebraic deve ser escolhida para true com o objetivo de que a simplificacedilhaão de inteiros algébricos tenha efeito.

 -- Variável de opcedilhaão: berlefact
     Valor Padrão: true

     Quando berlefact for false então o algorítmo de fatoracedilhaão de Kronecker será usado.  De outra forma o algorítmo de Berlekamp, que é o padrão, será usado.

 -- Funcedilhaão: bezout (P1, P2, X)
     uma alternativa para o comando resultant.  Isso retorna uma matriz.  determinant dessa matriz é o resultante desejado.

 -- Funcedilhaão: bothcoef (EXPR, X)
     Retorna uma lista da qual o primeiro membro é o coeficiente de X em EXPR (como achado por ratcoef se EXPR está na forma CRE de outro modo por coeff) e cujo segundo membro é a parte restante de EXPR.  Isto é, [A, B] onde EXPR = A*X + B.

     Exemplo:

          (%i1) islinear (expr, x) := block ([c],
                  c: bothcoef (rat (expr, x), x),
                  é (freeof (x, c) and c[1] # 0))$
          (%i2) islinear ((r^2 - (x - r)^2)/x, x);
          (%o2)                         true

 -- Funcedilhaão: coeff (EXPR, X, N)
     Retorna o coeficiente de X^N em EXPR.  N pode ser omitido se for 1.  X pode ser um átomo, ou subexpressão completa de EXPR e.g., sin(x), a[i+1], x + y, etc. (No último caso a expressão (x + y) pode ocorrer em EXPR).  Algumas vezes isso pode ser necessário para expandir ou fatorar EXPR com o objetivo de fazer X^N explicito.  Isso não é realizado por coeff.

     Exemplos:

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

 -- Funcedilhaão: combine (EXPR)
     Simplifica a adicedilhaão EXPR por termos combinados com o mesmo denominador dentro de um termo simples.

 -- Funcedilhaão: content (P_1, X_1, ..., X_N)
     Retorna uma lista cujo primeiro elemento é o máximo divisor comum dos coeficientes dos termos do polinômio P_1 na variável X_N (isso é o conteúdo) e cujo segundo elemento é o polinômio P_1 dividido pelo conteúdo.

     Exemplos:

          (%i1) content (2*x*y + 4*x^2*y^2, y);
                                             2
          (%o1)                   [2 x, 2 x y  + y]

 -- Funcedilhaão: denom (EXPR)
     Retorna o denominador da expressão racional EXPR.

 -- Funcedilhaão: divide (P_1, P_2, X_1, ..., X_N)
     calcula o quocietne e o resto do polinômio P_1 dividido pelo polinômio P_2, na variável principal do polinômio, X_N. As outras variáveis são como na funcedilhaão ratvars. O resultado é uma lista cujo primeiro elemento é o quociente e cujo segundo elemento é o resto.

     Exemplos:

          (%i1) divide (x + y, x - y, x);
          (%o1)                       [1, 2 y]
          (%i2) divide (x + y, x - y);
          (%o2)                      [- 1, 2 x]

     Note que y é a variável principal no segundo exemplo.

 -- Funcedilhaão: eliminate ([EQN_1, ..., EQN_N], [X_1, ..., X_K])
     Elimina variáveis de equacedilhaões (ou expressões assumidas iguais a zero) pegando resultantes sucessivos. Isso retorna uma lista de N - K expressões com K variáveis X_1, ..., X_K eliminadas.  Primeiro X_1 é eliminado retornando N - 1 expressões, então x_2 é eliminado, etc.  Se K = N então uma expressão simples em uma lista é retornada livre das variáveis X_1, ..., X_K.  Nesse caso solve é chamado para resolver a última resultante para a última variável.

     Exemplo:

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

 -- Funcedilhaão: ezgcd (P_1, P_2, P_3, ...)
     Retorna uma lista cujo primeiro elemento é o m.d.c. dos polinômios P_1, P_2, P_3, ...  e cujos restantes elementos são os polinômios divididos pelo mdc.  Isso sempre usa o algorítmo ezgcd.

 -- Variável de opcedilhaão: facexpand
     Valor Padrão: true

     facexpand controla se os fatores irredutíveis retornados por factor estão na forma expandida (o padrão) ou na forma recursiva (CRE normal).

 -- Funcedilhaão: factcomb (EXPR)
     Tenta combinar os coeficientes de fatoriais em EXPR com os próprios fatoriais convertendo, por exemplo, (n + 1)*n! em (n + 1)!.

     sumsplitfact se escolhida para false fará com que minfactorial seja aplicado após um factcomb.

 -- Funcedilhaão: factor (EXPR)
     Fatora a expressão EXPR, contendo qualquer número de variáveis ou funcedilhaões, em fatores irredutíveis sobre os inteiros. factor (EXPR, p) fatora EXPR sobre o campo dos inteiros com um elemento adjunto cujo menor polinômio é p.

     factor usa a funcedilhaão ifactors para fatorar inteiros.

     factorflag se false suprime a fatoracedilhaão de fatores inteiros de expressões racionais.

     dontfactor pode ser escolhida para uma lista de variáveis com relacedilhaão à qual fatoracedilhaão não é para ocorrer.  (Essa é inicialmente vazia).  Fatoracedilhaão também não acontece com relacedilhaão a quaisquer variáveis que são menos importantes (usando a ordenacedilhaão de variável assumida pela forma CRE) como essas na lista dontfactor.

     savefactors se true faz com que os fatores de uma expressão que é um produto de fatores seja guardada por certas funcedilhaões com o objetivo de aumentar a velocidade de futuras fatoracedilhaões de expressões contendo alguns dos mesmos fatores.

     berlefact se false então o algorítmo de fatoracedilhaão de Kronecker será usado de outra forma o algorítmo de Berlekamp, que é o padrão, será usado.

     intfaclim se true maxima irá interromper a fatoracedilhaão de inteiros se nenhum fator for encontrado após tentar divisões e o método rho de Pollard.  Se escolhida para false (esse é o caso quando o usuário chama factor explicitamente), a fatoracedilhaão completa do inteiro será tentada.  A escolha do usuário para intfaclim é usada para chamadas internas a factor. Dessa forma, intfaclim pode ser resetada para evitar que o Maxima gaste um tempo muito longo fatorando inteiros grandes.

     Exemplos:

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

 -- Variável de opcedilhaão: factorflag
     Valor Padrão: false

     Quando factorflag for false, suprime a fatoracedilhaão de fatores inteiros em expressões racionais.

 -- Funcedilhaão: factorout (EXPR, X_1, X_2, ...)
     Rearranja a adicedilhaão EXPR em uma adicedilhaão de parcelas da forma f (X_1, X_2, ...)*g onde g é um produto de expressões que não possuem qualquer X_I e f é fatorado.

 -- Funcedilhaão: factorsum (EXPR)
     Tenta agrupar parcelas em fatores de EXPR que são adicedilhaões em grupos de parcelas tais que sua adicedilhaão é fatorável.  factorsum pode recuperar o resultado de expand ((x + y)^2 + (z + w)^2) mas não pode recuperar expand ((x + 1)^2 + (x + y)^2) porque os termos possuem variáveis em comum.

     Exemplo:

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

 -- Funcedilhaão: fasttimes (P_1, P_2)
     Retorna o produto dos polinômios P_1 e P_2 usando um algorítmo especial para a multiplicacedilhaão de polinômios.  p_1 e p_2 podem ser de várias variáveis, densos, e aproximadamente do mesmo tamanho.  A multiplicacedilhaão clássica é de ordem n_1 n_2 onde n_1 é o grau de p_1 and n_2 é o grau de p_2. fasttimes é da ordem max (n_1, n_2)^1.585.

 -- Funcedilhaão: fullratsimp (EXPR)
     fullratsimp aplica repetidamente ratsimp seguido por simplificacedilhaão não racional a uma expressão até que nenhuma mudancedilhaa adicional ocorra, e retorna o resultado.

     Quando expressões não racionais estão envolvidas, uma chamada a ratsimp seguida como é usual por uma simplificacedilhaão não racional ("geral") pode não ser suficiente para retornar um resultado simplificado. Algumas vezes, mais que uma tal chamada pode ser necessária. fullratsimp faz esse processo convenientemente.

     fullratsimp (EXPR, X_1, ..., X_N) pega um ou mais argumentos similar a ratsimp e rat.

     Exemplo:

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

 -- Funcedilhaão: fullratsubst (A, B, C)
     é o mesmo que ratsubst exceto que essa chama a si mesma recursivamente sobre esse resultado até que o resultado para de mudar. Essa funcedilhaão é útil quando a expressão de substituicedilhaão e a expressão substituída tenham uma ou mais variáveis em comum.

     fullratsubst irá também aceitar seus argumentos no formato de lratsubst.  Isto é, o primeiro argumento pode ser uma substituicedilhaão simples de equacedilhaão ou uma lista de tais equacedilhaões, enquanto o segundo argumento é a expressão sendo processada.

     load ("lrats") chama fullratsubst e lratsubst.

     Exemplos:

          (%i1) load ("lrats")$

       * subst pode realizar multiplas substituicedilhaões. lratsubst é analogo 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

       * Se somente uma substituicedilhaão é desejada, então uma equacedilhaão simples pode ser dada como primeiro argumento.

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

       * fullratsubst é equivalente a ratsubst exceto que essa executa recursivamente até que seu resultado para de mudar.

          (%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 também aceita uma lista de equacedilhaões ou uma equacedilhaão simples como primeiro 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 pode causar uma recursão infinita.

          (%i9) errcatch (fullratsubst (b*a^2, a^2, a^3));

          *** - Lisp stack overflow. RESET

 -- Funcedilhaão: gcd (P_1, P_2, X_1, ...)
     Retorna o máximo divisor comum entre P_1 e P_2. O sinalizador gcd determina qual algorítmo é empregado. Escolhendo gcd para ez, subres, red, ou spmod seleciona o algorítmo ezgcd, subresultante prs, reduzido, ou modular, respectivamente.  Se gcd for false então gcd (P_1, P_2, X) sempre retorna 1 para todo X.  Muitas funcedilhaões (e.g.  ratsimp, factor, etc.) fazem com que mdc's sejam feitos implicitamente.  Para polinômios homogêneos é recomendado que gcd igual a subres seja usado.  Para pegar o mdc quando uma expressão algébrica está presente, e.g. gcd (X^2 - 2*sqrt(2)*X + 2, X - sqrt(2)), algebraic deve ser true e gcd não deve ser ez.  subres é um novo algorítmo, e pessoas que tenham estado usando a opcedilhaão red podem provavelmente alterar isso para subres.

     O sinalizador gcd, padrão: subres, se false irá também evitar o máximo divisor comum de ser usado quando expressões são convertidas para a forma de expressão racional canônica (CRE).  Isso irá algumas vezes aumentar a velocidade dos cálculos se mdc's não são requeridos.

 -- Funcedilhaão: gcdex (F, G)
 -- Funcedilhaão: gcdex (F, G, X)
     Retornam uma lista [A, B, U] onde U é o máximo divisor comum (mdc) entre F e G, e U é igual a A F + B G. Os argumentos F e G podem ser polinômios de uma variável, ou de outra forma polinômios em X uma main(principal) variável suprida desde que nós precisamos estar em um domínio de ideal principal para isso trabalhar. O mdc significa o mdc considerando F e G como polinômios de uma única variável com coeficientes sendo funcedilhaões racionais em outras variáveis.

     gcdex implementa o algorítmo Euclideano, onde temos a seqüência of L[i]: [a[i], b[i], r[i]] que são todos perpendiculares a [f, g, -1] e o próximo se é construído como se q = quotient(r[i]/r[i+1]) então L[i+2]: L[i] - q L[i+1], e isso encerra em L[i+1] quando o resto r[i+2] for zero.

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

     Note que o mdc adiante é 1 uma vez que trabalhamos em k(y)[x], o y+1 não pode ser esperado em k[y, x].

          (%i1) gcdex (x*(y + 1), y^2 - 1, x);
                                         1
          (%o1)/R/                 [0, ------, 1]
                                        2
                                       y  - 1

 -- Funcedilhaão: gcfactor (N)
     Fatora o inteiro Gaussiano N sobre os inteiros Gaussianos, i.e., números da forma A + B %i onde A e B são inteiros raconais (i.e.,  inteiros comuns).  Fatoracedilhaões são normalizadas fazendo A e B não negativos.

 -- Funcedilhaão: gfactor (EXPR)
     Fatora o polinômio EXPR sobre os inteiros de Gauss (isto é, os inteiros com a unidade imaginária %i adjunta). Isso é como factor (EXPR, A^2+1) trocando A por %i.

     Exemplo:

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

 -- Funcedilhaão: gfactorsum (EXPR)
     é similar a factorsum mas aplica gfactor em lugar de factor.

 -- Funcedilhaão: hipow (EXPR, X)
     Retorna o maior expoente explícito de X em EXPR. X pode ser uma variável ou uma expressão geral. Se X não aparece em EXPR, hipow retorna 0.

     hipow não considera expressões equivalentes a expr. Em particular, hipow não expande expr, então hipow (EXPR, X) e hipow (expand (EXPR, X)) podem retornar diferentes resultados.

     Exemplos:

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

 -- Variável de opcedilhaão: intfaclim
     Valor padrão: true

     Se true, maxima irá interromper a fatoracedilhaão de inteiros se nenhum fator for encontrado após tentar divisões e o método rho de Pollard e a fatoracedilhaão não será completada.

     Quando intfaclim for false (esse é o caso quando o usuário chama factor explicitamente), a fatoracedilhaão completa será tentada.  intfaclim é escolhida para false quando fatores são calculados em divisors, divsum e totient.

     Chamadas internas a factor respeitam o valor especificado pelo usuário para intfaclim. Setting intfaclim to true may reduce intfaclim. Escolhendo intfaclim para true podemos reduzir o tempo gasto fatorando grandes inteiros.

 -- Variável de opcedilhaão: keepfloat
     Valor Padrão: false

     Quando keepfloat for true, evitamos que números em ponto flutuante sejam racionalizados quando expressões que os possuem são então convertidas para a forma de expressão racional canônica (CRE).

 -- Funcedilhaão: lratsubst (L, EXPR)
     é análogo a subst (L, EXPR) exceto que esse usa ratsubst em lugar de subst.

     O primeiro argumento de lratsubst é uma equacedilhaão ou uma lista de equacedilhaões idênticas em formato para que sejam aceitas por subst.  As substituicedilhaões são feitas na ordem dada pela lista de equacedilhaões, isto é, da esquerda para a direita.

     load ("lrats") chama fullratsubst e lratsubst.

     Exemplos:

          (%i1) load ("lrats")$

       * subst pode realizar multiplas substituicedilhaões. lratsubst é analoga 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

       * Se somente uma substituicedilhaão for desejada, então uma equacedilhaão simples pode ser dada como primeiro argumento.

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

 -- Variável de opcedilhaão: modulus
     Valor Padrão: false

     Quando modulus for um número positivo P, operacedilhaões sobre os números racionais (como retornado por rat e funcedilhaões relacionadas) são realizadas módulo P, usando o então chamado sistema de módulo "balanceado" no qual N módulo P é definido como um inteiro K em [-(P-1)/2, ..., 0, ..., (P-1)/2] quando P for ímpar, ou [-(P/2 - 1), ..., 0, ...., P/2] quando P for par, tal que A P + K seja igual a N para algum inteiro A.

     Se EXPR já estiver na forma de expressão racional canônica (CRE) quando modulus for colocado em seu valor original, então você pode precisar repetir o rat EXPR, e.g., expr: rat (ratdisrep (expr)), com o objetivo de pegar resultados corretos.

     Tipicamente modulus é escolhido para um número primo. Se modulus for escolhido para um inteiro não primo positivo, essa escolha é aceita, mas uma mensagem de alerta é mostrada. Maxima permitirá que zero ou um inteiro negativo seja atribuído a modulus, embora isso não seja limpo se aquele tiver quaisquer conseqüências úteis.

 -- Funcedilhaão: num (EXPR)
     Retorna o numerador de EXPR se isso for uma razão. Se EXPR não for uma razão, EXPR é retornado.

     num avalia seu argumento.

 -- Funcedilhaão: polydecomp (P, X)

     Decompões o polinômio P na variável  X em uma composicedilhaão funcional de polinômios em X. polydecomp retorna uma lista [P_1, ..., P_N] tal que

          lambda ([x], p_1) (lambda ([x], p_2) (... (lambda ([x], p_n) (x)) ...))

     seja igual a P. O grau de P_I é maior que 1 para I menor que N.

     Tal decomposicedilhaão não é única.

     Exemplos:

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

     As seguintes funcedilhaões compõem L = [e_1, ..., e_n] como funcedilhaões em x; essa funcedilhaào é a inversa de polydecomp:

          compose (L, x) :=
            block ([r : x], for e in L do r : subst (e, x, r), r) $

     Re-exprimindo o exemplo acima usando compose:

          (%i3) polydecomp (compose ([x^2 - a, x^3 - x - 1], x), x);
                                  2       3
          (%o3)                 [x  - a, x  - x - 1]

     Note que apesar de compose (polydecomp (P, X), X) sempre retornar P (não expandido), polydecomp (compose ([P_1, ..., P_N], X), X) não necessáriamente retorna [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

 -- Funcedilhaão: quotient (P_1, P_2)
 -- Funcedilhaão: quotient (P_1, P_2, X_1, ..., X_N)
     Retorna o polinômio P_1 dividido pelo polinômio P_2. Os argumentos X_1, ..., X_N são interpretados como em ratvars.

     quotient retorna o primeiro elemento de uma lista de dois elementos retornada por divide.

 -- Funcedilhaão: rat (EXPR)
 -- Funcedilhaão: rat (EXPR, X_1, ..., X_N)
     Converte EXPR para a forma de expressão racional canônica (CRE) expandindo e combinando todos os termos sobre um denominador comum e cancelando para fora o máximo divisor comum entre o numerador e o denominador, também convertendo números em ponto flutuante para números racionais dentro da tolerância de ratepsilon. As variáveis são ordenadas de acordo com X_1, ..., X_N, se especificado, como em ratvars.

     rat geralmente não simplifica funcedilhaões outras que não sejam adicedilhaão +, subtracedilhaão -, multiplicacedilhaão *, divisão /, e exponenciacedilhaão com expoente inteiro, uma vez que ratsimp não manuseia esses casos. Note que átomos (números e variáveis) na forma CRE não são os mesmos que eles são na forma geral. Por exemplo, rat(x)- x retorna rat(0) que tem uma representacedilhaão interna diferente de 0.

     Quando ratfac for true, rat retorna uma forma parcialmente fatorada para CRE. Durante operacedilhaões racionais a expressão é mantida como totalmente fatorada como possível sem uma chamada ao pacote de fatoracedilhaão (factor).  Isso pode sempre economizar espacedilhao de memória e algum tempo em algumas computacedilhaões.  O numerador e o denominador são ainda tidos como relativamente primos (e.g.  rat ((x^2 - 1)^4/(x + 1)^2) retorna (x - 1)^4 (x + 1)^2), mas os fatores dentro de cada parte podem não ser relativamente primos.

     ratprint se false suprime a impressão de mensagens informando o usuário de conversões de números em ponto flutuante para números racionais.

     keepfloat se true evita que números em ponto flutuante sejam convertidos para números racionais.

     Veja também ratexpand e  ratsimp.

     Exemplos:

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

 -- Variável de opcedilhaão: ratalgdenom
     Valor Padrão: true

     Quando ratalgdenom for true, permite racionalizacedilhaão de denominadores com respeito a radicais tenham efeito. ratalgdenom tem efeito somente quando expressões racionais canônicas (CRE) forem usadas no modo algébrico.

 -- Funcedilhaão: ratcoef (EXPR, X, N)
 -- Funcedilhaão: ratcoef (EXPR, X)
     Retorna o coeficiente da expressão X^N dentro da expressão EXPR. Se omitido, N é assumido ser 1.

     O valor de retorno está livre (exceto possivelmente em um senso não racional) das variáveis em X. Se nenhum coeficiente desse tipo existe, 0 é retornado.

     ratcoef expande e simplifica racionalmente seu primeiro argumento e dessa forma pode produzir respostas diferentes das de coeff que é puramente sintática. Dessa forma ratcoef ((x + 1)/y + x, x) retorna (y + 1)/y ao passo que coeff retorna 1.

     ratcoef (EXPR, X, 0), visualiza EXPR como uma adicedilhaão, retornando uma soma desses termos que não possuem X. portanto se X ocorre para quaisquer expoentes negativos, ratcoef pode não ser usado.

     Uma vez que EXPR é racionalmente simplificada antes de ser examinada, coeficientes podem não aparecer inteiramente no caminho que eles foram pensados.

     Exemplo:

          (%i1) s: a*x + b*x + 5$
          (%i2) ratcoef (s, a + b);
          (%o2)                           x

 -- Funcedilhaão: ratdenom (EXPR)
     Retorna o denominador de EXPR, após forcedilhaar a conversão de EXPR para expressão racional canônica (CRE). O valor de retorno é a CRE.

     EXPR é forcedilhaada para uma CRE por rat se não for já uma CRE. Essa conversão pode mudar a forma de EXPR colocando todos os termos sobre um denominador comum.

     denom é similar, mas retorna uma expressão comum em lugar de uma CRE. Também, denom não tenta colocar todos os termos sobre um denominador comum, e dessa forma algumas expressões que são consideradas razões por ratdenom não são consideradas razões por denom.

 -- Variável de opcedilhaão: ratdenomdivide
     Valor Padrão: true

     Quando ratdenomdivide for true, ratexpand expande uma razão cujo o numerador for uma adicedilhaão dentro de uma soma de razões, tendo todos um denominador comum. De outra forma, ratexpand colapsa uma adicedilhaão de razões dentro de uma razão simples, cujo numerador seja a adicedilhaão dos numeradores de cada razão.

     Exemplos:

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

 -- Funcedilhaão: ratdiff (EXPR, X)
     Realiza a derivacedilhaão da expressão racional EXPR com relacedilhaão a X. EXPR deve ser uma razão de polinômios ou um polinômio em X. O argumento X pode ser uma variável ou uma subexpressão de EXPR.

     O resultado é equivalente a diff, embora talvez em uma forma diferente. ratdiff pode ser mais rápida que diff, para expressões racionais.

     ratdiff retorna uma expressão racional canônica (CRE) se expr for uma CRE. De outra forma, ratdiff retorna uma expressão geral.

     ratdiff considera somente as dependências de EXPR sobre X, e ignora quaisquer dependências estabelecidas por depends.

     Exemplo:

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

 -- Funcedilhaão: ratdisrep (EXPR)
     Retorna seu argumento como uma expressão geral. Se EXPR for uma expressão geral, é retornada inalterada.

     Tipicamente ratdisrep é chamada para converter uma expressão racional canônica (CRE) em uma expressão geral. Isso é algumas vezes conveniente se deseja-se parar o "contágio", ou caso se esteja usando funcedilhaões racionais em contextos não racionais.

     Veja também totaldisrep.

 -- Variável de opcedilhaão: ratepsilon
     Valor Padrão: 2.0e-8

     ratepsilon é a tolerância usada em conversões de números em ponto flutuante para números racionais.

 -- Funcedilhaão: ratexpand (EXPR)
 -- Variável de opcedilhaão: ratexpand
     Expande EXPR multiplicando para fora produtos de somas e somas exponenciadas, combinando fracedilhaões sobre um denominador comum, cancelando o máximo divisor comum entre entre o numerador e o denominador, então quebrando o numerador (se for uma soma) dentro de suas respectivas parcelas divididas pelo denominador.

     O valor de retorno de ratexpand é uma expressão geral, mesmo se EXPR for uma expressão racional canônica (CRE).

     O comutador ratexpand se true fará com que expressões CRE sejam completamente expandidas quando forem convertidas de volta para a forma geral ou mostradas, enquanto se for false então elas serão colocadas na forma recursiva. Veja também ratsimp.

     Quando ratdenomdivide for true, ratexpand expande uma razão na qual o numerador é uma adicedilhaão dentro de uma adicedilhaão de razões, todas tendo um denominador comum. De outra forma, ratexpand contrai uma soma de razões em uma razão simples, cujo numerador é a soma dos numeradores de cada razão.

     Quando keepfloat for true, evita que números em ponto flutuante sejam racionalizados quando expressões que contenham números em ponto flutuante forem convertidas para a forma de expressão racional canônica (CRE).

     Exemplos:

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

 -- Variável de opcedilhaão: ratfac
     Valor Padrão: false

     Quando ratfac for true, expressões racionais canônicas (CRE) são manipuladas na forma parcialmente fatorada.

     Durante operacedilhaões racionais a expressão é mantida como completamente fatorada como foi possível sem chamadas a factor. Isso pode sempre economizar espacedilhao e pode economizar tempo em algumas computacedilhaões. O numerador e o denominador são feitos relativamente primos, por exemplo rat ((x^2 - 1)^4/(x + 1)^2) retorna (x - 1)^4 (x + 1)^2), mas o fator dentro de cada parte pode não ser relativamente primo.

     No pacote ctensor (Manipulacedilhaão de componentes de tensores), tensores de Ricci, Einstein, Riemann, e de Weyl e a curvatura escalar são fatorados automaticamente quando ratfac for true. ratfac pode somente ser escolhido para casos onde as componentes tensoriais sejam sabidametne consistidas de poucos termos.

     Os esquemas de ratfac e de ratweight são incompatíveis e não podem ambos serem usados ao mesmo tempo.

 -- Funcedilhaão: ratnumer (EXPR)
     Retorna o numerador de EXPR, após forcedilhaar EXPR para uma expressão racional canônica (CRE). O valor de retorno é uma CRE.

     EXPR é forcedilhaada para uma CRE por rat se isso não for já uma CRE. Essa conversão pode alterar a forma de EXPR pela colocacedilhaão de todos os termos sobre um denominador comum.

     num é similar, mas retorna uma expressão comum em lugar de uma CRE. Também, num não tenta colocar todos os termos sobre um denominador comum, e dessa forma algumas expressões que são consideradas razões por ratnumer não são consideradas razões por num.

 -- Funcedilhaão: ratnump (EXPR)
     Retorna true se EXPR for um inteiro literal ou razão de inteiros literais, de outra forma retorna false.

 -- Funcedilhaão: ratp (EXPR)
     Retorna true se EXPR for uma expressão racional canônica (CRE) ou CRE extendida, de outra forma retorna false.

     CRE são criadas por rat e funcedilhaões relacionadas. CRE extendidas são criadas por taylor e funcedilhaões relacionadas.

 -- Variável de opcedilhaão: ratprint
     Valor Padrão: true

     Quando ratprint for true, uma mensagem informando ao usuário da conversão de números em ponto flutuante para números racionais é mostrada.

 -- Funcedilhaão: ratsimp (EXPR)
 -- Funcedilhaão: ratsimp (EXPR, X_1, ..., X_N)
     Simplifica a expressão EXPR e todas as suas subexpressões, incluindo os argumentos para funcedilhaões não racionais. O resultado é retornado como o quociente de dois polinômios na forma recursiva, isto é, os coeficientes de variável principal são polinômios em outras variáveis. Variáveis podem incluir funcedilhaões não racionais (e.g., sin (x^2 + 1)) e os argumentos para quaisquer tais funcedilhaões são também simplificados racionalmente.

     ratsimp (EXPR, X_1, ..., X_N) habilita simplificacedilhaão racional com a especiicacedilhaão de variável ordenando como em ratvars.

     Quando ratsimpexpons for true, ratsimp é aplicado para os expoentes de expressões durante a simplificacedilhaão.

     Veja também ratexpand. Note que ratsimp é afetado por algum dos sinalizadores que afetam ratexpand.

     Exemplos:

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

 -- Variável de opcedilhaão: ratsimpexpons
     Valor Padrão: false

     Quando ratsimpexpons for true, ratsimp é aplicado para os expoentes de expressões durante uma simplificacedilhaão.

 -- Funcedilhaão: ratsubst (A, B, C)
     Substitue A por B em C e retorna a expressão resultante. B pode também ser uma adicedilhaão, produto, expoente, etc.

     ratsubst sabe alguma coisa do significado de expressões uma vez que subst não é uma substituicedilhaão puramente sintática. Dessa forma subst (a, x + y, x + y + z) retorna x + y + z ao passo que ratsubst retorna z + a.

     Quando radsubstflag for true, ratsubst faz substituicedilhaão de radicais em expressões que explicitamente não possuem esses radicais.

     Exemplos:

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

 -- Funcedilhaão: ratvars (X_1, ..., X_N)
 -- Funcedilhaão: ratvars ()
 -- Variável de sistema: ratvars
     Declara variáveis principais X_1, ..., X_N para expressões racionais. X_N, se presente em uma expressão racional, é considerada a variável principal. De outra forma, X_[N-1] é considerada a variável principal se presente, e assim por diante até as variáveis precedentes para X_1, que é considerada a variável principal somente se nenhuma das variáveis que a sucedem estiver presente.

     Se uma variável em uma expressão racional não está presente na lista ratvars, a ela é dada uma prioridade menor que X_1.

     Os argumentos para ratvars podem ser ou variáveis ou funcedilhaões não racionais tais como sin(x).

     A variável ratvars é uma lista de argumentos da funcedilhaão ratvars quando ela foi chamada mais recentemente. Cada chamada para a funcedilhaão ratvars sobre-grava a lista apagando seu conteúdo anterior. ratvars () limpa a lista.

 -- Funcedilhaão: ratweight (X_1, W_1, ..., X_N, W_N)
 -- Funcedilhaão: ratweight ()
     Atribui um peso W_I para a variável X_I. Isso faz com que um termo seja substituído por 0 se seu peso exceder o valor da variável ratwtlvl (o padrão retorna sem truncacedilhaão). O peso de um termo é a soma dos produtos dos pesos de uma variável no termo vezes seu expoente. Por exemplo, o peso de 3 x_1^2 x_2 é 2 w_1 + w_2. A truncacedilhaão de acordo com ratwtlvl é realizada somente quando multiplicando ou exponencializando expressões racionais canônicas (CRE).

     ratweight () retorna a lista cumulativa de atribuicedilhaões de pesos.

     Nota: Os esquemas de ratfac e ratweight são incompatíveis e não podem ambo serem usados ao mesmo tempo.

     Exemplos:

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

 -- Variável de sistema: ratweights
     Valor Padrão: []

     ratweights é a lista de pesos atribuídos por ratweight. A lista é cumulativa: cada chamada a ratweight coloca ítens adicionais na lista.

     kill (ratweights) e save (ratweights) ambos trabalham como esperado.

 -- Variável de opcedilhaão: ratwtlvl
     Valor Padrão: false

     ratwtlvl é usada em combinacedilhaão com a funcedilhaão ratweight para controlar a truncacedilhaão de expressão racionais canônicas (CRE). Para o valor padrão false, nenhuma truncacedilhaão ocorre.

 -- Funcedilhaão: remainder (P_1, P_2)
 -- Funcedilhaão: remainder (P_1, P_2, X_1, ..., X_N)
     Retorna o resto do polinômio P_1 dividido pelo polinômio P_2. Os argumentos X_1, ..., X_N são interpretados como em ratvars.

     remainder retorna o segundo elemento de uma lista de dois elementos retornada por divide.

 -- Funcedilhaão: resultant (P_1, P_2, X)
 -- Variável: resultant
     Calcula o resultante de dois polinômios P_1 e P_2, eliminando a variável X. O resultante é um determinante dos coeficientes de X em P_1 e P_2, que é igual a zero se e somente se P_1 e P_2 tiverem um fator em comum não constante.

     Se P_1 ou P_2 puderem ser fatorados, pode ser desejável chamar factor antes de chamar resultant.

     A variável resultant controla que algorítmo será usado para calcular o resultante. subres para o prs subresultante, mod para o algorítmo resultante modular, e red para prs reduzido. Para muitos problemas subres pode ser melhor. Para alguns problemas com valores grandes de grau de uma única variável ou de duas variáveis mod pode ser melhor.

     A funcedilhaão bezout pega os mesmos argumentos que resultant e retorna uma matriz.  O determinante do valor de retorno é o resultante desejado.

 -- Variável de opcedilhaão: savefactors
     Valor Padrão: false

     Quando savefactors for true, faz com que os fatores de uma expressão que é um produto de fatores sejam gravados por certas funcedilhaões com o objetivo de aumentar a velocidade em posteriores fatoracedilhaões de expressões contendo algum desses mesmos fatores.

 -- Funcedilhaão: sqfr (EXPR)
     é similar a factor exceto que os fatores do polinômio são "livres de raízes". Isto é, eles possuem fatores somente de grau um. Esse algorítmo, que é também usado no primeiro estágio de factor, utiliza o fato que um polinômio tem em comum com sua n'ésima derivada todos os seus fatores de grau maior que n.  Dessa forma pegando o maior divisor comum com o polinômio das derivadas com relacedilhaão a cada variável no polinômio, todos os fatores de grau maior que 1 podem ser achados.

     Exemplo:

          (%i1) sqfr (4*x^4 + 4*x^3 - 3*x^2 - 4*x - 1);
                                          2   2
          (%o1)                  (2 x + 1)  (x  - 1)

 -- Funcedilhaão: tellrat (P_1, ..., P_N)
 -- Funcedilhaão: tellrat ()
     Adiciona ao anel dos inteiros algébricos conhecidos do Maxima os elementos que são as solucedilhaões dos polinômios P_1, ..., P_N. Cada argumento P_I é um polinômio concoeficientes inteiros.

     tellrat (X) efetivamente significa substituir 0 por X em funcedilhaões racionais.

     tellrat () retorna uma lista das substituicedilhaões correntes.

     algebraic deve ser escolhida para true com o objetivo de que a simplificacedilhaão de inteiros algébricos tenha efeito.

     Maxima inicialmente sabe sobre a unidade imaginária %i e todas as raízes de inteiros.

     Existe um comando untellrat que pega kernels (núcleos) e remove propriedades tellrat.

     Quando fazemos tellrat em um polinômio de várias variáveis, e.g., tellrat (x^2 - y^2), pode existir uma ambigüidade como para ou substituir Y^2 por X^2 ou vice-versa. Maxima seleciona uma ordenacedilhaão particular, mas se o usuário desejar especificar qual e.g. tellrat (y^2 = x^2) fornecedilhae uma sintaxe que diga para substituir Y^2 por X^2.

     Exemplos:

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

 -- Funcedilhaão: totaldisrep (EXPR)
     Converte toda subexpressão de EXPR da forma de expressão racionais canônicas (CRE) para a forma geral e retorna o resultado. Se EXPR é em sí mesma na forma CRE então totaldisrep é identica a ratdisrep.

     totaldisrep pode ser usada para fazer um ratdisrep em expressões tais como equacedilhaões, listas, matrizes, etc., que tiverem algumas subexpressões na forma CRE.

 -- Funcedilhaão: untellrat (X_1, ..., X_N)
     Remove propriedades tellrat de X_1, ..., X_N.