Funções e Variáveis Definidas para simplification (Manual do Maxima)

69.2, Funções e Variáveis Definidas para simplification

Package absimp
Package facexp
Pacote functs
Package ineq
Package rducon
Pacote scifac
Pacote sqdnst

69.2.1, Package absimp

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

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

load ("absimp") torna esse pacote disponível para uso. demo (absimp) faz uma demonstraçã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)

69.2.2, Package facexp

O pacote facexp contém muitas funções relacionadas a simplificaçõ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 relação a essas variáveis, e então fatorar seus coeficientes. Apesar de ser verdadeiro que esse procedimento é fácil de realizar usando as funções padrão do Maxima, ajustes adicionais podem se desejáveis, e esses toques finais podem ser mais difíceis de aplicar.

A função facsum e suas formas relacionadas fornecem um meio conveniente de controlar a estrutura de expressões por esse caminho. Outra funçã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 função pode ser útil quando expressões forem muito grandes.

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

Funçã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 relaçã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 repetições por através do aninhamento dos elementos desejados nas listas.

É possível que alguém possa querer usar facsum com relação a subexpressões mais complicadas, tal como log (x + y). Tais argumentos são também permitidos. Sem especificaçã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 relação a todos os log’s. Nessa situaçã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 relaçã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 apareça 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.

Funçã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.

Função: collectterms (expr, 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 função collecterms. collecterms pode pegar como argumentos todos os argumentos que podem ser fornecidos para essas outras funçõ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 esforço. Essa capacidade é especialmente útil quando a expressão a ser somada for muito grande.