| blob | 5a13de98d3db2981246188d7bddd2ad2c27789e2 |
1 @c Language: Brazilian Portuguese, Encoding: iso-8859-1
2 @c /Polynomials.texi/1.23/Sat Jun 2 00:13:03 2007/-ko/
3 @c FOR THE FUNCTIONS WHICH RETURN A CRE, BE SURE TO MENTION THAT
4 @menu
5 * Introdução a Polinômios::
6 * Funções e Variáveis Definidas para Polinômios::
7 @end menu
9 @node Introdução a Polinômios, Funções e Variáveis Definidas para Polinômios, Polinômios, Polinômios
10 @section Introdução a Polinômios
12 Polinômios são armazenados no Maxima ou na forma geral ou na
13 forma de Expressões Racionais Canônicas (CRE). Essa última é uma forma
14 padrão, e é usada internamente por operações tais como @code{factor}, @code{ratsimp}, e
15 assim por diante.
17 Expressões Racionais Canônicas constituem um tipo de representação
18 que é especialmente adequado para polinômios expandidos e funções
19 racionais (também para polinômios parcialmente fatorados e funções
20 racionais quando RATFAC for escolhida para @code{true}). Nessa forma CRE uma
21 ordenação de variáveis (da mais para a menos importante) é assumida para cada
22 expressão. Polinômios são representados recursivamente por uma lista
23 consistindo da variável principal seguida por uma série de pares de
24 expressões, uma para cada termo do polinômio. O primeiro membro de
25 cada par é o expoente da variável principal naquele termo e o
26 segundo membro é o coeficiente daquele termo que pode ser um número ou
27 um polinômio em outra variável novamente respresentado nessa forma. Sendo assim
28 a parte principal da forma CRE de 3*X^2-1 é (X 2 3 0 -1) e que a parte principal da
29 forma CRE de 2*X*Y+X-3 é (Y 1 (X 1 2) 0 (X 1 1 0 -3)) assumindo Y como sendo a
30 variável principal, e é (X 1 (Y 1 2 0 1) 0 -3) assumindo X como sendo a
31 variável principal. A variável principal é usualmente determineda pela ordem alfabética
32 reversa. As "variáveis" de uma expressão CRE não necessariamente devem ser atômicas. De fato
33 qualquer subexpressão cujo principal operador não for + - * / or ^ com expoente
34 inteiro será considerado uma "variável" da expressão (na forma CRE) na
35 qual essa ocorrer. Por exemplo as variáveis CRE da expressão
36 X+SIN(X+1)+2*SQRT(X)+1 são X, SQRT(X), e SIN(X+1). Se o usuário
37 não especifica uma ordem de variáveis pelo uso da função RATVARS
38 Maxima escolherá a alfabética por conta própria. Em geral, CREs representam
39 expressões racionais, isto é, razões de polinômios, onde o
40 numerador e o denominador não possuem fatores comuns, e o denominador for
41 positivo. A forma interna é essencialmente um par de polinômios (o
42 numerador e o denominador) precedidos pela lista de ordenação de variável. Se
43 uma expressão a ser mostrada estiver na forma CRE ou se contiver quaisquer
44 subexpressões na forma CRE, o símbolo /R/ seguirá o rótulo da linha.
45 Veja a função RAT para saber como converter uma expressão para a forma CRE. Uma
46 forma CRE extendida é usada para a representação de séries de Taylor. A
47 noção de uma expressão racional é extendida de modo que os expoentes das
48 variáveis podem ser números racionais positivos ou negativos em lugar de apenas
49 inteiros positivos e os coeficientes podem eles mesmos serem expressões
50 racionais como descrito acima em lugar de apenas polinômios. Estes são
51 representados internamente por uma forma polinomial recursiva que é similar
52 à forma CRE e é a generalização dessa mesma forma CRE, mas carrega informação
53 adicional tal com o grau de truncação. Do mesmo modo que na forma CRE, o
54 símbolo /T/ segue o rótulo de linha que contém as tais expressões.
56 @node Funções e Variáveis Definidas para Polinômios, , Introdução a Polinômios, Polinômios
57 @section Funções e Variáveis Definidas para Polinômios
59 @defvr {Variável de opção} algebraic
60 Valor Padrão: @code{false}
62 @code{algebraic} deve ser escolhida para @code{true} com o objetivo de que a
63 simplificação de inteiros algébricos tenha efeito.
65 @end defvr
67 @defvr {Variável de opção} berlefact
68 Valor Padrão: @code{true}
70 Quando @code{berlefact} for @code{false} então o algorítmo de fatoração de
71 Kronecker será usado. De outra forma o algorítmo de Berlekamp, que é o
72 padrão, será usado.
74 @end defvr
76 @c WHAT IS THIS ABOUT EXACTLY ??
77 @deffn {Função} bezout (@var{p1}, @var{p2}, @var{x})
78 uma alternativa para o comando @code{resultant}. Isso
79 retorna uma matriz. @code{determinant} dessa matriz é o resultante desejado.
81 @end deffn
83 @c REWORD THIS ITEM -- COULD BE MORE CONCISE
84 @deffn {Função} bothcoef (@var{expr}, @var{x})
85 Retorna uma lista da qual o primeiro membro é o
86 coeficiente de @var{x} em @var{expr} (como achado por @code{ratcoef} se @var{expr} está na forma CRE
87 de outro modo por @code{coeff}) e cujo segundo membro é a parte restante de
88 @var{expr}. Isto é, @code{[A, B]} onde @code{@var{expr} = A*@var{x} + B}.
90 Exemplo:
91 @c FOLLOWING GENERATED FROM THESE EXPRESSIONS
92 @c islinear (expr, x) := block ([c],
93 @c c: bothcoef (rat (expr, x), x),
94 @c é (freeof (x, c) and c[1] # 0))$
95 @c islinear ((r^2 - (x - r)^2)/x, x);
97 @example
98 (%i1) islinear (expr, x) := block ([c],
99 c: bothcoef (rat (expr, x), x),
100 é (freeof (x, c) and c[1] # 0))$
101 (%i2) islinear ((r^2 - (x - r)^2)/x, x);
102 (%o2) true
103 @end example
105 @end deffn
107 @deffn {Função} coeff (@var{expr}, @var{x}, @var{n})
108 Retorna o coeficiente de @code{@var{x}^@var{n}} em @var{expr}. @var{n} pode ser
109 omitido se for 1. @var{x} pode ser um átomo, ou subexpressão completa de
110 @var{expr} e.g., @code{sin(x)}, @code{a[i+1]}, @code{x + y}, etc. (No último caso a
111 expressão @code{(x + y)} pode ocorrer em @var{expr}). Algumas vezes isso pode ser necessário
112 para expandir ou fatorar @var{expr} com o objetivo de fazer @code{@var{x}^@var{n}} explicito. Isso não é
113 realizado por @code{coeff}.
115 Exemplos:
116 @c FOLLOWING GENERATED FROM THESE EXPRESSIONS
117 @c coeff (2*a*tan(x) + tan(x) + b = 5*tan(x) + 3, tan(x));
118 @c coeff (y + x*%e^x + 1, x, 0);
120 @example
121 (%i1) coeff (2*a*tan(x) + tan(x) + b = 5*tan(x) + 3, tan(x));
122 (%o1) 2 a + 1 = 5
123 (%i2) coeff (y + x*%e^x + 1, x, 0);
124 (%o2) y + 1
125 @end example
127 @end deffn
129 @deffn {Função} combine (@var{expr})
130 Simplifica a adição @var{expr} por termos combinados com o mesmo
131 denominador dentro de um termo simples.
133 @c NEED EXAMPLE HERE
134 @end deffn
136 @deffn {Função} content (@var{p_1}, @var{x_1}, ..., @var{x_n})
137 Retorna uma lista cujo primeiro elemento é
138 o máximo divisor comum dos coeficientes dos termos do
139 polinômio @var{p_1} na variável @var{x_n} (isso é o conteúdo) e cujo
140 segundo elemento é o polinômio @var{p_1} dividido pelo conteúdo.
141 @c APPEARS TO WORK AS ADVERTISED -- ONLY x_n HAS ANY EFFECT ON THE RESULT
142 @c WHAT ARE THE OTHER VARIABLES x_1 THROUGH x_{n-1} FOR ??
144 Exemplos:
145 @c FOLLOWING GENERATED FROM THESE EXPRESSIONS
146 @c content (2*x*y + 4*x^2*y^2, y);
148 @example
149 (%i1) content (2*x*y + 4*x^2*y^2, y);
150 2
151 (%o1) [2 x, 2 x y + y]
152 @end example
154 @end deffn
156 @deffn {Função} denom (@var{expr})
157 Retorna o denominador da expressão racional @var{expr}.
159 @end deffn
161 @deffn {Função} divide (@var{p_1}, @var{p_2}, @var{x_1}, ..., @var{x_n})
162 calcula o quocietne e o resto
163 do polinômio @var{p_1} dividido pelo polinômio @var{p_2}, na variável
164 principal do polinômio, @var{x_n}.
165 @c SPELL OUT THE PURPOSE OF THE OTHER VARIABLES
166 As outras variáveis são como na função @code{ratvars}.
167 O resultado é uma lista cujo primeiro elemento é o quociente
168 e cujo segundo elemento é o resto.
170 Exemplos:
171 @c FOLLOWING GENERATED FROM THESE EXPRESSIONS
172 @c divide (x + y, x - y, x);
173 @c divide (x + y, x - y);
175 @example
176 (%i1) divide (x + y, x - y, x);
177 (%o1) [1, 2 y]
178 (%i2) divide (x + y, x - y);
179 (%o2) [- 1, 2 x]
180 @end example
182 @noindent
183 Note que @code{y} é a variável principal no segundo exemplo.
185 @end deffn
187 @deffn {Função} eliminate ([@var{eqn_1}, ..., @var{eqn_n}], [@var{x_1}, ..., @var{x_k}])
188 Elimina variáveis de
189 equações (ou expressões assumidas iguais a zero) pegando resultantes
190 sucessivos. Isso retorna uma lista de @code{@var{n} - @var{k}} expressões com @var{k}
191 variáveis @var{x_1}, ..., @var{x_k} eliminadas. Primeiro @var{x_1} é eliminado retornando @code{@var{n} - 1}
192 expressões, então @code{x_2} é eliminado, etc. Se @code{@var{k} = @var{n}} então uma expressão simples em uma
193 lista é retornada livre das variáveis @var{x_1}, ..., @var{x_k}. Nesse caso @code{solve}
194 é chamado para resolver a última resultante para a última variável.
196 Exemplo:
197 @c FOLLOWING GENERATED FROM THESE EXPRESSIONS
198 @c expr1: 2*x^2 + y*x + z;
199 @c expr2: 3*x + 5*y - z - 1;
200 @c expr3: z^2 + x - y^2 + 5;
201 @c eliminate ([expr3, expr2, expr1], [y, z]);
203 @example
204 (%i1) expr1: 2*x^2 + y*x + z;
205 2
206 (%o1) z + x y + 2 x
207 (%i2) expr2: 3*x + 5*y - z - 1;
208 (%o2) - z + 5 y + 3 x - 1
209 (%i3) expr3: z^2 + x - y^2 + 5;
210 2 2
211 (%o3) z - y + x + 5
212 (%i4) eliminate ([expr3, expr2, expr1], [y, z]);
213 8 7 6 5 4
214 (%o4) [7425 x - 1170 x + 1299 x + 12076 x + 22887 x
216 3 2
217 - 5154 x - 1291 x + 7688 x + 15376]
218 @end example
220 @end deffn
222 @deffn {Função} ezgcd (@var{p_1}, @var{p_2}, @var{p_3}, ...)
223 Retorna uma lista cujo primeiro elemento é o m.d.c. dos
224 polinômios @var{p_1}, @var{p_2}, @var{p_3}, ... e cujos restantes elementos são os
225 polinômios divididos pelo mdc. Isso sempre usa o algorítmo
226 @code{ezgcd}.
228 @end deffn
230 @defvr {Variável de opção} facexpand
231 Valor Padrão: @code{true}
233 @code{facexpand} controla se os fatores irredutíveis
234 retornados por @code{factor} estão na forma expandida (o padrão) ou na forma recursiva
235 (CRE normal).
237 @end defvr
239 @deffn {Função} factcomb (@var{expr})
240 Tenta combinar os coeficientes de fatoriais em @var{expr}
241 com os próprios fatoriais convertendo, por exemplo, @code{(n + 1)*n!}
242 em @code{(n + 1)!}.
244 @code{sumsplitfact} se escolhida para @code{false} fará com que @code{minfactorial} seja
245 aplicado após um @code{factcomb}.
247 @c Example:
248 @c UH, THESE ARE THE EXPRESSIONS WHICH WERE GIVEN IN
249 @c THE PREVIOUS REVISION OF THIS FILE, BUT IN THIS CASE
250 @c factcomb HAS NO EFFECT -- I GUESS A DIFFERENT EXAMPLE IS CALLED FOR
251 @c (n + 1)^b*n!^b;
252 @c factcomb (%);
253 @end deffn
255 @deffn {Função} factor (@var{expr})
256 @deffnx {Função} factor (@var{expr}, @var{p})
258 Fatora a expressão @var{expr}, contendo qualquer número de
259 variáveis ou funções, em fatores irredutíveis sobre os inteiros.
260 @code{factor (@var{expr}, @var{p})} fatora @var{expr} sobre o campo dos inteiros com um elemento
261 adjunto cujo menor polinômio é @var{p}.
263 @code{factor} usa a função @code{ifactors} para fatorar inteiros.
265 @code{factorflag} se @code{false} suprime a fatoração de fatores inteiros
266 de expressões racionais.
268 @code{dontfactor} pode ser escolhida para uma lista de variáveis com relação à qual
269 fatoração não é para ocorrer. (Essa é inicialmente vazia). Fatoração também
270 não acontece com relação a quaisquer variáveis que são menos
271 importantes (usando a ordenação de variável assumida pela forma CRE) como
272 essas na lista @code{dontfactor}.
274 @code{savefactors} se @code{true} faz com que os fatores de uma expressão que
275 é um produto de fatores seja guardada por certas funções com o objetivo de
276 aumentar a velocidade de futuras fatorações de expressões contendo alguns dos
277 mesmos fatores.
279 @code{berlefact} se @code{false} então o algorítmo de fatoração de Kronecker será
280 usado de outra forma o algorítmo de Berlekamp, que é o padrão, será
281 usado.
283 @code{intfaclim} se @code{true} maxima irá interromper a fatoração de
284 inteiros se nenhum fator for encontrado após tentar divisões e o método rho de
285 Pollard. Se escolhida para @code{false} (esse é o caso quando o usuário chama
286 @code{factor} explicitamente), a fatoração completa do inteiro será
287 tentada. A escolha do usuário para @code{intfaclim} é usada para chamadas
288 internas a @code{factor}. Dessa forma, @code{intfaclim} pode ser resetada para evitar que o
289 Maxima gaste um tempo muito longo fatorando inteiros grandes.
291 Exemplos:
292 @c EXAMPLES BELOW ADAPTED FROM examples (factor)
293 @c factor (2^63 - 1);
294 @c factor (-8*y - 4*x + z^2*(2*y + x));
295 @c -1 - 2*x - x^2 + y^2 + 2*x*y^2 + x^2*y^2;
296 @c block ([dontfactor: [x]], factor (%/36/(1 + 2*y + y^2)));
297 @c factor (1 + %e^(3*x));
298 @c factor (1 + x^4, a^2 - 2);
299 @c factor (-y^2*z^2 - x*z^2 + x^2*y^2 + x^3);
300 @c (2 + x)/(3 + x)/(b + x)/(c + x)^2;
301 @c ratsimp (%);
302 @c partfrac (%, x);
303 @c map ('factor, %);
304 @c ratsimp ((x^5 - 1)/(x - 1));
305 @c subst (a, x, %);
306 @c factor (%th(2), %);
307 @c factor (1 + x^12);
308 @c factor (1 + x^99);
310 @example
311 (%i1) factor (2^63 - 1);
312 2
313 (%o1) 7 73 127 337 92737 649657
314 (%i2) factor (-8*y - 4*x + z^2*(2*y + x));
315 (%o2) (2 y + x) (z - 2) (z + 2)
316 (%i3) -1 - 2*x - x^2 + y^2 + 2*x*y^2 + x^2*y^2;
317 2 2 2 2 2
318 (%o3) x y + 2 x y + y - x - 2 x - 1
319 (%i4) block ([dontfactor: [x]], factor (%/36/(1 + 2*y + y^2)));
320 2
321 (x + 2 x + 1) (y - 1)
322 (%o4) ----------------------
323 36 (y + 1)
324 (%i5) factor (1 + %e^(3*x));
325 x 2 x x
326 (%o5) (%e + 1) (%e - %e + 1)
327 (%i6) factor (1 + x^4, a^2 - 2);
328 2 2
329 (%o6) (x - a x + 1) (x + a x + 1)
330 (%i7) factor (-y^2*z^2 - x*z^2 + x^2*y^2 + x^3);
331 2
332 (%o7) - (y + x) (z - x) (z + x)
333 (%i8) (2 + x)/(3 + x)/(b + x)/(c + x)^2;
334 x + 2
335 (%o8) ------------------------
336 2
337 (x + 3) (x + b) (x + c)
338 (%i9) ratsimp (%);
339 4 3
340 (%o9) (x + 2)/(x + (2 c + b + 3) x
342 2 2 2 2
343 + (c + (2 b + 6) c + 3 b) x + ((b + 3) c + 6 b c) x + 3 b c )
344 (%i10) partfrac (%, x);
345 2 4 3
346 (%o10) - (c - 4 c - b + 6)/((c + (- 2 b - 6) c
348 2 2 2 2
349 + (b + 12 b + 9) c + (- 6 b - 18 b) c + 9 b ) (x + c))
351 c - 2
352 - ---------------------------------
353 2 2
354 (c + (- b - 3) c + 3 b) (x + c)
356 b - 2
357 + -------------------------------------------------
358 2 2 3 2
359 ((b - 3) c + (6 b - 2 b ) c + b - 3 b ) (x + b)
361 1
362 - ----------------------------------------------
363 2
364 ((b - 3) c + (18 - 6 b) c + 9 b - 27) (x + 3)
365 (%i11) map ('factor, %);
366 2
367 c - 4 c - b + 6 c - 2
368 (%o11) - ------------------------- - ------------------------
369 2 2 2
370 (c - 3) (c - b) (x + c) (c - 3) (c - b) (x + c)
372 b - 2 1
373 + ------------------------ - ------------------------
374 2 2
375 (b - 3) (c - b) (x + b) (b - 3) (c - 3) (x + 3)
376 (%i12) ratsimp ((x^5 - 1)/(x - 1));
377 4 3 2
378 (%o12) x + x + x + x + 1
379 (%i13) subst (a, x, %);
380 4 3 2
381 (%o13) a + a + a + a + 1
382 (%i14) factor (%th(2), %);
383 2 3 3 2
384 (%o14) (x - a) (x - a ) (x - a ) (x + a + a + a + 1)
385 (%i15) factor (1 + x^12);
386 4 8 4
387 (%o15) (x + 1) (x - x + 1)
388 (%i16) factor (1 + x^99);
389 2 6 3
390 (%o16) (x + 1) (x - x + 1) (x - x + 1)
392 10 9 8 7 6 5 4 3 2
393 (x - x + x - x + x - x + x - x + x - x + 1)
395 20 19 17 16 14 13 11 10 9 7 6
396 (x + x - x - x + x + x - x - x - x + x + x
398 4 3 60 57 51 48 42 39 33
399 - x - x + x + 1) (x + x - x - x + x + x - x
401 30 27 21 18 12 9 3
402 - x - x + x + x - x - x + x + 1)
403 @end example
405 @end deffn
407 @defvr {Variável de opção} factorflag
408 Valor Padrão: @code{false}
410 @c WHAT IS THIS ABOUT EXACTLY ??
411 Quando @code{factorflag} for @code{false}, suprime a fatoração de
412 fatores inteiros em expressões racionais.
414 @end defvr
416 @deffn {Função} factorout (@var{expr}, @var{x_1}, @var{x_2}, ...)
417 Rearranja a adição @var{expr} em uma adição de
418 parcelas da forma @code{f (@var{x_1}, @var{x_2}, ...)*g} onde @code{g} é um produto de
419 expressões que não possuem qualquer @var{x_i} e @code{f} é fatorado.
420 @c NEED EXAMPLE HERE
422 @end deffn
424 @deffn {Função} factorsum (@var{expr})
425 Tenta agrupar parcelas em fatores de @var{expr} que são adições
426 em grupos de parcelas tais que sua adição é fatorável. @code{factorsum} pode
427 recuperar o resultado de @code{expand ((x + y)^2 + (z + w)^2)} mas não pode recuperar
428 @code{expand ((x + 1)^2 + (x + y)^2)} porque os termos possuem variáveis em comum.
430 Exemplo:
431 @c FOLLOWING GENERATED FROM THESE EXPRESSIONS
432 @c expand ((x + 1)*((u + v)^2 + a*(w + z)^2));
433 @c factorsum (%);
435 @example
436 (%i1) expand ((x + 1)*((u + v)^2 + a*(w + z)^2));
437 2 2 2 2
438 (%o1) a x z + a z + 2 a w x z + 2 a w z + a w x + v x
440 2 2 2 2
441 + 2 u v x + u x + a w + v + 2 u v + u
442 (%i2) factorsum (%);
443 2 2
444 (%o2) (x + 1) (a (z + w) + (v + u) )
445 @end example
447 @end deffn
449 @deffn {Função} fasttimes (@var{p_1}, @var{p_2})
450 Retorna o produto dos polinômios @var{p_1} e @var{p_2} usando um
451 algorítmo especial para a multiplicação de polinômios. @code{p_1} e @code{p_2} podem ser
452 de várias variáveis, densos, e aproximadamente do mesmo tamanho. A multiplicação
453 clássica é de ordem @code{n_1 n_2} onde
454 @code{n_1} é o grau de @code{p_1}
455 and @code{n_2} é o grau de @code{p_2}.
456 @code{fasttimes} é da ordem @code{max (n_1, n_2)^1.585}.
458 @end deffn
460 @deffn {Função} fullratsimp (@var{expr})
461 @code{fullratsimp} aplica
462 repetidamente @code{ratsimp} seguido por simplificação não racional a uma
463 expressão até que nenhuma mudança adicional ocorra,
464 e retorna o resultado.
466 Quando expressões não racionais estão envolvidas, uma chamada
467 a @code{ratsimp} seguida como é usual por uma simplificação não racional
468 ("geral") pode não ser suficiente para retornar um resultado simplificado.
469 Algumas vezes, mais que uma tal chamada pode ser necessária.
470 @code{fullratsimp} faz esse processo convenientemente.
472 @code{fullratsimp (@var{expr}, @var{x_1}, ..., @var{x_n})} pega um ou mais argumentos similar
473 a @code{ratsimp} e @code{rat}.
475 Exemplo:
476 @c FOLLOWING GENERATED FROM THESE EXPRESSIONS
477 @c expr: (x^(a/2) + 1)^2*(x^(a/2) - 1)^2/(x^a - 1);
478 @c ratsimp (expr);
479 @c fullratsimp (expr);
480 @c rat (expr);
482 @example
483 (%i1) expr: (x^(a/2) + 1)^2*(x^(a/2) - 1)^2/(x^a - 1);
484 a/2 2 a/2 2
485 (x - 1) (x + 1)
486 (%o1) -----------------------
487 a
488 x - 1
489 (%i2) ratsimp (expr);
490 2 a a
491 x - 2 x + 1
492 (%o2) ---------------
493 a
494 x - 1
495 (%i3) fullratsimp (expr);
496 a
497 (%o3) x - 1
498 (%i4) rat (expr);
499 a/2 4 a/2 2
500 (x ) - 2 (x ) + 1
501 (%o4)/R/ -----------------------
502 a
503 x - 1
504 @end example
506 @end deffn
508 @c SPELL OUT WHAT fullratsubst DOES INSTEAD OF ALLUDING TO ratsubst AND lratsubst
509 @c THIS ITEM NEEDS MORE WORK
510 @deffn {Função} fullratsubst (@var{a}, @var{b}, @var{c})
511 é o mesmo que @code{ratsubst} exceto que essa chama
512 a si mesma recursivamente sobre esse resultado até que o resultado para de mudar.
513 Essa função é útil quando a expressão de substituição e a
514 expressão substituída tenham uma ou mais variáveis em comum.
516 @code{fullratsubst} irá também aceitar seus argumentos no formato de
517 @code{lratsubst}. Isto é, o primeiro argumento pode ser uma substituição simples
518 de equação ou uma lista de tais equações, enquanto o segundo argumento é a
519 expressão sendo processada.
521 @code{load ("lrats")} chama @code{fullratsubst} e @code{lratsubst}.
523 Exemplos:
524 @c EXPRESSIONS ADAPTED FROM demo ("lrats")
525 @c CAN PROBABLY CUT OUT THE lratsubst STUFF (lratsubst HAS ITS OWN DESCRIPTION)
526 @c load ("lrats")$
527 @c subst ([a = b, c = d], a + c);
528 @c lratsubst ([a^2 = b, c^2 = d], (a + e)*c*(a + c));
529 @c lratsubst (a^2 = b, a^3);
530 @c ratsubst (b*a, a^2, a^3);
531 @c fullratsubst (b*a, a^2, a^3);
532 @c fullratsubst ([a^2 = b, b^2 = c, c^2 = a], a^3*b*c);
533 @c fullratsubst (a^2 = b*a, a^3);
534 @c errcatch (fullratsubst (b*a^2, a^2, a^3));
536 @example
537 (%i1) load ("lrats")$
538 @end example
539 @itemize @bullet
540 @item
541 @code{subst} pode realizar multiplas substituições.
542 @code{lratsubst} é analogo a @code{subst}.
543 @end itemize
544 @example
545 (%i2) subst ([a = b, c = d], a + c);
546 (%o2) d + b
547 (%i3) lratsubst ([a^2 = b, c^2 = d], (a + e)*c*(a + c));
548 (%o3) (d + a c) e + a d + b c
549 @end example
550 @itemize @bullet
551 @item
552 Se somente uma substituição é desejada, então uma equação
553 simples pode ser dada como primeiro argumento.
554 @end itemize
555 @example
556 (%i4) lratsubst (a^2 = b, a^3);
557 (%o4) a b
558 @end example
559 @itemize @bullet
560 @item
561 @code{fullratsubst} é equivalente a @code{ratsubst}
562 exceto que essa executa recursivamente até que seu resultado para de mudar.
563 @end itemize
564 @example
565 (%i5) ratsubst (b*a, a^2, a^3);
566 2
567 (%o5) a b
568 (%i6) fullratsubst (b*a, a^2, a^3);
569 2
570 (%o6) a b
571 @end example
572 @itemize @bullet
573 @item
574 @code{fullratsubst} também aceita uma lista de equações ou uma equação
575 simples como primeiro argumento.
576 @end itemize
577 @example
578 (%i7) fullratsubst ([a^2 = b, b^2 = c, c^2 = a], a^3*b*c);
579 (%o7) b
580 (%i8) fullratsubst (a^2 = b*a, a^3);
581 2
582 (%o8) a b
583 @end example
584 @itemize @bullet
585 @item
586 @c REWORD THIS SENTENCE
587 @code{fullratsubst} pode causar uma recursão infinita.
588 @end itemize
589 @example
590 (%i9) errcatch (fullratsubst (b*a^2, a^2, a^3));
592 *** - Lisp stack overflow. RESET
593 @end example
595 @end deffn
597 @c GCD IS A VARIABLE AND A FUNCTION
598 @c THIS ITEM NEEDS A LOT OF WORK
599 @deffn {Função} gcd (@var{p_1}, @var{p_2}, @var{x_1}, ...)
600 Retorna o máximo divisor comum entre @var{p_1} e @var{p_2}.
601 O sinalizador @code{gcd} determina qual algorítmo é empregado.
602 Escolhendo @code{gcd} para @code{ez}, @code{subres}, @code{red}, ou @code{spmod} seleciona o algorítmo @code{ezgcd},
603 subresultante @code{prs}, reduzido, ou modular,
604 respectivamente. Se @code{gcd} for @code{false} então @code{gcd (@var{p_1}, @var{p_2}, @var{x})} sempre retorna 1
605 para todo @var{x}. Muitas funções (e.g. @code{ratsimp}, @code{factor}, etc.) fazem com que mdc's
606 sejam feitos implicitamente. Para polinômios homogêneos é recomendado
607 que @code{gcd} igual a @code{subres} seja usado. Para pegar o mdc quando uma expressão algébrica está
608 presente, e.g. @code{gcd (@var{x}^2 - 2*sqrt(2)*@var{x} + 2, @var{x} - sqrt(2))}, @code{algebraic} deve ser
609 @code{true} e @code{gcd} não deve ser @code{ez}. @code{subres} é um novo algorítmo, e pessoas
610 que tenham estado usando a opção @code{red} podem provavelmente alterar isso para
611 @code{subres}.
613 O sinalizador @code{gcd}, padrão: @code{subres}, se @code{false} irá também evitar o máximo
614 divisor comum de ser usado quando expressões são convertidas para a forma de expressão racional
615 canônica (CRE). Isso irá algumas vezes aumentar a velocidade dos cálculos se mdc's não são
616 requeridos.
617 @c NEEDS EXAMPLES HERE
619 @end deffn
621 @c IN NEED OF SERIOUS CLARIFICATION HERE
622 @deffn {Função} gcdex (@var{f}, @var{g})
623 @deffnx {Função} gcdex (@var{f}, @var{g}, @var{x})
624 Retornam uma lista @code{[@var{a}, @var{b}, @var{u}]}
625 onde @var{u} é o máximo divisor comum (mdc) entre @var{f} e @var{g},
626 e @var{u} é igual a @code{@var{a} @var{f} + @var{b} @var{g}}.
627 Os argumentos @var{f} e @var{g} podem ser polinômios de uma variável,
628 ou de outra forma polinômios em @var{x} uma @b{main}(principal) variável suprida
629 desde que nós precisamos estar em um domínio de ideal principal para isso trabalhar.
630 O mdc significa o mdc considerando @var{f} e @var{g} como polinômios de uma única variável com coeficientes
631 sendo funções racionais em outras variáveis.
633 @code{gcdex} implementa o algorítmo Euclideano,
634 onde temos a seq@"{u}ência
635 of @code{L[i]: [a[i], b[i], r[i]]} que são todos perpendiculares
636 a @code{[f, g, -1]} e o próximo se é construído como
637 se @code{q = quotient(r[i]/r[i+1])} então @code{L[i+2]: L[i] - q L[i+1]}, e isso
638 encerra em @code{L[i+1]} quando o resto @code{r[i+2]} for zero.
640 @c FOLLOWING GENERATED FROM THESE EXPRESSIONS
641 @c gcdex (x^2 + 1, x^3 + 4);
642 @c % . [x^2 + 1, x^3 + 4, -1];
644 @example
645 (%i1) gcdex (x^2 + 1, x^3 + 4);
646 2
647 x + 4 x - 1 x + 4
648 (%o1)/R/ [- ------------, -----, 1]
649 17 17
650 (%i2) % . [x^2 + 1, x^3 + 4, -1];
651 (%o2)/R/ 0
652 @end example
654 @c SORRY FOR BEING DENSE BUT WHAT IS THIS ABOUT EXACTLY
655 Note que o mdc adiante é @code{1}
656 uma vez que trabalhamos em @code{k(y)[x]}, o @code{y+1} não pode ser esperado em @code{k[y, x]}.
658 @c FOLLOWING GENERATED FROM THESE EXPRESSIONS
659 @c gcdex (x*(y + 1), y^2 - 1, x);
661 @example
662 (%i1) gcdex (x*(y + 1), y^2 - 1, x);
663 1
664 (%o1)/R/ [0, ------, 1]
665 2
666 y - 1
667 @end example
669 @end deffn
672 @c CHOOSE ONE CHARACTERIZATION OF "GAUSSIAN INTEGERS" AND USE IT WHERE GAUSSIAN INTEGERS ARE REFERENCED
673 @deffn {Função} gcfactor (@var{n})
674 Fatora o inteiro Gaussiano @var{n} sobre os inteiros Gaussianos, i.e.,
675 números da forma @code{@var{a} + @var{b} @code{%i}} onde @var{a} e @var{b} são inteiros raconais
676 (i.e., inteiros comuns). Fatorações são normalizadas fazendo @var{a} e @var{b}
677 não negativos.
678 @c NEED EXAMPLES HERE
680 @end deffn
682 @c CHOOSE ONE CHARACTERIZATION OF "GAUSSIAN INTEGERS" AND USE IT WHERE GAUSSIAN INTEGERS ARE REFERENCED
683 @deffn {Função} gfactor (@var{expr})
684 Fatora o polinômio @var{expr} sobre os inteiros de Gauss
685 (isto é, os inteiros com a unidade imaginária @code{%i} adjunta).
686 @c "This is like" -- IS IT THE SAME OR NOT ??
687 Isso é como @code{factor (@var{expr}, @var{a}^2+1)} trocando @var{a} por @code{%i}.
689 Exemplo:
690 @c FOLLOWING GENERATED FROM THESE EXPRESSIONS
691 @c gfactor (x^4 - 1);
693 @example
694 (%i1) gfactor (x^4 - 1);
695 (%o1) (x - 1) (x + 1) (x - %i) (x + %i)
696 @end example
698 @end deffn
700 @c DESCRIBE THIS INDEPENDENTLY OF factorsum
701 @c THIS ITEM NEEDS MORE WORK
702 @deffn {Função} gfactorsum (@var{expr})
703 é similar a @code{factorsum} mas aplica @code{gfactor} em lugar
704 de @code{factor}.
706 @end deffn
708 @deffn {Função} hipow (@var{expr}, @var{x})
709 Retorna o maior expoente explícito de @var{x} em @var{expr}.
710 @var{x} pode ser uma variável ou uma expressão geral.
711 Se @var{x} não aparece em @var{expr},
712 @code{hipow} retorna @code{0}.
714 @code{hipow} não considera expressões equivalentes a @code{expr}.
715 Em particular, @code{hipow} não expande @code{expr},
716 então @code{hipow (@var{expr}, @var{x})} e @code{hipow (expand (@var{expr}, @var{x}))}
717 podem retornar diferentes resultados.
719 Exemplos:
721 @example
722 (%i1) hipow (y^3 * x^2 + x * y^4, x);
723 (%o1) 2
724 (%i2) hipow ((x + y)^5, x);
725 (%o2) 1
726 (%i3) hipow (expand ((x + y)^5), x);
727 (%o3) 5
728 (%i4) hipow ((x + y)^5, x + y);
729 (%o4) 5
730 (%i5) hipow (expand ((x + y)^5), x + y);
731 (%o5) 0
732 @end example
734 @end deffn
736 @defvr {Variável de opção} intfaclim
737 Valor padrão: true
739 Se @code{true}, maxima irá interromper a fatoração de
740 inteiros se nenhum fator for encontrado após tentar divisões e o método rho de
741 Pollard e a fatoração não será completada.
743 Quando @code{intfaclim} for @code{false} (esse é o caso quando o usuário
744 chama @code{factor} explicitamente), a fatoração completa será
745 tentada. @code{intfaclim} é escolhida para @code{false} quando fatores são
746 calculados em @code{divisors}, @code{divsum} e @code{totient}.
747 @c ANY OTHERS ??
749 @c WHAT ARE THESE MYSTERIOUS INTERNAL CALLS ?? (LET'S JUST LIST THE FUNCTIONS INVOLVED)
750 Chamadas internas a @code{factor} respeitam o valor especificado pelo usuário para
751 @code{intfaclim}. Setting @code{intfaclim} to @code{true} may reduce
752 @code{intfaclim}. Escolhendo @code{intfaclim} para @code{true} podemos reduzir
753 o tempo gasto fatorando grandes inteiros.
754 @c NEED EXAMPLES HERE
756 @end defvr
758 @defvr {Variável de opção} keepfloat
759 Valor Padrão: @code{false}
761 Quando @code{keepfloat} for @code{true}, evitamos que números
762 em ponto flutuante sejam racionalizados quando expressões que os possuem
763 são então convertidas para a forma de expressão racional canônica (CRE).
764 @c NEED EXAMPLES HERE
766 @end defvr
768 @c DESCRIBE lratsubst INDEPENDENTLY OF subst
769 @c THIS ITEM NEEDS MORE WORK
770 @deffn {Função} lratsubst (@var{L}, @var{expr})
771 é análogo a @code{subst (@var{L}, @var{expr})}
772 exceto que esse usa @code{ratsubst} em lugar de @code{subst}.
774 O primeiro argumento de
775 @code{lratsubst} é uma equação ou uma lista de equações idênticas em
776 formato para que sejam aceitas por @code{subst}. As
777 substituições são feitas na ordem dada pela lista de equações,
778 isto é, da esquerda para a direita.
780 @code{load ("lrats")} chama @code{fullratsubst} e @code{lratsubst}.
782 Exemplos:
783 @c EXPRESSIONS ADAPTED FROM demo ("lrats")
784 @c THIS STUFF CAN PROBABLY STAND REVISION -- EXAMPLES DON'T SEEM VERY ENLIGHTENING
785 @c load ("lrats")$
786 @c subst ([a = b, c = d], a + c);
787 @c lratsubst ([a^2 = b, c^2 = d], (a + e)*c*(a + c));
788 @c lratsubst (a^2 = b, a^3);
790 @example
791 (%i1) load ("lrats")$
792 @end example
793 @itemize @bullet
794 @item
795 @code{subst} pode realizar multiplas substituições.
796 @code{lratsubst} é analoga a @code{subst}.
797 @end itemize
798 @example
799 (%i2) subst ([a = b, c = d], a + c);
800 (%o2) d + b
801 (%i3) lratsubst ([a^2 = b, c^2 = d], (a + e)*c*(a + c));
802 (%o3) (d + a c) e + a d + b c
803 @end example
804 @itemize @bullet
805 @item
806 Se somente uma substituição for desejada, então uma equação
807 simples pode ser dada como primeiro argumento.
808 @end itemize
809 @example
810 (%i4) lratsubst (a^2 = b, a^3);
811 (%o4) a b
812 @end example
814 @end deffn
816 @defvr {Variável de opção} modulus
817 Valor Padrão: @code{false}
819 Quando @code{modulus} for um número positivo @var{p},
820 operações sobre os números racionais (como retornado por @code{rat} e funções relacionadas)
821 são realizadas módulo @var{p},
822 usando o então chamado sistema de módulo "balanceado"
823 no qual @code{@var{n} módulo @var{p}} é definido como
824 um inteiro @var{k} em @code{[-(@var{p}-1)/2, ..., 0, ..., (@var{p}-1)/2]}
825 quando @var{p} for ímpar, ou @code{[-(@var{p}/2 - 1), ..., 0, ...., @var{p}/2]} quando @var{p} for par,
826 tal que @code{@var{a} @var{p} + @var{k}} seja igual a @var{n} para algum inteiro @var{a}.
827 @c NEED EXAMPLES OF "BALANCED MODULUS" HERE
829 @c WHAT CAN THIS MEAN ?? IS THE MODULUS STORED WITH THE EXPRESSION ??
830 @c "... in order to get correct results" -- WHAT DO YOU GET IF YOU DON'T RE-RAT ??
831 Se @var{expr} já estiver na forma de expressão racional canônica (CRE) quando @code{modulus} for colocado em seu valor original,
832 então você pode precisar repetir o rat @var{expr}, e.g., @code{expr: rat (ratdisrep (expr))},
833 com o objetivo de pegar resultados corretos.
835 Tipicamente @code{modulus} é escolhido para um número primo.
836 Se @code{modulus} for escolhido para um inteiro não primo positivo,
837 essa escolha é aceita, mas uma mensagem de alerta é mostrada.
838 Maxima permitirá que zero ou um inteiro negativo seja atribuído a @code{modulus},
839 embora isso não seja limpo se aquele tiver quaisquer conseq@"{u}ências úteis.
841 @c NEED EXAMPLES HERE
842 @end defvr
844 @c APPARENTLY OBSOLETE: ONLY EFFECT OF $newfac COULD BE TO CAUSE NONEXISTENT FUNCTION NMULTFACT
845 @c TO BE CALLED (IN FUNCTION FACTOR72 IN src/factor.lisp CIRCA LINE 1400)
846 @c $newfac NOT USED IN ANY OTHER CONTEXT (ASIDE FROM DECLARATIONS)
847 @c COMMENT IT OUT NOW, CUT IT ON THE NEXT PASS THROUGH THIS FILE
848 @c @defvar newfac
849 @c Default value: @code{false}
850 @c
851 @c When @code{newfac} for @code{true}, @code{factor} will use the new factoring
852 @c routines.
853 @c
854 @c @end defvar
856 @deffn {Função} num (@var{expr})
857 Retorna o numerador de @var{expr} se isso for uma razão.
858 Se @var{expr} não for uma razão, @var{expr} é retornado.
860 @code{num} avalia seu argumento.
862 @c NEED SOME EXAMPLES HERE
863 @end deffn
865 @deffn {Função} polydecomp (@var{p}, @var{x})
867 Decompões o polinômio @var{p} na variável @var{x}
868 em uma composição funcional de polinômios em @var{x}.
869 @code{polydecomp} retorna uma lista @code{[@var{p_1}, ..., @var{p_n}]} tal que
871 @example
872 lambda ([x], p_1) (lambda ([x], p_2) (... (lambda ([x], p_n) (x)) ...))
873 @end example
875 seja igual a @var{p}.
876 O grau de @var{p_i} é maior que 1 para @var{i} menor que @var{n}.
878 Tal decomposição não é única.
880 Exemplos:
882 @c ===beg===
883 @c polydecomp (x^210, x);
884 @c p : expand (subst (x^3 - x - 1, x, x^2 - a));
885 @c polydecomp (p, x);
886 @c ===end===
887 @example
888 (%i1) polydecomp (x^210, x);
889 7 5 3 2
890 (%o1) [x , x , x , x ]
891 (%i2) p : expand (subst (x^3 - x - 1, x, x^2 - a));
892 6 4 3 2
893 (%o2) x - 2 x - 2 x + x + 2 x - a + 1
894 (%i3) polydecomp (p, x);
895 2 3
896 (%o3) [x - a, x - x - 1]
897 @end example
899 As seguintes funções compõem @code{L = [e_1, ..., e_n]} como funções em @code{x};
900 essa funçào é a inversa de @code{polydecomp}:
902 @c ===beg===
903 @c compose (L, x) :=
904 @c block ([r : x], for e in L do r : subst (e, x, r), r) $
905 @c ===end===
906 @example
907 compose (L, x) :=
908 block ([r : x], for e in L do r : subst (e, x, r), r) $
909 @end example
911 Re-exprimindo o exemplo acima usando @code{compose}:
913 @c ===beg===
914 @c polydecomp (compose ([x^2 - a, x^3 - x - 1], x), x);
915 @c ===end===
916 @example
917 (%i3) polydecomp (compose ([x^2 - a, x^3 - x - 1], x), x);
918 2 3
919 (%o3) [x - a, x - x - 1]
920 @end example
922 Note que apesar de @code{compose (polydecomp (@var{p}, @var{x}), @var{x})}
923 sempre retornar @var{p} (não expandido),
924 @code{polydecomp (compose ([@var{p_1}, ..., @var{p_n}], @var{x}), @var{x})} @i{não}
925 necessáriamente retorna @code{[@var{p_1}, ..., @var{p_n}]}:
927 @c ===beg===
928 @c polydecomp (compose ([x^2 + 2*x + 3, x^2], x), x);
929 @c polydecomp (compose ([x^2 + x + 1, x^2 + x + 1], x), x);
930 @c ===end===
931 @example
932 (%i4) polydecomp (compose ([x^2 + 2*x + 3, x^2], x), x);
933 2 2
934 (%o4) [x + 2, x + 1]
935 (%i5) polydecomp (compose ([x^2 + x + 1, x^2 + x + 1], x), x);
936 2 2
937 x + 3 x + 5
938 (%o5) [------, ------, 2 x + 1]
939 4 2
940 @end example
942 @end deffn
944 @deffn {Função} quotient (@var{p_1}, @var{p_2})
945 @deffnx {Função} quotient (@var{p_1}, @var{p_2}, @var{x_1}, ..., @var{x_n})
946 Retorna o polinômio @var{p_1} dividido pelo polinômio @var{p_2}.
947 Os argumentos @var{x_1}, ..., @var{x_n} são interpretados como em @code{ratvars}.
949 @code{quotient} retorna o primeiro elemento de uma lista de dois elementos retornada por @code{divide}.
951 @c NEED SOME EXAMPLES HERE
952 @end deffn
954 @c THIS ITEM CAN PROBABLY BE IMPROVED
955 @deffn {Função} rat (@var{expr})
956 @deffnx {Função} rat (@var{expr}, @var{x_1}, ..., @var{x_n})
957 Converte @var{expr} para a forma de expressão racional canônica (CRE) expandindo e
958 combinando todos os termos sobre um denominador comum e cancelando para fora o
959 máximo divisor comum entre o numerador e o denominador, também
960 convertendo números em ponto flutuante para números racionais dentro da
961 tolerância de @code{ratepsilon}.
962 As variáveis são ordenadas de acordo com
963 @var{x_1}, ..., @var{x_n}, se especificado, como em @code{ratvars}.
965 @code{rat} geralmente não simplifica funções outras que não sejam
966 adição @code{+}, subtração @code{-}, multiplicação @code{*}, divisão @code{/}, e
967 exponenciação com expoente inteiro,
968 uma vez que @code{ratsimp} não manuseia esses casos.
969 Note que átomos (números e variáveis) na forma CRE não são os
970 mesmos que eles são na forma geral.
971 Por exemplo, @code{rat(x)- x} retorna
972 @code{rat(0)} que tem uma representação interna diferente de 0.
974 @c WHAT'S THIS ABOUT EXACTLY ??
975 Quando @code{ratfac} for @code{true}, @code{rat} retorna uma forma parcialmente fatorada para CRE.
976 Durante operações racionais a expressão é
977 mantida como totalmente fatorada como possível sem uma chamada ao
978 pacote de fatoração (@code{factor}). Isso pode sempre economizar espaço de memória e algum tempo
979 em algumas computações. O numerador e o denominador são ainda tidos como
980 relativamente primos
981 (e.g. @code{rat ((x^2 - 1)^4/(x + 1)^2)} retorna @code{(x - 1)^4 (x + 1)^2)},
982 mas os fatores dentro de cada parte podem não ser relativamente primos.
984 @code{ratprint} se @code{false} suprime a impressão de mensagens
985 informando o usuário de conversões de números em ponto flutuante para
986 números racionais.
988 @code{keepfloat} se @code{true} evita que números em ponto flutuante sejam
989 convertidos para números racionais.
991 Veja também @code{ratexpand} e @code{ratsimp}.
993 Exemplos:
994 @c FOLLOW GENERATED FROM THESE EXPRESSIONS
995 @c ((x - 2*y)^4/(x^2 - 4*y^2)^2 + 1)*(y + a)*(2*y + x) /(4*y^2 + x^2);
996 @c rat (%, y, a, x);
998 @example
999 (%i1) ((x - 2*y)^4/(x^2 - 4*y^2)^2 + 1)*(y + a)*(2*y + x) /(4*y^2 + x^2);
1000 4
1001 (x - 2 y)
1002 (y + a) (2 y + x) (------------ + 1)
1003 2 2 2
1004 (x - 4 y )
1005 (%o1) ------------------------------------
1006 2 2
1007 4 y + x
1008 (%i2) rat (%, y, a, x);
1009 2 a + 2 y
1010 (%o2)/R/ ---------
1011 x + 2 y
1012 @end example
1014 @end deffn
1016 @defvr {Variável de opção} ratalgdenom
1017 Valor Padrão: @code{true}
1019 Quando @code{ratalgdenom} for @code{true}, permite racionalização de
1020 denominadores com respeito a radicais tenham efeito.
1021 @code{ratalgdenom} tem efeito somente quando expressões racionais canônicas (CRE) forem usadas no modo algébrico.
1023 @end defvr
1025 @c THIS ITEM NEEDS MORE WORK
1026 @deffn {Função} ratcoef (@var{expr}, @var{x}, @var{n})
1027 @deffnx {Função} ratcoef (@var{expr}, @var{x})
1028 Retorna o coeficiente da expressão @code{@var{x}^@var{n}}
1029 dentro da expressão @var{expr}.
1030 Se omitido, @var{n} é assumido ser 1.
1032 O valor de retorno está livre
1033 (exceto possivelmente em um senso não racional) das variáveis em @var{x}.
1034 Se nenhum coeficiente desse tipo existe, 0 é retornado.
1036 @code{ratcoef}
1037 expande e simplifica racionalmente seu primeiro argumento e dessa forma pode
1038 produzir respostas diferentes das de @code{coeff} que é puramente
1039 sintática.
1040 @c MOVE THIS TO EXAMPLES SECTION
1041 Dessa forma @code{ratcoef ((x + 1)/y + x, x)} retorna @code{(y + 1)/y} ao passo que @code{coeff} retorna 1.
1043 @code{ratcoef (@var{expr}, @var{x}, 0)}, visualiza @var{expr} como uma adição,
1044 retornando uma soma desses termos que não possuem @var{x}.
1045 @c "SHOULD NOT" -- WHAT DOES THIS MEAN ??
1046 portanto se @var{x} ocorre para quaisquer expoentes negativos, @code{ratcoef} pode não ser usado.
1048 @c WHAT IS THE INTENT HERE ??
1049 Uma vez que @var{expr} é racionalmente
1050 simplificada antes de ser examinada, coeficientes podem não aparecer inteiramente
1051 no caminho que eles foram pensados.
1053 Exemplo:
1054 @c FOLLOWING GENERATED FROM THESE EXPRESSIONS
1055 @c s: a*x + b*x + 5$
1056 @c ratcoef (s, a + b);
1058 @example
1059 (%i1) s: a*x + b*x + 5$
1060 (%i2) ratcoef (s, a + b);
1061 (%o2) x
1062 @end example
1063 @c NEED MORE EXAMPLES HERE
1065 @end deffn
1067 @deffn {Função} ratdenom (@var{expr})
1068 Retorna o denominador de @var{expr},
1069 após forçar a conversão de @var{expr} para expressão racional canônica (CRE).
1070 O valor de retorno é a CRE.
1072 @c ACTUALLY THE CONVERSION IS CARRIED OUT BY ratf BUT THAT'S WHAT $rat CALLS
1073 @var{expr} é forçada para uma CRE por @code{rat}
1074 se não for já uma CRE.
1075 Essa conversão pode mudar a forma de @var{expr} colocando todos os termos
1076 sobre um denominador comum.
1078 @code{denom} é similar, mas retorna uma expressão comum em lugar de uma CRE.
1079 Também, @code{denom} não tenta colocar todos os termos sobre um denominador comum,
1080 e dessa forma algumas expressões que são consideradas razões por @code{ratdenom}
1081 não são consideradas razões por @code{denom}.
1083 @c NEEDS AN EXAMPLE HERE
1084 @end deffn
1086 @defvr {Variável de opção} ratdenomdivide
1087 Valor Padrão: @code{true}
1089 Quando @code{ratdenomdivide} for @code{true},
1090 @code{ratexpand} expande uma razão cujo o numerador for uma adição
1091 dentro de uma soma de razões,
1092 tendo todos um denominador comum.
1093 De outra forma, @code{ratexpand} colapsa uma adição de razões dentro de uma razão simples,
1094 cujo numerador seja a adição dos numeradores de cada razão.
1096 Exemplos:
1098 @example
1099 (%i1) expr: (x^2 + x + 1)/(y^2 + 7);
1100 2
1101 x + x + 1
1102 (%o1) ----------
1103 2
1104 y + 7
1105 (%i2) ratdenomdivide: true$
1106 (%i3) ratexpand (expr);
1107 2
1108 x x 1
1109 (%o3) ------ + ------ + ------
1110 2 2 2
1111 y + 7 y + 7 y + 7
1112 (%i4) ratdenomdivide: false$
1113 (%i5) ratexpand (expr);
1114 2
1115 x + x + 1
1116 (%o5) ----------
1117 2
1118 y + 7
1119 (%i6) expr2: a^2/(b^2 + 3) + b/(b^2 + 3);
1120 2
1121 b a
1122 (%o6) ------ + ------
1123 2 2
1124 b + 3 b + 3
1125 (%i7) ratexpand (expr2);
1126 2
1127 b + a
1128 (%o7) ------
1129 2
1130 b + 3
1131 @end example
1133 @end defvr
1135 @deffn {Função} ratdiff (@var{expr}, @var{x})
1136 Realiza a derivação da expressão racional @var{expr} com relação a @var{x}.
1137 @var{expr} deve ser uma razão de polinômios ou um polinômio em @var{x}.
1138 O argumento @var{x} pode ser uma variável ou uma subexpressão de @var{expr}.
1139 @c NOT CLEAR (FROM READING CODE) HOW x OTHER THAN A VARIABLE IS HANDLED --
1140 @c LOOKS LIKE (a+b), 10*(a+b), (a+b)^2 ARE ALL TREATED LIKE (a+b);
1141 @c HOW TO DESCRIBE THAT ??
1143 O resultado é equivalente a @code{diff}, embora talvez em uma forma diferente.
1144 @code{ratdiff} pode ser mais rápida que @code{diff}, para expressões racionais.
1146 @code{ratdiff} retorna uma expressão racional canônica (CRE) se @code{expr} for uma CRE.
1147 De outra forma, @code{ratdiff} retorna uma expressão geral.
1149 @code{ratdiff} considera somente as dependências de @var{expr} sobre @var{x},
1150 e ignora quaisquer dependências estabelecidas por @code{depends}.
1152 @c WHAT THIS IS ABOUT -- ratdiff (rat (factor (expr)), x) AND ratdiff (factor (rat (expr)), x) BOTH SUCCEED
1153 @c COMMENTING THIS OUT UNTIL SOMEONE CAN ESTABLISH SOME CRE'S FOR WHICH ratdiff FAILS
1154 @c However, @code{ratdiff} should not be used on factored CRE forms;
1155 @c use @code{diff} instead for such expressões.
1157 Exemplo:
1158 @c FOLLOWING GENERATED FROM THESE EXPRESSIONS
1159 @c expr: (4*x^3 + 10*x - 11)/(x^5 + 5);
1160 @c ratdiff (expr, x);
1161 @c expr: f(x)^3 - f(x)^2 + 7;
1162 @c ratdiff (expr, f(x));
1163 @c expr: (a + b)^3 + (a + b)^2;
1164 @c ratdiff (expr, a + b);
1166 @example
1167 (%i1) expr: (4*x^3 + 10*x - 11)/(x^5 + 5);
1168 3
1169 4 x + 10 x - 11
1170 (%o1) ----------------
1171 5
1172 x + 5
1173 (%i2) ratdiff (expr, x);
1174 7 5 4 2
1175 8 x + 40 x - 55 x - 60 x - 50
1176 (%o2) - ---------------------------------
1177 10 5
1178 x + 10 x + 25
1179 (%i3) expr: f(x)^3 - f(x)^2 + 7;
1180 3 2
1181 (%o3) f (x) - f (x) + 7
1182 (%i4) ratdiff (expr, f(x));
1183 2
1184 (%o4) 3 f (x) - 2 f(x)
1185 (%i5) expr: (a + b)^3 + (a + b)^2;
1186 3 2
1187 (%o5) (b + a) + (b + a)
1188 (%i6) ratdiff (expr, a + b);
1189 2 2
1190 (%o6) 3 b + (6 a + 2) b + 3 a + 2 a
1191 @end example
1193 @end deffn
1195 @deffn {Função} ratdisrep (@var{expr})
1196 Retorna seu argumento como uma expressão geral.
1197 Se @var{expr} for uma expressão geral, é retornada inalterada.
1199 Tipicamente @code{ratdisrep} é chamada para converter uma expressão racional canônica (CRE)
1200 em uma expressão geral.
1201 @c NOT REALLY FOND OF YOU-CAN-DO-THIS-YOU-CAN-DO-THAT STATEMENTS
1202 Isso é algumas vezes conveniente se deseja-se parar o "contágio", ou
1203 caso se esteja usando funções racionais em contextos não racionais.
1205 Veja também @code{totaldisrep}.
1207 @end deffn
1209 @defvr {Variável de opção} ratepsilon
1210 Valor Padrão: 2.0e-8
1212 @code{ratepsilon} é a tolerância usada em conversões
1213 de números em ponto flutuante para números racionais.
1215 @c NEED EXAMPLES HERE
1216 @end defvr
1218 @deffn {Função} ratexpand (@var{expr})
1219 @deffnx {Variável de opção} ratexpand
1220 Expande @var{expr} multiplicando para fora produtos de somas e
1221 somas exponenciadas, combinando frações sobre um denominador comum,
1222 cancelando o máximo divisor comum entre entre o numerador e o
1223 denominador, então quebrando o numerador (se for uma soma) dentro de suas
1224 respectivas parcelas divididas pelo denominador.
1226 O valor de retorno de @code{ratexpand} é uma expressão geral,
1227 mesmo se @var{expr} for uma expressão racional canônica (CRE).
1229 @c WHAT DOES THE FOLLOWING MEAN EXACTLY ??
1230 O comutador @code{ratexpand} se @code{true} fará com que expressões
1231 CRE sejam completamente expandidas quando forem convertidas de volta para
1232 a forma geral ou mostradas, enquanto se for @code{false} então elas serão colocadas
1233 na forma recursiva.
1234 Veja também @code{ratsimp}.
1236 Quando @code{ratdenomdivide} for @code{true},
1237 @code{ratexpand} expande uma razão na qual o numerador é uma adição
1238 dentro de uma adição de razões,
1239 todas tendo um denominador comum.
1240 De outra forma, @code{ratexpand} contrai uma soma de razões em uma razão simples,
1241 cujo numerador é a soma dos numeradores de cada razão.
1243 Quando @code{keepfloat} for @code{true}, evita que números
1244 em ponto flutuante sejam racionalizados quando expressões que contenham
1245 números em ponto flutuante forem convertidas para a forma de expressão racional canônica (CRE).
1247 Exemplos:
1248 @c FOLLOWING GENERATED FROM THESE EXPRESSIONS
1249 @c ratexpand ((2*x - 3*y)^3);
1250 @c expr: (x - 1)/(x + 1)^2 + 1/(x - 1);
1251 @c expand (expr);
1252 @c ratexpand (expr);
1254 @example
1255 (%i1) ratexpand ((2*x - 3*y)^3);
1256 3 2 2 3
1257 (%o1) - 27 y + 54 x y - 36 x y + 8 x
1258 (%i2) expr: (x - 1)/(x + 1)^2 + 1/(x - 1);
1259 x - 1 1
1260 (%o2) -------- + -----
1261 2 x - 1
1262 (x + 1)
1263 (%i3) expand (expr);
1264 x 1 1
1265 (%o3) ------------ - ------------ + -----
1266 2 2 x - 1
1267 x + 2 x + 1 x + 2 x + 1
1268 (%i4) ratexpand (expr);
1269 2
1270 2 x 2
1271 (%o4) --------------- + ---------------
1272 3 2 3 2
1273 x + x - x - 1 x + x - x - 1
1274 @end example
1276 @end deffn
1278 @defvr {Variável de opção} ratfac
1279 Valor Padrão: @code{false}
1281 Quando @code{ratfac} for @code{true},
1282 expressões racionais canônicas (CRE) são manipuladas na forma parcialmente fatorada.
1284 Durante operações racionais a
1285 expressão é mantida como completamente fatorada como foi possível sem chamadas a @code{factor}.
1286 Isso pode sempre economizar espaço e pode economizar tempo em algumas computações.
1287 O numerador e o denominador são feitos relativamente primos, por exemplo
1288 @code{rat ((x^2 - 1)^4/(x + 1)^2)} retorna @code{(x - 1)^4 (x + 1)^2)},
1289 mas o fator dentro de cada parte pode não ser relativamente primo.
1291 No pacote @code{ctensor} (Manipulação de componentes de tensores),
1292 tensores de Ricci, Einstein, Riemann, e de Weyl e a curvatura escalar
1293 são fatorados automaticamente quando @code{ratfac} for @code{true}.
1294 @i{@code{ratfac} pode somente ser
1295 escolhido para casos onde as componentes tensoriais sejam sabidametne consistidas de
1296 poucos termos.}
1298 Os esquemas de @code{ratfac} e de @code{ratweight} são incompatíveis e não podem
1299 ambos serem usados ao mesmo tempo.
1301 @c NEED EXAMPLES HERE
1302 @end defvr
1304 @deffn {Função} ratnumer (@var{expr})
1305 Retorna o numerador de @var{expr},
1306 após forçar @var{expr} para uma expressão racional canônica (CRE).
1307 O valor de retorno é uma CRE.
1309 @c ACTUALLY THE CONVERSION IS CARRIED OUT BY ratf BUT THAT'S WHAT $rat CALLS
1310 @var{expr} é forçada para uma CRE por @code{rat}
1311 se isso não for já uma CRE.
1312 Essa conversão pode alterar a forma de @var{expr} pela colocação de todos os termos
1313 sobre um denominador comum.
1315 @code{num} é similar, mas retorna uma expressão comum em lugar de uma CRE.
1316 Também, @code{num} não tenta colocar todos os termos sobre um denominador comum,
1317 e dessa forma algumas expressões que são consideradas razões por @code{ratnumer}
1318 não são consideradas razões por @code{num}.
1320 @c NEEDS AN EXAMPLE HERE
1321 @end deffn
1323 @deffn {Função} ratnump (@var{expr})
1324 Retorna @code{true} se @var{expr} for um inteiro literal ou razão de inteiros literais,
1325 de outra forma retorna @code{false}.
1327 @end deffn
1329 @deffn {Função} ratp (@var{expr})
1330 Retorna @code{true} se @var{expr} for uma expressão racional canônica (CRE) ou CRE extendida,
1331 de outra forma retorna @code{false}.
1333 CRE são criadas por @code{rat} e funções relacionadas.
1334 CRE extendidas são criadas por @code{taylor} e funções relacionadas.
1336 @end deffn
1338 @defvr {Variável de opção} ratprint
1339 Valor Padrão: @code{true}
1341 Quando @code{ratprint} for @code{true},
1342 uma mensagem informando ao usuário da conversão de números em ponto flutuante
1343 para números racionais é mostrada.
1345 @end defvr
1347 @deffn {Função} ratsimp (@var{expr})
1348 @deffnx {Função} ratsimp (@var{expr}, @var{x_1}, ..., @var{x_n})
1349 Simplifica a expressão @var{expr} e todas as suas subexpressões,
1350 incluindo os argumentos para funções não racionais.
1351 O resultado é retornado como o quociente de dois polinômios na forma recursiva,
1352 isto é, os coeficientes de variável principal são polinômios em outras variáveis.
1353 Variáveis podem incluir funções não racionais (e.g., @code{sin (x^2 + 1)})
1354 e os argumentos para quaisquer tais funções são também simplificados racionalmente.
1356 @code{ratsimp (@var{expr}, @var{x_1}, ..., @var{x_n})}
1357 habilita simplificação racional com a
1358 especiicação de variável ordenando como em @code{ratvars}.
1360 Quando @code{ratsimpexpons} for @code{true},
1361 @code{ratsimp} é aplicado para os expoentes de expressões durante a simplificação.
1363 Veja também @code{ratexpand}.
1364 Note que @code{ratsimp} é afetado por algum dos
1365 sinalizadores que afetam @code{ratexpand}.
1367 Exemplos:
1368 @c FOLLOWING GENERATED FROM THESE EXPRESSIONS
1369 @c sin (x/(x^2 + x)) = exp ((log(x) + 1)^2 - log(x)^2);
1370 @c ratsimp (%);
1371 @c ((x - 1)^(3/2) - (x + 1)*sqrt(x - 1))/sqrt((x - 1)*(x + 1));
1372 @c ratsimp (%);
1373 @c x^(a + 1/a), ratsimpexpons: true;
1375 @example
1376 (%i1) sin (x/(x^2 + x)) = exp ((log(x) + 1)^2 - log(x)^2);
1377 2 2
1378 x (log(x) + 1) - log (x)
1379 (%o1) sin(------) = %e
1380 2
1381 x + x
1382 (%i2) ratsimp (%);
1383 1 2
1384 (%o2) sin(-----) = %e x
1385 x + 1
1386 (%i3) ((x - 1)^(3/2) - (x + 1)*sqrt(x - 1))/sqrt((x - 1)*(x + 1));
1387 3/2
1388 (x - 1) - sqrt(x - 1) (x + 1)
1389 (%o3) --------------------------------
1390 sqrt((x - 1) (x + 1))
1391 (%i4) ratsimp (%);
1392 2 sqrt(x - 1)
1393 (%o4) - -------------
1394 2
1395 sqrt(x - 1)
1396 (%i5) x^(a + 1/a), ratsimpexpons: true;
1397 2
1398 a + 1
1399 ------
1400 a
1401 (%o5) x
1402 @end example
1404 @end deffn
1406 @defvr {Variável de opção} ratsimpexpons
1407 Valor Padrão: @code{false}
1409 Quando @code{ratsimpexpons} for @code{true},
1410 @code{ratsimp} é aplicado para os expoentes de expressões durante uma simplificação.
1412 @c NEED AN EXAMPLE HERE -- RECYCLE THE ratsimpexpons EXAMPLE FROM ratsimp ABOVE
1413 @end defvr
1415 @deffn {Função} ratsubst (@var{a}, @var{b}, @var{c})
1416 Substitue @var{a} por @var{b} em @var{c} e retorna a expressão resultante.
1417 @c "ETC" SUGGESTS THE READER KNOWS WHAT ELSE GOES THERE -- NOT LIKELY THE CASE
1418 @var{b} pode também ser uma adição, produto, expoente, etc.
1420 @c WHAT, EXACTLY, DOES ratsubst KNOW ??
1421 @code{ratsubst} sabe alguma coisa do significado de expressões
1422 uma vez que @code{subst} não é uma substituição puramente sintática.
1423 Dessa forma @code{subst (a, x + y, x + y + z)} retorna @code{x + y + z}
1424 ao passo que @code{ratsubst} retorna @code{z + a}.
1426 Quando @code{radsubstflag} for @code{true},
1427 @code{ratsubst} faz substituição de radicais em expressões
1428 que explicitamente não possuem esses radicais.
1430 Exemplos:
1431 @c EXAMPLES BELOW ADAPTED FROM examples (ratsubst)
1432 @c WITH SOME ADDITIONAL STUFF
1433 @c ratsubst (a, x*y^2, x^4*y^3 + x^4*y^8);
1434 @c cos(x)^4 + cos(x)^3 + cos(x)^2 + cos(x) + 1;
1435 @c ratsubst (1 - sin(x)^2, cos(x)^2, %);
1436 @c ratsubst (1 - cos(x)^2, sin(x)^2, sin(x)^4);
1437 @c radsubstflag: false$
1438 @c ratsubst (u, sqrt(x), x);
1439 @c radsubstflag: true$
1440 @c ratsubst (u, sqrt(x), x);
1442 @example
1443 (%i1) ratsubst (a, x*y^2, x^4*y^3 + x^4*y^8);
1444 3 4
1445 (%o1) a x y + a
1446 (%i2) cos(x)^4 + cos(x)^3 + cos(x)^2 + cos(x) + 1;
1447 4 3 2
1448 (%o2) cos (x) + cos (x) + cos (x) + cos(x) + 1
1449 (%i3) ratsubst (1 - sin(x)^2, cos(x)^2, %);
1450 4 2 2
1451 (%o3) sin (x) - 3 sin (x) + cos(x) (2 - sin (x)) + 3
1452 (%i4) ratsubst (1 - cos(x)^2, sin(x)^2, sin(x)^4);
1453 4 2
1454 (%o4) cos (x) - 2 cos (x) + 1
1455 (%i5) radsubstflag: false$
1456 (%i6) ratsubst (u, sqrt(x), x);
1457 (%o6) x
1458 (%i7) radsubstflag: true$
1459 (%i8) ratsubst (u, sqrt(x), x);
1460 2
1461 (%o8) u
1462 @end example
1464 @end deffn
1466 @deffn {Função} ratvars (@var{x_1}, ..., @var{x_n})
1467 @deffnx {Função} ratvars ()
1468 @deffnx {Variável de sistema} ratvars
1469 Declara variáveis principais @var{x_1}, ..., @var{x_n} para expressões racionais.
1470 @var{x_n}, se presente em uma expressão racional, é considerada a variável principal.
1471 De outra forma, @var{x_[n-1]} é considerada a variável principal se presente,
1472 e assim por diante até as variáveis precedentes para @var{x_1},
1473 que é considerada a variável principal somente se nenhuma das variáveis que a sucedem estiver presente.
1475 Se uma variável em uma expressão racional não está presente na lista @code{ratvars},
1476 a ela é dada uma prioridade menor que @var{x_1}.
1478 Os argumentos para @code{ratvars} podem ser ou variáveis ou funções não racionais
1479 tais como @code{sin(x)}.
1481 A variável @code{ratvars} é uma lista de argumentos da
1482 função @code{ratvars} quando ela foi chamada mais recentemente.
1483 Cada chamada para a função @code{ratvars} sobre-grava a lista apagando seu conteúdo anterior.
1484 @code{ratvars ()} limpa a lista.
1486 @c NEED EXAMPLES HERE
1487 @end deffn
1489 @deffn {Função} ratweight (@var{x_1}, @var{w_1}, ..., @var{x_n}, @var{w_n})
1490 @deffnx {Função} ratweight ()
1491 Atribui um peso @var{w_i} para a variável @var{x_i}.
1492 Isso faz com que um termo seja substituído por 0 se seu peso exceder o
1493 valor da variável @code{ratwtlvl} (o padrão retorna sem truncação).
1494 O peso de um termo é a soma dos produtos dos
1495 pesos de uma variável no termo vezes seu expoente.
1496 Por exemplo, o peso de @code{3 x_1^2 x_2} é @code{2 w_1 + w_2}.
1497 A truncação de acordo com @code{ratwtlvl} é realizada somente quando multiplicando
1498 ou exponencializando expressões racionais canônicas (CRE).
1500 @code{ratweight ()} retorna a lista cumulativa de atribuições de pesos.
1502 Nota: Os esquemas de @code{ratfac} e @code{ratweight} são incompatíveis e não podem
1503 ambo serem usados ao mesmo tempo.
1505 Exemplos:
1506 @c FOLLOWING GENERATED FROM THESE EXPRESSIONS
1507 @c ratweight (a, 1, b, 1);
1508 @c expr1: rat(a + b + 1)$
1509 @c expr1^2;
1510 @c ratwtlvl: 1$
1511 @c expr1^2;
1513 @example
1514 (%i1) ratweight (a, 1, b, 1);
1515 (%o1) [a, 1, b, 1]
1516 (%i2) expr1: rat(a + b + 1)$
1517 (%i3) expr1^2;
1518 2 2
1519 (%o3)/R/ b + (2 a + 2) b + a + 2 a + 1
1520 (%i4) ratwtlvl: 1$
1521 (%i5) expr1^2;
1522 (%o5)/R/ 2 b + 2 a + 1
1523 @end example
1525 @end deffn
1527 @defvr {Variável de sistema} ratweights
1528 Valor Padrão: @code{[]}
1530 @code{ratweights} é a lista de pesos atribuídos por @code{ratweight}.
1531 A lista é cumulativa:
1532 cada chamada a @code{ratweight} coloca ítens adicionais na lista.
1534 @c DO WE REALLY NEED TO MENTION THIS ??
1535 @code{kill (ratweights)} e @code{save (ratweights)} ambos trabalham como esperado.
1537 @end defvr
1539 @defvr {Variável de opção} ratwtlvl
1540 Valor Padrão: @code{false}
1542 @code{ratwtlvl} é usada em combinação com a função
1543 @code{ratweight} para controlar a truncação de expressão racionais canônicas (CRE).
1544 Para o valor padrão @code{false}, nenhuma truncação ocorre.
1546 @end defvr
1548 @deffn {Função} remainder (@var{p_1}, @var{p_2})
1549 @deffnx {Função} remainder (@var{p_1}, @var{p_2}, @var{x_1}, ..., @var{x_n})
1550 Retorna o resto do polinômio @var{p_1} dividido pelo polinômio @var{p_2}.
1551 Os argumentos @var{x_1}, ..., @var{x_n} são interpretados como em @code{ratvars}.
1553 @code{remainder} retorna o segundo elemento
1554 de uma lista de dois elementos retornada por @code{divide}.
1556 @c NEED SOME EXAMPLES HERE
1557 @end deffn
1559 @c CAN PROBABLY BE CLARIFIED
1560 @deffn {Função} resultant (@var{p_1}, @var{p_2}, @var{x})
1561 @deffnx {Variável} resultant
1562 Calcula o resultante de dois polinômios @var{p_1} e @var{p_2},
1563 eliminando a variável @var{x}.
1564 O resultante é um determinante dos coeficientes de @var{x}
1565 em @var{p_1} e @var{p_2},
1566 que é igual a zero
1567 se e somente se @var{p_1} e @var{p_2} tiverem um fator em comum não constante.
1569 Se @var{p_1} ou @var{p_2} puderem ser fatorados,
1570 pode ser desejável chamar @code{factor} antes de chamar @code{resultant}.
1572 A variável @code{resultant} controla que algorítmo será usado para calcular
1573 o resultante.
1574 @c WHAT DOES THE FOLLOWING MEAN EXACTLY ??
1575 @code{subres} para o prs subresultante,
1576 @code{mod} para o algorítmo resultante modular,
1577 e @code{red} para prs reduzido.
1578 Para muitos problemas @code{subres} pode ser melhor.
1579 Para alguns problemas com valores grandes de grau de uma única variável ou de duas variáveis @code{mod} pode ser melhor.
1581 A função @code{bezout} pega os mesmos argumentos que @code{resultant} e retorna
1582 uma matriz. O determinante do valor de retorno é o resultante desejado.
1584 @c NEED AN EXAMPLE HERE
1585 @end deffn
1587 @defvr {Variável de opção} savefactors
1588 Valor Padrão: @code{false}
1590 @c "certain functions" -- WHICH ONES ??
1591 Quando @code{savefactors} for @code{true}, faz com que os fatores de uma
1592 expressão que é um produto de fatores sejam gravados por certas
1593 funções com o objetivo de aumentar a velocidade em posteriores fatorações de expressões
1594 contendo algum desses mesmos fatores.
1596 @end defvr
1598 @c I CAN'T TELL WHAT THIS IS SUPPOSED TO BE ABOUT
1599 @deffn {Função} sqfr (@var{expr})
1600 é similar a @code{factor} exceto que os fatores do polinômio são "livres de raízes".
1601 Isto é, eles possuem fatores somente de grau um.
1602 Esse algorítmo, que é também usado no primeiro estágio de @code{factor}, utiliza
1603 o fato que um polinômio tem em comum com sua n'ésima derivada todos
1604 os seus fatores de grau maior que n. Dessa forma pegando o maior divisor comum
1605 com o polinômio das
1606 derivadas com relação a cada variável no polinômio, todos
1607 os fatores de grau maior que 1 podem ser achados.
1609 Exemplo:
1610 @c FOLLOWING GENERATED FROM THIS EXPRESSION
1611 @c sqfr (4*x^4 + 4*x^3 - 3*x^2 - 4*x - 1);
1613 @example
1614 (%i1) sqfr (4*x^4 + 4*x^3 - 3*x^2 - 4*x - 1);
1615 2 2
1616 (%o1) (2 x + 1) (x - 1)
1617 @end example
1619 @end deffn
1621 @c THIS ITEM STILL NEEDS WORK
1622 @deffn {Função} tellrat (@var{p_1}, ..., @var{p_n})
1623 @deffnx {Função} tellrat ()
1624 Adiciona ao anel dos inteiros algébricos conhecidos do Maxima
1625 os elementos que são as soluções dos polinômios @var{p_1}, ..., @var{p_n}.
1626 Cada argumento @var{p_i} é um polinômio concoeficientes inteiros.
1628 @code{tellrat (@var{x})} efetivamente significa substituir 0 por @var{x} em funções
1629 racionais.
1631 @code{tellrat ()} retorna uma lista das substituições correntes.
1633 @code{algebraic} deve ser escolhida para @code{true} com o objetivo de que a simplificação de
1634 inteiros algébricos tenha efeito.
1636 Maxima inicialmente sabe sobre a unidade imaginária @code{%i}
1637 e todas as raízes de inteiros.
1639 Existe um comando @code{untellrat} que pega kernels (núcleos) e
1640 remove propriedades @code{tellrat}.
1642 Quando fazemos @code{tellrat} em um polinômio
1643 de várias variáveis, e.g., @code{tellrat (x^2 - y^2)}, pode existir uma ambig@"{u}idade como para
1644 ou substituir @code{@var{y}^2} por @code{@var{x}^2}
1645 ou vice-versa.
1646 Maxima seleciona uma ordenação particular, mas se o usuário desejar especificar qual e.g.
1647 @code{tellrat (y^2 = x^2)} forneçe uma sintaxe que diga para substituir
1648 @code{@var{y}^2} por @code{@var{x}^2}.
1650 @c CAN'T TELL WHAT THIS IS ABOUT -- tellrat(w^3-1)$ algebraic:true$ rat(1/(w^2-w));
1651 @c DOES NOT YIELD AN ERROR, SO WHAT IS THE POINT ABOUT ratalgdenom ??
1652 @c When you @code{tellrat} reducible polinomials, you want to be careful not to
1653 @c attempt to rationalize a denominador with a zero divisor. E.g.
1654 @c tellrat(w^3-1)$ algebraic:true$ rat(1/(w^2-w)); will give "quotient by
1655 @c zero". This error can be avoided by setting @code{ratalgdenom} to @code{false}.
1657 Exemplos:
1658 @c EXAMPLE ADAPTED FROM example (tellrat)
1659 @c 10*(%i + 1)/(%i + 3^(1/3));
1660 @c ev (ratdisrep (rat(%)), algebraic);
1661 @c tellrat (1 + a + a^2);
1662 @c 1/(a*sqrt(2) - 1) + a/(sqrt(3) + sqrt(2));
1663 @c ev (ratdisrep (rat(%)), algebraic);
1664 @c tellrat (y^2 = x^2);
1666 @example
1667 (%i1) 10*(%i + 1)/(%i + 3^(1/3));
1668 10 (%i + 1)
1669 (%o1) -----------
1670 1/3
1671 %i + 3
1672 (%i2) ev (ratdisrep (rat(%)), algebraic);
1673 2/3 1/3 2/3 1/3
1674 (%o2) (4 3 - 2 3 - 4) %i + 2 3 + 4 3 - 2
1675 (%i3) tellrat (1 + a + a^2);
1676 2
1677 (%o3) [a + a + 1]
1678 (%i4) 1/(a*sqrt(2) - 1) + a/(sqrt(3) + sqrt(2));
1679 1 a
1680 (%o4) ------------- + -----------------
1681 sqrt(2) a - 1 sqrt(3) + sqrt(2)
1682 (%i5) ev (ratdisrep (rat(%)), algebraic);
1683 (7 sqrt(3) - 10 sqrt(2) + 2) a - 2 sqrt(2) - 1
1684 (%o5) ----------------------------------------------
1685 7
1686 (%i6) tellrat (y^2 = x^2);
1687 2 2 2
1688 (%o6) [y - x , a + a + 1]
1689 @end example
1691 @end deffn
1693 @deffn {Função} totaldisrep (@var{expr})
1694 Converte toda subexpressão de @var{expr} da forma de expressão racionais canônicas (CRE) para
1695 a forma geral e retorna o resultado.
1696 Se @var{expr} é em sí mesma na forma CRE então @code{totaldisrep} é identica a
1697 @code{ratdisrep}.
1699 @code{totaldisrep} pode ser usada para
1700 fazer um @code{ratdisrep} em expressões tais como equações, listas, matrizes, etc., que
1701 tiverem algumas subexpressões na forma CRE.
1703 @c NEED EXAMPLES HERE
1704 @end deffn
1706 @deffn {Função} untellrat (@var{x_1}, ..., @var{x_n})
1707 Remove propriedades @code{tellrat} de @var{x_1}, ..., @var{x_n}.
1709 @c NEED EXAMPLES HERE
1710 @end deffn