[ < ] | [ > ] |  | [ << ] | [ Up ] | [ >> ] |  |  |  |  | [Top] | [Contents] | [Index] | [ ? ]

# 65. simplification

[ < ] | [ > ] |  | [ << ] | [ Up ] | [ >> ] |  |  |  |  | [Top] | [Contents] | [Index] | [ ? ]

## 65.1 Introdução a simplification

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.

[ < ] | [ > ] |  | [ << ] | [ Up ] | [ >> ] |  |  |  |  | [Top] | [Contents] | [Index] | [ ? ]

## 65.2 Definições para simplification

[ < ] | [ > ] |  | [ << ] | [ Up ] | [ >> ] |  |  |  |  | [Top] | [Contents] | [Index] | [ ? ]

### 65.2.1 Package absimp

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)

[ < ] | [ > ] |  | [ << ] | [ Up ] | [ >> ] |  |  |  |  | [Top] | [Contents] | [Index] | [ ? ]

### 65.2.2 Package facexp

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.

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 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`.

Variável global: nextlayerfactor

  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`.

Variável global: facsum_combine

  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.

Função: factorfacsum (expr, arg_1, ... arg_n)

  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.

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.

[ < ] | [ > ] |  | [ << ] | [ Up ] | [ >> ] |  |  |  |  | [Top] | [Contents] | [Index] | [ ? ]

### 65.2.3 Pacote functs

Funçã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 função escreva primeiramente `load(functs)`.

Função: wronskian ([f_1, ..., f_n], x)

  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)`.

Função: tracematrix (M)

  Retorna o traço (somatório dos elementos da diagonal principal) da matriz M.

  Para usar essa função escreva primeiramente `load(functs)`.

Função: rational (`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)`.

Funçã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 função escreva primeiramente `load(functs)`.

Funçã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 função escreva primeiramente `load(functs)`.

Funçã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 função escreva primeiramente `load(functs)`.

Funçã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 função escreva primeiramente `load(functs)`.

Funçã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 função escreva primeiramente `load(functs)`.

Funçã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 função escreva primeiramente `load(functs)`.

Função: arithsum (a, d, n)

  Retorna a soma dos elementos da série aritmética de 1 a n.

  Para usar essa função escreva primeiramente `load(functs)`.

Funçã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 função escreva primeiramente `load(functs)`.

Função: gaussprob (x)

  Retorna a função de probalilidade de Gauss `%e^(-x^2/2) / sqrt(2*%pi)`.

  Para usar essa função escreva primeiramente `load(functs)`.

Função: gd (x)

  Retorna a função de Gudermann `2 * atan(%e^x - %pi/2)`.

  Para usar essa função escreva primeiramente `load(functs)`.

Função: agd (x)

  Retorna o inverso da função de Gudermann `log (tan (%pi/4 + x/2)))`.

  Para usar essa função escreva primeiramente `load(functs)`.

Função: vers (x)

  Retorna o sinus versus `1 - cos (x)`.

  Para usar essa função escreva primeiramente `load(functs)`.

Função: covers (x)

  Retorna o sinus versus do complemento `1 - sin (x)`.

  Para usar essa função escreva primeiramente `load(functs)`.

Função: exsec (x)

  Retorna a parte externa da secante `sec (x) - 1`.

  Para usar essa função escreva primeiramente `load(functs)`.

Função: hav (x)

  Retorna o semi-sinus versus `(1 - cos(x))/2`.

  Para usar essa função escreva primeiramente `load(functs)`.

Função: combination (n, r)

  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)`.

Função: permutation (n, r)

  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)`.

[ < ] | [ > ] |  | [ << ] | [ Up ] | [ >> ] |  |  |  |  | [Top] | [Contents] | [Index] | [ ? ]

### 65.2.4 Package ineq

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.

[ < ] | [ > ] |  | [ << ] | [ Up ] | [ >> ] |  |  |  |  | [Top] | [Contents] | [Index] | [ ? ]

### 65.2.5 Package rducon

Função: reduce_consts (expr)

  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.

[ < ] | [ > ] |  | [ << ] | [ Up ] | [ >> ] |  |  |  |  | [Top] | [Contents] | [Index] | [ ? ]

### 65.2.6 Pacote scifac

Função: gcfac (expr)

  `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:

  1. Factores 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 factorizaçõ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 ó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.

[ < ] | [ > ] |  | [ << ] | [ Up ] | [ >> ] |  |  |  |  | [Top] | [Contents] | [Index] | [ ? ]

### 65.2.7 Pacote sqdnst

Funçã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 função disponível para uso.

[ << ] | [ >> ] |  |  |  |  |  | [Top] | [Contents] | [Index] | [ ? ]

This document was generated by U-Cygwin\ASSI on noviembre, 12 2017 using texi2html 1.76.