| blob | db56c394d0e20874e9bf56efbd5e90ec3e77117a |
1 @c Language: Brazilian Portuguese, Encoding: iso-8859-1
2 @c /Equations.texi/1.25/Sat Jun 2 00:12:41 2007/-ko/
3 @c end concepts Equations
4 @menu
5 * Funções e Variáveis Definidas para Equações::
6 @end menu
8 @node Funções e Variáveis Definidas para Equações, , Equações, Equações
9 @section Funções e Variáveis Definidas para Equações
11 @c NEED A DESCRIPTION OF %rnum AS WELL
12 @defvr {Variável} %rnum_list
13 Valor padrão: @code{[]}
15 @code{%rnum_list} é a lista de variáveis introduzidas em soluções
16 por @code{algsys}.
17 @code{%r} variáveis São adicionadas a @code{%rnum_list} na ordem em que
18 forem criadas.
19 Isso é conveniente para fazer substituições dentro da
20 solução mais tarde.
21 @c WHAT DOES THIS STATEMENT MEAN ??
22 É recomendado usar essa lista em lugar de
23 fazer @code{concat ('%r, j)}.
25 @c NEED EXAMPLE HERE
26 @end defvr
28 @defvr {Variável} algexact
29 Valor padrão: @code{false}
31 @code{algexact} afeta o comportamento de @code{algsys} como segue:
33 Se @code{algexact} é @code{true},
34 @code{algsys} sempre chama @code{solve} e então usa @code{realroots}
35 sobre falhas de @code{solve}.
37 Se @code{algexact} é @code{false}, @code{solve} é chamada somente se
38 o eliminante não for de uma variável, ou se for uma quadrática ou uma
39 biquadrada.
41 Dessa forma @code{algexact: true} não garante somente soluções
42 exatas, apenas que @code{algsys} tentará primeiro pegar
43 soluções exatas, e somente retorna aproximações quando tudo mais falha.
45 @c ABOVE DESCRIPTION NOT TOO CLEAR -- MAYBE EXAMPLES WILL HELP
46 @end defvr
48 @deffn {Função} algsys ([@var{expr_1}, ..., @var{expr_m}], [@var{x_1}, ..., @var{x_n}])
49 @deffnx {Função} algsys ([@var{eqn_1}, ..., @var{eqn_m}], [@var{x_1}, ..., @var{x_n}])
50 Resolve polinômios simultâneos @var{expr_1}, ..., @var{expr_m}
51 ou equações polinômiais @var{eqn_1}, ..., @var{eqn_m}
52 para as variáveis @var{x_1}, ..., @var{x_n}.
53 Uma expressão @var{expr} é equivalente a uma equação @code{@var{expr} = 0}.
54 Pode existir mais equações que variáveis ou vice-versa.
56 @code{algsys} retorna uma lista de soluções,
57 com cada solução dada com uma lista de valores de estado das equações
58 das variáveis @var{x_1}, ..., @var{x_n} que satisfazem o sistema de equações.
59 Se @code{algsys} não pode achar uma solução, uma lista vazia @code{[]} é retornada.
61 Os símbolos @code{%r1}, @code{%r2}, ...,
62 são introduzidos tantos quantos forem necessários para representar parâmetros arbitrários na solução;
63 essas variáveis são também anexadas à lista @code{%rnum_list}.
65 O método usado é o seguinte:
67 (1) Primeiro as equações são fatoradas e quebradas em subsistemas.
69 (2) Para cada subsistema @var{S_i}, uma equação @var{E} e uma variável @var{x} são
70 selecionados.
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 exata.
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 usuário 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 exatas 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 é atualmente 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ômial @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} fatore 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 multiplas 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 algorítmo diferente naquele caso.
182 @code{allroots} rejeita não-polinômios. Isso requer que o numerador
183 após a classificação (@code{rat}'ing) poderá ser um polinômio, e isso requer que o
184 denominador seja quando muito um número complexo. Com um resultado disso @code{allroots}
185 irá sempre retornar uma expressão equivalente (mas fatorada), se
186 @code{polyfactor} for @code{true}.
188 Para polinômios complexos um algorítmo por Jenkins e Traub é
189 usado (Algorithm 419, @i{Comm. ACM}, vol. 15, (1972), p. 97).
190 Para polinômios reais o algorítmo usado é devido a Jenkins (Algorithm 493, @i{ACM TOMS},
191 vol. 1, (1975), p.178).
193 Exemplos:
194 @c EXAMPLES GENERATED BY THESE INPUTS:
195 @c eqn: (1 + 2*x)^3 = 13.5*(1 + x^5);
196 @c soln: allroots (eqn);
197 @c for e in soln
198 @c do (e2: subst (e, eqn), disp (expand (lhs(e2) - rhs(e2))));
199 @c polyfactor: true$
200 @c allroots (eqn);
202 @example
203 (%i1) eqn: (1 + 2*x)^3 = 13.5*(1 + x^5);
204 3 5
205 (%o1) (2 x + 1) = 13.5 (x + 1)
206 (%i2) soln: allroots (eqn);
207 (%o2) [x = .8296749902129361, x = - 1.015755543828121,
209 x = .9659625152196369 %i - .4069597231924075,
211 x = - .9659625152196369 %i - .4069597231924075, x = 1.0]
212 (%i3) for e in soln
213 do (e2: subst (e, eqn), disp (expand (lhs(e2) - rhs(e2))));
214 - 3.5527136788005E-15
216 - 5.32907051820075E-15
218 4.44089209850063E-15 %i - 4.88498130835069E-15
220 - 4.44089209850063E-15 %i - 4.88498130835069E-15
222 3.5527136788005E-15
224 (%o3) done
225 (%i4) polyfactor: true$
226 (%i5) allroots (eqn);
227 (%o5) - 13.5 (x - 1.0) (x - .8296749902129361)
229 2
230 (x + 1.015755543828121) (x + .8139194463848151 x
232 + 1.098699797110288)
233 @end example
235 @end deffn
237 @defvr {Variável} backsubst
238 Valor padrão: @code{true}
240 @c WHAT IS THE CONTEXT HERE ?? (TO WHICH OTHER FUNCTION DOES THIS APPLY ??)
241 Quando @code{backsubst} é @code{false}, evita substituições
242 em expressões anteriores após as equações terem sido triangularizadas. Isso pode
243 ser de grande ajuda em problemas muito grandes onde substituição em expressões anteriores pode vir a causar
244 a geração de expressões extremamente largas.
246 @end defvr
248 @defvr {Variável} breakup
249 Valor padrão: @code{true}
251 Quando @code{breakup} é @code{true}, @code{solve} expressa soluções
252 de equações cúbicas e quárticas em termos de subexpressões comuns,
253 que são atribuídas a rótulos de expressões intermediárias (@code{%t1}, @code{%t2}, etc.).
254 De outra forma, subexpressões comuns não são identificadas.
256 @code{breakup: true} tem efeito somente quando @code{programmode} é @code{false}.
258 Exemplos:
260 @example
261 (%i1) programmode: false$
262 (%i2) breakup: true$
263 (%i3) solve (x^3 + x^2 - 1);
265 sqrt(23) 25 1/3
266 (%t3) (--------- + --)
267 6 sqrt(3) 54
268 Solution:
270 sqrt(3) %i 1
271 ---------- - -
272 sqrt(3) %i 1 2 2 1
273 (%t4) x = (- ---------- - -) %t3 + -------------- - -
274 2 2 9 %t3 3
276 sqrt(3) %i 1
277 - ---------- - -
278 sqrt(3) %i 1 2 2 1
279 (%t5) x = (---------- - -) %t3 + ---------------- - -
280 2 2 9 %t3 3
282 1 1
283 (%t6) x = %t3 + ----- - -
284 9 %t3 3
285 (%o6) [%t4, %t5, %t6]
286 (%i6) breakup: false$
287 (%i7) solve (x^3 + x^2 - 1);
288 Solution:
290 sqrt(3) %i 1
291 ---------- - -
292 2 2 sqrt(23) 25 1/3
293 (%t7) x = --------------------- + (--------- + --)
294 sqrt(23) 25 1/3 6 sqrt(3) 54
295 9 (--------- + --)
296 6 sqrt(3) 54
298 sqrt(3) %i 1 1
299 (- ---------- - -) - -
300 2 2 3
302 sqrt(23) 25 1/3 sqrt(3) %i 1
303 (%t8) x = (--------- + --) (---------- - -)
304 6 sqrt(3) 54 2 2
306 sqrt(3) %i 1
307 - ---------- - -
308 2 2 1
309 + --------------------- - -
310 sqrt(23) 25 1/3 3
311 9 (--------- + --)
312 6 sqrt(3) 54
314 sqrt(23) 25 1/3 1 1
315 (%t9) x = (--------- + --) + --------------------- - -
316 6 sqrt(3) 54 sqrt(23) 25 1/3 3
317 9 (--------- + --)
318 6 sqrt(3) 54
319 (%o9) [%t7, %t8, %t9]
320 @end example
322 @end defvr
324 @deffn {Função} dimension (@var{eqn})
325 @deffnx {Função} dimension (@var{eqn_1}, ..., @var{eqn_n})
326 @code{dimen} é um pacote de análise dimensional.
327 @code{load ("dimen")} chama esse pacote.
328 @code{demo ("dimen")} mostra uma cura demostração.
329 @c I GUESS THIS SHOULD BE EXPANDED TO COVER EACH FUNCTION IN THE PACKAGE
331 @end deffn
333 @defvr {Variável} dispflag
334 Valor padrão: @code{true}
336 @c WHAT DOES THIS MEAN ??
337 Se escolhida para @code{false} dentro de um @code{block} inibirá
338 a visualização da saída gerada pelas funções solve chamadas de
339 dentro de @code{block}. Terminando @code{block} com um sinal de dolar, $, escolhe
340 @code{dispflag} para @code{false}.
342 @end defvr
344 @c THIS COULD BENEFIT FROM REPHRASING
345 @deffn {Função} funcsolve (@var{eqn}, @var{g}(@var{t}))
346 Retorna @code{[@var{g}(@var{t}) = ...]} ou @code{[]}, dependendo de existir
347 ou não uma função racional @code{@var{g}(@var{t})} satisfazendo @var{eqn},
348 que deve ser de primeira ordem, polinômio linear em (para esse caso)
349 @code{@var{g}(@var{t})} e @code{@var{g}(@var{t}+1)}
351 @example
352 (%i1) eqn: (n + 1)*f(n) - (n + 3)*f(n + 1)/(n + 1) = (n - 1)/(n + 2);
353 (n + 3) f(n + 1) n - 1
354 (%o1) (n + 1) f(n) - ---------------- = -----
355 n + 1 n + 2
356 (%i2) funcsolve (eqn, f(n));
358 Equações dependentes eliminadas: (4 3)
359 n
360 (%o2) f(n) = ---------------
361 (n + 1) (n + 2)
362 @end example
364 Atenção: essa é uma implementação muito rudimentar -- muitas verificações de segurança
365 e obviamente generalizações estão ausêntes.
367 @end deffn
369 @defvr {Variável} globalsolve
370 Valor padrão: @code{false}
372 When @code{globalsolve} for @code{true},
373 variáveis para as quais as equações são resolvidas são atribuidas aos valores da solução encontrados por @code{linsolve},
374 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 com 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 usuário 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 padrã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 exata.
474 De outra forma, isso é a
475 palavra @code{approximate} ou @code{incomplete} correspondendo à forma inexata 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 usuário, 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 intermediárias 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 padrã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 padrã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 padrã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 sequ@"{u}ê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 padrã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 intermediárias
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 padrã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 seq@"{u}ê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 exata.
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 exatamente.
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 intermediárias @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 usuário, 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 padrã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 afetando @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 multiplo 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 padrã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ômica
945 exceto 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 fatores então @code{solve} é chamada sobre cada um dos fatores. 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 afetam @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 Quando @code{programmode} for @code{false},
993 @code{solve} mostra soluções com rótulos de expressões intermediárias (@code{%t}),
994 e retorna a lista de rótulos.
996 Quando @code{globalsolve} for @code{true} e o problema for resolver duas ou mais equações lineares,
997 cada variável para a qual a equação for resolvida é associada a seu valor na solução das equações.
999 Exemplos:
1000 @c FOLLOWING ADAPTED FROM example (solve)
1001 @c ===beg===
1002 @c solve (asin (cos (3*x))*(f(x) - 1), x);
1003 @c ev (solve (5^f(x) = 125, f(x)), solveradcan);
1004 @c [4*x^2 - y^2 = 12, x*y - x = 2];
1005 @c solve (%, [x, y]);
1006 @c solve (1 + a*x + x^3, x);
1007 @c solve (x^3 - 1);
1008 @c solve (x^6 - 1);
1009 @c ev (x^6 - 1, %[1]);
1010 @c expand (%);
1011 @c x^2 - 1;
1012 @c solve (%, x);
1013 @c ev (%th(2), %[1]);
1014 @c ===end===
1015 @example
1016 (%i1) solve (asin (cos (3*x))*(f(x) - 1), x);
1018 SOLVE is using arc-trig functions to get a solution.
1019 Some solutions will be lost.
1020 %pi
1021 (%o1) [x = ---, f(x) = 1]
1022 6
1023 (%i2) ev (solve (5^f(x) = 125, f(x)), solveradcan);
1024 log(125)
1025 (%o2) [f(x) = --------]
1026 log(5)
1027 (%i3) [4*x^2 - y^2 = 12, x*y - x = 2];
1028 2 2
1029 (%o3) [4 x - y = 12, x y - x = 2]
1030 (%i4) solve (%, [x, y]);
1031 (%o4) [[x = 2, y = 2], [x = .5202594388652008 %i
1033 - .1331240357358706, y = .0767837852378778
1035 - 3.608003221870287 %i], [x = - .5202594388652008 %i
1037 - .1331240357358706, y = 3.608003221870287 %i
1039 + .0767837852378778], [x = - 1.733751846381093,
1041 y = - .1535675710019696]]
1042 (%i5) solve (1 + a*x + x^3, x);
1043 3
1044 sqrt(3) %i 1 sqrt(4 a + 27) 1 1/3
1045 (%o5) [x = (- ---------- - -) (--------------- - -)
1046 2 2 6 sqrt(3) 2
1048 sqrt(3) %i 1
1049 (---------- - -) a
1050 2 2
1051 - --------------------------, x =
1052 3
1053 sqrt(4 a + 27) 1 1/3
1054 3 (--------------- - -)
1055 6 sqrt(3) 2
1057 3
1058 sqrt(3) %i 1 sqrt(4 a + 27) 1 1/3
1059 (---------- - -) (--------------- - -)
1060 2 2 6 sqrt(3) 2
1062 sqrt(3) %i 1
1063 (- ---------- - -) a
1064 2 2
1065 - --------------------------, x =
1066 3
1067 sqrt(4 a + 27) 1 1/3
1068 3 (--------------- - -)
1069 6 sqrt(3) 2
1071 3
1072 sqrt(4 a + 27) 1 1/3 a
1073 (--------------- - -) - --------------------------]
1074 6 sqrt(3) 2 3
1075 sqrt(4 a + 27) 1 1/3
1076 3 (--------------- - -)
1077 6 sqrt(3) 2
1078 (%i6) solve (x^3 - 1);
1079 sqrt(3) %i - 1 sqrt(3) %i + 1
1080 (%o6) [x = --------------, x = - --------------, x = 1]
1081 2 2
1082 (%i7) solve (x^6 - 1);
1083 sqrt(3) %i + 1 sqrt(3) %i - 1
1084 (%o7) [x = --------------, x = --------------, x = - 1,
1085 2 2
1087 sqrt(3) %i + 1 sqrt(3) %i - 1
1088 x = - --------------, x = - --------------, x = 1]
1089 2 2
1090 (%i8) ev (x^6 - 1, %[1]);
1091 6
1092 (sqrt(3) %i + 1)
1093 (%o8) ----------------- - 1
1094 64
1095 (%i9) expand (%);
1096 (%o9) 0
1097 (%i10) x^2 - 1;
1098 2
1099 (%o10) x - 1
1100 (%i11) solve (%, x);
1101 (%o11) [x = - 1, x = 1]
1102 (%i12) ev (%th(2), %[1]);
1103 (%o12) 0
1104 @end example
1106 @end deffn
1108 @defvr {Variável de opção} solvedecomposes
1109 Valor padrão: @code{true}
1111 Quando @code{solvedecomposes} é @code{true}, @code{solve} chama
1112 @code{polydecomp} se perguntado para resolver polinômios.
1113 @c OTHERWISE WHAT HAPPENS -- CAN'T SOLVE POLYNOMIALS, OR SOME OTHER METHOD IS USED ??
1115 @end defvr
1117 @defvr {Variável de opção} solveexplicit
1118 Valor padrão: @code{false}
1120 Quando @code{solveexplicit} é @code{true}, inibe @code{solve} de
1121 retornar soluções implícitas, isto é, soluções da forma @code{F(x) = 0}
1122 onde @code{F} é alguma função.
1123 @c NEED AN EXAMPLE HERE
1125 @end defvr
1127 @defvr {Variável de opção} solvefactors
1128 Valor padrão: @code{true}
1130 @c WHAT IS THIS ABOUT EXACTLY ??
1131 Quando @code{solvefactors} é @code{false}, @code{solve} não tenta
1132 fatorar a expressão. O @code{false} escolhido pode ser desejado em alguns casos
1133 onde a fatoração não é necessária.
1134 @c NEED AN EXAMPLE HERE
1136 @end defvr
1138 @defvr {Variável de opção} solvenullwarn
1139 Valor padrão: @code{true}
1141 Quando @code{solvenullwarn} é @code{true},
1142 @code{solve} imprime uma mensagem de alerta se chamada com ou uma lista equação ou uma variável lista nula.
1143 Por exemplo, @code{solve ([], [])} imprimirá duas mensagens de alerta e retorna @code{[]}.
1145 @end defvr
1147 @defvr {Variável de opção} solveradcan
1148 Valor padrão: @code{false}
1150 Quando @code{solveradcan} é @code{true}, @code{solve} chama @code{radcan}
1151 que faz @code{solve} lento mas permitirá certamente que problemas
1152 contendo exponeniais e logarítmos sejam resolvidos.
1153 @c NEED AN EXAMPLE HERE
1155 @end defvr
1157 @defvr {Variável de opção} solvetrigwarn
1158 Valor padrão: @code{true}
1160 @c MAYBE THIS CAN BE CLARIFIED
1161 Quando @code{solvetrigwarn} é @code{true},
1162 @code{solve} pode imprimir uma mensagem dizendo que está usando funções
1163 trigonométricas inversas para resolver a equação, e desse modo perdendo
1164 soluções.
1165 @c NEED AN EXAMPLE HERE
1167 @end defvr
1169 @defvr {Variável de opção} solve_inconsistent_error
1170 Valor padrão: @code{true}
1172 Quando @code{solve_inconsistent_error} for @code{true}, @code{solve} e
1173 @code{linsolve} resultam em erro se as equações a serem resolvidas forem inconsistentes.
1175 Se @code{false}, @code{solve} e @code{linsolve} retornam uma lista vazia @code{[]}
1176 se as equações forem inconsistentes.
1178 Exemplo:
1180 @example
1181 (%i1) solve_inconsistent_error: true$
1182 (%i2) solve ([a + b = 1, a + b = 2], [a, b]);
1183 Inconsistent equações: (2)
1184 -- an error. Quitting. To debug this try debugmode(true);
1185 (%i3) solve_inconsistent_error: false$
1186 (%i4) solve ([a + b = 1, a + b = 2], [a, b]);
1187 (%o4) []
1188 @end example
1190 @end defvr