@c Language: Brazilian Portuguese, Encoding: iso-8859-1
@c /simplifications.texi/1.6/Thu Jun  7 02:12:31 2007//
@menu
* Introdu@value{cedilha}@~{a}o a simplification::
* Fun@value{cedilha}@~{o}es e Vari@'{a}veis Definidas para simplification::
@end menu

@node Introdu@value{cedilha}@~{a}o a simplification, Fun@value{cedilha}@~{o}es e Vari@'{a}veis Definidas para simplification, simplification, simplification
@section Introdu@value{cedilha}@~{a}o a simplification

O diret@'{o}rio @code{maxima/share/simplification} cont@'{e}m muitos scripts
que implementam regras de simplifica@value{cedilha}@~{a}o e fun@value{cedilha}@~{o}es,
e tamb@'{e}m algumas fun@value{cedilha}@~{o}es n@~{a}o relacionadas a simplifica@value{cedilha}@~{a}o.

@node Fun@value{cedilha}@~{o}es e Vari@'{a}veis Definidas para simplification,  , Introdu@value{cedilha}@~{a}o a simplification, simplification
@section Fun@value{cedilha}@~{o}es e Vari@'{a}veis Definidas para simplification

@c Adapted from absimp.usg ----------------------

@c @defvr {Add-on package} (WITH HYPHEN) CONFUSES DESCRIBE (CAN'T FIND END OF ITEM)
@c SAME WITH OTHER "ADD-ON PACKAGES" HERE (FACEXP, INEQ)
@subsection Package absimp

O pacote @code{absimp} cont@'{e}m regras de compara@value{cedilha}@~{a}o de seq@"{u}@^{e}ncias decaractere que
extendem as regras internas de simplifica@value{cedilha}@~{a}o para as fun@value{cedilha}@~{o}es @code{abs} e
@code{signum}.
@code{absimp} respeita as rela@value{cedilha}@~{o}es
estabelecidas com a fun@value{cedilha}@~{a}o interna @code{assume} e por meio de declara@value{cedilha}@~{o}es tais
como @code{modedeclare (m, even, n, odd)}  para inteiros paes ou @'{i}mpares.

@code{absimp} define as fun@value{cedilha}@~{o}es @code{unitramp} e @code{unitstep}
em termos de @code{abs} e @code{signum}.

@code{load (absimp)} torna esse pacote dispon@'{i}vel para uso.
@code{demo (absimp)} faz uma demonstra@value{cedilha}@~{a}o desse pacote.

Exemplos:

@c ===beg===
@c load (absimp)$
@c (abs (x))^2;
@c diff (abs (x), x);
@c cosh (abs (x));
@c ===end===
@example
(%i1) load (absimp)$
(%i2) (abs (x))^2;
                                       2
(%o2)                                 x
(%i3) diff (abs (x), x);
                                      x
(%o3)                               ------
                                    abs(x)
(%i4) cosh (abs (x));
(%o4)                               cosh(x)
@end example

@c disol.usg: "disolate" already in doc/info/Expressions.texi

@c elim.usg: "eliminate" already in doc/info/Polynomials.texi

@c Adapted from facexp.usg ----------------------
@c ALL OF THE TEXT IN FACEXP.USG IS VERY VAGUE.
@c I HAVE NO IDEA WHAT THESE FUNCTIONS DO.
@c ALL OF THESE ITEMS NEED TO BE HEAVILY REVISED
@c (ASSUMING THIS PACKAGE IS SOMETHING WE WANT TO INVEST TIME IN)
@subsection Package facexp

@c THIS IS VERY VAGUE. JUST WHAT DOES THIS DO?
O pacote @code{facexp} cont@'{e}m muitas fun@value{cedilha}@~{o}es relacionadas a simplifica@value{cedilha}@~{o}es que
fornecem ao usu@'{a}rio a habilidade de estruturar express@~{o}es por meio de expans@~{a}o
controlada.   Essa capacidade @'{e} especialmente @'{u}til quando a express@~{a}o
cont@'{e}m vari@'{a}veis que possuem significado f@'{i}sico, porque @'{e} muitas vezes verdadeiro
que a forma mais econ@^{o}mica de uma tal express@~{a}o pode ser obtida por meio de
uma expans@~{a}o completa da express@~{a}o com rela@value{cedilha}@~{a}o a essas vari@'{a}veis, e ent@~{a}o
fatorar seus coeficientes.  Apesar de ser verdadeiro que esse procedimento @'{e}
f@'{a}cil de realizar usando as fun@value{cedilha}@~{o}es padr@~{a}o do Maxima, ajustes
adicionais podem se desej@'{a}veis, e esses toques finais podem ser
mais dif@'{i}ceis de aplicar.

A fun@value{cedilha}@~{a}o @code{facsum}  e suas formas relacionadas
fornecem um meio conveniente de controlar a estrutura de express@~{o}es
por esse caminho.  Outra fun@value{cedilha}@~{a}o, @code{collectterms}, pode ser usada para adicionar duas ou
mais express@~{o}es que j@'{a} tenham sido simplificadas para essa forma, sem
resimplificar a express@~{a}o completa novamente.  Essa fun@value{cedilha}@~{a}o pode ser
@'{u}til quando express@~{o}es forem muito grandes.

@c CAN'T FIND ANY SUCH FILE "DIAGEVAL".
@c THERE ARE COMMENTED-OUT DEFNS OF FACTENEXPAND, FACEXPTEN, AND FACTORFACEXPTEN
@c IN FACEXP (AND NOWHERE ELSE).
@c COMMENTING OUT THIS TEXT FOR NOW.
@c Note:  @code{factenexpand}, @code{facexpten}, and @code{factorfacexpten}  are available  only
@c after loading @code{diageval}. They are special functions used for  tensor
@c manipulation.

@code{load (facexp)} torna dispon;ivel para uso esse pacote.
@code{demo (facexp)} faz uma demonstra@value{cedilha}@~{a}o desse pacote.

@c THIS IS VERY VAGUE. JUST WHAT DOES THIS DO?
@c SOME EXAMPLES WOULD HELP HERE
@deffn {Fun@value{cedilha}@~{a}o} facsum (@var{expr}, @var{arg_1}, ..., @var{arg_n})
Retorna uma forma de @var{expr}  que depende dos
argumentos @var{arg_1}, ..., @var{arg_n}.
Os argumentos podem ser quaisquer formas adequadas para @code{ratvars}, ou eles podem ser
listas  de tais formas.  Se os argumentos n@~{a}o forem listas, ent@~{a}o a forma
retornada @'{e} completamente expandida com rela@value{cedilha}@~{a}o aos argumentos,  e os
coeficientes dos argumentos foram fatorados.  Esses coeficientes s@~{a}o
livres dos argumentos, exceto talvez no sentido n@~{a}o racional.

Se quaisquer dos argumentos forem listas, ent@~{a}o todas as tais listas s@~{a}o combinadas
em uma lista simples,   e em lugar de chamar @code{factor}   sobre os
coeficientes  dos  argumentos,  @code{facsum}  chama a si mesma sobre esses
coeficientes, usando  essa nova lista simples que foi constru@'{i}da como o novo
argumento listo  para essa chamada recursiva.  Esse processo pode ser repetido para um
quantidade arbitr@'{a}ria de repeti@value{cedilha}@~{o}es por atrav@'{e}s do aninhamento dos elementos desejados nas listas.

@'{E} poss@'{i}vel que algu@'{e}m possa querer usar @code{facsum} com rela@value{cedilha}@~{a}o a subexpress@~{o}es
mais complicadas,  tal como  @code{log (x + y)}.  Tais argumentos s@~{a}o
tamb@'{e}m permitidos.   Sem especifica@value{cedilha}@~{a}o de vari@'{a}vel,  por exemplo
@code{facsum (@var{expr})}, o resultado retornado @'{e} o mesmo que o que @'{e} retornado por meio de
@code{ratsimp (@var{expr})}.

Ocasionalmente o usu@'{a}rio pode querer obter quaisquer das formas abaixo
para express@~{o}es que s@~{a}o especificadas somente por meio de seus operadores l@'{i}deres.
Por exemplo, algu@'{e}m pode querer usar @code{facsum} com rela@value{cedilha}@~{a}o a todos os @code{log}'s.  Nessa
situa@value{cedilha}@~{a}o, algu@'{e}m pode incluir no meio dos argumentos ou o c@'{o}digo
dos @code{log}'s espec@'{i}ficos que devem ser tratados po esse caminho ou alternativamente a
express@~{a}o  @code{operator (log)} ou a express@~{a}o @code{'operator (log)}.   Se algu@'{e}m quiser usar
@code{facsum} na express@~{a}o @var{expr} com rela@value{cedilha}@~{a}o aos operadores @var{op_1}, ..., @var{op_n},
pode-se avaliar @code{facsum (@var{expr}, operator (@var{op_1}, ..., @var{op_n}))}.
A forma @code{operator} pode tamb@'{e}m aparecer dentro de uma lista de argumentos.

Adicionalmente,  a escolha de comutadores @code{facsum_combine}  e
@code{nextlayerfactor} pode afetar o resultado de @code{facsum}.
@end deffn

@defvr {Vari@'{a}vel global} nextlayerfactor
Valor padr@~{a}o: @code{false}

Quando @code{nextlayerfactor} for @code{true}, chamadas recursivas a @code{facsum}
s@~{a}o aplicadas aos fatores da forma fatorada dos
coeficientes dos argumentos.

Quando @code{nextlayerfactor} for @code{false}, @code{facsum} @'{e} aplicada a
cada coeficiente como um todo mesmo se chamadas recursivas a @code{facsum} acontecerem.

A inclus@~{a}o do @'{a}tomo
@code{nextlayerfactor} na lista argumento de @code{facsum}  tem o efeito de
@code{nextlayerfactor: true}, mas para o pr@'{o}ximo n@'{i}vel da express@~{a}o @i{somente}.
Uma vez que @code{nextlayerfactor} @'{e} sempre associado ou a @code{true} ou a  @code{false}, @code{nextlayerfactor}
deve ser apresentada com ap@'{o}strofo simples mesmo que @code{nextlayerfactor} apare@value{cedilha}a na lista de argumento de @code{facsum}.
@end defvr

@defvr {Vari@'{a}vel global} facsum_combine
Valor padr@~{a}o: @code{true}

@code{facsum_combine} controla a forma do resultado final retornada por meio de
@code{facsum}  quando seu argumento @'{e} um quociente de polin@^{o}mios.   Se
@code{facsum_combine} for @code{false}  ent@~{a}o a forma ser@'{a} retornada como um somat@'{o}rio
completamente expandido como descrito acima,  mas se @code{true},  ent@~{a}o a express@~{a}o
retornada @'{e} uma raz@~{a}o de polin@^{o}mios, com cada polin@^{o}mio na forma
descrita acima.

A escolha de @code{true} desse comutador @'{e} @'{u}til quando se
deseja para @code{facsum} ambos o numerador e o denominador de uma express@~{a}o
racional,  mas n@~{a}o se deseja que o denominador seja multiplicado
de forma completa pelos termos do numerador.
@end defvr

@deffn {Fun@value{cedilha}@~{a}o} factorfacsum (@var{expr}, @var{arg_1}, ... @var{arg_n})
Retorna uma forma de @var{expr}  que @'{e}
obtida por meio de chamada a @code{facsum} sobre os fatores de @var{expr} com @var{arg_1}, ... @var{arg_n} como
argumentos.  Se qualqeur dos fatores de @var{expr} estiver elevado a um expoente, ambos
o fator e o expoente ir@~{a}o ser processados por esse meio.
@end deffn

@deffn {Fun@value{cedilha}@~{a}o} collectterms (@var{expr}, @var{arg_1}, ..., @var{arg_n})
Se muitas express@~{o}es tiverem sido
simplificadas com @code{facsum}, @code{factorfacsum},  @code{factenexpand},  @code{facexpten} ou
com @code{factorfacexpten},  e elas est@~{a}o para serem adicionadas umas @`as outras, pode ser
desej@'{a}vel combin@'{a}-las usando a fun@value{cedilha}@~{a}o @code{collecterms}.
@code{collecterms} pode pegar como argumentos todos os argumentos que podem ser
fornecidos para essas outras fun@value{cedilha}@~{o}es associadas com excess@~{a}o de
@code{nextlayerfactor}, que n@~{a}o tem efeito sobre @code{collectterms}.  A vantagem
de @code{collectterms}  est@'{a} em que @code{collectterms} retorna uma forma similar a @code{facsum}, mas
uma vez que @code{collectterms} est@'{a} adicionando forma que j@'{a} tenham sido processadas por @code{facsum},
@code{collectterms} n@~{a}o precisa repetir aquele esfor@value{cedilha}o.   Essa capacidade @'{e}
especialmente @'{u}til quando a express@~{a}o a ser somada for muito grande.
@end deffn

@c Adapted from functs.usg ----------------------

@c conjugate already described in doc/info/Matrices.texi
@subsection Pacote functs

@deffn {Fun@value{cedilha}@~{a}o} rempart (@var{expr}, @var{n})
Remove a parte @var{n} da express@~{a}o @var{expr}.

Se @var{n} @'{e} uma lsita da forma @code{[@var{l}, @var{m}]}
ent@~{a}o as partes de @var{l} at@'{e} @var{m} s@~{a}o removidas.

Para usar essa fun@value{cedilha}@~{a}o escreva primeiramente @code{load(functs)}.
@end deffn

@deffn {Fun@value{cedilha}@~{a}o} wronskian ([@var{f_1}, ..., @var{f_n}], @var{x})
Retorna a matriz Wronskiana das fun@value{cedilha}@~{o}es @var{f_1}, ..., @var{f_n} na vari@'{a}vel @var{x}.

@var{f_1}, ..., @var{f_n} pode ser o nome de fun@value{cedilha}@~{o}es definidas pelo usu@'{a}rio,
ou express@~{o}es na vari@'{a}vel @var{x}.

O determinante da matriz Wronskiana @'{e} o determinante Wronskiano do conjunto de fun@value{cedilha}@~{o}es.
As fun@value{cedilha}@~{o}es s@~{a}o linearmente independentes entre si se seu determinante for igual a zero.

Para usar essa fun@value{cedilha}@~{a}o escreva primeiramente @code{load(functs)}.
@end deffn

@c adjoint already described in doc/info/Matrices.texi

@deffn {Fun@value{cedilha}@~{a}o} tracematrix (@var{M})
Retorna o tra@value{cedilha}o (somat@'{o}rio dos elementos da diagonal principal) da matriz @var{M}.

Para usar essa fun@value{cedilha}@~{a}o escreva primeiramente @code{load(functs)}.
@end deffn

@deffn {Fun@value{cedilha}@~{a}o} rational (@code{z})
Multiplica o numerador e o denominador de @var{z} pelo complexo conjugado do denominador,
racionalizando dessa forma o denominador complexo.
Retorna a forma de express@~{a}o racional can@^{o}nica (CRE) se fornecida uma CRE, caso contr@'{a}rio retorna a forma geral.

Para usar essa fun@value{cedilha}@~{a}o escreva primeiramente @code{load(functs)}.
@end deffn

@c uprobe calls ?uprobe and assumes file is a list => obsolete, not common lisp

@c kronecker superseded by kron_delta in src/nset.lisp

@deffn {Fun@value{cedilha}@~{a}o} nonzeroandfreeof (@var{x}, @var{expr})
Retorna @code{true} se @var{expr} for diferente de zero e @code{freeof (@var{x}, @var{expr})} retorna @code{true}.
Retorna @code{false} de outra forma.

Para usar essa fun@value{cedilha}@~{a}o escreva primeiramente @code{load(functs)}.
@end deffn

@deffn {Fun@value{cedilha}@~{a}o} linear (@var{expr}, @var{x})
Quando @var{expr} for uma express@~{a}o linear na vari@'{a}vel @var{x},
@code{linear} retorna @code{@var{a}*@var{x} + @var{b}} onde @var{a} @'{e} diferente de zero,
e @var{a} e @var{b} s@~{a}o livres de @var{x}.
De outra forma, @code{linear} retorna @var{expr}.

Para usar essa fun@value{cedilha}@~{a}o escreva primeiramente @code{load(functs)}.
@end deffn

@deffn {Fun@value{cedilha}@~{a}o} gcdivide (@var{p}, @var{q})
Quando @code{takegcd} for @code{true},
@code{gcdivide} divide os polin@^{o}mios @var{p} e @var{q} por seu maior divisor comum (MDC)
e retorna a raz@~{a}o dos resultados.

Quando @code{takegcd} for @code{false},
@code{gcdivide} retorna a raz@~{a}o @code{@var{p}/@var{q}}.

Para usar essa fun@value{cedilha}@~{a}o escreva primeiramente @code{load(functs)}.
@end deffn

@c lcm already described in doc/info/Number.texi

@deffn {Fun@value{cedilha}@~{a}o} arithmetic (@var{a}, @var{d}, @var{n})
Retorna o @var{n}-@'{e}siomo termo da s@'{e}rie aritm@'{e}tica
@code{@var{a}, @var{a} + @var{d}, @var{a} + 2*@var{d}, ..., @var{a} + (@var{n} - 1)*@var{d}}.

Para usar essa fun@value{cedilha}@~{a}o escreva primeiramente @code{load(functs)}.
@end deffn

@deffn {Fun@value{cedilha}@~{a}o} geometric (@var{a}, @var{r}, @var{n})
Retorna o @var{n}-@'{e}simo termo da s@'{e}rie geom@'{e}trica
@code{@var{a}, @var{a}*@var{r}, @var{a}*@var{r}^2, ..., @var{a}*@var{r}^(@var{n} - 1)}.

Para usar essa fun@value{cedilha}@~{a}o escreva primeiramente @code{load(functs)}.
@end deffn

@deffn {Fun@value{cedilha}@~{a}o} harmonic (@var{a}, @var{b}, @var{c}, @var{n})
Retorna o @var{n}-@'{e}simo termo da s@'{e}rie harm@^{o}nica
@code{@var{a}/@var{b}, @var{a}/(@var{b} + @var{c}), @var{a}/(@var{b} + 2*@var{c}), ..., @var{a}/(@var{b} + (@var{n} - 1)*@var{c})}.

Para usar essa fun@value{cedilha}@~{a}o escreva primeiramente @code{load(functs)}.
@end deffn

@deffn {Fun@value{cedilha}@~{a}o} arithsum (@var{a}, @var{d}, @var{n})
Retorna a soma dos elementos da s@'{e}rie aritm@'{e}tica de 1 a @var{n}.

Para usar essa fun@value{cedilha}@~{a}o escreva primeiramente @code{load(functs)}.
@end deffn

@deffn {Fun@value{cedilha}@~{a}o} geosum (@var{a}, @var{r}, @var{n})
Retorna a soma dos elementos da s@'{e}rie geom@'{e}trica de 1 a @var{n}.  Se @var{n} for
infinito (@code{inf}) ent@~{a}o a soma ser@'{a} finita se e somente se o valor absoluto
de @var{r} for menor que 1.

Para usar essa fun@value{cedilha}@~{a}o escreva primeiramente @code{load(functs)}.
@end deffn

@deffn {Fun@value{cedilha}@~{a}o} gaussprob (@var{x})
Retorna a fun@value{cedilha}@~{a}o de probalilidade de Gauss
@code{%e^(-@var{x}^2/2) / sqrt(2*%pi)}.

Para usar essa fun@value{cedilha}@~{a}o escreva primeiramente @code{load(functs)}.
@end deffn

@deffn {Fun@value{cedilha}@~{a}o} gd (@var{x})
Retorna a fun@value{cedilha}@~{a}o de Gudermann
@code{2 * atan(%e^@var{x} - %pi/2)}.

Para usar essa fun@value{cedilha}@~{a}o escreva primeiramente @code{load(functs)}.
@end deffn

@deffn {Fun@value{cedilha}@~{a}o} agd (@var{x})
Retorna o inverso da fun@value{cedilha}@~{a}o de Gudermann
@code{log (tan (%pi/4 + x/2)))}.

Para usar essa fun@value{cedilha}@~{a}o escreva primeiramente @code{load(functs)}.
@end deffn

@deffn {Fun@value{cedilha}@~{a}o} vers (@var{x})
Retorna o @i{sinus versus} @code{1 - cos (x)}.

Para usar essa fun@value{cedilha}@~{a}o escreva primeiramente @code{load(functs)}.
@end deffn

@deffn {Fun@value{cedilha}@~{a}o} covers (@var{x})
Retorna o @i{sinus versus} do complemento @code{1 - sin (@var{x})}.

Para usar essa fun@value{cedilha}@~{a}o escreva primeiramente @code{load(functs)}.
@end deffn

@deffn {Fun@value{cedilha}@~{a}o} exsec (@var{x})
Retorna a parte externa da secante @code{sec (@var{x}) - 1}.

Para usar essa fun@value{cedilha}@~{a}o escreva primeiramente @code{load(functs)}.
@end deffn

@deffn {Fun@value{cedilha}@~{a}o} hav (@var{x})
Retorna o semi-@i{sinus versus} @code{(1 - cos(x))/2}.

Para usar essa fun@value{cedilha}@~{a}o escreva primeiramente @code{load(functs)}.
@end deffn

@c REDUNDANT WITH BINOMIAL COEFFICIENT; CUT IT ??
@deffn {Fun@value{cedilha}@~{a}o} combination (@var{n}, @var{r})
Retorna o n@'{u}mero de combina@value{cedilha}@~{o}es de @var{n} objetos
tomados em grupos de @var{r} elementos.

Para usar essa fun@value{cedilha}@~{a}o escreva primeiramente @code{load(functs)}.
@end deffn

@c REDUNDANT WITH PERMUTATIONS FUNCTION IN NSET; CUT IT ??
@deffn {Fun@value{cedilha}@~{a}o} permutation (@var{n}, @var{r})
Retorna o n@'{u}mero de permuta@value{cedilha}@~{o}es de @var{r} objetos
selecionados de um conjunto de @var{n} objetos.

Para usar essa fun@value{cedilha}@~{a}o escreva primeiramente @code{load(functs)}.
@end deffn

@c Adapted from ineq.usg ----------------------
@c THIS PACKAGE IS INTERESTING BUT THIS TEXT NEEDS WORK AND EXAMPLES
@subsection Package ineq

O pacote @code{ineq} cont@'{e}m regras de simplifica@value{cedilha}@~{a}o
para desigualdades.

Sess@~{a}o exemplo:

@c ===beg===
@c load(ineq)$
@c a>=4;  /* uma desigualdade exemplo */
@c (b>c)+%; /* adiciona uma segunda e estrita desigualdade */
@c 7*(x<y); /* multiplica por um n@'{u}mero positivo */
@c -2*(x>=3*z); /* multiplica por um n@'{u}mero negativo */
@c (1+a^2)*(1/(1+a^2)<=1); /* Maxima sabe que 1+a^2 > 0 */
@c assume(x>0)$ x*(2<3); /* assumindo x>0 */
@c a>=b; /* outra desigualdade */
@c 3+%; /* adiciona alguma coisa @`a desigualdade imediatamente acima */
@c %-3; /* retirando essa alguma coisa */
@c a>=c-b; /* ainda outra desigualdade */
@c b+%; /* adiciona b a ambos os lados da desigualdade */
@c %-c; /* subtrai c de ambos os lados */
@c -%;  /* multiplica por by -1 */
@c (z-1)^2>-2*z; /* determining truth of assertion */
@c expand(%)+2*z; /* expand this and add 2*z to both sides */
@c %,pred;
@c ===end===
@example
(%i1) load(ineq)$
Warning: Putting rules on '+' or '*' is inefficient, and may not work.
Warning: Putting rules on '+' or '*' is inefficient, and may not work.
Warning: Putting rules on '+' or '*' is inefficient, and may not work.
Warning: Putting rules on '+' or '*' is inefficient, and may not work.
Warning: Putting rules on '+' or '*' is inefficient, and may not work.
Warning: Putting rules on '+' or '*' is inefficient, and may not work.
Warning: Putting rules on '+' or '*' is inefficient, and may not work.
Warning: Putting rules on '+' or '*' is inefficient, and may not work.
(%i2) a>=4;  /* uma desigualdade exemplo */
(%o2)                               a >= 4
(%i3) (b>c)+%; /* adiciona uma segunda e estrita desigualdade */
(%o3)                            b + a > c + 4
(%i4) 7*(x<y); /* multiplica por um n@'{u}mero positivo */
(%o4)                              7 x < 7 y
(%i5) -2*(x>=3*z); /* multiplica por um n@'{u}mero negativo */
(%o5)                           - 2 x <= - 6 z
(%i6) (1+a^2)*(1/(1+a^2)<=1); /* Maxima sabe que 1+a^2 > 0 */
                                        2
(%o6)                             1 <= a  + 1
(%i7) assume(x>0)$ x*(2<3); /* assumindo x>0 */
(%o7)                              2 x < 3 x
(%i8) a>=b; /* outa desigualdade */
(%o8)                               a >= b
(%i9) 3+%; /* adiciona alguma coisa @`a desigualdade imediatamente acima */
(%o9)                           a + 3 >= b + 3
(%i10) %-3; /* retirando essa alguma coisa */
(%o10)                              a >= b
(%i11) a>=c-b; /* ainda outra desigualdade */
(%o11)                            a >= c - b
(%i12) b+%; /* adiciona b a ambos os lados da desigualdade */
(%o12)                            b + a >= c
(%i13) %-c; /* subtrai c de ambos os lados */
(%o13)                         - c + b + a >= 0
(%i14) -%;  /* multiplica por -1 */
(%o14)                          c - b - a <= 0
(%i15) (z-1)^2>-2*z; /* determinando a verdade de uma assertiva */
                                      2
(%o15)                         (z - 1)  > - 2 z
(%i16) expand(%)+2*z; /* expandindo essa assertiva e adicionado 2*z a ambos os lados */
                                   2
(%o16)                            z  + 1 > 0
(%i17) %,pred;
(%o17)                               true
@end example

Seja cuidadoso com o uso dos par@^{e}ntesis
em torno de desigualdades: quando o usu@'{a}rio digita @code{(A > B) + (C = 5)} o
resultado @'{e} @code{A + C > B + 5}, mas @code{A > B + C = 5} @'{e} um erro de sintaxe,
e @code{(A > B + C) = 5} @'{e} alguma coisa completametne diferente.

Fa@value{cedilha}a @code{disprule (all)} para ver uma lista completa
das defini@value{cedilha}@~{o}es de regras.

O usu@'{a}rio ser@'{a} questionado se o Maxima for
incapaz de decidir o sinal de uma quantidade multiplicando uma desigualdade.

O mais comum recurso estranho @'{e} ilustrado por:

@c ===beg===
@c eq: a > b;
@c 2*eq;
@c % - eq;
@c ===end===
@example
(%i1) eq: a > b;
(%o1)                                a > b
(%i2) 2*eq;
(%o2)                              2 (a > b)
(%i3) % - eq;
(%o3)                                a > b
@end example

Outro problema @'{e} 0 vezes uma desigualdade; o padr@~{a}o para isso
acontecer @'{e} 0 ter sido colocado @`a esquerda sozinho. Todavia, se voc@^{e} digitar 
@code{X*@var{some_inequality}} e Maxima perguntar sobre o sinal de @code{X} e voc@^{e}
responder @code{zero} (ou @code{z}), o programa retorna @code{X*@var{some_inequality}}
e n@~{a}o utiliza a informa@value{cedilha}@~{a}o que @code{X} @'{e} 0. Voc@^{e} pode fazer @code{ev (%, x: 0)} em casos
semelhantes a esse, como a base de dados ir@'{a} somente ser usada para prop@'{o}sitos de compara@value{cedilha}@~{a}o
em decis@~{o}es, e n@~{a}o para o prop@'{o}sito de avalia@value{cedilha}@~{a}o de @code{X}.

O usu@'{a}rio pode notar uma resposta lenta quando esse pacote @'{e} disponibilizado para uso, como
o simplificador @'{e} for@value{cedilha}ado a examinar mais regras do precisaria sem esse
pacote, ent@~{a}o voc@^{e} pode desejar remover essas regras ap@'{o}s fazer uso
delas. Fa@value{cedilha}a @code{kill (rules)} para eliminar todas as regras (incluindo qualquer
regra que voc@^{e} possa ter definido); ou voc@^{e} pode ser mais seletivo
eliminando somente algumas delas; ou use @code{remrule} sobre uma regra espec@'{i}fica.

Note que se voc@^{e} disponibiliza para uso esse pacote ap@'{o}s definir suas pr@'{o}prias
regras voc@^{e} ir@'{a} sobrscrever suas regras que possuirem nomes identicos a nomes contidos em regras do pacote. As
regras no pacote s@~{a}o:
@code{*rule1}, ..., @code{*rule8},
@code{+rule1}, ..., @code{+rule18},
e voc@^{e} deve colocar o nome de regra entre aspas duplas ao referir-se a eles, como
em @code{remrule ("+", "+rule1")} para especificamente remover a primeira regra sobre @code{"+"}
ou @code{disprule ("*rule2")} para mostrar a defini@value{cedilha}@~{a}o da segunda regra multiplicativa.

@c lrats.usg: "lratsubst" and "fullratsubst" already in doc/info/Polynomials.texi

@c Adapted from rducon.usg ----------------------
@c THIS IS AN INTERESTING FUNCTION BUT THIS TEXT NEEDS WORK AND EXAMPLES
@subsection Package rducon

@deffn {Fun@value{cedilha}@~{a}o} reduce_consts (@var{expr})
Substitui subexpress@~{o}es constantes de @var{expr} com
constru@'{i}da com @'{a}tomos constantes, gravando a defini@value{cedilha}@~{a}o de todas essas
constantes constru@'{i}das na lista de equa@value{cedilha}@~{o}es @code{const_eqns}, e
retornando a express@~{a}o modificada @var{expr}.  Essas partes de @var{expr} s@~{a}o constantes que
retornam @code{true} quando operadas por meio da fun@value{cedilha}@~{a}o @code{constantp}.  Conseq@"{u}@^{e}ntemente,
antes de usar @code{reduce_consts}, se pode fazer

@example
declare ([@var{objeto que vai receber a propriedade constante}], constant)$
@end example

para escolher a base de dados das quantidades constantes ocorrendo em suas
express@~{o}es.

Se voc@^{e} est@'{a} planejando gerar sa@'{i}das em Fortran ap@'{o}s esses c@'{a}lculos
simb@'{o}licos, uma das primeiras se@value{cedilha}@~{o}es de c@'{o}digo pode ser o c@'{a}lculo
de todas as constantes.  Para gerar esse segmento de c@'{o}digo, fa@value{cedilha}a

@example
map ('fortran, const_eqns)$
@end example

Variables como @code{const_eqns} que afetam @code{reduce_consts} s@~{a}o:

@code{const_prefix} (valor padr@~{a}o: @code{xx}) @'{e} a seq@"{u}@^{e}ncia de caracteres usada para prefixar todos
os s@'{i}mbolos gerados por @code{reduce_consts} para representar subexpress@~{o}es constantes.

@code{const_counter} (valor padr@~{a}o: 1) @'{e} o @'{i}ndice inteiro usado para gerar s@'{i}mbolos
@'{u}nicos para representar cada subexpress@~{a}o constante emcontrada por @code{reduce_consts}.

@code{load (rducon)} torna essa fun@value{cedilha}@~{a}o dispon@'{i}vel para uso.
@code{demo (rducon)} faz uma demonstra@value{cedilha}@~{a}o dessa fun@value{cedilha}@~{a}o.
@end deffn

@c rncomb.usg: "rncombine" already in doc/info/Miscellaneous.texi

@c Adapted from scifac.usg ----------------------
@subsection Pacote scifac

@deffn {Fun@value{cedilha}@~{a}o} gcfac (@var{expr})
@code{gcfac} fun@value{cedilha}@~{a}o de fatora@value{cedilha}@~{a}o que tenta aplicar a mesma heur@'{i}stica que
cient@'{i}stas aplicam em tentativas de fazer express@~{o}es extremamente simples.  @code{gcfac} est@'{a} limitada
a fatora@value{cedilha}@~{o}es monomiais.  Para um somat@'{o}rio, @code{gcfac} faz o seguinte:

@enumerate
@item
Fatores sobre os inteiros.
@item
Coloca em evid@^{e}ncia o maior expoente de termos ocorrendo como
coeficientes, independentemente da complexidade dos termos.
@item
Usa (1) e (2) em fatora@value{cedilha}@~{o}es de pares de termos adjascentes.
@item
Repetidamente e recursivamente aplica essas t@'{e}cnicas at@'{e} que
a express@~{a}o n@~{a}o mais mude.
@end enumerate

O item (3) n@~{a}o necess@'{a}riamente faz uma tarefa @'{o}tima fatora@value{cedilha}@~{a}o
par a par devido @`a dificuldade combinat@'{o}ria natural de encontrar
qual de todas dos poss@'{i}veis rearranjos de pares retorna o mais
compacto resultado de fatora@value{cedilha}@~{a}o de um par.

@code{load (scifac)} torna essa fun@value{cedilha}@~{a}o dispon@'{i}vel para uso.
@code{demo (scifac)} faz uma demonstra@value{cedilha}@~{a}o dessa fun@value{cedilha}@~{a}o.
@end deffn

@c Adapted from sqdnst.usg ----------------------
@c THIS FUNCTION IS INTERESTING BUT THIS TEXT NEEDS WORK. HOW DEEPLY CAN SQRT BE NESTED ??
@subsection Pacote sqdnst

@deffn {Fun@value{cedilha}@~{a}o} sqrtdenest (@var{expr})
Desaninha @code{sqrt} de simples, num@'{e}rico, bin@^{o}mios de ra@'{i}zes irracionais de n@'{u}meros racionais , onde for poss@'{i}vel.  E.g.

@c ===beg===
@c load (sqdnst)$
@c sqrt(sqrt(3)/2+1)/sqrt(11*sqrt(2)-12);
@c sqrtdenest(%);
@c ===end===
@example
(%i1) load (sqdnst)$
(%i2) sqrt(sqrt(3)/2+1)/sqrt(11*sqrt(2)-12);
                                    sqrt(3)
                               sqrt(------- + 1)
                                       2
(%o2)                        ---------------------
                             sqrt(11 sqrt(2) - 12)
(%i3) sqrtdenest(%);
                                  sqrt(3)   1
                                  ------- + -
                                     2      2
(%o3)                            -------------
                                    1/4    3/4
                                 3 2    - 2
@end example

Algumas vezes isso ajuda na hora de aplicar @code{sqrtdenest} mais que uma vez, sobre coisas como
@code{(19601-13860 sqrt(2))^(7/4)}.

@code{load (sqdnst)} Torna essa fun@value{cedilha}@~{a}o dispon@'{i}vel para uso.
@end deffn

@c stopex.usg: "expandwrt", "expandwrt_denom", and "expandwrt_factored" already in doc/info/Simplification.texi
