doc/info/pt/Equations.texi

   1 @c /Equations.texi/1.24/Thu Nov  2 05:46:56 2006/-ko/
   2 @c end concepts Equations
   3 @menu
   4 * Definições para Equações::
   5 @end menu
   6
   7 @node Definições para Equações,  , Equações, Equações
   8 @section Definições para Equações
   9
  10 @c NEED A DESCRIPTION OF %rnum AS WELL
  11 @defvr {Variável} %rnum_list
  12 Valor por omissão: @code{[]}
  13
  14 @code{%rnum_list} é a lista de variáveis introduzidas em soluções
  15 por @code{algsys}.
  16 @code{%r} variáveis São adicionadas a @code{%rnum_list} na ordem em que
  17 forem criadas.
  18 Isso é conveniente para fazer substituições dentro da
  19 solução mais tarde.
  20 @c WHAT DOES THIS STATEMENT MEAN ??
  21 É recomendado usar essa lista em lugar de
  22 fazer @code{concat ('%r, j)}.
  23
  24 @c NEED EXAMPLE HERE
  25 @end defvr
  26
  27 @defvr {Variável} algexact
  28 Valor por omissão: @code{false}
  29
  30 @code{algexact} afecta o comportamento de @code{algsys} como segue:
  31
  32 Se @code{algexact} é @code{true},
  33 @code{algsys} sempre chama @code{solve} e então usa @code{realroots}
  34 sobre falhas de @code{solve}.
  35
  36 Se @code{algexact} é @code{false}, @code{solve} é chamada somente se
  37 o eliminante não for de uma variável, ou se for uma quadrática ou uma
  38 biquadrada.
  39
  40 Dessa forma @code{algexact: true} não garante soluções
  41 exactas, apenas que @code{algsys} tentará primeiro pegar
  42 soluções exactas, e somente retorna aproximações quando tudo mais falha.
  43
  44 @c ABOVE DESCRIPTION NOT TOO CLEAR -- MAYBE EXAMPLES WILL HELP
  45 @end defvr
  46
  47 @deffn {Função} algsys ([@var{expr_1}, ..., @var{expr_m}], [@var{x_1}, ..., @var{x_n}])
  48 @deffnx {Função} algsys ([@var{eqn_1}, ..., @var{eqn_m}], [@var{x_1}, ..., @var{x_n}])
  49 Resolve polinómios simultâneos @var{expr_1}, ..., @var{expr_m}
  50 ou equações polin@^omiais @var{eqn_1}, ..., @var{eqn_m}
  51 para as variáveis @var{x_1}, ..., @var{x_n}.
  52 Uma expressão @var{expr} é equivalente a uma equação @code{@var{expr} = 0}.
  53 Pode existir mais equações que variáveis ou vice-versa.
  54
  55 @code{algsys} retorna uma lista de soluções,
  56 com cada solução dada com uma lista de valores de estado das equações
  57 das variáveis @var{x_1}, ..., @var{x_n} que satisfazem o sistema de equações.
  58 Se @code{algsys} não pode achar uma solução, uma lista vazia @code{[]} é retornada.
  59
  60 Os símbolos @code{%r1}, @code{%r2}, ...,
  61 são introduzidos tantos quantos forem necessários para representar parâmetros arbitrários na solução;
  62 essas variáveis são também anexadas à lista @code{%rnum_list}.
  63
  64 O método usado é o seguinte:
  65
  66 (1) Primeiro as equações são factorizaadas e quebradas
  67 em subsistemas.
  68
  69 (2) Para cada subsistema @var{S_i}, uma equação @var{E} e uma variável @var{x} são
  70 seleccionados.
  71 A variável é escolhida para ter o menor grau não zero.
  72 Então a resultante de @var{E} e @var{E_j} em relação a @var{x} é calculada para cada um das
  73 equações restantes @var{E_j} nos subsistemas @var{S_i}.
  74 Isso retorna um novo subsistema @var{S_i'} em umas poucas variáveis, como @var{x} tenha sido eliminada.
  75 O processo agora retorna ao passo (1).
  76
  77 (3) Eventualmente, um subsistema consistindo de uma equação simples é
  78 obtido.  Se a equação é de várias variáveis e aproximações na
  79 forma de números em ponto flutuante nã tenham sido introduzidas, então @code{solve} é
  80 chamada para achar uma solução exacta.
  81
  82 Em alguns casos, @code{solve} não está habilitada a achar uma solução,
  83 ou se isso é feito a solução pode ser uma expressão expressão muito larga.
  84
  85 @c REMAINDER OF (3) IS PRETTY COMPLEX.  HOW CAN IT BE CLARIFIED ??
  86 Se a equação é de uma única variável e é ou linear, ou quadrática, ou
  87 biquadrada, então novamente @code{solve} é chamada se aproximações não tiverem
  88 sido introduzidas.  Se aproximações tiverem sido introduzidas ou a
  89 equação não é de uma única variável e nem tão pouco linear, quadratica, ou
  90 biquadrada, então o comutador @code{realonly} é @code{true}, A função
  91 @code{realroots} é chamada para achar o valor real das soluções.  Se
  92 @code{realonly} é @code{false}, então @code{allroots} é chamada a qual procura por
  93 soluções reais e complexas.
  94
  95 Se @code{algsys} produz uma solução que tem
  96 poucos digitos significativos que o requerido, o utilizador pode escolher o valor
  97 de @code{algepsilon} para um valor maior.
  98
  99 Se @code{algexact} é escolhido para
 100 @code{true}, @code{solve} será sempre chamada.
 101 @c algepsilon IS IN Floating.texi -- MAY WANT TO BRING IT INTO THIS FILE
 102
 103 (4) Finalmente, as soluções obtidas no passo (3) são substituídas dentro
 104 dos níveis prévios e o processo de solução retorna para (1).
 105 @c "PREVIOUS LEVELS" -- WHAT ARE THOSE ??
 106
 107 Quando @code{algsys} encontrar uma equação de várias variáveis que contém
 108 aproximações em ponto flutuante (usualmente devido a suas falhas em achar
 109 soluções exactas por um estágio mais fácil), então não tentará
 110 aplicar métodos exatos para tais equações e em lugar disso imprime a mensagem:
 111 "@code{algsys} cannot solve - system too complicated."
 112
 113 Interações com @code{radcan} podem produzir expressões largas ou
 114 complicadas.
 115 Naquele caso, pode ser possível isolar partes do resultado
 116 com @code{pickapart} ou @code{reveal}.
 117
 118 Ocasionalmente, @code{radcan} pode introduzir uma unidade imaginária
 119 @code{%i} dentro de uma solução que é actualmente avaliada como real.
 120
 121 Exemplos:
 122
 123 @c ===beg===
 124 @c e1: 2*x*(1 - a1) - 2*(x - 1)*a2;
 125 +@c e2: a2 - a1;
 126 +@c e3: a1*(-y - x^2 + 1);
 127 @c e4: a2*(y - (x - 1)^2);
 128 @c algsys ([e1, e2, e3, e4], [x, y, a1, a2]);
 129 @c e1: x^2 - y^2;
 130 @c e2: -1 - y + 2*y^2 - x + x^2;
 131 @c algsys ([e1, e2], [x, y]);
 132 @c ===end===
 133 @example
 134 (%i1) e1: 2*x*(1 - a1) - 2*(x - 1)*a2;
 135 (%o1)              2 (1 - a1) x - 2 a2 (x - 1)
 136 (%i2) e2: a2 - a1;
 137 (%o2)                        a2 - a1
 138 (%i3) e3: a1*(-y - x^2 + 1);
 139                                    2
 140 (%o3)                   a1 (- y - x  + 1)
 141 (%i4) e4: a2*(y - (x - 1)^2);
 142                                        2
 143 (%o4)                   a2 (y - (x - 1) )
 144 (%i5) algsys ([e1, e2, e3, e4], [x, y, a1, a2]);
 145 (%o5) [[x = 0, y = %r1, a1 = 0, a2 = 0],
 146
 147                                   [x = 1, y = 0, a1 = 1, a2 = 1]]
 148 (%i6) e1: x^2 - y^2;
 149                               2    2
 150 (%o6)                        x  - y
 151 (%i7) e2: -1 - y + 2*y^2 - x + x^2;
 152                          2        2
 153 (%o7)                 2 y  - y + x  - x - 1
 154 (%i8) algsys ([e1, e2], [x, y]);
 155                  1            1
 156 (%o8) [[x = - -------, y = -------],
 157               sqrt(3)      sqrt(3)
 158
 159         1              1             1        1
 160 [x = -------, y = - -------], [x = - -, y = - -], [x = 1, y = 1]]
 161      sqrt(3)        sqrt(3)          3        3
 162 @end example
 163
 164 @end deffn
 165
 166 @deffn {Função} allroots (@var{expr})
 167 @deffnx {Função} allroots (@var{eqn})
 168 Calcula aproximações numéricas de raízes reais e complexas do
 169 polinómio @var{expr} ou equação polin@^omial @var{eqn} de uma variável.
 170
 171 @c polyfactor IS NOT OTHERWISE DOCUMENTED
 172 O sinalizador @code{polyfactor} quando @code{true} faz com que
 173 @code{allroots} factore o polinómio sobre os números reais se o
 174 polinómio for real, ou sobre os números complexos, se o polinómio for
 175 complexo.
 176
 177 @code{allroots} pode retornar resultados imprecisos no caso de múltiplas raízes.
 178 Se o polinómio for real, @code{allroots (%i*@var{p})}) pode retornar
 179 aproximações mais precisas que @code{allroots (@var{p})},
 180 como @code{allroots} invoca um algoritmo diferente naquele caso.
 181
 182 @code{allroots} rejeita expressoões que não sejam polinómios.
 183 Isso requer que o numerador após a classificação
 184 (@code{rat}'ing) poderá ser um polinómio, e isso requer que o
 185 denominador seja quando muito um número complexo.  Com esse tipo
 186 resultado @code{allroots} irá sempre produzir uma expressão
 187 equivalente (mas factorizada), se @code{polyfactor} for @code{true}.
 188
 189 Para polinómios complexos um algoritmo por Jenkins e Traub é
 190 usado (Algorithm 419, @i{Comm.  ACM}, vol.  15, (1972), p.  97).
 191 Para polinómios reais o algoritmo usado é devido a Jenkins (Algorithm 493, @i{ACM TOMS},
 192 vol.  1, (1975), p.178).
 193
 194 Exemplos:
 195 @c EXAMPLES GENERATED BY THESE INPUTS:
 196 @c eqn: (1 + 2*x)^3 = 13.5*(1 + x^5);
 197 @c soln: allroots (eqn);
 198 @c for e in soln
 199 @c         do (e2: subst (e, eqn), disp (expand (lhs(e2) - rhs(e2))));
 200 @c polyfactor: true$
 201 @c allroots (eqn);
 202
 203 @example
 204 (%i1) eqn: (1 + 2*x)^3 = 13.5*(1 + x^5);
 205                             3          5
 206 (%o1)              (2 x + 1)  = 13.5 (x  + 1)
 207 (%i2) soln: allroots (eqn);
 208 (%o2) [x = .8296749902129361, x = - 1.015755543828121,
 209
 210 x = .9659625152196369 %i - .4069597231924075,
 211
 212 x = - .9659625152196369 %i - .4069597231924075, x = 1.0]
 213 (%i3) for e in soln
 214         do (e2: subst (e, eqn), disp (expand (lhs(e2) - rhs(e2))));
 215                       - 3.5527136788005E-15
 216
 217                      - 5.32907051820075E-15
 218
 219          4.44089209850063E-15 %i - 4.88498130835069E-15
 220
 221         - 4.44089209850063E-15 %i - 4.88498130835069E-15
 222
 223                        3.5527136788005E-15
 224
 225 (%o3)                         done
 226 (%i4) polyfactor: true$
 227 (%i5) allroots (eqn);
 228 (%o5) - 13.5 (x - 1.0) (x - .8296749902129361)
 229
 230                            2
 231  (x + 1.015755543828121) (x  + .8139194463848151 x
 232
 233  + 1.098699797110288)
 234 @end example
 235
 236 @end deffn
 237
 238 @defvr {Variável} backsubst
 239 Valor por omissão: @code{true}
 240
 241 @c WHAT IS THE CONTEXT HERE ?? (TO WHICH OTHER FUNCTION DOES THIS APPLY ??)
 242 Quando @code{backsubst} é @code{false}, evita substituições
 243 em expressões anteriores após as equações terem sido triangularizadas.  Isso pode
 244 ser de grande ajuda em problemas muito grandes onde substituição em expressões anteriores pode vir a causar
 245 a geração de expressões extremamente largas.
 246
 247 @end defvr
 248
 249 @defvr {Variável} breakup
 250 Valor por omissão: @code{true}
 251
 252 Quando @code{breakup} é @code{true}, @code{solve} expressa soluções
 253 de equações cúbicas e quárticas em termos de subexpressões comuns,
 254 que são atribuídas a rótulos de expressões intermédias (@code{%t1}, @code{%t2}, etc.).
 255 De outra forma, subexpressões comuns não são identificadas.
 256
 257 @code{breakup: true} tem efeito somente quando @code{programmode} é @code{false}.
 258
 259 Exemplos:
 260
 261 @example
 262 (%i1) programmode: false$
 263 (%i2) breakup: true$
 264 (%i3) solve (x^3 + x^2 - 1);
 265
 266                         sqrt(23)    25 1/3
 267 (%t3)                  (--------- + --)
 268                         6 sqrt(3)   54
 269 Solution:
 270
 271                                       sqrt(3) %i   1
 272                                       ---------- - -
 273                 sqrt(3) %i   1            2        2   1
 274 (%t4)    x = (- ---------- - -) %t3 + -------------- - -
 275                     2        2            9 %t3        3
 276
 277                                       sqrt(3) %i   1
 278                                     - ---------- - -
 279               sqrt(3) %i   1              2        2   1
 280 (%t5)    x = (---------- - -) %t3 + ---------------- - -
 281                   2        2             9 %t3         3
 282
 283                                    1     1
 284 (%t6)                  x = %t3 + ----- - -
 285                                  9 %t3   3
 286 (%o6)                    [%t4, %t5, %t6]
 287 (%i6) breakup: false$
 288 (%i7) solve (x^3 + x^2 - 1);
 289 Solution:
 290
 291              sqrt(3) %i   1
 292              ---------- - -
 293                  2        2        sqrt(23)    25 1/3
 294 (%t7) x = --------------------- + (--------- + --)
 295              sqrt(23)    25 1/3    6 sqrt(3)   54
 296           9 (--------- + --)
 297              6 sqrt(3)   54
 298
 299                                               sqrt(3) %i   1    1
 300                                            (- ---------- - -) - -
 301                                                   2        2    3
 302
 303            sqrt(23)    25 1/3  sqrt(3) %i   1
 304 (%t8) x = (--------- + --)    (---------- - -)
 305            6 sqrt(3)   54          2        2
 306
 307                                             sqrt(3) %i   1
 308                                           - ---------- - -
 309                                                 2        2      1
 310                                       + --------------------- - -
 311                                            sqrt(23)    25 1/3   3
 312                                         9 (--------- + --)
 313                                            6 sqrt(3)   54
 314
 315             sqrt(23)    25 1/3             1             1
 316 (%t9)  x = (--------- + --)    + --------------------- - -
 317             6 sqrt(3)   54          sqrt(23)    25 1/3   3
 318                                  9 (--------- + --)
 319                                     6 sqrt(3)   54
 320 (%o9)                    [%t7, %t8, %t9]
 321 @end example
 322
 323 @end defvr
 324
 325 @deffn {Função} dimension (@var{eqn})
 326 @deffnx {Função} dimension (@var{eqn_1}, ..., @var{eqn_n})
 327 @code{dimen} é um pacote de análise dimensional.
 328 @code{load ("dimen")} chama esse pacote.
 329 @code{demo ("dimen")} mostra uma cura demostração.
 330 @c I GUESS THIS SHOULD BE EXPANDED TO COVER EACH FUNCTION IN THE PACKAGE
 331
 332 @end deffn
 333
 334 @defvr {Variável} dispflag
 335 Valor por omissão: @code{true}
 336
 337 @c WHAT DOES THIS MEAN ??
 338 Se escolhida para @code{false} dentro de um @code{block} inibirá
 339 a visualização da saída gerada pelas funções solve chamadas de
 340 dentro de @code{block}.  Terminando @code{block} com um sinal de dolar, $, escolhe
 341 @code{dispflag} para @code{false}.
 342
 343 @end defvr
 344
 345 @c THIS COULD BENEFIT FROM REPHRASING
 346 @deffn {Função} funcsolve (@var{eqn}, @var{g}(@var{t}))
 347 Retorna @code{[@var{g}(@var{t}) = ...]}  ou @code{[]}, dependendo de existir
 348 ou não uma função racional @code{@var{g}(@var{t})} satisfazendo @var{eqn},
 349 que deve ser de primeira ordem, polinómio linear em (para esse caso)
 350 @code{@var{g}(@var{t})} e @code{@var{g}(@var{t}+1)}
 351
 352 @example
 353 (%i1) eqn: (n + 1)*f(n) - (n + 3)*f(n + 1)/(n + 1) = (n - 1)/(n + 2);
 354                             (n + 3) f(n + 1)   n - 1
 355 (%o1)        (n + 1) f(n) - ---------------- = -----
 356                                  n + 1         n + 2
 357 (%i2) funcsolve (eqn, f(n));
 358
 359 Equações dependentes eliminadas:  (4 3)
 360                                    n
 361 (%o2)                f(n) = ---------------
 362                             (n + 1) (n + 2)
 363 @end example
 364
 365 Atenção: essa é uma implementação muito rudimentar -- muitas verificações de segurança
 366 e obviamente generalizações estão ausêntes.
 367
 368 @end deffn
 369
 370 @defvr {Variável} globalsolve
 371 Valor por omissão: @code{false}
 372
 373 When @code{globalsolve} for @code{true},
 374 variáveis para as quais as equações são resolvidas são atribuidas aos valores da solução encontrados por @code{linsolve},
 375 e por @code{solve} quando resolvendo duas ou mais equações lineares.
 376 Quando @code{globalsolve} for @code{false},
 377 soluções encontradas por @code{linsolve} e por @code{solve} quando resolvendo duas ou mais equações lineares
 378 são espressas como equações,
 379 e as variáveis para as quais a equação foi resolvida não são atribuidas.
 380
 381 Quando resolvendo qualquer coisa outra que não duas equações lineares ou mais,
 382 @code{solve} ignora @code{globalsolve}.
 383 Outras funções que resolvem equações (e.g., @code{algsys}) sempre ignoram @code{globalsolve}.
 384
 385 Exemplos:
 386
 387 @example
 388 (%i1) globalsolve: true$
 389 (%i2) solve ([x + 3*y = 2, 2*x - y = 5], [x, y]);
 390 Solution
 391
 392                                  17
 393 (%t2)                        x : --
 394                                  7
 395
 396                                    1
 397 (%t3)                        y : - -
 398                                    7
 399 (%o3)                     [[%t2, %t3]]
 400 (%i3) x;
 401                                17
 402 (%o3)                          --
 403                                7
 404 (%i4) y;
 405                                  1
 406 (%o4)                          - -
 407                                  7
 408 (%i5) globalsolve: false$
 409 (%i6) kill (x, y)$
 410 (%i7) solve ([x + 3*y = 2, 2*x - y = 5], [x, y]);
 411 Solution
 412
 413                                  17
 414 (%t7)                        x = --
 415                                  7
 416
 417                                    1
 418 (%t8)                        y = - -
 419                                    7
 420 (%o8)                     [[%t7, %t8]]
 421 (%i8) x;
 422 (%o8)                           x
 423 (%i9) y;
 424 (%o9)                           y
 425 @end example
 426
 427 @end defvr
 428
 429 @c THIS DESCRIPTION NEEDS WORK AND EXAMPLES
 430 @c MERGE IN TEXT FROM share/integequations/inteqn.usg
 431 @c AND EXAMPLES FROM .../intexs.mac
 432 @deffn {Função} ieqn (@var{ie}, @var{unk}, @var{tech}, @var{n}, @var{guess})
 433 @code{inteqn} é um pacote para resolver equações integrais.
 434 @code{load ("inteqn")} carrega esse pacote.
 435
 436 @var{ie} é a equação integral; @var{unk} é a função desconhecida; @var{tech} é a
 437 técnica a ser tentada nesses dados acima (@var{tech} = @code{first} significa: tente
 438 a primeira técnica que achar uma solução; @var{tech} = @code{all} significa: tente todas a
 439 técnicas aplicáveis); @var{n} é o número máximo de termos a serem usados de
 440 @code{taylor}, @code{neumann}, @code{firstkindseries}, ou @code{fredseries} (isso é também o
 441 número máximo de ciclos de recurssão para o método de diferenciação); @var{guess} é
 442 o inicial suposto para @code{neumann} ou @code{firstkindseries}.
 443
 444 Valores padrão do segundo até o quinto parâmetro são:
 445
 446 @var{unk}: @code{@var{p}(@var{x})}, onde @var{p} é a primeira função encontrada em um integrando
 447 que é desconhecida para Maxima e @var{x} é a variável que ocorre como um
 448 argumento para a primeira ocorrência de @var{p} achada fora de uma integral no
 449 caso de equações @code{secondkind} , ou é somente outra variável
 450 ao lado da variável de integração em equações @code{firstkind}.  Se uma
 451 tentativa de procurar por @var{x} falha, o utilizador será perguntado para suprir a
 452 variável independente.
 453
 454 tech: @code{first}
 455
 456 n: 1
 457
 458 guess: @code{none} o que fará com que @code{neumann} e @code{firstkindseries} use
 459 @code{@var{f}(@var{x})} como uma suposição inicial.
 460
 461 @end deffn
 462
 463 @defvr {Variável de opção} ieqnprint
 464 Valor por omissão: @code{true}
 465
 466 @code{ieqnprint} governa o comportamento do resultado
 467 retornado pelo comando @code{ieqn}.  Quando @code{ieqnprint} é
 468 @code{false}, as listas retornadas pela função @code{ieqn} são da forma
 469
 470    [@var{solução}, @var{tecnica usada}, @var{nterms}, @var{sinalizador}]
 471
 472 onde @var{sinalizador} é retirado se a solução for exacta.
 473
 474 De outra forma, isso é a
 475 palavra @code{approximate} ou @code{incomplete} correspondendo à forma inexacta ou
 476 forma aberta de solução, respectivamente.  Se um método de série foi usado,
 477 @var{nterms} fornece o número de termos usados (que poderá ser menor que os n
 478 dados para @code{ieqn} se ocorrer um erro evita a geração de termos adicionais).
 479
 480 @end defvr
 481
 482 @deffn {Função} lhs (@var{expr})
 483 Retorna o lado esquerdo (isto é, o primeiro argumento)
 484 da expressão @var{expr},
 485 quando o operador de @var{expr}
 486 for um dos operadores relacionais @code{< <= = # equal notequal >= >},
 487 @c MENTION -> (MARROW) IN THIS LIST IF/WHEN THE PARSER RECOGNIZES IT
 488 um dos operadores de atribuição @code{:= ::= : ::},
 489 ou um operadro infixo definido pelo utilizador, como declarado por meio de @code{infix}.
 490
 491 Quando @var{expr} for um átomo ou
 492 seu operador for alguma coisa que não esses listados acima,
 493 @code{lhs} retorna @var{expr}.
 494
 495 Veja também @code{rhs}.
 496
 497 Exemplos:
 498
 499 @c ===beg===
 500 @c e: aa + bb = cc;
 501 @c lhs (e);
 502 @c rhs (e);
 503 @c [lhs (aa < bb), lhs (aa <= bb), lhs (aa >= bb), lhs (aa > bb)];
 504 @c [lhs (aa = bb), lhs (aa # bb), lhs (equal (aa, bb)), lhs (notequal (aa, bb))];
 505 @c e1: '(foo(x) := 2*x);
 506 @c e2: '(bar(y) ::= 3*y);
 507 @c e3: '(x : y);
 508 @c e4: '(x :: y);
 509 @c [lhs (e1), lhs (e2), lhs (e3), lhs (e4)];
 510 @c infix ("][");
 511 @c lhs (aa ][ bb);
 512 @c ===end===
 513 @example
 514 (%i1) e: aa + bb = cc;
 515 (%o1)                     bb + aa = cc
 516 (%i2) lhs (e);
 517 (%o2)                        bb + aa
 518 (%i3) rhs (e);
 519 (%o3)                          cc
 520 (%i4) [lhs (aa < bb), lhs (aa <= bb), lhs (aa >= bb), lhs (aa > bb)];
 521 (%o4)                   [aa, aa, aa, aa]
 522 (%i5) [lhs (aa = bb), lhs (aa # bb), lhs (equal (aa, bb)), lhs (notequal (aa, bb))];
 523 (%o5)                   [aa, aa, aa, aa]
 524 (%i6) e1: '(foo(x) := 2*x);
 525 (%o6)                     foo(x) := 2 x
 526 (%i7) e2: '(bar(y) ::= 3*y);
 527 (%o7)                    bar(y) ::= 3 y
 528 (%i8) e3: '(x : y);
 529 (%o8)                         x : y
 530 (%i9) e4: '(x :: y);
 531 (%o9)                        x :: y
 532 (%i10) [lhs (e1), lhs (e2), lhs (e3), lhs (e4)];
 533 (%o10)               [foo(x), bar(y), x, x]
 534 (%i11) infix ("][");
 535 (%o11)                         ][
 536 (%i12) lhs (aa ][ bb);
 537 (%o12)                         aa
 538 @end example
 539
 540 @end deffn
 541
 542 @c REVISIT -- THERE'S PROBABLY MORE TO SAY HERE
 543 @deffn {Função} linsolve ([@var{expr_1}, ..., @var{expr_m}], [@var{x_1}, ..., @var{x_n}])
 544 Resolve a lista de
 545 equações lineares simultâneas para a lista de variáveis.  As expressões
 546 devem ser cada uma polinómios nas variáveis e podem ser equações.
 547
 548 Quando @code{globalsolve} é @code{true} então variáveis que foram resolvidas
 549 serão escolhidas para a solução do conjunto de equações simultâneas.
 550
 551 Quando @code{backsubst} é @code{false}, @code{linsolve}
 552 não realiza substituição em equações anteriores após
 553 as equações terem sido triangularizadas.  Isso pode ser necessário em problemas
 554 muito grandes onde substituição em equações anteriores poderá causar a geração de
 555 expressões extremamente largas.
 556
 557 Quando @code{linsolve_params} for @code{true},
 558 @code{linsolve} também gera símbolos @code{%r}
 559 usados para representar parâmetros arbitrários descritos no manual sob
 560 @code{algsys}.
 561 De outra forma, @code{linsolve} resolve um menor-determinado sistema de
 562 equações com algumas variáveis expressas em termos de outras.
 563
 564 Quando @code{programmode} for @code{false},
 565 @code{linsolve} mostra a solução com expressões intermédias com rótulos (@code{%t}),
 566 e retorna a lista de rótulos.
 567
 568 @c ===beg===
 569 @c e1: x + z = y;
 570 @c e2: 2*a*x - y = 2*a^2;
 571 @c e3: y - 2*z = 2;
 572 @c [globalsolve: false, programmode: true];
 573 @c linsolve ([e1, e2, e3], [x, y, z]);
 574 @c [globalsolve: false, programmode: false];
 575 @c linsolve ([e1, e2, e3], [x, y, z]);
 576 @c ''%;
 577 @c [globalsolve: true, programmode: false];
 578 @c linsolve ([e1, e2, e3], [x, y, z]);
 579 @c ''%;
 580 @c [x, y, z];
 581 @c [globalsolve: true, programmode: true];
 582 @c linsolve ([e1, e2, e3], '[x, y, z]);
 583 @c [x, y, z];
 584 @c ===end===
 585 @example
 586 (%i1) e1: x + z = y;
 587 (%o1)                       z + x = y
 588 (%i2) e2: 2*a*x - y = 2*a^2;
 589                                        2
 590 (%o2)                   2 a x - y = 2 a
 591 (%i3) e3: y - 2*z = 2;
 592 (%o3)                      y - 2 z = 2
 593 (%i4) [globalsolve: false, programmode: true];
 594 (%o4)                     [false, true]
 595 (%i5) linsolve ([e1, e2, e3], [x, y, z]);
 596 (%o5)            [x = a + 1, y = 2 a, z = a - 1]
 597 (%i6) [globalsolve: false, programmode: false];
 598 (%o6)                    [false, false]
 599 (%i7) linsolve ([e1, e2, e3], [x, y, z]);
 600 Solution
 601
 602 (%t7)                       z = a - 1
 603
 604 (%t8)                        y = 2 a
 605
 606 (%t9)                       x = a + 1
 607 (%o9)                    [%t7, %t8, %t9]
 608 (%i9) ''%;
 609 (%o9)            [z = a - 1, y = 2 a, x = a + 1]
 610 (%i10) [globalsolve: true, programmode: false];
 611 (%o10)                    [true, false]
 612 (%i11) linsolve ([e1, e2, e3], [x, y, z]);
 613 Solution
 614
 615 (%t11)                      z : a - 1
 616
 617 (%t12)                       y : 2 a
 618
 619 (%t13)                      x : a + 1
 620 (%o13)                 [%t11, %t12, %t13]
 621 (%i13) ''%;
 622 (%o13)           [z : a - 1, y : 2 a, x : a + 1]
 623 (%i14) [x, y, z];
 624 (%o14)                 [a + 1, 2 a, a - 1]
 625 (%i15) [globalsolve: true, programmode: true];
 626 (%o15)                    [true, true]
 627 (%i16) linsolve ([e1, e2, e3], '[x, y, z]);
 628 (%o16)           [x : a + 1, y : 2 a, z : a - 1]
 629 (%i17) [x, y, z];
 630 (%o17)                 [a + 1, 2 a, a - 1]
 631 @end example
 632
 633 @end deffn
 634
 635 @c DO ANY FUNCTIONS OTHER THAN linsolve RESPECT linsolvewarn ??
 636 @defvr {Variável} linsolvewarn
 637 Valor por omissão: @code{true}
 638
 639 Quando @code{linsolvewarn} é @code{true},
 640 @code{linsolve} imprime uma mensagem "Dependent equações eliminated".
 641
 642 @end defvr
 643
 644 @defvr {Variável} linsolve_params
 645 Valor por omissão: @code{true}
 646
 647 Quando @code{linsolve_params} é @code{true}, @code{linsolve} também gera
 648 os símbolos @code{%r} usados para representar parâmetros arbitrários descritos no
 649 manual sob @code{algsys}.
 650 De outra forma, @code{linsolve} resolve um menor-determinado sistema de
 651 equações com algumas variáveis expressas em termos e outras.
 652
 653 @end defvr
 654
 655 @defvr {Variável} multiplicities
 656 Valor por omissão: @code{not_set_yet}
 657
 658 @code{multiplicities} é escolhida para uma lista de
 659 multiplicidades das soluções individuais retornadas por @code{solve} ou
 660 @code{realroots}.
 661 @c NEED AN EXAMPLE HERE
 662
 663 @end defvr
 664
 665 @deffn {Função} nroots (@var{p}, @var{low}, @var{high})
 666 Retorna o número de raízes reais do polinómio
 667 real de uma única variável @var{p} no intervalo semi-aberto
 668 @code{(@var{low}, @var{high}]}.
 669 Uma extremidade do intervalo podem ser @code{minf} ou @code{inf}.
 670 infinito e mais infinito.
 671
 672 @code{nroots} usa o método das sequuências de Sturm.
 673
 674 @example
 675 (%i1) p: x^10 - 2*x^4 + 1/2$
 676 (%i2) nroots (p, -6, 9.1);
 677 (%o2)                           4
 678 @end example
 679
 680 @end deffn
 681
 682 @c NEEDS WORK
 683 @deffn {Função} nthroot (@var{p}, @var{n})
 684 Onde p é um polinómio com coeficientes inteiros e
 685 n é um inteiro positivo retorna q, um polinómio sobre os inteiros, tal
 686 que q^n=p ou imprime uma mensagem de erro indicando que p não é uma potência n-ésima
 687 perfeita.  Essa rotina é mais rápida que @code{factor} ou mesmo @code{sqfr}.
 688
 689 @end deffn
 690
 691 @defvr {Variável} programmode
 692 Valor por omissão: @code{true}
 693
 694 Quando @code{programmode} é @code{true},
 695 @code{solve}, @code{realroots}, @code{allroots}, e @code{linsolve}
 696 retornam soluções como elementos em uma lista.
 697 @c WHAT DOES BACKSUBSTITUTION HAVE TO DO WITH RETURN VALUES ??
 698 (Exceto quando @code{backsubst} é escolhido para @code{false}, nesse caso
 699 @code{programmode: false} é assumido.)
 700
 701 Quando @code{programmode} é @code{false}, @code{solve}, etc.
 702 cria rótulos de expressões intermédias
 703 @code{%t1}, @code{t2}, etc., e atribui as soluções para eles.
 704 @c NEED AN EXAMPLE HERE
 705
 706 @end defvr
 707
 708 @defvr {Variável} realonly
 709 Valor por omissão: @code{false}
 710
 711 Quando @code{realonly} é @code{true}, @code{algsys} retorna somente
 712 aquelas soluções que estão livres de @code{%i}.
 713
 714 @end defvr
 715
 716 @deffn {Função} realroots (@var{expr}, @var{bound})
 717 @deffnx {Função} realroots (@var{eqn}, @var{bound})
 718 @deffnx {Função} realroots (@var{expr})
 719 @deffnx {Função} realroots (@var{eqn})
 720 Calcula aproximações racionais das raízes reais da expressão polinomial @var{expr}
 721 ou da equação polinomial @var{eqn} de uma variável,
 722 dentro de uma tolerância de @var{bound}.
 723 coeficientes de @var{expr} ou de @var{eqn} devem ser números literais;
 724 constantes símbolo tais como @code{%pi} são rejeitadas.
 725
 726 @code{realroots} atribui as multiplicidades das raízes que encontrar
 727 para a variável global @code{multiplicities}.
 728
 729 @code{realroots} constrói uma sequência de Sturm para delimitar cada raíz,
 730 e então palica a bisecção para redefinir as aproximações.
 731 Todos os coeficientes são convertidos para os equivalentes racionais antes da busca por raízes,
 732 e cálculos são realizados por meio de aritmética racional exacta.
 733 Mesmo se alguns coeficientes forem números em ponto flutuante,
 734 os resultados são racionais (a menos que forçados a números em ponto flutuante por @code{float} ou por @code{numer} flags).
 735
 736 Quando @var{bound} for menor que 1, todas as raízes inteiras são encontradas exactamente.
 737 Quando @var{bound} não for especificado, será assumido como sendo igual à variável globa @code{rootsepsilon}.
 738
 739 Quando a varável global @code{programmode} for @code{true},
 740 @code{realroots} retorna uma lista da forma @code{[x = @var{x_1}, x = @var{x_2}, ...]}.
 741 Quando @code{programmode} for @code{false},
 742 @code{realroots} cria rótulos de expressões intermédias @code{%t1}, @code{%t2}, ...,
 743 atribui os resultados a eles, e retorna a lista de rótulos.
 744
 745 Exemplos:
 746 @c ===beg===
 747 @c realroots (-1 - x + x^5, 5e-6);
 748 @c ev (%[1], float);
 749 @c ev (-1 - x + x^5, %);
 750 @c ===end===
 751
 752 @example
 753 (%i1) realroots (-1 - x + x^5, 5e-6);
 754                                612003
 755 (%o1)                     [x = ------]
 756                                524288
 757 (%i2) ev (%[1], float);
 758 (%o2)                 x = 1.167303085327148
 759 (%i3) ev (-1 - x + x^5, %);
 760 (%o3)                - 7.396496210176905E-6
 761 @end example
 762
 763 @c ===beg===
 764 @c realroots (expand ((1 - x)^5 * (2 - x)^3 * (3 - x)), 1e-20);
 765 @c multiplicities;
 766 @c ===end===
 767
 768 @example
 769 (%i1) realroots (expand ((1 - x)^5 * (2 - x)^3 * (3 - x)), 1e-20);
 770 (%o1)                 [x = 1, x = 2, x = 3]
 771 (%i2) multiplicities;
 772 (%o2)                       [5, 3, 1]
 773 @end example
 774
 775 @end deffn
 776
 777 @deffn {Função} rhs (@var{expr})
 778 Retorna o lado direito (isto é, o segundo argumento)
 779 da expressão @var{expr},
 780 quando o operador de @var{expr}
 781 for um dos operadores relacionais @code{< <= = # equal notequal >= >},
 782 @c MENTION -> (MARROW) IN THIS LIST IF/WHEN THE PARSER RECOGNIZES IT
 783 um dos operadores de atribuição @code{:= ::= : ::},
 784 ou um operador binário infixo definido pelo utilizador, como declarado por meio de @code{infix}.
 785
 786 Quando @var{expr} for um étomo ou
 787 seu operadro for alguma coisa que não esses listados acima,
 788 @code{rhs} retorna 0.
 789
 790 Veja também @code{lhs}.
 791
 792 Exemplos:
 793
 794 @c ===beg===
 795 @c e: aa + bb = cc;
 796 @c lhs (e);
 797 @c rhs (e);
 798 @c [rhs (aa < bb), rhs (aa <= bb), rhs (aa >= bb), rhs (aa > bb)];
 799 @c [rhs (aa = bb), rhs (aa # bb), rhs (equal (aa, bb)), rhs (notequal (aa, bb))];
 800 @c e1: '(foo(x) := 2*x);
 801 @c e2: '(bar(y) ::= 3*y);
 802 @c e3: '(x : y);
 803 @c e4: '(x :: y);
 804 @c [rhs (e1), rhs (e2), rhs (e3), rhs (e4)];
 805 @c infix ("][");
 806 @c rhs (aa ][ bb);
 807 @c ===end===
 808 @example
 809 (%i1) e: aa + bb = cc;
 810 (%o1)                     bb + aa = cc
 811 (%i2) lhs (e);
 812 (%o2)                        bb + aa
 813 (%i3) rhs (e);
 814 (%o3)                          cc
 815 (%i4) [rhs (aa < bb), rhs (aa <= bb), rhs (aa >= bb), rhs (aa > bb)];
 816 (%o4)                   [bb, bb, bb, bb]
 817 (%i5) [rhs (aa = bb), rhs (aa # bb), rhs (equal (aa, bb)), rhs (notequal (aa, bb))];
 818 (%o5)                   [bb, bb, bb, bb]
 819 (%i6) e1: '(foo(x) := 2*x);
 820 (%o6)                     foo(x) := 2 x
 821 (%i7) e2: '(bar(y) ::= 3*y);
 822 (%o7)                    bar(y) ::= 3 y
 823 (%i8) e3: '(x : y);
 824 (%o8)                         x : y
 825 (%i9) e4: '(x :: y);
 826 (%o9)                        x :: y
 827 (%i10) [rhs (e1), rhs (e2), rhs (e3), rhs (e4)];
 828 (%o10)                  [2 x, 3 y, y, y]
 829 (%i11) infix ("][");
 830 (%o11)                         ][
 831 (%i12) rhs (aa ][ bb);
 832 (%o12)                         bb
 833 @end example
 834
 835 @end deffn
 836
 837 @defvr {Variável de opção} rootsconmode
 838 Valor por omissão: @code{true}
 839
 840 @code{rootsconmode} governa o comportamento do comando
 841 @code{rootscontract}.  Veja @code{rootscontract} para detalhes.
 842
 843 @end defvr
 844
 845 @c NEEDS WORK
 846 @deffn {Função} rootscontract (@var{expr})
 847 Converte produtos de raízes em raízes de produtos.
 848 Por exemplo,
 849 @code{rootscontract (sqrt(x)*y^(3/2))} retorna @code{sqrt(x*y^3)}.
 850
 851 Quando @code{radexpand} é @code{true} e @code{domain} é @code{real},
 852 @code{rootscontract} converte @code{abs} em @code{sqrt}, e.g.,
 853 @code{rootscontract (abs(x)*sqrt(y))} retorna @code{sqrt(x^2*y)}.
 854
 855 Existe uma opção @code{rootsconmode}
 856 afectando @code{rootscontract} como segue:
 857
 858 @example
 859 Problem            Value of        Result of applying
 860                   rootsconmode        rootscontract
 861
 862 x^(1/2)*y^(3/2)      false          (x*y^3)^(1/2)
 863 x^(1/2)*y^(1/4)      false          x^(1/2)*y^(1/4)
 864 x^(1/2)*y^(1/4)      true           (x*y^(1/2))^(1/2)
 865 x^(1/2)*y^(1/3)      true           x^(1/2)*y^(1/3)
 866 x^(1/2)*y^(1/4)      all            (x^2*y)^(1/4)
 867 x^(1/2)*y^(1/3)      all            (x^3*y^2)^(1/6)
 868 @end example
 869
 870 Quando @code{rootsconmode} é @code{false}, @code{rootscontract} contrai somente como relação a expoentes
 871 de número racional cujos denominadores são os mesmos.  A chave para os exemplos
 872 @code{rootsconmode: true} é simplesmente que 2 divides 4 mas não
 873 divide 3.  @code{rootsconmode: all} envolve pegar o menor múltiplo comum
 874 dos denominadores dos expoentes.
 875
 876 @code{rootscontract} usa @code{ratsimp} em uma maneira similar a @code{logcontract}.
 877
 878 Exemplos:
 879 @c FOLLOWING ADAPTED FROM example (rootscontract)
 880 @c rootsconmode: false$
 881 @c rootscontract (x^(1/2)*y^(3/2));
 882 @c rootscontract (x^(1/2)*y^(1/4));
 883 @c rootsconmode: true$
 884 @c rootscontract (x^(1/2)*y^(1/4));
 885 @c rootscontract (x^(1/2)*y^(1/3));
 886 @c rootsconmode: all$
 887 @c rootscontract (x^(1/2)*y^(1/4));
 888 @c rootscontract (x^(1/2)*y^(1/3));
 889 @c rootsconmode: false$
 890 @c rootscontract (sqrt(sqrt(x) + sqrt(1 + x))
 891 @c                     *sqrt(sqrt(1 + x) - sqrt(x)));
 892 @c rootsconmode: true$
 893 @c rootscontract (sqrt(5 + sqrt(5)) - 5^(1/4)*sqrt(1 + sqrt(5)));
 894
 895 @example
 896 (%i1) rootsconmode: false$
 897 (%i2) rootscontract (x^(1/2)*y^(3/2));
 898                                    3
 899 (%o2)                      sqrt(x y )
 900 (%i3) rootscontract (x^(1/2)*y^(1/4));
 901                                    1/4
 902 (%o3)                     sqrt(x) y
 903 (%i4) rootsconmode: true$
 904 (%i5) rootscontract (x^(1/2)*y^(1/4));
 905 (%o5)                    sqrt(x sqrt(y))
 906 (%i6) rootscontract (x^(1/2)*y^(1/3));
 907                                    1/3
 908 (%o6)                     sqrt(x) y
 909 (%i7) rootsconmode: all$
 910 (%i8) rootscontract (x^(1/2)*y^(1/4));
 911                               2   1/4
 912 (%o8)                       (x  y)
 913 (%i9) rootscontract (x^(1/2)*y^(1/3));
 914                              3  2 1/6
 915 (%o9)                      (x  y )
 916 (%i10) rootsconmode: false$
 917 (%i11) rootscontract (sqrt(sqrt(x) + sqrt(1 + x))
 918                     *sqrt(sqrt(1 + x) - sqrt(x)));
 919 (%o11)                          1
 920 (%i12) rootsconmode: true$
 921 (%i13) rootscontract (sqrt(5 + sqrt(5)) - 5^(1/4)*sqrt(1 + sqrt(5)));
 922 (%o13)                          0
 923 @end example
 924
 925 @end deffn
 926
 927 @defvr {Variável de opção} rootsepsilon
 928 Valor por omissão: 1.0e-7
 929
 930 @code{rootsepsilon} é a tolerância que estabelece o
 931 intervalo de conficência para as raízes achadas pela função @code{realroots}.
 932 @c IS IT GUARANTEED THAT |ACTUAL - ESTIMATE| < rootepsilon OR IS IT SOME OTHER NOTION ??
 933 @c NEED EXAMPLE HERE
 934
 935 @end defvr
 936
 937 @c NEEDS WORK
 938 @deffn {Função} solve (@var{expr}, @var{x})
 939 @deffnx {Função} solve (@var{expr})
 940 @deffnx {Função} solve ([@var{eqn_1}, ..., @var{eqn_n}], [@var{x_1}, ..., @var{x_n}])
 941 Resolve a equação algébrica @var{expr} para a variável
 942 @var{x} e retorna uma lista de equações solução em @var{x}.  Se @var{expr} não é uma
 943 equação, a equação @code{@var{expr} = 0} é assumida em seu lugar.
 944 @var{x} pode ser uma função (e.g. @code{f(x)}), ou outra expressão não at@^omica
 945 excepto uma adição ou um produto.  @var{x} pode ser omitido se @var{expr} contém somente uma
 946 variável.  @var{expr} pode ser uma expressão racional, e pode conter
 947 funções trigonométricas, exponenciais, etc.
 948
 949 O seguinte método é usado:
 950
 951 Tome @var{E} sendo a expressão e @var{X} sendo a variável.  Se @var{E} é linear em @var{X}
 952 então isso é trivialmente resolvido para @var{X}.  De outra forma se @var{E} é da forma
 953 @code{A*X^N + B} então o resultado é @code{(-B/A)^1/N)} vezes as @code{N}'ésimas raízes da
 954 unidade.
 955
 956 Se @var{E} não é linear em @var{X} então o máximo divisor comum (mdc) dos expoentes de @var{X} em @var{E} (digamos
 957 @var{N}) é dividido dentro dos expoentes e a multiplicidade das raízes é
 958 multiplicada por @var{N}.  Então @code{solve} é chamada novamente sobre o resultado.
 959 Se @var{E} for dada em factores então @code{solve} é chamada sobre cada um dos factores.  Finalmente
 960 @code{solve} usará as fórmulas quadráticas, cúbicas, ou quárticas onde
 961 necessário.
 962
 963 No caso onde @var{E} for um polinómio em alguma função de variável a ser
 964 resolvida, digamos @code{F(X)}, então isso é primeiro resolvida para @code{F(X)} (chama o
 965 resultado @var{C}), então a equação @code{F(X)=C} pode ser resolvida para @var{X} fornecendo o
 966 inverso da função @var{F} que é conhecida.
 967
 968 @code{breakup} se @code{false} fará com que @code{solve} expresse as soluções de
 969 equações cúbicas ou quárticas como expressões simples ao invés de como feito
 970 em cima de várias subexpressões comuns que é o padrão.
 971
 972 @code{multiplicities} - será escolhido para uma lista de multiplicidades de
 973 soluções individuais retornadas por @code{solve}, @code{realroots}, ou @code{allroots}.
 974 Tente @code{apropos (solve)} para os comutadores que afectam @code{solve}.  @code{describe} pode
 975 então ser usada sobre o nome do comutador individual se seu proprósito não é
 976 claro.
 977
 978 @code{solve ([@var{eqn_1}, ..., @var{eqn_n}], [@var{x_1}, ..., @var{x_n}])}
 979 resolve um sistema de equações polinomiais
 980 (lineares ou não-lineares) simultâneas por chamada a @code{linsolve} ou
 981 @code{algsys} e retorna uma lista de listas solução nas variáveis.  No
 982 caso de @code{linsolve} essa lista conterá uma lista simples de
 983 soluções.  Isso pega duas listas como argumentos.  A primeira lista
 984 representa as equações a serem resolvidas; a segunda lista é a
 985 lista de desconhecidos a ser determinada.  Se o número total de
 986 variáveis nas equações é igual ao número de equações, a
 987 segunda lista-argumento pode ser omitida.  Para sistemas lineares se as dadas
 988 equações não são compatíveis, a mensagem @code{inconsistent} será
 989 mostrada (veja o comutador @code{solve_inconsistent_error} ); se não existe
 990 solução única, então @code{singular} será mostrado.
 991
 992 Exemplos:
 993 @c FOLLOWING ADAPTED FROM example (solve)
 994 @c solve (asin (cos (3*x))*(f(x) - 1), x);
 995 @c ev (solve (5^f(x) = 125, f(x)), solveradcan);
 996 @c [4*x^2 - y^2 = 12, x*y - x = 2];
 997 @c solve (%, [x, y]);
 998 @c solve (1 + a*x + x^3, x);
 999 @c solve (x^3 - 1);
1000 @c solve (x^6 - 1);
1001 @c ev (x^6 - 1, %[1]);
1002 @c expand (%);
1003 @c x^2 - 1;
1004 @c solve (%, x);
1005 @c ev (%th(2), %[1]);
1006
1007 @example
1008 (%i1) solve (asin (cos (3*x))*(f(x) - 1), x);
1009
1010 SOLVE is using arc-trig functions to get a solution.
1011 Some soluções will be lost.
1012                             %pi
1013 (%o1)                  [x = ---, f(x) = 1]
1014                              6
1015 (%i2) ev (solve (5^f(x) = 125, f(x)), solveradcan);
1016                                 log(125)
1017 (%o2)                   [f(x) = --------]
1018                                  log(5)
1019 (%i3) [4*x^2 - y^2 = 12, x*y - x = 2];
1020                       2    2
1021 (%o3)             [4 x  - y  = 12, x y - x = 2]
1022 (%i4) solve (%, [x, y]);
1023 (%o4) [[x = 2, y = 2], [x = .5202594388652008 %i
1024
1025  - .1331240357358706, y = .0767837852378778
1026
1027  - 3.608003221870287 %i], [x = - .5202594388652008 %i
1028
1029  - .1331240357358706, y = 3.608003221870287 %i
1030
1031  + .0767837852378778], [x = - 1.733751846381093,
1032
1033 y = - .1535675710019696]]
1034 (%i5) solve (1 + a*x + x^3, x);
1035                                        3
1036               sqrt(3) %i   1   sqrt(4 a  + 27)   1 1/3
1037 (%o5) [x = (- ---------- - -) (--------------- - -)
1038                   2        2      6 sqrt(3)      2
1039
1040         sqrt(3) %i   1
1041        (---------- - -) a
1042             2        2
1043  - --------------------------, x =
1044               3
1045       sqrt(4 a  + 27)   1 1/3
1046    3 (--------------- - -)
1047          6 sqrt(3)      2
1048
1049                           3
1050  sqrt(3) %i   1   sqrt(4 a  + 27)   1 1/3
1051 (---------- - -) (--------------- - -)
1052      2        2      6 sqrt(3)      2
1053
1054          sqrt(3) %i   1
1055       (- ---------- - -) a
1056              2        2
1057  - --------------------------, x =
1058               3
1059       sqrt(4 a  + 27)   1 1/3
1060    3 (--------------- - -)
1061          6 sqrt(3)      2
1062
1063          3
1064  sqrt(4 a  + 27)   1 1/3               a
1065 (--------------- - -)    - --------------------------]
1066     6 sqrt(3)      2                  3
1067                               sqrt(4 a  + 27)   1 1/3
1068                            3 (--------------- - -)
1069                                  6 sqrt(3)      2
1070 (%i6) solve (x^3 - 1);
1071              sqrt(3) %i - 1        sqrt(3) %i + 1
1072 (%o6)   [x = --------------, x = - --------------, x = 1]
1073                    2                     2
1074 (%i7) solve (x^6 - 1);
1075            sqrt(3) %i + 1      sqrt(3) %i - 1
1076 (%o7) [x = --------------, x = --------------, x = - 1,
1077                  2                   2
1078
1079                      sqrt(3) %i + 1        sqrt(3) %i - 1
1080                x = - --------------, x = - --------------, x = 1]
1081                            2                     2
1082 (%i8) ev (x^6 - 1, %[1]);
1083                                       6
1084                       (sqrt(3) %i + 1)
1085 (%o8)                 ----------------- - 1
1086                              64
1087 (%i9) expand (%);
1088 (%o9)                           0
1089 (%i10) x^2 - 1;
1090                               2
1091 (%o10)                       x  - 1
1092 (%i11) solve (%, x);
1093 (%o11)                  [x = - 1, x = 1]
1094 (%i12) ev (%th(2), %[1]);
1095 (%o12)                          0
1096 @end example
1097
1098 @end deffn
1099
1100 @defvr {Variável de opção} solvedecomposes
1101 Valor por omissão: @code{true}
1102
1103 Quando @code{solvedecomposes} é @code{true}, @code{solve} chama
1104 @code{polydecomp} se perguntado para resolver polinómios.
1105 @c OTHERWISE WHAT HAPPENS -- CAN'T SOLVE POLYNOMIALS, OR SOME OTHER METHOD IS USED ??
1106
1107 @end defvr
1108
1109 @defvr {Variável de opção} solveexplicit
1110 Valor por omissão: @code{false}
1111
1112 Quando @code{solveexplicit} é @code{true}, inibe @code{solve} de
1113 retornar soluções implícitas, isto é, soluções da forma @code{F(x) = 0}
1114 onde @code{F} é alguma função.
1115 @c NEED AN EXAMPLE HERE
1116
1117 @end defvr
1118
1119 @defvr {Variável de opção} solvefactors
1120 Valor por omissão: @code{true}
1121
1122 @c WHAT IS THIS ABOUT EXACTLY ??
1123 Quando @code{solvefactors} é @code{false}, @code{solve} não tenta
1124 factorizar a expressão. A escolha do @code{false} poderá ser útil
1125 em alguns casos onde a factorização não é
1126 necessária.
1127 @c NEED AN EXAMPLE HERE
1128
1129 @end defvr
1130
1131 @defvr {Variável de opção} solvenullwarn
1132 Valor por omissão: @code{true}
1133
1134 Quando @code{solvenullwarn} é @code{true},
1135 @code{solve} imprime uma mensagem de alerta se chamada com ou uma lista equação ou uma variável lista nula.
1136 Por exemplo, @code{solve ([], [])} imprimirá duas mensagens de alerta e retorna @code{[]}.
1137
1138 @end defvr
1139
1140 @defvr {Variável de opção} solveradcan
1141 Valor por omissão: @code{false}
1142
1143 Quando @code{solveradcan} é @code{true}, @code{solve} chama @code{radcan}
1144 que faz @code{solve} lento mas permitirá certamente que problemas
1145 contendo exponeniais e logaritmos sejam resolvidos.
1146 @c NEED AN EXAMPLE HERE
1147
1148 @end defvr
1149
1150 @defvr {Variável de opção} solvetrigwarn
1151 Valor por omissão: @code{true}
1152
1153 @c MAYBE THIS CAN BE CLARIFIED
1154 Quando @code{solvetrigwarn} é @code{true},
1155 @code{solve} pode imprimir uma mensagem dizendo que está usando funções
1156 trigonométricas inversas para resolver a equação, e desse modo perdendo
1157 soluções.
1158 @c NEED AN EXAMPLE HERE
1159
1160 @end defvr
1161
1162 @defvr {Variável de opção} solve_inconsistent_error
1163 Valor por omissão: @code{true}
1164
1165 Quando @code{solve_inconsistent_error} é
1166 @code{true}, @code{solve} e
1167 @code{linsolve} resultam em erro se as equações a serem resolvidas são inconsistentes.
1168
1169 Se @code{false}, @code{solve} e @code{linsolve} retornam uma lista vazia @code{[]}
1170 se as equações forem inconsistentes.
1171
1172 Exemplo:
1173
1174 @example
1175 (%i1) solve_inconsistent_error: true$
1176 (%i2) solve ([a + b = 1, a + b = 2], [a, b]);
1177 Inconsistent equações:  (2)
1178  -- an error.  Quitting.  To debug this try debugmode(true);
1179 (%i3) solve_inconsistent_error: false$
1180 (%i4) solve ([a + b = 1, a + b = 2], [a, b]);
1181 (%o4)                          []
1182 @end example
1183
1184 @end defvr
1185