| blob | ae98477245502de58e7a249423aa6aa618774043 |
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
7 @node Definições para Equações, , Equações, Equações
8 @section Definições para Equações
10 @c NEED A DESCRIPTION OF %rnum AS WELL
11 @defvr {Variável} %rnum_list
12 Valor por omissão: @code{[]}
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)}.
24 @c NEED EXAMPLE HERE
25 @end defvr
27 @defvr {Variável} algexact
28 Valor por omissão: @code{false}
30 @code{algexact} afecta o comportamento de @code{algsys} como segue:
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}.
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.
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.
44 @c ABOVE DESCRIPTION NOT TOO CLEAR -- MAYBE EXAMPLES WILL HELP
45 @end defvr
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.
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.
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}.
64 O método usado é o seguinte:
66 (1) Primeiro as equações são factorizaadas e quebradas
67 em subsistemas.
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).
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.
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.
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.
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.
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
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 ??
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."
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}.
118 Ocasionalmente, @code{radcan} pode introduzir uma unidade imaginária
119 @code{%i} dentro de uma solução que é actualmente avaliada como real.
121 Exemplos:
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],
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)
159 1 1 1 1
160 [x = -------, y = - -------], [x = - -, y = - -], [x = 1, y = 1]]
161 sqrt(3) sqrt(3) 3 3
162 @end example
164 @end deffn
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.
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.
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.
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}.
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).
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);
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,
210 x = .9659625152196369 %i - .4069597231924075,
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
217 - 5.32907051820075E-15
219 4.44089209850063E-15 %i - 4.88498130835069E-15
221 - 4.44089209850063E-15 %i - 4.88498130835069E-15
223 3.5527136788005E-15
225 (%o3) done
226 (%i4) polyfactor: true$
227 (%i5) allroots (eqn);
228 (%o5) - 13.5 (x - 1.0) (x - .8296749902129361)
230 2
231 (x + 1.015755543828121) (x + .8139194463848151 x
233 + 1.098699797110288)
234 @end example
236 @end deffn
238 @defvr {Variável} backsubst
239 Valor por omissão: @code{true}
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.
247 @end defvr
249 @defvr {Variável} breakup
250 Valor por omissão: @code{true}
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.
257 @code{breakup: true} tem efeito somente quando @code{programmode} é @code{false}.
259 Exemplos:
261 @example
262 (%i1) programmode: false$
263 (%i2) breakup: true$
264 (%i3) solve (x^3 + x^2 - 1);
266 sqrt(23) 25 1/3
267 (%t3) (--------- + --)
268 6 sqrt(3) 54
269 Solution:
271 sqrt(3) %i 1
272 ---------- - -
273 sqrt(3) %i 1 2 2 1
274 (%t4) x = (- ---------- - -) %t3 + -------------- - -
275 2 2 9 %t3 3
277 sqrt(3) %i 1
278 - ---------- - -
279 sqrt(3) %i 1 2 2 1
280 (%t5) x = (---------- - -) %t3 + ---------------- - -
281 2 2 9 %t3 3
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:
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
299 sqrt(3) %i 1 1
300 (- ---------- - -) - -
301 2 2 3
303 sqrt(23) 25 1/3 sqrt(3) %i 1
304 (%t8) x = (--------- + --) (---------- - -)
305 6 sqrt(3) 54 2 2
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
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
323 @end defvr
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
332 @end deffn
334 @defvr {Variável} dispflag
335 Valor por omissão: @code{true}
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}.
343 @end defvr
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)}
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));
359 Equações dependentes eliminadas: (4 3)
360 n
361 (%o2) f(n) = ---------------
362 (n + 1) (n + 2)
363 @end example
365 Atenção: essa é uma implementação muito rudimentar -- muitas verificações de segurança
366 e obviamente generalizações estão ausêntes.
368 @end deffn
370 @defvr {Variável} globalsolve
371 Valor por omissão: @code{false}
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.
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}.
385 Exemplos:
387 @example
388 (%i1) globalsolve: true$
389 (%i2) solve ([x + 3*y = 2, 2*x - y = 5], [x, y]);
390 Solution
392 17
393 (%t2) x : --
394 7
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
413 17
414 (%t7) x = --
415 7
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
427 @end defvr
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.
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}.
444 Valores padrão do segundo até o quinto parâmetro são:
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.
454 tech: @code{first}
456 n: 1
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.
461 @end deffn
463 @defvr {Variável de opção} ieqnprint
464 Valor por omissão: @code{true}
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
470 [@var{solução}, @var{tecnica usada}, @var{nterms}, @var{sinalizador}]
472 onde @var{sinalizador} é retirado se a solução for exacta.
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).
480 @end defvr
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}.
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}.
495 Veja também @code{rhs}.
497 Exemplos:
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
540 @end deffn
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.
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.
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.
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.
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.
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
602 (%t7) z = a - 1
604 (%t8) y = 2 a
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
615 (%t11) z : a - 1
617 (%t12) y : 2 a
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
633 @end deffn
635 @c DO ANY FUNCTIONS OTHER THAN linsolve RESPECT linsolvewarn ??
636 @defvr {Variável} linsolvewarn
637 Valor por omissão: @code{true}
639 Quando @code{linsolvewarn} é @code{true},
640 @code{linsolve} imprime uma mensagem "Dependent equações eliminated".
642 @end defvr
644 @defvr {Variável} linsolve_params
645 Valor por omissão: @code{true}
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.
653 @end defvr
655 @defvr {Variável} multiplicities
656 Valor por omissão: @code{not_set_yet}
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
663 @end defvr
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.
672 @code{nroots} usa o método das sequuências de Sturm.
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
680 @end deffn
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}.
689 @end deffn
691 @defvr {Variável} programmode
692 Valor por omissão: @code{true}
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.)
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
706 @end defvr
708 @defvr {Variável} realonly
709 Valor por omissão: @code{false}
711 Quando @code{realonly} é @code{true}, @code{algsys} retorna somente
712 aquelas soluções que estão livres de @code{%i}.
714 @end defvr
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.
726 @code{realroots} atribui as multiplicidades das raízes que encontrar
727 para a variável global @code{multiplicities}.
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).
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}.
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.
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===
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
763 @c ===beg===
764 @c realroots (expand ((1 - x)^5 * (2 - x)^3 * (3 - x)), 1e-20);
765 @c multiplicities;
766 @c ===end===
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
775 @end deffn
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}.
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.
790 Veja também @code{lhs}.
792 Exemplos:
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
835 @end deffn
837 @defvr {Variável de opção} rootsconmode
838 Valor por omissão: @code{true}
840 @code{rootsconmode} governa o comportamento do comando
841 @code{rootscontract}. Veja @code{rootscontract} para detalhes.
843 @end defvr
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)}.
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)}.
855 Existe uma opção @code{rootsconmode}
856 afectando @code{rootscontract} como segue:
858 @example
859 Problem Value of Result of applying
860 rootsconmode rootscontract
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
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.
876 @code{rootscontract} usa @code{ratsimp} em uma maneira similar a @code{logcontract}.
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)));
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
925 @end deffn
927 @defvr {Variável de opção} rootsepsilon
928 Valor por omissão: 1.0e-7
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
935 @end defvr
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.
949 O seguinte método é usado:
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.
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.
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.
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.
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.
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.
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]);
1007 @example
1008 (%i1) solve (asin (cos (3*x))*(f(x) - 1), x);
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
1025 - .1331240357358706, y = .0767837852378778
1027 - 3.608003221870287 %i], [x = - .5202594388652008 %i
1029 - .1331240357358706, y = 3.608003221870287 %i
1031 + .0767837852378778], [x = - 1.733751846381093,
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
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
1049 3
1050 sqrt(3) %i 1 sqrt(4 a + 27) 1 1/3
1051 (---------- - -) (--------------- - -)
1052 2 2 6 sqrt(3) 2
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
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
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
1098 @end deffn
1100 @defvr {Variável de opção} solvedecomposes
1101 Valor por omissão: @code{true}
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 ??
1107 @end defvr
1109 @defvr {Variável de opção} solveexplicit
1110 Valor por omissão: @code{false}
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
1117 @end defvr
1119 @defvr {Variável de opção} solvefactors
1120 Valor por omissão: @code{true}
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
1129 @end defvr
1131 @defvr {Variável de opção} solvenullwarn
1132 Valor por omissão: @code{true}
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{[]}.
1138 @end defvr
1140 @defvr {Variável de opção} solveradcan
1141 Valor por omissão: @code{false}
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
1148 @end defvr
1150 @defvr {Variável de opção} solvetrigwarn
1151 Valor por omissão: @code{true}
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
1160 @end defvr
1162 @defvr {Variável de opção} solve_inconsistent_error
1163 Valor por omissão: @code{true}
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.
1169 Se @code{false}, @code{solve} e @code{linsolve} retornam uma lista vazia @code{[]}
1170 se as equações forem inconsistentes.
1172 Exemplo:
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
1184 @end defvr