Manual do Maxima: 12. Polinômios

[ < ] | [ > ] |  | [ << ] | [ Up ] | [ >> ] |  |  |  |  | [Top] | [Contents] | [Índice] | [ ? ]

# 12. Polinômios

[ < ] | [ > ] |  | [ << ] | [ Up ] | [ >> ] |  |  |  |  | [Top] | [Contents] | [Índice] | [ ? ]

## 12.1 Introduçã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 operações tais como `factor`, `ratsimp`, e assim por diante.

Expressões Racionais Canônicas constituem um tipo de representação que é especialmente adequado para polinômios expandidos e funções racionais (também para polinômios parcialmente fatorados e funções racionais quando RATFAC for escolhida para `true`). Nessa forma CRE uma ordenaçã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 funçã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 ordenaçã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 função RAT para saber como converter uma expressão para a forma CRE. Uma forma CRE extendida é usada para a representação de séries de Taylor. A noçã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 generalização dessa mesma forma CRE, mas carrega informação adicional tal com o grau de truncaçã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.

[ < ] | [ > ] |  | [ << ] | [ Up ] | [ >> ] |  |  |  |  | [Top] | [Contents] | [Índice] | [ ? ]

## 12.2 Funções e Variáveis Definidas para Polinômios

Variável de opção: algebraic

  Valor Padrão: `false`

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

Variável de opção: berlefact

  Valor Padrão: `true`

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

Função: bezout (p1, p2, x)

  uma alternativa para o comando `resultant`. Isso retorna uma matriz. `determinant` dessa matriz é o resultante desejado.

Funçã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

Funçã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

Função: combine (expr)

  Simplifica a adição expr por termos combinados com o mesmo denominador dentro de um termo simples.

Funçã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]

Função: denom (expr)

  Retorna o denominador da expressão racional expr.

Funçã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 funçã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.

Função: eliminate ([eqn_1, ..., eqn_n], [x_1, ..., x_k])

  Elimina variáveis de equaçõ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]

Funçã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 opçã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).

Funçã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`.

Função: factor (expr)
Função: factor (expr, p)

  Fatora a expressão expr, contendo qualquer número de variáveis ou funçõ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 função `ifactors` para fatorar inteiros.

  `factorflag` se `false` suprime a fatoração de fatores inteiros de expressões racionais.

  `dontfactor` pode ser escolhida para uma lista de variáveis com relação à qual fatoração não é para ocorrer. (Essa é inicialmente vazia). Fatoração também não acontece com relação a quaisquer variáveis que são menos importantes (usando a ordenaçã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 funções com o objetivo de aumentar a velocidade de futuras fatorações de expressões contendo alguns dos mesmos fatores.

  `berlefact` se `false` então o algorítmo de fatoraçã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 fatoraçã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 fatoraçã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 opção: factorflag

  Valor Padrão: `false`

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

Função: factorout (expr, x_1, x_2, ...)

  Rearranja a adição expr em uma adiçã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.

Função: factorsum (expr)

  Tenta agrupar parcelas em fatores de expr que são adições em grupos de parcelas tais que sua adiçã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) )

Função: fasttimes (p_1, p_2)

  Retorna o produto dos polinômios p_1 e p_2 usando um algorítmo especial para a multiplicação de polinômios. `p_1` e `p_2` podem ser de várias variáveis, densos, e aproximadamente do mesmo tamanho. A multiplicaçã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`.

Função: fullratsimp (expr)

  `fullratsimp` aplica repetidamente `ratsimp` seguido por simplificação não racional a uma expressão até que nenhuma mudança adicional ocorra, e retorna o resultado.

  Quando expressões não racionais estão envolvidas, uma chamada a `ratsimp` seguida como é usual por uma simplificaçã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

Funçã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 função é útil quando a expressão de substituiçã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 substituição simples de equação ou uma lista de tais equações, enquanto o segundo argumento é a expressão sendo processada.

  `load ("lrats")` chama `fullratsubst` e `lratsubst`.

  Exemplos:

      (%i1) load ("lrats")$

  - `subst` pode realizar multiplas substituiçõ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 substituição é desejada, então uma equaçã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 equações ou uma equaçã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

Funçã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 funçõ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 opçã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.

Função: gcdex (f, g)
Funçã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 funçõ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

Funçã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). Fatorações são normalizadas fazendo a e b não negativos.

Funçã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)

Função: gfactorsum (expr)

  é similar a `factorsum` mas aplica `gfactor` em lugar de `factor`.

Funçã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 opção: intfaclim

  Valor padrão: true

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

  Quando `intfaclim` for `false` (esse é o caso quando o usuário chama `factor` explicitamente), a fatoraçã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 opçã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).

Funçã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 equação ou uma lista de equações idênticas em formato para que sejam aceitas por `subst`. As substituições são feitas na ordem dada pela lista de equações, isto é, da esquerda para a direita.

  `load ("lrats")` chama `fullratsubst` e `lratsubst`.

  Exemplos:

      (%i1) load ("lrats")$

  - `subst` pode realizar multiplas substituiçõ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 substituição for desejada, então uma equação simples pode ser dada como primeiro argumento.

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

