| blob | 72e255bf013ab3f9087fe97a5efa60de5efbbb0c |
1 @c /Polynomials.texi/1.22/Sun May 21 07:18:29 2006/-ko/
2 @c FOR THE FUNCTIONS WHICH RETURN A CRE, BE SURE TO MENTION THAT
3 @menu
4 * Introdução a Polinómios::
5 * Definições para Polinómios::
6 @end menu
8 @node Introdução a Polinómios, Definições para Polinómios, Polinómios, Polinómios
9 @section Introdução a Polinómios
11 Polinómios são armazenados no Maxima ou na forma geral ou na
12 forma de Expressões Racionais Canónicas (CRE). Essa última é uma forma
13 padrão, e é usada internamente por operações tais como @code{factor}, @code{ratsimp}, e
14 assim por diante.
16 Expressões Racionais Canónicas constituem um tipo de representação
17 que é especialmente adequado para polinómios expandidos e funções
18 racionais (também para polinómios parcialmente factorizados e funções
19 racionais quando RATFAC for escolhida para @code{true}). Nessa forma CRE uma
20 ordenação de variáveis (da mais para a menos importante) é assumida para cada
21 expressão. Polinómios são representados recursivamente por uma lista
22 consistindo da variável principal seguida por uma série de pares de
23 expressões, uma para cada termo do polinómio. O primeiro membro de
24 cada par é o expoente da variável principal naquele termo e o
25 segundo membro é o coeficiente daquele termo que pode ser um número ou
26 um polinómio em outra variável novamente respresentado nessa forma. Sendo assim
27 a parte principal da forma CRE de 3*X^2-1 é (X 2 3 0 -1) e que a parte principal da
28 forma CRE de 2*X*Y+X-3 é (Y 1 (X 1 2) 0 (X 1 1 0 -3)) assumindo Y como sendo a
29 variável principal, e é (X 1 (Y 1 2 0 1) 0 -3) assumindo X como sendo a
30 variável principal. A variável principal é usualmente determineda pela ordem alfabética
31 reversa. As "variáveis" de uma expressão CRE não necessariamente devem ser at@^omicas. De facto
32 qualquer subexpressão cujo principal operador não for + - * / or ^ com expoente
33 inteiro será considerado uma "variável" da expressão (na forma CRE) na
34 qual essa ocorrer. Por exemplo as variáveis CRE da expressão
35 X+SIN(X+1)+2*SQRT(X)+1 são X, SQRT(X), e SIN(X+1). Se o utilizador
36 não especifica uma ordem de variáveis pelo uso da função RATVARS
37 Maxima escolherá a alfabética por conta própria. Em geral, CREs representam
38 expressões racionais, isto é, razões de polinómios, onde o
39 numerador e o denominador não possuem factores comuns, e o denominador for
40 positivo. A forma interna é essencialmente um par de polinómios (o
41 numerador e o denominador) precedidos pela lista de ordenação de variável. Se
42 uma expressão a ser mostrada estiver na forma CRE ou se contiver quaisquer
43 subexpressões na forma CRE, o símbolo /R/ seguirá o rótulo da linha.
44 Veja a função RAT para saber como converter uma expressão para a forma CRE. Uma
45 forma CRE extendida é usada para a representação de séries de Taylor. A
46 noção de uma expressão racional é extendida de modo que os expoentes das
47 variáveis podem ser números racionais positivos ou negativos em lugar de apenas
48 inteiros positivos e os coeficientes podem eles mesmos serem expressões
49 racionais como descrito acima em lugar de apenas polinómios. Estes são
50 representados internamente por uma forma polinomial recursiva que é similar
51 à forma CRE e é a generalização dessa mesma forma CRE, mas carrega informação
52 adicional tal com o grau de truncação. Do mesmo modo que na forma CRE, o
53 símbolo /T/ segue o rótulo de linha que contém as tais expressões.
55 @node Definições para Polinómios, , Introdução a Polinómios, Polinómios
56 @section Definições para Polinómios
58 @defvr {Variável de opção} algebraic
59 Valor Padrão: @code{false}
61 @code{algebraic} deve ser escolhida para @code{true} com o objectivo de que a
62 simplificação de inteiros algébricos tenha efeito.
64 @end defvr
66 @defvr {Variável de opção} berlefact
67 Valor Padrão: @code{true}
69 Quando @code{berlefact} for @code{false} então o algoritmo de factorização de
70 Kronecker será usado. De outra forma o algoritmo de Berlekamp, que é o
71 padrão, será usado.
73 @end defvr
75 @c WHAT IS THIS ABOUT EXACTLY ??
76 @deffn {Função} bezout (@var{p1}, @var{p2}, @var{x})
77 uma alternativa para o comando @code{resultant}. Isso
78 retorna uma matriz. @code{determinant} dessa matriz é o resultante desejado.
80 @end deffn
82 @c REWORD THIS ITEM -- COULD BE MORE CONCISE
83 @deffn {Função} bothcoef (@var{expr}, @var{x})
84 Retorna uma lista da qual o primeiro membro é o
85 coeficiente de @var{x} em @var{expr} (como achado por @code{ratcoef} se @var{expr} está na forma CRE
86 de outro modo por @code{coeff}) e cujo segundo membro é a parte restante de
87 @var{expr}. Isto é, @code{[A, B]} onde @code{@var{expr} = A*@var{x} + B}.
89 Exemplo:
90 @c FOLLOWING GENERATED FROM THESE EXPRESSIONS
91 @c islinear (expr, x) := block ([c],
92 @c c: bothcoef (rat (expr, x), x),
93 @c é (freeof (x, c) and c[1] # 0))$
94 @c islinear ((r^2 - (x - r)^2)/x, x);
96 @example
97 (%i1) islinear (expr, x) := block ([c],
98 c: bothcoef (rat (expr, x), x),
99 é (freeof (x, c) and c[1] # 0))$
100 (%i2) islinear ((r^2 - (x - r)^2)/x, x);
101 (%o2) true
102 @end example
104 @end deffn
106 @deffn {Função} coeff (@var{expr}, @var{x}, @var{n})
107 Retorna o coeficiente de @code{@var{x}^@var{n}} em @var{expr}. @var{n} pode ser
108 omitido se for 1. @var{x} pode ser um átomo, ou subexpressão completa de
109 @var{expr} e.g., @code{sin(x)}, @code{a[i+1]}, @code{x + y}, etc. (No último caso a
110 expressão @code{(x + y)} pode ocorrer em @var{expr}). Algumas vezes isso pode ser necessário
111 para expandir ou factorizar @var{expr} com o objectivo de fazer @code{@var{x}^@var{n}} explicito. Isso não é
112 realizado por @code{coeff}.
114 Exemplos:
115 @c FOLLOWING GENERATED FROM THESE EXPRESSIONS
116 @c coeff (2*a*tan(x) + tan(x) + b = 5*tan(x) + 3, tan(x));
117 @c coeff (y + x*%e^x + 1, x, 0);
119 @example
120 (%i1) coeff (2*a*tan(x) + tan(x) + b = 5*tan(x) + 3, tan(x));
121 (%o1) 2 a + 1 = 5
122 (%i2) coeff (y + x*%e^x + 1, x, 0);
123 (%o2) y + 1
124 @end example
126 @end deffn
128 @deffn {Função} combine (@var{expr})
129 Simplifica a adição @var{expr} por termos combinados com o mesmo
130 denominador dentro de um termo simples.
132 @c NEED EXAMPLE HERE
133 @end deffn
135 @deffn {Função} content (@var{p_1}, @var{x_1}, ..., @var{x_n})
136 Retorna uma lista cujo primeiro elemento é
137 o máximo divisor comum dos coeficientes dos termos do
138 polinómio @var{p_1} na variável @var{x_n} (isso é o conteúdo) e cujo
139 segundo elemento é o polinómio @var{p_1} dividido pelo conteúdo.
140 @c APPEARS TO WORK AS ADVERTISED -- ONLY x_n HAS ANY EFFECT ON THE RESULT
141 @c WHAT ARE THE OTHER VARIABLES x_1 THROUGH x_{n-1} FOR ??
143 Exemplos:
144 @c FOLLOWING GENERATED FROM THESE EXPRESSIONS
145 @c content (2*x*y + 4*x^2*y^2, y);
147 @example
148 (%i1) content (2*x*y + 4*x^2*y^2, y);
149 2
150 (%o1) [2 x, 2 x y + y]
151 @end example
153 @end deffn
155 @deffn {Função} denom (@var{expr})
156 Retorna o denominador da expressão racional @var{expr}.
158 @end deffn
160 @deffn {Função} divide (@var{p_1}, @var{p_2}, @var{x_1}, ..., @var{x_n})
161 calcula o quocietne e o resto
162 do polinómio @var{p_1} dividido pelo polinómio @var{p_2}, na variável
163 principal do polinómio, @var{x_n}.
164 @c SPELL OUT THE PURPOSE OF THE OTHER VARIABLES
165 As outras variáveis são como na função @code{ratvars}.
166 O resultado é uma lista cujo primeiro elemento é o quociente
167 e cujo segundo elemento é o resto.
169 Exemplos:
170 @c FOLLOWING GENERATED FROM THESE EXPRESSIONS
171 @c divide (x + y, x - y, x);
172 @c divide (x + y, x - y);
174 @example
175 (%i1) divide (x + y, x - y, x);
176 (%o1) [1, 2 y]
177 (%i2) divide (x + y, x - y);
178 (%o2) [- 1, 2 x]
179 @end example
181 @noindent
182 Note que @code{y} é a variável principal no segundo exemplo.
184 @end deffn
186 @deffn {Função} eliminate ([@var{eqn_1}, ..., @var{eqn_n}], [@var{x_1}, ..., @var{x_k}])
187 Elimina variáveis de
188 equações (ou expressões assumidas iguais a zero) obtendo resultantes
189 sucessivos. Isso retorna uma lista de @code{@var{n} - @var{k}} expressões com @var{k}
190 variáveis @var{x_1}, ..., @var{x_k} eliminadas. Primeiro @var{x_1} é eliminado retornando @code{@var{n} - 1}
191 expressões, então @code{x_2} é eliminado, etc. Se @code{@var{k} = @var{n}} então uma expressão simples em uma
192 lista é retornada livre das variáveis @var{x_1}, ..., @var{x_k}. Nesse caso @code{solve}
193 é chamado para resolver a última resultante para a última variável.
195 Exemplo:
196 @c FOLLOWING GENERATED FROM THESE EXPRESSIONS
197 @c expr1: 2*x^2 + y*x + z;
198 @c expr2: 3*x + 5*y - z - 1;
199 @c expr3: z^2 + x - y^2 + 5;
200 @c eliminate ([expr3, expr2, expr1], [y, z]);
202 @example
203 (%i1) expr1: 2*x^2 + y*x + z;
204 2
205 (%o1) z + x y + 2 x
206 (%i2) expr2: 3*x + 5*y - z - 1;
207 (%o2) - z + 5 y + 3 x - 1
208 (%i3) expr3: z^2 + x - y^2 + 5;
209 2 2
210 (%o3) z - y + x + 5
211 (%i4) eliminate ([expr3, expr2, expr1], [y, z]);
212 8 7 6 5 4
213 (%o4) [7425 x - 1170 x + 1299 x + 12076 x + 22887 x
215 3 2
216 - 5154 x - 1291 x + 7688 x + 15376]
217 @end example
219 @end deffn
221 @deffn {Função} ezgcd (@var{p_1}, @var{p_2}, @var{p_3}, ...)
222 Retorna uma lista cujo primeiro elemento é o m.d.c. dos
223 polinómios @var{p_1}, @var{p_2}, @var{p_3}, ... e cujos restantes elementos são os
224 polinómios divididos pelo mdc. Isso sempre usa o algoritmo
225 @code{ezgcd}.
227 @end deffn
229 @defvr {Variável de opção} facexpand
230 Valor Padrão: @code{true}
232 @code{facexpand} controla se os factores irredutíveis
233 retornados por @code{factor} estão na forma expandida (o padrão) ou na forma recursiva
234 (CRE normal).
236 @end defvr
238 @deffn {Função} factcomb (@var{expr})
239 Tenta combinar os coeficientes de factoriais em @var{expr}
240 com os próprios factoriais convertendo, por exemplo, @code{(n + 1)*n!}
241 em @code{(n + 1)!}.
243 @code{sumsplitfact} se escolhida para @code{false} fará com que @code{minfactorial} seja
244 aplicado após um @code{factcomb}.
246 @c Example:
247 @c UH, THESE ARE THE EXPRESSIONS WHICH WERE GIVEN IN
248 @c THE PREVIOUS REVISION OF THIS FILE, BUT IN THIS CASE
249 @c factcomb HAS NO EFFECT -- I GUESS A DIFFERENT EXAMPLE IS CALLED FOR
250 @c (n + 1)^b*n!^b;
251 @c factcomb (%);
252 @end deffn
254 @deffn {Função} factor (@var{expr})
255 @deffnx {Função} factor (@var{expr}, @var{p})
257 Factoriza a expressão @var{expr}, contendo qualquer número de
258 variáveis ou funções, em factores irredutíveis sobre os inteiros.
259 @code{factor (@var{expr}, @var{p})} factoriza @var{expr} sobre o campo dos inteiros com um elemento
260 adjunto cujo menor polinómio é @var{p}.
262 @code{factor} usa a função @code{ifactors} para factorizar inteiros.
264 @code{factorflag} se @code{false} suprime a factorização de factores inteiros
265 de expressões racionais.
267 @code{dontfactor} pode ser escolhida para uma lista de variáveis com relação à qual
268 factorização não é para ocorrer. (Essa é inicialmente vazia). Factorização também
269 não acontece com relação a quaisquer variáveis que são menos
270 importantes (usando a ordenação de variável assumida pela forma CRE) como
271 essas na lista @code{dontfactor}.
273 @code{savefactors} se @code{true} faz com que os factores de uma expressão que
274 é um produto de factores seja guardada por certas funções com o objectivo de
275 aumentar a velocidade de futuras factorizações de expressões contendo alguns dos
276 mesmos factores.
278 @code{berlefact} se @code{false} então o algoritmo de factorização de Kronecker será
279 usado de outra forma o algoritmo de Berlekamp, que é o padrão, será
280 usado.
282 @code{intfaclim} se @code{true} maxima irá interromper a factorização de
283 inteiros se nenhum factor for encontrado após tentar divisões e o método rho de
284 Pollard. Se escolhida para @code{false} (esse é o caso quando o utilizador chama
285 @code{factor} explicitamente), a factorização completa do inteiro será
286 tentada. A escolha do utilizador para @code{intfaclim} é usada para chamadas
287 internas a @code{factor}. Dessa forma, @code{intfaclim} pode ser resetada para evitar que o
288 Maxima gaste um tempo muito longo factorizando inteiros grandes.
290 Exemplos:
291 @c EXAMPLES BELOW ADAPTED FROM examples (factor)
292 @c factor (2^63 - 1);
293 @c factor (-8*y - 4*x + z^2*(2*y + x));
294 @c -1 - 2*x - x^2 + y^2 + 2*x*y^2 + x^2*y^2;
295 @c block ([dontfactor: [x]], factor (%/36/(1 + 2*y + y^2)));
296 @c factor (1 + %e^(3*x));
297 @c factor (1 + x^4, a^2 - 2);
298 @c factor (-y^2*z^2 - x*z^2 + x^2*y^2 + x^3);
299 @c (2 + x)/(3 + x)/(b + x)/(c + x)^2;
300 @c ratsimp (%);
301 @c partfrac (%, x);
302 @c map ('factor, %);
303 @c ratsimp ((x^5 - 1)/(x - 1));
304 @c subst (a, x, %);
305 @c factor (%th(2), %);
306 @c factor (1 + x^12);
307 @c factor (1 + x^99);
309 @example
310 (%i1) factor (2^63 - 1);
311 2
312 (%o1) 7 73 127 337 92737 649657
313 (%i2) factor (-8*y - 4*x + z^2*(2*y + x));
314 (%o2) (2 y + x) (z - 2) (z + 2)
315 (%i3) -1 - 2*x - x^2 + y^2 + 2*x*y^2 + x^2*y^2;
316 2 2 2 2 2
317 (%o3) x y + 2 x y + y - x - 2 x - 1
318 (%i4) block ([dontfactor: [x]], factor (%/36/(1 + 2*y + y^2)));
319 2
320 (x + 2 x + 1) (y - 1)
321 (%o4) ----------------------
322 36 (y + 1)
323 (%i5) factor (1 + %e^(3*x));
324 x 2 x x
325 (%o5) (%e + 1) (%e - %e + 1)
326 (%i6) factor (1 + x^4, a^2 - 2);
327 2 2
328 (%o6) (x - a x + 1) (x + a x + 1)
329 (%i7) factor (-y^2*z^2 - x*z^2 + x^2*y^2 + x^3);
330 2
331 (%o7) - (y + x) (z - x) (z + x)
332 (%i8) (2 + x)/(3 + x)/(b + x)/(c + x)^2;
333 x + 2
334 (%o8) ------------------------
335 2
336 (x + 3) (x + b) (x + c)
337 (%i9) ratsimp (%);
338 4 3
339 (%o9) (x + 2)/(x + (2 c + b + 3) x
341 2 2 2 2
342 + (c + (2 b + 6) c + 3 b) x + ((b + 3) c + 6 b c) x + 3 b c )
343 (%i10) partfrac (%, x);
344 2 4 3
345 (%o10) - (c - 4 c - b + 6)/((c + (- 2 b - 6) c
347 2 2 2 2
348 + (b + 12 b + 9) c + (- 6 b - 18 b) c + 9 b ) (x + c))
350 c - 2
351 - ---------------------------------
352 2 2
353 (c + (- b - 3) c + 3 b) (x + c)
355 b - 2
356 + -------------------------------------------------
357 2 2 3 2
358 ((b - 3) c + (6 b - 2 b ) c + b - 3 b ) (x + b)
360 1
361 - ----------------------------------------------
362 2
363 ((b - 3) c + (18 - 6 b) c + 9 b - 27) (x + 3)
364 (%i11) map ('factor, %);
365 2
366 c - 4 c - b + 6 c - 2
367 (%o11) - ------------------------- - ------------------------
368 2 2 2
369 (c - 3) (c - b) (x + c) (c - 3) (c - b) (x + c)
371 b - 2 1
372 + ------------------------ - ------------------------
373 2 2
374 (b - 3) (c - b) (x + b) (b - 3) (c - 3) (x + 3)
375 (%i12) ratsimp ((x^5 - 1)/(x - 1));
376 4 3 2
377 (%o12) x + x + x + x + 1
378 (%i13) subst (a, x, %);
379 4 3 2
380 (%o13) a + a + a + a + 1
381 (%i14) factor (%th(2), %);
382 2 3 3 2
383 (%o14) (x - a) (x - a ) (x - a ) (x + a + a + a + 1)
384 (%i15) factor (1 + x^12);
385 4 8 4
386 (%o15) (x + 1) (x - x + 1)
387 (%i16) factor (1 + x^99);
388 2 6 3
389 (%o16) (x + 1) (x - x + 1) (x - x + 1)
391 10 9 8 7 6 5 4 3 2
392 (x - x + x - x + x - x + x - x + x - x + 1)
394 20 19 17 16 14 13 11 10 9 7 6
395 (x + x - x - x + x + x - x - x - x + x + x
397 4 3 60 57 51 48 42 39 33
398 - x - x + x + 1) (x + x - x - x + x + x - x
400 30 27 21 18 12 9 3
401 - x - x + x + x - x - x + x + 1)
402 @end example
404 @end deffn
406 @defvr {Variável de opção} factorflag
407 Valor Padrão: @code{false}
409 @c WHAT IS THIS ABOUT EXACTLY ??
410 Quando @code{factorflag} for @code{false}, suprime a factorização de
411 factores inteiros em expressões racionais.
413 @end defvr
415 @deffn {Função} factorout (@var{expr}, @var{x_1}, @var{x_2}, ...)
416 Rearranja a adição @var{expr} em uma adição de
417 parcelas da forma @code{f (@var{x_1}, @var{x_2}, ...)*g} onde @code{g} é um produto de
418 expressões que não possuem qualquer @var{x_i} e @code{f} é factorizado.
419 @c NEED EXAMPLE HERE
421 @end deffn
423 @deffn {Função} factorsum (@var{expr})
424 Tenta agrupar parcelas em factores de @var{expr} que são adições
425 em grupos de parcelas tais que sua adição é factorável. @code{factorsum} pode
426 recuperar o resultado de @code{expand ((x + y)^2 + (z + w)^2)} mas não pode recuperar
427 @code{expand ((x + 1)^2 + (x + y)^2)} porque os termos possuem variáveis em comum.
429 Exemplo:
430 @c FOLLOWING GENERATED FROM THESE EXPRESSIONS
431 @c expand ((x + 1)*((u + v)^2 + a*(w + z)^2));
432 @c factorsum (%);
434 @example
435 (%i1) expand ((x + 1)*((u + v)^2 + a*(w + z)^2));
436 2 2 2 2
437 (%o1) a x z + a z + 2 a w x z + 2 a w z + a w x + v x
439 2 2 2 2
440 + 2 u v x + u x + a w + v + 2 u v + u
441 (%i2) factorsum (%);
442 2 2
443 (%o2) (x + 1) (a (z + w) + (v + u) )
444 @end example
446 @end deffn
448 @deffn {Função} fasttimes (@var{p_1}, @var{p_2})
449 Retorna o produto dos polinómios @var{p_1} e @var{p_2} usando um
450 algoritmo especial para a multiplicação de polinómios. @code{p_1} e @code{p_2} podem ser
451 de várias variáveis, densos, e aproximadamente do mesmo tamanho. A multiplicação
452 clássica é de ordem @code{n_1 n_2} onde
453 @code{n_1} é o grau de @code{p_1}
454 and @code{n_2} é o grau de @code{p_2}.
455 @code{fasttimes} é da ordem @code{max (n_1, n_2)^1.585}.
457 @end deffn
459 @deffn {Função} fullratsimp (@var{expr})
460 @code{fullratsimp} aplica
461 repetidamente @code{ratsimp} seguido por simplificação não racional a uma
462 expressão até que nenhuma mudança adicional ocorra,
463 e retorna o resultado.
465 Quando expressões não racionais estão envolvidas, uma chamada
466 a @code{ratsimp} seguida como é usual por uma simplificação não racional
467 ("geral") pode não ser suficiente para retornar um resultado simplificado.
468 Algumas vezes, mais que uma tal chamada pode ser necessária.
469 @code{fullratsimp} faz esse processo convenientemente.
471 @code{fullratsimp (@var{expr}, @var{x_1}, ..., @var{x_n})} aceita um ou
472 mais argumentos similar a @code{ratsimp} e @code{rat}.
474 Exemplo:
475 @c FOLLOWING GENERATED FROM THESE EXPRESSIONS
476 @c expr: (x^(a/2) + 1)^2*(x^(a/2) - 1)^2/(x^a - 1);
477 @c ratsimp (expr);
478 @c fullratsimp (expr);
479 @c rat (expr);
481 @example
482 (%i1) expr: (x^(a/2) + 1)^2*(x^(a/2) - 1)^2/(x^a - 1);
483 a/2 2 a/2 2
484 (x - 1) (x + 1)
485 (%o1) -----------------------
486 a
487 x - 1
488 (%i2) ratsimp (expr);
489 2 a a
490 x - 2 x + 1
491 (%o2) ---------------
492 a
493 x - 1
494 (%i3) fullratsimp (expr);
495 a
496 (%o3) x - 1
497 (%i4) rat (expr);
498 a/2 4 a/2 2
499 (x ) - 2 (x ) + 1
500 (%o4)/R/ -----------------------
501 a
502 x - 1
503 @end example
505 @end deffn
507 @c SPELL OUT WHAT fullratsubst DOES INSTEAD OF ALLUDING TO ratsubst AND lratsubst
508 @c THIS ITEM NEEDS MORE WORK
509 @deffn {Função} fullratsubst (@var{a}, @var{b}, @var{c})
510 é o mesmo que @code{ratsubst} excepto que essa chama
511 a si mesma recursivamente sobre esse resultado até que o resultado para de mudar.
512 Essa função é útil quando a expressão de substituição e a
513 expressão substituída tenham uma ou mais variáveis em comum.
515 @code{fullratsubst} irá também aceitar seus argumentos no formato de
516 @code{lratsubst}. Isto é, o primeiro argumento pode ser uma substituição simples
517 de equação ou uma lista de tais equações, enquanto o segundo argumento é a
518 expressão sendo processada.
520 @code{load ("lrats")} chama @code{fullratsubst} e @code{lratsubst}.
522 Exemplos:
523 @c EXPRESSIONS ADAPTED FROM demo ("lrats")
524 @c CAN PROBABLY CUT OUT THE lratsubst STUFF (lratsubst HAS ITS OWN DESCRIPTION)
525 @c load ("lrats")$
526 @c subst ([a = b, c = d], a + c);
527 @c lratsubst ([a^2 = b, c^2 = d], (a + e)*c*(a + c));
528 @c lratsubst (a^2 = b, a^3);
529 @c ratsubst (b*a, a^2, a^3);
530 @c fullratsubst (b*a, a^2, a^3);
531 @c fullratsubst ([a^2 = b, b^2 = c, c^2 = a], a^3*b*c);
532 @c fullratsubst (a^2 = b*a, a^3);
533 @c errcatch (fullratsubst (b*a^2, a^2, a^3));
535 @example
536 (%i1) load ("lrats")$
537 @end example
538 @itemize @bullet
539 @item
540 @code{subst} pode realizar multiplas substituições.
541 @code{lratsubst} é analogo a @code{subst}.
542 @end itemize
543 @example
544 (%i2) subst ([a = b, c = d], a + c);
545 (%o2) d + b
546 (%i3) lratsubst ([a^2 = b, c^2 = d], (a + e)*c*(a + c));
547 (%o3) (d + a c) e + a d + b c
548 @end example
549 @itemize @bullet
550 @item
551 Se somente uma substituição é desejada, então uma equação
552 simples pode ser dada como primeiro argumento.
553 @end itemize
554 @example
555 (%i4) lratsubst (a^2 = b, a^3);
556 (%o4) a b
557 @end example
558 @itemize @bullet
559 @item
560 @code{fullratsubst} é equivalente a @code{ratsubst}
561 excepto que essa executa recursivamente até que seu resultado para de mudar.
562 @end itemize
563 @example
564 (%i5) ratsubst (b*a, a^2, a^3);
565 2
566 (%o5) a b
567 (%i6) fullratsubst (b*a, a^2, a^3);
568 2
569 (%o6) a b
570 @end example
571 @itemize @bullet
572 @item
573 @code{fullratsubst} também aceita uma lista de equações ou uma equação
574 simples como primeiro argumento.
575 @end itemize
576 @example
577 (%i7) fullratsubst ([a^2 = b, b^2 = c, c^2 = a], a^3*b*c);
578 (%o7) b
579 (%i8) fullratsubst (a^2 = b*a, a^3);
580 2
581 (%o8) a b
582 @end example
583 @itemize @bullet
584 @item
585 @c REWORD THIS SENTENCE
586 @code{fullratsubst} pode causar uma recursão infinita.
587 @end itemize
588 @example
589 (%i9) errcatch (fullratsubst (b*a^2, a^2, a^3));
591 *** - Lisp stack overflow. RESET
592 @end example
594 @end deffn
596 @c GCD IS A VARIABLE AND A FUNCTION
597 @c THIS ITEM NEEDS A LOT OF WORK
598 @deffn {Função} gcd (@var{p_1}, @var{p_2}, @var{x_1}, ...)
599 Retorna o máximo divisor comum entre @var{p_1} e @var{p_2}.
600 O sinalizador @code{gcd} determina qual algoritmo é empregado.
601 Escolhendo @code{gcd} para @code{ez}, @code{subres}, @code{red}, ou @code{spmod} selecciona o algoritmo @code{ezgcd},
602 subresultante @code{prs}, reduzido, ou modular,
603 respectivamente. Se @code{gcd} for @code{false} então @code{gcd (@var{p_1}, @var{p_2}, @var{x})} sempre retorna 1
604 para todo @var{x}. Muitas funções (e.g. @code{ratsimp}, @code{factor}, etc.) fazem com que mdc's
605 sejam feitos implicitamente. Para polinómios homogêneos é recomendado
606 que @code{gcd} igual a @code{subres} seja usado. Para obter o mdc quando uma expressão algébrica está
607 presente, e.g. @code{gcd (@var{x}^2 - 2*sqrt(2)*@var{x} + 2, @var{x} - sqrt(2))}, @code{algebraic} deve ser
608 @code{true} e @code{gcd} não deve ser @code{ez}. @code{subres} é um novo algoritmo, e pessoas
609 que tenham estado usando a opção @code{red} podem provavelmente alterar isso para
610 @code{subres}.
612 O sinalizador @code{gcd}, padrão: @code{subres}, se @code{false} irá também evitar o máximo
613 divisor comum de ser usado quando expressões são convertidas para a forma de expressão racional
614 canónica (CRE). Isso irá algumas vezes aumentar a velocidade dos cálculos se mdc's não são
615 requeridos.
616 @c NEEDS EXAMPLES HERE
618 @end deffn
620 @c IN NEED OF SERIOUS CLARIFICATION HERE
621 @deffn {Função} gcdex (@var{f}, @var{g})
622 @deffnx {Função} gcdex (@var{f}, @var{g}, @var{x})
623 Retornam uma lista @code{[@var{a}, @var{b}, @var{u}]}
624 onde @var{u} é o máximo divisor comum (mdc) entre @var{f} e @var{g},
625 e @var{u} é igual a @code{@var{a} @var{f} + @var{b} @var{g}}.
626 Os argumentos @var{f} e @var{g} podem ser polinómios de uma variável,
627 ou de outra forma polinómios em @var{x} uma @b{main}(principal) variável suprida
628 desde que nós precisamos estar em um domínio de ideal principal para isso trabalhar.
629 O mdc significa o mdc considerando @var{f} e @var{g} como polinómios de uma única variável com coeficientes
630 sendo funções racionais em outras variáveis.
632 @code{gcdex} implementa o algoritmo Euclideano,
633 onde temos a sequência
634 of @code{L[i]: [a[i], b[i], r[i]]} que são todos perpendiculares
635 a @code{[f, g, -1]} e o próximo se é construído como
636 se @code{q = quotient(r[i]/r[i+1])} então @code{L[i+2]: L[i] - q L[i+1]}, e isso
637 encerra em @code{L[i+1]} quando o resto @code{r[i+2]} for zero.
639 @c FOLLOWING GENERATED FROM THESE EXPRESSIONS
640 @c gcdex (x^2 + 1, x^3 + 4);
641 @c % . [x^2 + 1, x^3 + 4, -1];
643 @example
644 (%i1) gcdex (x^2 + 1, x^3 + 4);
645 2
646 x + 4 x - 1 x + 4
647 (%o1)/R/ [- ------------, -----, 1]
648 17 17
649 (%i2) % . [x^2 + 1, x^3 + 4, -1];
650 (%o2)/R/ 0
651 @end example
653 @c SORRY FOR BEING DENSE BUT WHAT IS THIS ABOUT EXACTLY
654 Note que o mdc adiante é @code{1}
655 uma vez que trabalhamos em @code{k(y)[x]}, o @code{y+1} não pode ser esperado em @code{k[y, x]}.
657 @c FOLLOWING GENERATED FROM THESE EXPRESSIONS
658 @c gcdex (x*(y + 1), y^2 - 1, x);
660 @example
661 (%i1) gcdex (x*(y + 1), y^2 - 1, x);
662 1
663 (%o1)/R/ [0, ------, 1]
664 2
665 y - 1
666 @end example
668 @end deffn
671 @c CHOOSE ONE CHARACTERIZATION OF "GAUSSIAN INTEGERS" AND USE IT WHERE GAUSSIAN INTEGERS ARE REFERENCED
672 @deffn {Função} gcfactor (@var{n})
673 Factoriza o inteiro Gaussiano @var{n} sobre os inteiros Gaussianos, i.e.,
674 números da forma @code{@var{a} + @var{b} @code{%i}} onde @var{a} e @var{b} são inteiros raconais
675 (i.e., inteiros comuns). Factorizações são normalizadas fazendo @var{a} e @var{b}
676 não negativos.
677 @c NEED EXAMPLES HERE
679 @end deffn
681 @c CHOOSE ONE CHARACTERIZATION OF "GAUSSIAN INTEGERS" AND USE IT WHERE GAUSSIAN INTEGERS ARE REFERENCED
682 @deffn {Função} gfactor (@var{expr})
683 Factoriza o polinómio @var{expr} sobre os inteiros de Gauss
684 (isto é, os inteiros com a unidade imaginária @code{%i} adjunta).
685 @c "This is like" -- IS IT THE SAME OR NOT ??
686 Isso é como @code{factor (@var{expr}, @var{a}^2+1)} trocando @var{a} por @code{%i}.
688 Exemplo:
689 @c FOLLOWING GENERATED FROM THESE EXPRESSIONS
690 @c gfactor (x^4 - 1);
692 @example
693 (%i1) gfactor (x^4 - 1);
694 (%o1) (x - 1) (x + 1) (x - %i) (x + %i)
695 @end example
697 @end deffn
699 @c DESCRIBE THIS INDEPENDENTLY OF factorsum
700 @c THIS ITEM NEEDS MORE WORK
701 @deffn {Função} gfactorsum (@var{expr})
702 é similar a @code{factorsum} mas aplica @code{gfactor} em lugar
703 de @code{factor}.
705 @end deffn
707 @deffn {Função} hipow (@var{expr}, @var{x})
708 Retorna o maior expoente explícito de @var{x} em @var{expr}.
709 @var{x} pode ser uma variável ou uma expressão geral.
710 Se @var{x} não aparece em @var{expr},
711 @code{hipow} retorna @code{0}.
713 @code{hipow} não considera expressões equivalentes a @code{expr}.
714 Em particular, @code{hipow} não expande @code{expr},
715 então @code{hipow (@var{expr}, @var{x})} e @code{hipow (expand (@var{expr}, @var{x}))}
716 podem retornar diferentes resultados.
718 Exemplos:
720 @example
721 (%i1) hipow (y^3 * x^2 + x * y^4, x);
722 (%o1) 2
723 (%i2) hipow ((x + y)^5, x);
724 (%o2) 1
725 (%i3) hipow (expand ((x + y)^5), x);
726 (%o3) 5
727 (%i4) hipow ((x + y)^5, x + y);
728 (%o4) 5
729 (%i5) hipow (expand ((x + y)^5), x + y);
730 (%o5) 0
731 @end example
733 @end deffn
735 @defvr {Variável de opção} intfaclim
736 Valor por omissão: true
738 Se @code{true}, maxima irá interromper a factorização de
739 inteiros se nenhum factor for encontrado após tentar divisões e o método rho de
740 Pollard e a factorização não será completada.
742 Quando @code{intfaclim} for @code{false} (esse é o caso quando o utilizador
743 chama @code{factor} explicitamente), a factorização completa será
744 tentada. @code{intfaclim} é escolhida para @code{false} quando factores são
745 calculados em @code{divisors}, @code{divsum} e @code{totient}.
746 @c ANY OTHERS ??
748 @c WHAT ARE THESE MYSTERIOUS INTERNAL CALLS ?? (LET'S JUST LIST THE FUNCTIONS INVOLVED)
749 Chamadas internas a @code{factor} respeitam o valor especificado pelo utilizador para
750 @code{intfaclim}. Setting @code{intfaclim} to @code{true} may reduce
751 @code{intfaclim}. Escolhendo @code{intfaclim} para @code{true} podemos reduzir
752 o tempo gasto factorizando grandes inteiros.
753 @c NEED EXAMPLES HERE
755 @end defvr
757 @defvr {Variável de opção} keepfloat
758 Valor Padrão: @code{false}
760 Quando @code{keepfloat} for @code{true}, evitamos que números
761 em ponto flutuante sejam racionalizados quando expressões que os possuem
762 são então convertidas para a forma de expressão racional canónica (CRE).
763 @c NEED EXAMPLES HERE
765 @end defvr
767 @c DESCRIBE lratsubst INDEPENDENTLY OF subst
768 @c THIS ITEM NEEDS MORE WORK
769 @deffn {Função} lratsubst (@var{L}, @var{expr})
770 é análogo a @code{subst (@var{L}, @var{expr})}
771 excepto que esse usa @code{ratsubst} em lugar de @code{subst}.
773 O primeiro argumento de
774 @code{lratsubst} é uma equação ou uma lista de equações idênticas em
775 formato para que sejam aceitas por @code{subst}. As
776 substituições são feitas na ordem dada pela lista de equações,
777 isto é, da esquerda para a direita.
779 @code{load ("lrats")} chama @code{fullratsubst} e @code{lratsubst}.
781 Exemplos:
782 @c EXPRESSIONS ADAPTED FROM demo ("lrats")
783 @c THIS STUFF CAN PROBABLY STAND REVISION -- EXAMPLES DON'T SEEM VERY ENLIGHTENING
784 @c load ("lrats")$
785 @c subst ([a = b, c = d], a + c);
786 @c lratsubst ([a^2 = b, c^2 = d], (a + e)*c*(a + c));
787 @c lratsubst (a^2 = b, a^3);
789 @example
790 (%i1) load ("lrats")$
791 @end example
792 @itemize @bullet
793 @item
794 @code{subst} pode realizar multiplas substituições.
795 @code{lratsubst} é analoga a @code{subst}.
796 @end itemize
797 @example
798 (%i2) subst ([a = b, c = d], a + c);
799 (%o2) d + b
800 (%i3) lratsubst ([a^2 = b, c^2 = d], (a + e)*c*(a + c));
801 (%o3) (d + a c) e + a d + b c
802 @end example
803 @itemize @bullet
804 @item
805 Se somente uma substituição for desejada, então uma equação
806 simples pode ser dada como primeiro argumento.
807 @end itemize
808 @example
809 (%i4) lratsubst (a^2 = b, a^3);
810 (%o4) a b
811 @end example
813 @end deffn
815 @defvr {Variável de opção} modulus
816 Valor Padrão: @code{false}
818 Quando @code{modulus} for um número positivo @var{p},
819 operações sobre os números racionais (como retornado por @code{rat} e funções relacionadas)
820 são realizadas módulo @var{p},
821 usando o então chamado sistema de módulo "balanceado"
822 no qual @code{@var{n} módulo @var{p}} é definido como
823 um inteiro @var{k} em @code{[-(@var{p}-1)/2, ..., 0, ..., (@var{p}-1)/2]}
824 quando @var{p} for ímpar, ou @code{[-(@var{p}/2 - 1), ..., 0, ...., @var{p}/2]} quando @var{p} for par,
825 tal que @code{@var{a} @var{p} + @var{k}} seja igual a @var{n} para algum inteiro @var{a}.
826 @c NEED EXAMPLES OF "BALANCED MODULUS" HERE
828 @c WHAT CAN THIS MEAN ?? IS THE MODULUS STORED WITH THE EXPRESSION ??
829 @c "... in order to get correct results" -- WHAT DO YOU GET IF YOU DON'T RE-RAT ??
830 Se @var{expr} já estiver na forma de expressão racional canónica
831 (CRE) quando @code{modulus} for colocado no seu valor original, então
832 pode precisar repetir o rat @var{expr}, e.g., @code{expr: rat (ratdisrep
833 (expr))}, com o objectivo de obter resultados correctos.
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 consequê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 factorizada para CRE.
976 Durante operações racionais a expressão é
977 mantida como totalmente factorizada como possível sem uma chamada ao
978 pacote de factorizaçã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 factores 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 utilizador 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 (excepto 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 factorizada.
1284 Durante operações racionais a
1285 expressão é mantida como completamente factorizada 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 factor 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 factorizados 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 utilizador 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} é afectado por algum dos
1365 sinalizadores que afectam @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 factor em comum não constante.
1569 Se @var{p_1} ou @var{p_2} puderem ser factorizados,
1570 pode ser desejável chamar @code{factor} antes de chamar @code{resultant}.
1572 A variável @code{resultant} controla que algoritmo 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 algoritmo 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} aceita 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 factores de uma
1592 expressão que é um produto de factores sejam gravados por certas
1593 funções com o objectivo de aumentar a velocidade em posteriores factorizações de expressões
1594 contendo algum desses mesmos factores.
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} excepto que os factores do polinómio são "livres de raízes".
1601 Isto é, eles possuem factores somente de grau um.
1602 Esse algoritmo, que é também usado no primeiro estágio de @code{factor}, utiliza
1603 o facto que um polinómio tem em comum com sua n'ésima derivada todos
1604 os seus factores de grau maior que n. Dessa forma obtendo 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 factores 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})} efectivamente 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 objectivo 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 recebe 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 ambiguidade como para
1644 ou substituir @code{@var{y}^2} por @code{@var{x}^2}
1645 ou vice-versa.
1646 Maxima selecciona uma ordenação particular, mas se o utilizador 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