Introducedilhaão a simplification
=================================

O diretório maxima/share/simplification contém muitos scripts que implementam regras de simplificacedilhaão e funcedilhaões, e também algumas funcedilhaões não relacionadas a simplificacedilhaão.

Funcedilhaões e Variáveis Definidas para simplification
=======================================================

Package absimp
--------------

O pacote absimp contém regras de comparacedilhaão de seqüências decaractere que extendem as regras internas de simplificacedilhaão para as funcedilhaões abs e signum. absimp respeita as relacedilhaões estabelecidas com a funcedilhaão interna assume e por meio de declaracedilhaões tais como modedeclare (m, even, n, odd)  para inteiros paes ou ímpares.

absimp define as funcedilhaões unitramp e unitstep em termos de abs e signum.

load (absimp) torna esse pacote disponível para uso. demo (absimp) faz uma demonstracedilhaão desse pacote.

Exemplos:

     (%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)

Package facexp
--------------

O pacote facexp contém muitas funcedilhaões relacionadas a simplificacedilhaões que fornecem ao usuário a habilidade de estruturar expressões por meio de expansão controlada.   Essa capacidade é especialmente útil quando a expressão contém variáveis que possuem significado físico, porque é muitas vezes verdadeiro que a forma mais econômica de uma tal expressão pode ser obtida por meio de uma expansão completa da expressão com relacedilhaão a essas variáveis, e então fatorar seus coeficientes.  Apesar de ser verdadeiro que esse procedimento é fácil de realizar usando as funcedilhaões padrão do Maxima, ajustes adicionais podem se desejáveis, e esses toques finais podem ser mais difíceis de aplicar.

A funcedilhaão facsum  e suas formas relacionadas fornecem um meio conveniente de controlar a estrutura de expressões por esse caminho.  Outra funcedilhaão, collectterms, pode ser usada para adicionar duas ou mais expressões que já tenham sido simplificadas para essa forma, sem resimplificar a expressão completa novamente.  Essa funcedilhaão pode ser útil quando expressões forem muito grandes.

load (facexp) torna dispon;ivel para uso esse pacote. demo (facexp) faz uma demonstracedilhaão desse pacote.

 -- Funcedilhaão: facsum (EXPR, ARG_1, ..., ARG_N)
     Retorna uma forma de EXPR  que depende dos argumentos ARG_1, ..., ARG_N. Os argumentos podem ser quaisquer formas adequadas para ratvars, ou eles podem ser listas  de tais formas.  Se os argumentos não forem listas, então a forma retornada é completamente expandida com relacedilhaão aos argumentos,  e os coeficientes dos argumentos foram fatorados.  Esses coeficientes são livres dos argumentos, exceto talvez no sentido não racional.

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

     É possível que alguém possa querer usar facsum com relacedilhaão a subexpressões mais complicadas,  tal como  log (x + y).  Tais argumentos são também permitidos.   Sem especificacedilhaão de variável,  por exemplo facsum (EXPR), o resultado retornado é o mesmo que o que é retornado por meio de ratsimp (EXPR).

     Ocasionalmente o usuário pode querer obter quaisquer das formas abaixo para expressões que são especificadas somente por meio de seus operadores líderes. Por exemplo, alguém pode querer usar facsum com relacedilhaão a todos os log's.  Nessa situacedilhaão, alguém pode incluir no meio dos argumentos ou o código dos log's específicos que devem ser tratados po esse caminho ou alternativamente a expressão  operator (log) ou a expressão 'operator (log).   Se alguém quiser usar facsum na expressão EXPR com relacedilhaão aos operadores OP_1, ..., OP_N, pode-se avaliar facsum (EXPR, operator (OP_1, ..., OP_N)). A forma operator pode também aparecer dentro de uma lista de argumentos.

     Adicionalmente,  a escolha de comutadores facsum_combine  e nextlayerfactor pode afetar o resultado de facsum.

 -- Variável global: nextlayerfactor
     Valor padrão: false

     Quando nextlayerfactor for true, chamadas recursivas a facsum são aplicadas aos fatores da forma fatorada dos coeficientes dos argumentos.

     Quando nextlayerfactor for false, facsum é aplicada a cada coeficiente como um todo mesmo se chamadas recursivas a facsum acontecerem.

     A inclusão do átomo nextlayerfactor na lista argumento de facsum  tem o efeito de nextlayerfactor: true, mas para o próximo nível da expressão somente. Uma vez que nextlayerfactor é sempre associado ou a true ou a  false, nextlayerfactor deve ser apresentada com apóstrofo simples mesmo que nextlayerfactor aparecedilhaa na lista de argumento de facsum.

 -- Variável global: facsum_combine
     Valor padrão: true

     facsum_combine controla a forma do resultado final retornada por meio de facsum  quando seu argumento é um quociente de polinômios.   Se facsum_combine for false  então a forma será retornada como um somatório completamente expandido como descrito acima,  mas se true,  então a expressão retornada é uma razão de polinômios, com cada polinômio na forma descrita acima.

     A escolha de true desse comutador é útil quando se deseja para facsum ambos o numerador e o denominador de uma expressão racional,  mas não se deseja que o denominador seja multiplicado de forma completa pelos termos do numerador.

 -- Funcedilhaão: factorfacsum (EXPR, ARG_1, ... ARG_N)
     Retorna uma forma de EXPR  que é obtida por meio de chamada a facsum sobre os fatores de EXPR com ARG_1, ... ARG_N como argumentos.  Se qualqeur dos fatores de EXPR estiver elevado a um expoente, ambos o fator e o expoente irão ser processados por esse meio.

 -- Funcedilhaão: collectterms (ARG_1, ..., ARG_N)
     Se muitas expressões tiverem sido simplificadas com facsum, factorfacsum,  factenexpand,  facexpten ou com factorfacexpten,  e elas estão para serem adicionadas umas às outras, pode ser desejável combiná-las usando a funcedilhaão collecterms. collecterms pode pegar como argumentos todos os argumentos que podem ser fornecidos para essas outras funcedilhaões associadas com excessão de nextlayerfactor, que não tem efeito sobre collectterms.  A vantagem de collectterms  está em que collectterms retorna uma forma similar a facsum, mas uma vez que collectterms está adicionando forma que já tenham sido processadas por facsum, collectterms não precisa repetir aquele esforcedilhao.   Essa capacidade é especialmente útil quando a expressão a ser somada for muito grande.