Variável de opção: modulus

  Valor Padrão: `false`

  Quando `modulus` for um número positivo p, operações sobre os números racionais (como retornado por `rat` e funçõ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.

Funçã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.

Função: polydecomp (p, x)

  Decompões o polinômio p na variável x em uma composiçã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 decomposiçã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 funções compõem `L = [e_1, ..., e_n]` como funções em `x`; essa funçà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

Função: quotient (p_1, p_2)
Funçã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`.

Função: rat (expr)
Funçã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 funções outras que não sejam adição `+`, subtração `-`, multiplicação `*`, divisão `/`, e exponenciaçã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 representação interna diferente de 0.

  Quando `ratfac` for `true`, `rat` retorna uma forma parcialmente fatorada para CRE. Durante operações racionais a expressão é mantida como totalmente fatorada como possível sem uma chamada ao pacote de fatoração (`factor`). Isso pode sempre economizar espaço de memória e algum tempo em algumas computaçõ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 opção: ratalgdenom

  Valor Padrão: `true`

  Quando `ratalgdenom` for `true`, permite racionalizaçã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.

Função: ratcoef (expr, x, n)
Funçã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 adiçã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

Função: ratdenom (expr)

  Retorna o denominador de expr, após forçar a conversão de expr para expressão racional canônica (CRE). O valor de retorno é a CRE.

  expr é forçada 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 opção: ratdenomdivide

  Valor Padrão: `true`

  Quando `ratdenomdivide` for `true`, `ratexpand` expande uma razão cujo o numerador for uma adição dentro de uma soma de razões, tendo todos um denominador comum. De outra forma, `ratexpand` colapsa uma adição de razões dentro de uma razão simples, cujo numerador seja a adiçã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

Função: ratdiff (expr, x)

  Realiza a derivação da expressão racional expr com relaçã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

Funçã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 funções racionais em contextos não racionais.

  Veja também `totaldisrep`.

Variável de opçã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.

Função: ratexpand (expr)
Variável de opção: ratexpand

  Expande expr multiplicando para fora produtos de somas e somas exponenciadas, combinando fraçõ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 adição dentro de uma adiçã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 opção: ratfac

  Valor Padrão: `false`

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

  Durante operações racionais a expressão é mantida como completamente fatorada como foi possível sem chamadas a `factor`. Isso pode sempre economizar espaço e pode economizar tempo em algumas computaçõ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` (Manipulaçã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.

Função: ratnumer (expr)

  Retorna o numerador de expr, após forçar expr para uma expressão racional canônica (CRE). O valor de retorno é uma CRE.

  expr é forçada para uma CRE por `rat` se isso não for já uma CRE. Essa conversão pode alterar a forma de expr pela colocaçã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`.

Função: ratnump (expr)

  Retorna `true` se expr for um inteiro literal ou razão de inteiros literais, de outra forma retorna `false`.

Funçã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 funções relacionadas. CRE extendidas são criadas por `taylor` e funções relacionadas.

Variável de opçã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.

Função: ratsimp (expr)
Função: ratsimp (expr, x_1, ..., x_n)

  Simplifica a expressão expr e todas as suas subexpressões, incluindo os argumentos para funçõ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 funções não racionais (e.g., `sin (x^2 + 1)`) e os argumentos para quaisquer tais funções são também simplificados racionalmente.

  `ratsimp (expr, x_1, ..., x_n)` habilita simplificação racional com a especiicação de variável ordenando como em `ratvars`.

  Quando `ratsimpexpons` for `true`, `ratsimp` é aplicado para os expoentes de expressões durante a simplificaçã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 opção: ratsimpexpons

  Valor Padrão: `false`

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

Função: ratsubst (a, b, c)

  Substitue a por b em c e retorna a expressão resultante. b pode também ser uma adição, produto, expoente, etc.

  `ratsubst` sabe alguma coisa do significado de expressões uma vez que `subst` não é uma substituiçã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 substituiçã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

Função: ratvars (x_1, ..., x_n)
Funçã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 funções não racionais tais como `sin(x)`.

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

Função: ratweight (x_1, w_1, ..., x_n, w_n)
Funçã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 truncaçã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 truncação de acordo com `ratwtlvl` é realizada somente quando multiplicando ou exponencializando expressões racionais canônicas (CRE).

  `ratweight ()` retorna a lista cumulativa de atribuiçõ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 opção: ratwtlvl

  Valor Padrão: `false`

  `ratwtlvl` é usada em combinação com a função `ratweight` para controlar a truncação de expressão racionais canônicas (CRE). Para o valor padrão `false`, nenhuma truncação ocorre.

Função: remainder (p_1, p_2)
Funçã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`.

Funçã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 função `bezout` pega os mesmos argumentos que `resultant` e retorna uma matriz. O determinante do valor de retorno é o resultante desejado.

Variável de opçã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 funções com o objetivo de aumentar a velocidade em posteriores fatorações de expressões contendo algum desses mesmos fatores.

Funçã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 relaçã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)

Função: tellrat (p_1, ..., p_n)
Função: tellrat ()

  Adiciona ao anel dos inteiros algébricos conhecidos do Maxima os elementos que são as soluçõ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 funções racionais.

  `tellrat ()` retorna uma lista das substituições correntes.

  `algebraic` deve ser escolhida para `true` com o objetivo de que a simplificaçã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 ordenação particular, mas se o usuário desejar especificar qual e.g. `tellrat (y^2 = x^2)` forneçe 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]

Funçã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 equações, listas, matrizes, etc., que tiverem algumas subexpressões na forma CRE.

Função: untellrat (x_1, ..., x_n)

  Remove propriedades `tellrat` de x_1, ..., x_n.

[ << ] | [ >> ] |  |  |  |  |  | [Top] | [Contents] | [Índice] | [ ? ]

This document was generated by Viktor T. Toth on Outubro, 3 2017 using texi2html 1.76.