Funcedilhaões e Variáveis Definidas para Equacedilhaões
=======================================================

 -- Variável: %rnum_list
     Valor padrão: []

     %rnum_list é a lista de variáveis introduzidas em solucedilhaões por algsys. %r variáveis São adicionadas a %rnum_list na ordem em que forem criadas. Isso é conveniente para fazer substituicedilhaões dentro da solucedilhaão mais tarde. É recomendado usar essa lista em lugar de fazer concat ('%r, j).

 -- Variável: algexact
     Valor padrão: false

     algexact afeta o comportamento de algsys como segue:

     Se algexact é true, algsys sempre chama solve e então usa realroots sobre falhas de solve.

     Se algexact é false, solve é chamada somente se o eliminante não for de uma variável, ou se for uma quadrática ou uma biquadrada.

     Dessa forma algexact: true não garante somente solucedilhaões exatas, apenas que algsys tentará primeiro pegar solucedilhaões exatas, e somente retorna aproximacedilhaões quando tudo mais falha.

 -- Funcedilhaão: algsys ([EXPR_1, ..., EXPR_M], [X_1, ..., X_N])
 -- Funcedilhaão: algsys ([EQN_1, ..., EQN_M], [X_1, ..., X_N])
     Resolve polinômios simultâneos EXPR_1, ..., EXPR_M ou equacedilhaões polinômiais EQN_1, ..., EQN_M para as variáveis X_1, ..., X_N. Uma expressão EXPR é equivalente a uma equacedilhaão EXPR = 0. Pode existir mais equacedilhaões que variáveis ou vice-versa.

     algsys retorna uma lista de solucedilhaões, com cada solucedilhaão dada com uma lista de valores de estado das equacedilhaões das variáveis X_1, ..., X_N que satisfazem o sistema de equacedilhaões. Se algsys não pode achar uma solucedilhaão, uma lista vazia [] é retornada.

     Os símbolos %r1, %r2, ..., são introduzidos tantos quantos forem necessários para representar parâmetros arbitrários na solucedilhaão; essas variáveis são também anexadas à lista %rnum_list.

     O método usado é o seguinte:

     (1) Primeiro as equacedilhaões são fatoradas e quebradas em subsistemas.

     (2) Para cada subsistema S_I, uma equacedilhaão E e uma variável X são selecionados. A variável é escolhida para ter o menor grau não zero. Então a resultante de E e E_J em relacedilhaão a X é calculada para cada um das equacedilhaões restantes E_J nos subsistemas S_I. Isso retorna um novo subsistema S_I' em umas poucas variáveis, como X tenha sido eliminada. O processo agora retorna ao passo (1).

     (3) Eventualmente, um subsistema consistindo de uma equacedilhaão simples é obtido.  Se a equacedilhaão é de várias variáveis e aproximacedilhaões na forma de números em ponto flutuante nã tenham sido introduzidas, então solve é chamada para achar uma solucedilhaão exata.

     Em alguns casos, solve não está habilitada a achar uma solucedilhaão, ou se isso é feito a solucedilhaão pode ser uma expressão expressão muito larga.

     Se a equacedilhaão é de uma única variável e é ou linear, ou quadrática, ou biquadrada, então novamente solve é chamada se aproximacedilhaões não tiverem sido introduzidas.  Se aproximacedilhaões tiverem sido introduzidas ou a equacedilhaão não é de uma única variável e nem tão pouco linear, quadratica, ou biquadrada, então o comutador realonly é true, A funcedilhaão realroots é chamada para achar o valor real das solucedilhaões.  Se realonly é false, então allroots é chamada a qual procura por solucedilhaões reais e complexas.

     Se algsys produz uma solucedilhaão que tem poucos digitos significativos que o requerido, o usuário pode escolher o valor de algepsilon para um valor maior.

     Se algexact é escolhido para true, solve será sempre chamada.

     (4) Finalmente, as solucedilhaões obtidas no passo (3) são substituídas dentro dos níveis prévios e o processo de solucedilhaão retorna para (1).

     Quando algsys encontrar uma equacedilhaão de várias variáveis que contém aproximacedilhaões em ponto flutuante (usualmente devido a suas falhas em achar solucedilhaões exatas por um estágio mais fácil), então não tentará aplicar métodos exatos para tais equacedilhaões e em lugar disso imprime a mensagem: "algsys cannot solve - system too complicated."

     Interacedilhaões com radcan podem produzir expressões largas ou complicadas. Naquele caso, pode ser possível isolar partes do resultado com pickapart ou reveal.

     Ocasionalmente, radcan pode introduzir uma unidade imaginária %i dentro de uma solucedilhaão que é atualmente avaliada como real.

     Exemplos:

     + e2: a2 - a1; + e3: a1*(-y - x^2 + 1);

          (%i1) e1: 2*x*(1 - a1) - 2*(x - 1)*a2;
          (%o1)              2 (1 - a1) x - 2 a2 (x - 1)
          (%i2) e2: a2 - a1;
          (%o2)                        a2 - a1
          (%i3) e3: a1*(-y - x^2 + 1);
                                             2
          (%o3)                   a1 (- y - x  + 1)
          (%i4) e4: a2*(y - (x - 1)^2);
                                                 2
          (%o4)                   a2 (y - (x - 1) )
          (%i5) algsys ([e1, e2, e3, e4], [x, y, a1, a2]);
          (%o5) [[x = 0, y = %r1, a1 = 0, a2 = 0],

                                            [x = 1, y = 0, a1 = 1, a2 = 1]]
          (%i6) e1: x^2 - y^2;
                                        2    2
          (%o6)                        x  - y
          (%i7) e2: -1 - y + 2*y^2 - x + x^2;
                                   2        2
          (%o7)                 2 y  - y + x  - x - 1
          (%i8) algsys ([e1, e2], [x, y]);
                           1            1
          (%o8) [[x = - -------, y = -------],
                        sqrt(3)      sqrt(3)

                  1              1             1        1
          [x = -------, y = - -------], [x = - -, y = - -], [x = 1, y = 1]]
               sqrt(3)        sqrt(3)          3        3

 -- Funcedilhaão: allroots (EXPR)
 -- Funcedilhaão: allroots (EQN)
     Calcula aproximacedilhaões numéricas de raízes reais e complexas do polinômio EXPR ou equacedilhaão polinômial EQN de uma variável.

     O sinalizador polyfactor quando true faz com que allroots fatore o polinômio sobre os números reais se o polinômio for real, ou sobre os números complexos, se o polinômio for complexo.

     allroots pode retornar resultados imprecisos no caso de multiplas raízes. Se o polinômio for real, allroots (%i*P)) pode retornar aproximacedilhaões mais precisas que allroots (P), como allroots invoca um algorítmo diferente naquele caso.

     allroots rejeita não-polinômios.  Isso requer que o numerador após a classificacedilhaão (rat'ing) poderá ser um polinômio, e isso requer que o denominador seja quando muito um número complexo.  Com um resultado disso allroots irá sempre retornar uma expressão equivalente (mas fatorada), se polyfactor for true.

     Para polinômios complexos um algorítmo por Jenkins e Traub é usado (Algorithm 419, Comm.  ACM, vol.  15, (1972), p.  97). Para polinômios reais o algorítmo usado é devido a Jenkins (Algorithm 493, ACM TOMS, vol.  1, (1975), p.178).

     Exemplos:

          (%i1) eqn: (1 + 2*x)^3 = 13.5*(1 + x^5);
                                      3          5
          (%o1)              (2 x + 1)  = 13.5 (x  + 1)
          (%i2) soln: allroots (eqn);
          (%o2) [x = .8296749902129361, x = - 1.015755543828121,

          x = .9659625152196369 %i - .4069597231924075,

          x = - .9659625152196369 %i - .4069597231924075, x = 1.0]
          (%i3) for e in soln
                  do (e2: subst (e, eqn), disp (expand (lhs(e2) - rhs(e2))));
                                - 3.5527136788005E-15

                               - 5.32907051820075E-15

                   4.44089209850063E-15 %i - 4.88498130835069E-15

                  - 4.44089209850063E-15 %i - 4.88498130835069E-15

                                 3.5527136788005E-15

          (%o3)                         done
          (%i4) polyfactor: true$
          (%i5) allroots (eqn);
          (%o5) - 13.5 (x - 1.0) (x - .8296749902129361)

                                     2
           (x + 1.015755543828121) (x  + .8139194463848151 x

           + 1.098699797110288)

 -- Variável: backsubst
     Valor padrão: true

     Quando backsubst é false, evita substituicedilhaões em expressões anteriores após as equacedilhaões terem sido triangularizadas.  Isso pode ser de grande ajuda em problemas muito grandes onde substituicedilhaão em expressões anteriores pode vir a causar a geracedilhaão de expressões extremamente largas.

 -- Variável: breakup
     Valor padrão: true

     Quando breakup é true, solve expressa solucedilhaões de equacedilhaões cúbicas e quárticas em termos de subexpressões comuns, que são atribuídas a rótulos de expressões intermediárias (%t1, %t2, etc.). De outra forma, subexpressões comuns não são identificadas.

     breakup: true tem efeito somente quando programmode é false.

     Exemplos:

          (%i1) programmode: false$
          (%i2) breakup: true$
          (%i3) solve (x^3 + x^2 - 1);

                                  sqrt(23)    25 1/3
          (%t3)                  (--------- + --)
                                  6 sqrt(3)   54
          Solution:

                                                sqrt(3) %i   1
                                                ---------- - -
                          sqrt(3) %i   1            2        2   1
          (%t4)    x = (- ---------- - -) %t3 + -------------- - -
                              2        2            9 %t3        3

                                                sqrt(3) %i   1
                                              - ---------- - -
                        sqrt(3) %i   1              2        2   1
          (%t5)    x = (---------- - -) %t3 + ---------------- - -
                            2        2             9 %t3         3

                                             1     1
          (%t6)                  x = %t3 + ----- - -
                                           9 %t3   3
          (%o6)                    [%t4, %t5, %t6]
          (%i6) breakup: false$
          (%i7) solve (x^3 + x^2 - 1);
          Solution:

                       sqrt(3) %i   1
                       ---------- - -
                           2        2        sqrt(23)    25 1/3
          (%t7) x = --------------------- + (--------- + --)
                       sqrt(23)    25 1/3    6 sqrt(3)   54
                    9 (--------- + --)
                       6 sqrt(3)   54

                                                        sqrt(3) %i   1    1
                                                     (- ---------- - -) - -
                                                            2        2    3

                     sqrt(23)    25 1/3  sqrt(3) %i   1
          (%t8) x = (--------- + --)    (---------- - -)
                     6 sqrt(3)   54          2        2

                                                      sqrt(3) %i   1
                                                    - ---------- - -
                                                          2        2      1
                                                + --------------------- - -
                                                     sqrt(23)    25 1/3   3
                                                  9 (--------- + --)
                                                     6 sqrt(3)   54

                      sqrt(23)    25 1/3             1             1
          (%t9)  x = (--------- + --)    + --------------------- - -
                      6 sqrt(3)   54          sqrt(23)    25 1/3   3
                                           9 (--------- + --)
                                              6 sqrt(3)   54
          (%o9)                    [%t7, %t8, %t9]

 -- Funcedilhaão: dimension (EQN)
 -- Funcedilhaão: dimension (EQN_1, ..., EQN_N)
     dimen é um pacote de análise dimensional. load ("dimen") chama esse pacote. demo ("dimen") mostra uma cura demostracedilhaão.

 -- Variável: dispflag
     Valor padrão: true

     Se escolhida para false dentro de um block inibirá a visualizacedilhaão da saída gerada pelas funcedilhaões solve chamadas de dentro de block.  Terminando block com um sinal de dolar, $, escolhe dispflag para false.

 -- Funcedilhaão: funcsolve (EQN, G(T))
     Retorna [G(T) = ...]  ou [], dependendo de existir ou não uma funcedilhaão racional G(T) satisfazendo EQN, que deve ser de primeira ordem, polinômio linear em (para esse caso) G(T) e G(T+1)

          (%i1) eqn: (n + 1)*f(n) - (n + 3)*f(n + 1)/(n + 1) = (n - 1)/(n + 2);
                                      (n + 3) f(n + 1)   n - 1
          (%o1)        (n + 1) f(n) - ---------------- = -----
                                           n + 1         n + 2
          (%i2) funcsolve (eqn, f(n));

          Equacedilhaões dependentes eliminadas:  (4 3)
                                             n
          (%o2)                f(n) = ---------------
                                      (n + 1) (n + 2)

     Atencedilhaão: essa é uma implementacedilhaão muito rudimentar -- muitas verificacedilhaões de segurancedilhaa e obviamente generalizacedilhaões estão ausêntes.

 -- Variável: globalsolve
     Valor padrão: false

     When globalsolve for true, variáveis para as quais as equacedilhaões são resolvidas são atribuidas aos valores da solucedilhaão encontrados por linsolve, e por solve quando resolvendo duas ou mais equacedilhaões lineares.

     Quando globalsolve for false, solucedilhaões encontradas por linsolve e por solve quando resolvendo duas ou mais equacedilhaões lineares são espressas como equacedilhaões, e as variáveis para as quais a equacedilhaão foi resolvida não são atribuidas.

     Quando resolvendo qualquer coisa outra que não duas equacedilhaões lineares ou mais, solve ignora globalsolve. Outras funcedilhaões que resolvem equacedilhaões (e.g., algsys) sempre ignoram globalsolve.

     Exemplos:

          (%i1) globalsolve: true$
          (%i2) solve ([x + 3*y = 2, 2*x - y = 5], [x, y]);
          Solution

                                           17
          (%t2)                        x : --
                                           7

                                             1
          (%t3)                        y : - -
                                             7
          (%o3)                     [[%t2, %t3]]
          (%i3) x;
                                         17
          (%o3)                          --
                                         7
          (%i4) y;
                                           1
          (%o4)                          - -
                                           7
          (%i5) globalsolve: false$
          (%i6) kill (x, y)$
          (%i7) solve ([x + 3*y = 2, 2*x - y = 5], [x, y]);
          Solution

                                           17
          (%t7)                        x = --
                                           7

                                             1
          (%t8)                        y = - -
                                             7
          (%o8)                     [[%t7, %t8]]
          (%i8) x;
          (%o8)                           x
          (%i9) y;
          (%o9)                           y

 -- Funcedilhaão: ieqn (IE, UNK, TECH, N, GUESS)
     inteqn é um pacote para resolver equacedilhaões com integrais. load ("inteqn") carrega esse pacote.

     IE é a equacedilhaão integral; UNK é a funcedilhaão desconhecida; TECH é a técnica a ser tentada nesses dados acima (TECH = first significa: tente a primeira técnica que achar uma solucedilhaão; TECH = all significa: tente todas a técnicas aplicáveis); N é o número máximo de termos a serem usados de taylor, neumann, firstkindseries, ou fredseries (isso é também o número máximo de ciclos de recurssão para o método de diferenciacedilhaão); GUESS é o inicial suposto para neumann ou firstkindseries.

     Valores padrão do segundo até o quinto parâmetro são:

     UNK: P(X), onde P é a primeira funcedilhaão encontrada em um integrando que é desconhecida para Maxima e X é a variável que ocorre como um argumento para a primeira ocorrência de P achada fora de uma integral no caso de equacedilhaões secondkind , ou é somente outra variável ao lado da variável de integracedilhaão em equacedilhaões firstkind.  Se uma tentativa de procurar por X falha, o usuário será perguntado para suprir a variável independente.

     tech: first

     n: 1

     guess: none o que fará com que neumann e firstkindseries use F(X) como uma suposicedilhaão inicial.

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

     ieqnprint governa o comportamento do resultado retornado pelo comando ieqn.  Quando ieqnprint é false, as listas retornadas pela funcedilhaão ieqn são da forma

     [SOLUCEDILHAÃO, TECNICA USADA, NTERMS, SINALIZADOR]

     onde SINALIZADOR é retirado se a solucedilhaão for exata.

     De outra forma, isso é a palavra approximate ou incomplete correspondendo à forma inexata ou forma aberta de solucedilhaão, respectivamente.  Se um método de série foi usado, NTERMS fornece o número de termos usados (que poderá ser menor que os n dados para ieqn se ocorrer um erro evita a geracedilhaão de termos adicionais).

 -- Funcedilhaão: lhs (EXPR)
     Retorna o lado esquerdo (isto é, o primeiro argumento) da expressão EXPR, quando o operador de EXPR for um dos operadores relacionais < <= = # equal notequal >= >, um dos operadores de atribuicedilhaão := ::= : ::, ou um operadro infixo definido pelo usuário, como declarado por meio de infix.

     Quando EXPR for um átomo ou seu operador for alguma coisa que não esses listados acima, lhs retorna EXPR.

     Veja também rhs.

     Exemplos:

          (%i1) e: aa + bb = cc;
          (%o1)                     bb + aa = cc
          (%i2) lhs (e);
          (%o2)                        bb + aa
          (%i3) rhs (e);
          (%o3)                          cc
          (%i4) [lhs (aa < bb), lhs (aa <= bb), lhs (aa >= bb), lhs (aa > bb)];
          (%o4)                   [aa, aa, aa, aa]
          (%i5) [lhs (aa = bb), lhs (aa # bb), lhs (equal (aa, bb)), lhs (notequal (aa, bb))];
          (%o5)                   [aa, aa, aa, aa]
          (%i6) e1: '(foo(x) := 2*x);
          (%o6)                     foo(x) := 2 x
          (%i7) e2: '(bar(y) ::= 3*y);
          (%o7)                    bar(y) ::= 3 y
          (%i8) e3: '(x : y);
          (%o8)                         x : y
          (%i9) e4: '(x :: y);
          (%o9)                        x :: y
          (%i10) [lhs (e1), lhs (e2), lhs (e3), lhs (e4)];
          (%o10)               [foo(x), bar(y), x, x]
          (%i11) infix ("][");
          (%o11)                         ][
          (%i12) lhs (aa ][ bb);
          (%o12)                         aa

 -- Funcedilhaão: linsolve ([EXPR_1, ..., EXPR_M], [X_1, ..., X_N])
     Resolve a lista de equacedilhaões lineares simultâneas para a lista de variáveis.  As expressões devem ser cada uma polinômios nas variáveis e podem ser equacedilhaões.

     Quando globalsolve é true então variáveis que foram resolvidas serão escolhidas para a solucedilhaão do conjunto de equacedilhaões simultâneas.

     Quando backsubst é false, linsolve não realiza substituicedilhaão em equacedilhaões anteriores após as equacedilhaões terem sido triangularizadas.  Isso pode ser necessário em problemas muito grandes onde substituicedilhaão em equacedilhaões anteriores poderá causar a geracedilhaão de expressões extremamente largas.

     Quando linsolve_params for true, linsolve também gera símbolos %r usados para representar parâmetros arbitrários descritos no manual sob algsys. De outra forma, linsolve resolve um menor-determinado sistema de equacedilhaões com algumas variáveis expressas em termos de outras.

     Quando programmode for false, linsolve mostra a solucedilhaão com expressões intermediárias com rótulos (%t), e retorna a lista de rótulos.

          (%i1) e1: x + z = y;
          (%o1)                       z + x = y
          (%i2) e2: 2*a*x - y = 2*a^2;
                                                 2
          (%o2)                   2 a x - y = 2 a
          (%i3) e3: y - 2*z = 2;
          (%o3)                      y - 2 z = 2
          (%i4) [globalsolve: false, programmode: true];
          (%o4)                     [false, true]
          (%i5) linsolve ([e1, e2, e3], [x, y, z]);
          (%o5)            [x = a + 1, y = 2 a, z = a - 1]
          (%i6) [globalsolve: false, programmode: false];
          (%o6)                    [false, false]
          (%i7) linsolve ([e1, e2, e3], [x, y, z]);
          Solution

          (%t7)                       z = a - 1

          (%t8)                        y = 2 a

          (%t9)                       x = a + 1
          (%o9)                    [%t7, %t8, %t9]
          (%i9) ''%;
          (%o9)            [z = a - 1, y = 2 a, x = a + 1]
          (%i10) [globalsolve: true, programmode: false];
          (%o10)                    [true, false]
          (%i11) linsolve ([e1, e2, e3], [x, y, z]);
          Solution

          (%t11)                      z : a - 1

          (%t12)                       y : 2 a

          (%t13)                      x : a + 1
          (%o13)                 [%t11, %t12, %t13]
          (%i13) ''%;
          (%o13)           [z : a - 1, y : 2 a, x : a + 1]
          (%i14) [x, y, z];
          (%o14)                 [a + 1, 2 a, a - 1]
          (%i15) [globalsolve: true, programmode: true];
          (%o15)                    [true, true]
          (%i16) linsolve ([e1, e2, e3], '[x, y, z]);
          (%o16)           [x : a + 1, y : 2 a, z : a - 1]
          (%i17) [x, y, z];
          (%o17)                 [a + 1, 2 a, a - 1]

 -- Variável: linsolvewarn
     Valor padrão: true

     Quando linsolvewarn é true, linsolve imprime uma mensagem "Dependent equacedilhaões eliminated".

 -- Variável: linsolve_params
     Valor padrão: true

     Quando linsolve_params é true, linsolve também gera os símbolos %r usados para representar parâmetros arbitrários descritos no manual sob algsys. De outra forma, linsolve resolve um menor-determinado sistema de equacedilhaões com algumas variáveis expressas em termos e outras.

 -- Variável: multiplicities
     Valor padrão: not_set_yet

     multiplicities é escolhida para uma lista de multiplicidades das solucedilhaões individuais retornadas por solve ou realroots.

 -- Funcedilhaão: nroots (P, LOW, HIGH)
     Retorna o número de raízes reais do polinômio real de uma única variável P no intervalo semi-aberto (LOW, HIGH]. Uma extremidade do intervalo podem ser minf ou inf. infinito e mais infinito.

     nroots usa o método das sequüências de Sturm.

          (%i1) p: x^10 - 2*x^4 + 1/2$
          (%i2) nroots (p, -6, 9.1);
          (%o2)                           4

 -- Funcedilhaão: nthroot (P, N)
     Onde p é um polinômio com coeficientes inteiros e n é um inteiro positivo retorna q, um polinômio sobre os inteiros, tal que q^n=p ou imprime uma mensagem de erro indicando que p não é uma potência n-ésima perfeita.  Essa rotina é mais rápida que factor ou mesmo sqfr.

 -- Variável: programmode
     Valor padrão: true

     Quando programmode é true, solve, realroots, allroots, e linsolve retornam solucedilhaões como elementos em uma lista. (Exceto quando backsubst é escolhido para false, nesse caso programmode: false é assumido.)

     Quando programmode é false, solve, etc. cria rótulos de expressões intermediárias %t1, t2, etc., e atribui as solucedilhaões para eles.

 -- Variável: realonly
     Valor padrão: false

     Quando realonly é true, algsys retorna somente aquelas solucedilhaões que estão livres de %i.

 -- Funcedilhaão: realroots (EXPR, BOUND)
 -- Funcedilhaão: realroots (EQN, BOUND)
 -- Funcedilhaão: realroots (EXPR)
 -- Funcedilhaão: realroots (EQN)
     Calcula aproximacedilhaões racionais das raízes reais da expressão polinomial EXPR ou da equacedilhaão polinomial EQN de uma variável, dentro de uma tolerância de BOUND. coeficientes de EXPR ou de EQN devem ser números literais; constantes símbolo tais como %pi são rejeitadas.

     realroots atribui as multiplicidades das raízes que encontrar para a variável global multiplicities.

     realroots constrói uma seqüência de Sturm para delimitar cada raíz, e então palica a biseccedilhaão para redefinir as aproximacedilhaões. Todos os coeficientes são convertidos para os equivalentes racionais antes da busca por raízes, e cálculos são realizados por meio de aritmética racional exata. Mesmo se alguns coeficientes forem números em ponto flutuante, os resultados são racionais (a menos que forcedilhaados a números em ponto flutuante por float ou por numer flags).

     Quando BOUND for menor que 1, todas as raízes inteiras são encontradas exatamente. Quando BOUND não for especificado, será assumido como sendo igual à variável globa rootsepsilon.

     Quando a varável global programmode for true, realroots retorna uma lista da forma [x = X_1, x = X_2, ...]. Quando programmode for false, realroots cria rótulos de expressões intermediárias %t1, %t2, ..., atribui os resultados a eles, e retorna a lista de rótulos.

     Exemplos:

          (%i1) realroots (-1 - x + x^5, 5e-6);
                                         612003
          (%o1)                     [x = ------]
                                         524288
          (%i2) ev (%[1], float);
          (%o2)                 x = 1.167303085327148
          (%i3) ev (-1 - x + x^5, %);
          (%o3)                - 7.396496210176905E-6

          (%i1) realroots (expand ((1 - x)^5 * (2 - x)^3 * (3 - x)), 1e-20);
          (%o1)                 [x = 1, x = 2, x = 3]
          (%i2) multiplicities;
          (%o2)                       [5, 3, 1]

 -- Funcedilhaão: rhs (EXPR)
     Retorna o lado direito (isto é, o segundo argumento) da expressão EXPR, quando o operador de EXPR for um dos operadores relacionais < <= = # equal notequal >= >, um dos operadores de atribuicedilhaão := ::= : ::, ou um operador binário infixo definido pelo usuário, como declarado por meio de infix.

     Quando EXPR for um étomo ou seu operadro for alguma coisa que não esses listados acima, rhs retorna 0.

     Veja também lhs.

     Exemplos:

          (%i1) e: aa + bb = cc;
          (%o1)                     bb + aa = cc
          (%i2) lhs (e);
          (%o2)                        bb + aa
          (%i3) rhs (e);
          (%o3)                          cc
          (%i4) [rhs (aa < bb), rhs (aa <= bb), rhs (aa >= bb), rhs (aa > bb)];
          (%o4)                   [bb, bb, bb, bb]
          (%i5) [rhs (aa = bb), rhs (aa # bb), rhs (equal (aa, bb)), rhs (notequal (aa, bb))];
          (%o5)                   [bb, bb, bb, bb]
          (%i6) e1: '(foo(x) := 2*x);
          (%o6)                     foo(x) := 2 x
          (%i7) e2: '(bar(y) ::= 3*y);
          (%o7)                    bar(y) ::= 3 y
          (%i8) e3: '(x : y);
          (%o8)                         x : y
          (%i9) e4: '(x :: y);
          (%o9)                        x :: y
          (%i10) [rhs (e1), rhs (e2), rhs (e3), rhs (e4)];
          (%o10)                  [2 x, 3 y, y, y]
          (%i11) infix ("][");
          (%o11)                         ][
          (%i12) rhs (aa ][ bb);
          (%o12)                         bb

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

     rootsconmode governa o comportamento do comando rootscontract.  Veja rootscontract para detalhes.

 -- Funcedilhaão: rootscontract (EXPR)
     Converte produtos de raízes em raízes de produtos. Por exemplo, rootscontract (sqrt(x)*y^(3/2)) retorna sqrt(x*y^3).

     Quando radexpand é true e domain é real, rootscontract converte abs em sqrt, e.g., rootscontract (abs(x)*sqrt(y)) retorna sqrt(x^2*y).

     Existe uma opcedilhaão rootsconmode afetando rootscontract como segue:

          Problem            Value of        Result of applying
                            rootsconmode        rootscontract

          x^(1/2)*y^(3/2)      false          (x*y^3)^(1/2)
          x^(1/2)*y^(1/4)      false          x^(1/2)*y^(1/4)
          x^(1/2)*y^(1/4)      true           (x*y^(1/2))^(1/2)
          x^(1/2)*y^(1/3)      true           x^(1/2)*y^(1/3)
          x^(1/2)*y^(1/4)      all            (x^2*y)^(1/4)
          x^(1/2)*y^(1/3)      all            (x^3*y^2)^(1/6)

     Quando rootsconmode é false, rootscontract contrai somente como relacedilhaão a expoentes de número racional cujos denominadores são os mesmos.  A chave para os exemplos rootsconmode: true é simplesmente que 2 divides 4 mas não divide 3.  rootsconmode: all envolve pegar o menor multiplo comum dos denominadores dos expoentes.

     rootscontract usa ratsimp em uma maneira similar a logcontract.

     Exemplos:

          (%i1) rootsconmode: false$
          (%i2) rootscontract (x^(1/2)*y^(3/2));
                                             3
          (%o2)                      sqrt(x y )
          (%i3) rootscontract (x^(1/2)*y^(1/4));
                                             1/4
          (%o3)                     sqrt(x) y
          (%i4) rootsconmode: true$
          (%i5) rootscontract (x^(1/2)*y^(1/4));
          (%o5)                    sqrt(x sqrt(y))
          (%i6) rootscontract (x^(1/2)*y^(1/3));
                                             1/3
          (%o6)                     sqrt(x) y
          (%i7) rootsconmode: all$
          (%i8) rootscontract (x^(1/2)*y^(1/4));
                                        2   1/4
          (%o8)                       (x  y)
          (%i9) rootscontract (x^(1/2)*y^(1/3));
                                       3  2 1/6
          (%o9)                      (x  y )
          (%i10) rootsconmode: false$
          (%i11) rootscontract (sqrt(sqrt(x) + sqrt(1 + x))
                              *sqrt(sqrt(1 + x) - sqrt(x)));
          (%o11)                          1
          (%i12) rootsconmode: true$
          (%i13) rootscontract (sqrt(5 + sqrt(5)) - 5^(1/4)*sqrt(1 + sqrt(5)));
          (%o13)                          0

 -- Variável de opcedilhaão: rootsepsilon
     Valor padrão: 1.0e-7

     rootsepsilon é a tolerância que estabelece o intervalo de conficência para as raízes achadas pela funcedilhaão realroots.

 -- Funcedilhaão: solve (EXPR, X)
 -- Funcedilhaão: solve (EXPR)
 -- Funcedilhaão: solve ([EQN_1, ..., EQN_N], [X_1, ..., X_N])
     Resolve a equacedilhaão algébrica EXPR para a variável X e retorna uma lista de equacedilhaões solucedilhaão em X.  Se EXPR não é uma equacedilhaão, a equacedilhaão EXPR = 0 é assumida em seu lugar. X pode ser uma funcedilhaão (e.g. f(x)), ou outra expressão não atômica exceto uma adicedilhaão ou um produto.  X pode ser omitido se EXPR contém somente uma variável.  EXPR pode ser uma expressão racional, e pode conter funcedilhaões trigonométricas, exponenciais, etc.

     O seguinte método é usado:

     Tome E sendo a expressão e X sendo a variável.  Se E é linear em X então isso é trivialmente resolvido para X.  De outra forma se E é da forma A*X^N + B então o resultado é (-B/A)^1/N) vezes as N'ésimas raízes da unidade.

     Se E não é linear em X então o máximo divisor comum (mdc) dos expoentes de X em E (digamos N) é dividido dentro dos expoentes e a multiplicidade das raízes é multiplicada por N.  Então solve é chamada novamente sobre o resultado. Se E for dada em fatores então solve é chamada sobre cada um dos fatores.  Finalmente solve usará as fórmulas quadráticas, cúbicas, ou quárticas onde necessário.

     No caso onde E for um polinômio em alguma funcedilhaão de variável a ser resolvida, digamos F(X), então isso é primeiro resolvida para F(X) (chama o resultado C), então a equacedilhaão F(X)=C pode ser resolvida para X fornecendo o inverso da funcedilhaão F que é conhecida.

     breakup se false fará com que solve expresse as solucedilhaões de equacedilhaões cúbicas ou quárticas como expressões simples ao invés de como feito em cima de várias subexpressões comuns que é o padrão.

     multiplicities - será escolhido para uma lista de multiplicidades de solucedilhaões individuais retornadas por solve, realroots, ou allroots. Tente apropos (solve) para os comutadores que afetam solve.  describe pode então ser usada sobre o nome do comutador individual se seu proprósito não é claro.

     solve ([EQN_1, ..., EQN_N], [X_1, ..., X_N]) resolve um sistema de equacedilhaões polinomiais (lineares ou não-lineares) simultâneas por chamada a linsolve ou algsys e retorna uma lista de listas solucedilhaão nas variáveis.  No caso de linsolve essa lista conterá uma lista simples de solucedilhaões.  Isso pega duas listas como argumentos.  A primeira lista representa as equacedilhaões a serem resolvidas; a segunda lista é a lista de desconhecidos a ser determinada.  Se o número total de variáveis nas equacedilhaões é igual ao número de equacedilhaões, a segunda lista-argumento pode ser omitida.  Para sistemas lineares se as dadas equacedilhaões não são compatíveis, a mensagem inconsistent será mostrada (veja o comutador solve_inconsistent_error ); se não existe solucedilhaão única, então singular será mostrado.

     Quando programmode for false, solve mostra solucedilhaões com rótulos de expressões intermediárias (%t), e retorna a lista de rótulos.

     Quando globalsolve for true e o problema for resolver duas ou mais equacedilhaões lineares, cada variável para a qual a equacedilhaão for resolvida é associada a seu valor na solucedilhaão das equacedilhaões.

     Exemplos:

          (%i1) solve (asin (cos (3*x))*(f(x) - 1), x);

          SOLVE is using arc-trig functions to get a solution.
          Some solutions will be lost.
                                      %pi
          (%o1)                  [x = ---, f(x) = 1]
                                       6
          (%i2) ev (solve (5^f(x) = 125, f(x)), solveradcan);
                                          log(125)
          (%o2)                   [f(x) = --------]
                                           log(5)
          (%i3) [4*x^2 - y^2 = 12, x*y - x = 2];
                                2    2
          (%o3)             [4 x  - y  = 12, x y - x = 2]
          (%i4) solve (%, [x, y]);
          (%o4) [[x = 2, y = 2], [x = .5202594388652008 %i

           - .1331240357358706, y = .0767837852378778

           - 3.608003221870287 %i], [x = - .5202594388652008 %i

           - .1331240357358706, y = 3.608003221870287 %i

           + .0767837852378778], [x = - 1.733751846381093,

          y = - .1535675710019696]]
          (%i5) solve (1 + a*x + x^3, x);
                                                 3
                        sqrt(3) %i   1   sqrt(4 a  + 27)   1 1/3
          (%o5) [x = (- ---------- - -) (--------------- - -)
                            2        2      6 sqrt(3)      2

                  sqrt(3) %i   1
                 (---------- - -) a
                      2        2
           - --------------------------, x =
                        3
                sqrt(4 a  + 27)   1 1/3
             3 (--------------- - -)
                   6 sqrt(3)      2

                                    3
           sqrt(3) %i   1   sqrt(4 a  + 27)   1 1/3
          (---------- - -) (--------------- - -)
               2        2      6 sqrt(3)      2

                   sqrt(3) %i   1
                (- ---------- - -) a
                       2        2
           - --------------------------, x =
                        3
                sqrt(4 a  + 27)   1 1/3
             3 (--------------- - -)
                   6 sqrt(3)      2

                   3
           sqrt(4 a  + 27)   1 1/3               a
          (--------------- - -)    - --------------------------]
              6 sqrt(3)      2                  3
                                        sqrt(4 a  + 27)   1 1/3
                                     3 (--------------- - -)
                                           6 sqrt(3)      2
          (%i6) solve (x^3 - 1);
                       sqrt(3) %i - 1        sqrt(3) %i + 1
          (%o6)   [x = --------------, x = - --------------, x = 1]
                             2                     2
          (%i7) solve (x^6 - 1);
                     sqrt(3) %i + 1      sqrt(3) %i - 1
          (%o7) [x = --------------, x = --------------, x = - 1,
                           2                   2

                               sqrt(3) %i + 1        sqrt(3) %i - 1
                         x = - --------------, x = - --------------, x = 1]
                                     2                     2
          (%i8) ev (x^6 - 1, %[1]);
                                                6
                                (sqrt(3) %i + 1)
          (%o8)                 ----------------- - 1
                                       64
          (%i9) expand (%);
          (%o9)                           0
          (%i10) x^2 - 1;
                                        2
          (%o10)                       x  - 1
          (%i11) solve (%, x);
          (%o11)                  [x = - 1, x = 1]
          (%i12) ev (%th(2), %[1]);
          (%o12)                          0

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

     Quando solvedecomposes é true, solve chama polydecomp se perguntado para resolver polinômios.

 -- Variável de opcedilhaão: solveexplicit
     Valor padrão: false

     Quando solveexplicit é true, inibe solve de retornar solucedilhaões implícitas, isto é, solucedilhaões da forma F(x) = 0 onde F é alguma funcedilhaão.

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

     Quando solvefactors é false, solve não tenta fatorar a expressão.  O false escolhido pode ser desejado em alguns casos onde a fatoracedilhaão não é necessária.

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

     Quando solvenullwarn é true, solve imprime uma mensagem de alerta se chamada com ou uma lista equacedilhaão ou uma variável lista nula. Por exemplo, solve ([], []) imprimirá duas mensagens de alerta e retorna [].

 -- Variável de opcedilhaão: solveradcan
     Valor padrão: false

     Quando solveradcan é true, solve chama radcan que faz solve lento mas permitirá certamente que problemas contendo exponeniais e logarítmos sejam resolvidos.

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

     Quando solvetrigwarn é true, solve pode imprimir uma mensagem dizendo que está usando funcedilhaões trigonométricas inversas para resolver a equacedilhaão, e desse modo perdendo solucedilhaões.

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

     Quando solve_inconsistent_error for true, solve e linsolve resultam em erro se as equacedilhaões a serem resolvidas forem inconsistentes.

     Se false, solve e linsolve retornam uma lista vazia [] se as equacedilhaões forem inconsistentes.

     Exemplo:

          (%i1) solve_inconsistent_error: true$
          (%i2) solve ([a + b = 1, a + b = 2], [a, b]);
          Inconsistent equacedilhaões:  (2)
           -- an error.  Quitting.  To debug this try debugmode(true);
          (%i3) solve_inconsistent_error: false$
          (%i4) solve ([a + b = 1, a + b = 2], [a, b]);
          (%o4)                          []