Pacote functs
-------------

 -- Funcedilhaão: rempart (EXPR, N)
     Remove a parte N da expressão EXPR.

     Se N é uma lsita da forma [L, M] então as partes de L até M são removidas.

     Para usar essa funcedilhaão escreva primeiramente load(functs).

 -- Funcedilhaão: wronskian ([F_1, ..., F_N], X)
     Retorna a matriz Wronskiana das funcedilhaões F_1, ..., F_N na variável X.

     F_1, ..., F_N pode ser o nome de funcedilhaões definidas pelo usuário, ou expressões na variável X.

     O determinante da matriz Wronskiana é o determinante Wronskiano do conjunto de funcedilhaões. As funcedilhaões são linearmente independentes entre si se seu determinante for igual a zero.

     Para usar essa funcedilhaão escreva primeiramente load(functs).

 -- Funcedilhaão: tracematrix (M)
     Retorna o tracedilhao (somatório dos elementos da diagonal principal) da matriz M.

     Para usar essa funcedilhaão escreva primeiramente load(functs).

 -- Funcedilhaão: rational (z)
     Multiplica o numerador e o denominador de Z pelo complexo conjugado do denominador, racionalizando dessa forma o denominador complexo. Retorna a forma de expressão racional canônica (CRE) se fornecida uma CRE, caso contrário retorna a forma geral.

     Para usar essa funcedilhaão escreva primeiramente load(functs).

 -- Funcedilhaão: logand (x,y)
     Retorna o "e" lógico (bit-wise) dos argumento x e do argumento y.

     Para usar essa funcedilhaão escreva primeiramente load(functs).

 -- Funcedilhaão: logor (x,y)
     Retorna o "ou" lógico (bit-wise) dos argumento x e do argumento y.

     Para usar essa funcedilhaão escreva primeiramente load(functs).

 -- Funcedilhaão: logxor (x,y)
     Retorna "ou-exclusivo" lógico (bit-wise) dos argumento x e do argumento y.

     Para usar essa funcedilhaão escreva primeiramente load(functs).

 -- Funcedilhaão: nonzeroandfreeof (X, EXPR)
     Retorna true se EXPR for diferente de zero e freeof (X, EXPR) retorna true. Retorna false de outra forma.

     Para usar essa funcedilhaão escreva primeiramente load(functs).

 -- Funcedilhaão: linear (EXPR, X)
     Quando EXPR for uma expressão linear na variável X, linear retorna A*X + B onde A é diferente de zero, e A e B são livres de X. De outra forma, linear retorna EXPR.

     Para usar essa funcedilhaão escreva primeiramente load(functs).

 -- Funcedilhaão: gcdivide (P, Q)
     Quando takegcd for true, gcdivide divide os polinômios P e Q por seu maior divisor comum (MDC) e retorna a razão dos resultados.

     Quando takegcd for false, gcdivide retorna a razão P/Q.

     Para usar essa funcedilhaão escreva primeiramente load(functs).

 -- Funcedilhaão: arithmetic (A, D, N)
     Retorna o N-ésiomo termo da série aritmética A, A + D, A + 2*D, ..., A + (N - 1)*D.

     Para usar essa funcedilhaão escreva primeiramente load(functs).

 -- Funcedilhaão: geometric (A, R, N)
     Retorna o N-ésimo termo da série geométrica A, A*R, A*R^2, ..., A*R^(N - 1).

     Para usar essa funcedilhaão escreva primeiramente load(functs).

 -- Funcedilhaão: harmonic (A, B, C, N)
     Retorna o N-ésimo termo da série harmônica A/B, A/(B + C), A/(B + 2*C), ..., A/(B + (N - 1)*C).

     Para usar essa funcedilhaão escreva primeiramente load(functs).

 -- Funcedilhaão: arithsum (A, D, N)
     Retorna a soma dos elementos da série aritmética de 1 a N.

     Para usar essa funcedilhaão escreva primeiramente load(functs).

 -- Funcedilhaão: geosum (A, R, N)
     Retorna a soma dos elementos da série geométrica de 1 a N.  Se N for infinito (inf) então a soma será finita se e somente se o valor absoluto de R for menor que 1.

     Para usar essa funcedilhaão escreva primeiramente load(functs).

 -- Funcedilhaão: gaussprob (X)
     Retorna a funcedilhaão de probalilidade de Gauss %e^(-X^2/2) / sqrt(2*%pi).

     Para usar essa funcedilhaão escreva primeiramente load(functs).

 -- Funcedilhaão: gd (X)
     Retorna a funcedilhaão de Gudermann 2 * atan(%e^X - %pi/2).

     Para usar essa funcedilhaão escreva primeiramente load(functs).

 -- Funcedilhaão: agd (X)
     Retorna o inverso da funcedilhaão de Gudermann log (tan (%pi/4 + x/2))).

     Para usar essa funcedilhaão escreva primeiramente load(functs).

 -- Funcedilhaão: vers (X)
     Retorna o sinus versus 1 - cos (x).

     Para usar essa funcedilhaão escreva primeiramente load(functs).

 -- Funcedilhaão: covers (X)
     Retorna o sinus versus do complemento 1 - sin (X).

     Para usar essa funcedilhaão escreva primeiramente load(functs).

 -- Funcedilhaão: exsec (X)
     Retorna a parte externa da secante sec (X) - 1.

     Para usar essa funcedilhaão escreva primeiramente load(functs).

 -- Funcedilhaão: hav (X)
     Retorna o semi-sinus versus (1 - cos(x))/2.

     Para usar essa funcedilhaão escreva primeiramente load(functs).

 -- Funcedilhaão: combination (N, R)
     Retorna o número de combinacedilhaões de N objetos tomados em grupos de R elementos.

     Para usar essa funcedilhaão escreva primeiramente load(functs).

 -- Funcedilhaão: permutation (N, R)
     Retorna o número de permutacedilhaões de R objetos selecionados de um conjunto de N objetos.

     Para usar essa funcedilhaão escreva primeiramente load(functs).

