Próximo: Definições para simplification, Anterior: simplification, Acima: simplification [Conteúdo][Índice]
O directório maxima/share/simplification contém muitos scripts
que implementam regras de simplificação e funções,
e também algumas funções não relacionadas a simplificação.
Anterior: Introdução a simplification, Acima: simplification [Conteúdo][Índice]
O pacote absimp contém regras de comparação de sequê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)
O pacote facexp contém muitas funções relacionadas a simplificações que
fornecem ao utilizador 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
factorizar 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.
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 factorizados. Esses coeficientes são
livres dos argumentos, excepto 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 utilizador 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 eespecí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 afectar o ressultado de facsum.
Valor por omissão: false
Quando nextlayerfactor for true, chamadas recursivas a facsum
são aplicdas aos factores da forma factorizada 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 efieto 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.
Valor por omissã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
completametne 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 dumerador 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.
Retorna uma forma de expr que é
obtida por meio de chamada a facsum sobre os factores de expr com arg_1, ... arg_n como
argumentos. Se qualqeur dos factores de expr estiver elevado a um expoente, ambos
o factor e o expoente irão ser processados por esse meio.
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.
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 função escreva primeiramente load("functs").
Retorna a matriz Wronskiana das funções f_1, ..., f_n na variável x.
f_1, ..., f_n pode ser o nome de funções definidas pelo utilizador, ou expressões na variável x.
O determinante da matriz Wronskiana é o determinante Wronskiano do conjunto de funções. As funções são linearmente independentes entre si se seu determinante for igual a zero.
Para usar essa função escreva primeiramente load("functs").
Retorna o traço (somatório dos elementos da diagonal principal) da matriz M.
Para usar essa função escreva primeiramente load("functs").
z) ¶Multiplica o numerador e o denominador de z pelo complexo conjugado do denominador, racionando 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 função escreva primeiramente load("functs").
Retorna true se expr for diferente de zero e freeof (x, expr) retorna true.
Retorna false de outra forma.
Para usar essa função escreva primeiramente load("functs").
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 função escreva primeiramente load("functs").
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 função escreva primeiramente load("functs").
Retorna o n-ésiomo termo da série aritmética
a, a + d, a + 2*d, ..., a + (n - 1)*d.
Para usar essa função escreva primeiramente load("functs").
Retorna o n-ésimo termo da série geométrica
a, a*r, a*r^2, ..., a*r^(n - 1).
Para usar essa função escreva primeiramente load("functs").
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 função escreva primeiramente load("functs").
Retorna a soma dos elementos da série aritmética de 1 a n.
Para usar essa função escreva primeiramente load("functs").
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 função escreva primeiramente load("functs").
Retorna a função de probalilidade de Gauss
%e^(-x^2/2) / sqrt(2*%pi).
Para usar essa função escreva primeiramente load("functs").
Retorna a função de Gudermann
2 * atan(%e^x - %pi/2).
Para usar essa função escreva primeiramente load("functs").
Retorna o inverso da função de Gudermann
log (tan (%pi/4 + x/2))).
Para usar essa função escreva primeiramente load("functs").
Retorna o sinus versus 1 - cos (x).
Para usar essa função escreva primeiramente load("functs").
Retorna o sinus versus do complemento 1 - sin (x).
Para usar essa função escreva primeiramente load("functs").
Retorna a parte externa da secante sec (x) - 1.
Para usar essa função escreva primeiramente load("functs").
Retorna o semi-sinus versus (1 - cos(x))/2.
Para usar essa função escreva primeiramente load("functs").
Retorna o número de combinações de n objectos tomados em grupos de r elementos.
Para usar essa função escreva primeiramente load("functs").
Retorna o número de permutações de r objectos seleccionados de um conjunto de n objectos.
Para usar essa função escreva primeiramente load("functs").
O pacote ineq contém regras de simplificaçã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 utilizador digita (A > B) + (C = 5) o
resltado é A + C > B + 5, mas A > B + C = 5 é um erro de sintaxe,
e (A > B + C) = 5 é alguma coisa completametne diferente.
Faça disprule (all) para ver uma lista completa
das definições de regras.
O utilizador 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. Contudo, se
digitar X*some_inequality e Maxima perguntar sobre o sinal
de X e responder zero (ou z), o programa retorna
X*some_inequality e não utiliza a
informação que X é 0. Pode usar ev (%, x:
0) em casos semelhantes a esse; a base de dados irá somente ser usada
para propósitos de comparação em decisões, e não
para o propósito de avaliação de X.
O utilizador pode notar uma resposta lenta quando esse pacote é
disponibilizado para uso, como o simplificador é forçado
a examinar mais regras do precisaria sem esse pacote, então pode
desejar remover essas regras após fazer uso delas. Faça
kill (rules) para eliminar todas as regras (incluindo qualquer
regra que possa ter definido); ou pode ser mais selectivo
eliminando somente algumas delas; ou use remrule sobre uma regra
específica.
Note que se disponibilizar esse pacote para ser usado, após definir
suas próprias regras, irá sobrescrever as suas regras que possuirem
nomes identicos a nomes contidos nas regras do pacote. As regras no
pacote são: *rule1, ..., *rule8, +rule1, ...,
+rule18, e 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 definição da
segunda regra multiplicativa.
Substitui subexpressões constantes de expr com
construída com átomos constantes, gravando a definição de todas essas
constantes construídas na lista de equaçõ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 função constantp. Consequêntemente,
antes de usar reduce_consts, se pode fazer
declare ([objecto que vai receber a propriedade constante], constant)$
para escolher a base de dados das quantidades constantes ocorrendo em suas expressões.
Se está a planear gerar saídas em Fortran após esses cálculos simbólicos, uma das primeiras secções de código pode ser o cálculo de todas as constantes. Para gerar esse segmento de código, faça
map ('fortran, const_eqns)$
Variables como const_eqns que afectam reduce_consts são:
const_prefix (valor padrão: xx) é a sequê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 função disponível para uso.
demo (rducon) faz uma demonstração dessa função.
gcfac função de factorização que tenta aplicar a mesma heurística que
cientístas aplicam em tentativas de fazer expressões extremamente simples. gcfac está limitada
a factorizações monomiais. Para um somatório, gcfac faz o seguinte:
O item (3) não necessáriamente faz uma tarefa óptima factorizaçã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 factorização de um par.
load ("scifac") torna essa função disponível para uso.
demo (scifac) faz uma demonstração dessa função.
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 função disponível para uso.