Package ineq
------------

O pacote ineq contém regras de simplificacedilhaão para desigualdades.

Sessão exemplo:

     (%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úmero positivo */
     (%o4)                              7 x < 7 y
     (%i5) -2*(x>=3*z); /* multiplica por um nú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 à 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

Seja cuidadoso com o uso dos parêntesis em torno de desigualdades: quando o usuário digita (A > B) + (C = 5) o resultado é A + C > B + 5, mas A > B + C = 5 é um erro de sintaxe, e (A > B + C) = 5 é alguma coisa completametne diferente.

Facedilhaa disprule (all) para ver uma lista completa das definicedilhaões de regras.

O usuário será questionado se o Maxima for incapaz de decidir o sinal de uma quantidade multiplicando uma desigualdade.

O mais comum recurso estranho é ilustrado por:

     (%i1) eq: a > b;
     (%o1)                                a > b
     (%i2) 2*eq;
     (%o2)                              2 (a > b)
     (%i3) % - eq;
     (%o3)                                a > b

Outro problema é 0 vezes uma desigualdade; o padrão para isso acontecer é 0 ter sido colocado à esquerda sozinho. Todavia, se você digitar X*SOME_INEQUALITY e Maxima perguntar sobre o sinal de X e você responder zero (ou z), o programa retorna X*SOME_INEQUALITY e não utiliza a informacedilhaão que X é 0. Você pode fazer ev (%, x: 0) em casos semelhantes a esse, como a base de dados irá somente ser usada para propósitos de comparacedilhaão em decisões, e não para o propósito de avaliacedilhaão de X.

O usuário pode notar uma resposta lenta quando esse pacote é disponibilizado para uso, como o simplificador é forcedilhaado a examinar mais regras do precisaria sem esse pacote, então você pode desejar remover essas regras após fazer uso delas. Facedilhaa kill (rules) para eliminar todas as regras (incluindo qualquer regra que você possa ter definido); ou você pode ser mais seletivo eliminando somente algumas delas; ou use remrule sobre uma regra específica.

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

Package rducon
--------------

 -- Funcedilhaão: reduce_consts (EXPR)
     Substitui subexpressões constantes de EXPR com construída com átomos constantes, gravando a definicedilhaão de todas essas constantes construídas na lista de equacedilhaões const_eqns, e retornando a expressão modificada EXPR.  Essas partes de EXPR são constantes que retornam true quando operadas por meio da funcedilhaão constantp.  Conseqüêntemente, antes de usar reduce_consts, se pode fazer

          declare ([OBJETO QUE VAI RECEBER A PROPRIEDADE CONSTANTE], constant)$

     para escolher a base de dados das quantidades constantes ocorrendo em suas expressões.

     Se você está planejando gerar saídas em Fortran após esses cálculos simbólicos, uma das primeiras secedilhaões de código pode ser o cálculo de todas as constantes.  Para gerar esse segmento de código, facedilhaa

          map ('fortran, const_eqns)$

     Variables como const_eqns que afetam reduce_consts são:

     const_prefix (valor padrão: xx) é a seqüência de caracteres usada para prefixar todos os símbolos gerados por reduce_consts para representar subexpressões constantes.

     const_counter (valor padrão: 1) é o índice inteiro usado para gerar símbolos únicos para representar cada subexpressão constante emcontrada por reduce_consts.

     load (rducon) torna essa funcedilhaão disponível para uso. demo (rducon) faz uma demonstracedilhaão dessa funcedilhaão.

Pacote scifac
-------------

 -- Funcedilhaão: gcfac (EXPR)
     gcfac funcedilhaão de fatoracedilhaão que tenta aplicar a mesma heurística que cientístas aplicam em tentativas de fazer expressões extremamente simples.  gcfac está limitada a fatoracedilhaões monomiais.  Para um somatório, gcfac faz o seguinte:

      1. Fatores sobre os inteiros.

      2. Coloca em evidência o maior expoente de termos ocorrendo como coeficientes, independentemente da complexidade dos termos.

      3. Usa (1) e (2) em fatoracedilhaões de pares de termos adjascentes.

      4. Repetidamente e recursivamente aplica essas técnicas até que a expressão não mais mude.

     O item (3) não necessáriamente faz uma tarefa ótima fatoracedilhaão par a par devido à dificuldade combinatória natural de encontrar qual de todas dos possíveis rearranjos de pares retorna o mais compacto resultado de fatoracedilhaão de um par.

     load (scifac) torna essa funcedilhaão disponível para uso. demo (scifac) faz uma demonstracedilhaão dessa funcedilhaão.

Pacote sqdnst
-------------

 -- Funcedilhaão: sqrtdenest (EXPR)
     Desaninha sqrt de simples, numérico, binômios de raízes irracionais de números racionais , onde for possível.  E.g.

          (%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

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

     load (sqdnst) Torna essa funcedilhaão disponível para uso.