This is maxima.info, produced by makeinfo version 6.7 from maxima.texi.

Esse é um Manual do Maxima no formato Texinfo

   Copyright 1994,2001 William F. Schelter

START-INFO-DIR-ENTRY
* Maxima: (maxima).     Um sistema de álgebra computacional.
END-INFO-DIR-ENTRY


File: maxima.info,  Node: Top,  Next: Introdução ao Maxima,  Prev: (dir),  Up: (dir)

Manual do Maxima
****************

Maxima é um sistema de álgebra computacional, implementado em Lisp.

   Maxima é derivado do sistema Macsyma, desenvolvido no MIT nos anos de
1968 a 1982 como parte do Projeto MAC. MIT remanejou uma cópia do código
fonte do Macsyma para o Departamento de Energia em 1982; aquela versão é
agora conhecida como Macsyma DOE. Uma cópia do Macsyma DOE foi mantida
pelo Professor William F. Schelter da Universidade do Texas de 1982 até
sua morte em 2001.  Em 1998, Schelter obteve permissão do Departamento
de Energia para liberar o código fonte do Macsyma DOE sob a Licença
Pública GNU, e em 2000 ele iniciou o projeto Maxima no SourceForge para
manter e desenvolver o Macsyma DOE, agora chamado Maxima.

   Notas de tradução:

   Com o término da tradução inicia-se o processo de revisão da mesma.
Está aberta a temporada de caça aos erros de tradução, erros de
hifenização e de adequação entre a linguagem matemática inglesa e a
linguagem matemática brasileira.  Caso você me envie alguma correção ou
melhoria a comunidade matemática que utiliza o Sofware Livre lhe ficará
muito grata ( e nós, da equipe do Maxima, também).

   O código fonte deste documento encontra-se no formato texinfo.  Para
contribuir com a equipe do Maxima na tarefa de manter a tradução para o
português sempre atualizada envie um e-mail para <maxima at math dot
utexas dot edu>.

   Em caso de dúvida sobre algum trecho deste manual consulte o original
inglês.  Caso sua dúvida persista ou tenha alguma
sugestão/aperfeiçoamento/ crítica mande-nos um e-mail no endereço acima.

   Versão do manual no formato pdf: maxima.pdf

   Versão do manual no formato info: maxima-info.tar.gz

   Veja o arquivo AUTHORS para conhecer todos os mantenedores do Maxima.

* Menu:

Infraestrutura do Maxima

* Introdução ao Maxima::        Exemplo de sessões do Maxima.
* Detecção e Relato de Erros::  Encontrando e relatando erros no Maxima.
* Ajuda::                       Solicitando ajuda de dentro de uma
                                sessão do Maxima.
* Linha de Comando::            Sintaxe de linha de comando do Maxima.
* Operadores::                  Operadores usados em expressões do Maxima.
* Expressões::                  Expressões no Maxima.
* Simplificação::               Simplificando expressões.
* Montando Gráficos::           Saídas gráficas em 2D e 3D.
* Entrada e Saída::             Entrada e saída de arquivos.
* Ponto Flutuante::             Rotinas numéricas de baixo nível.
* Contextos::                   Conjunto de fatos assumidos.

Suporte a áreas específicas da matemática

* Polinômios::                  Formas padrão para polinômios, e
                                funções operando sobre polinômios.
* Constantes::                  Constantes numéricas.
* Logarítmos::                  Manipulação de expressões envolvendo
                                logarítmos.
* Trigonometria::               Manipulando expressões com trigonometria e
                                Funções trigonométricas inversas.
* Funções Especiais::           Funções especiais
* Funções Elípticas::           Funções Elípticas e Integrais
* Limites::                     Limites de expressões.
* Diferenciação::               Cálculo diferencial.
* Integração::                  Cálculo integral.
* Equações::                    Definindo e resolvendo equações.
* Equações Diferenciais::       Definindo e resolvendo equações diferenciais.
* Numérico::                    Integração numérica, transformações
                                de Fourier, etc.
* Arrays ::                     Criando e trabalhando com arrays.
* Matrizes e Álgebra Linear::   Operações com Matrizes.
* Funções Afins::
* itensor::                     Manipulação de índice de Tensores.
* ctensor::                     Manipulação de componentes de Tensores.
* Pacote atensor::              Manipulação de Tensores Algébricos.
* Séries::                      Taylor e séries de potência.
* Teoria dos Números::          Teoria dos números.
* Simetrias::                   Polinômios simétricos
* Grupos::                      Álgebra Abstrata.

Facilidades avançadas e programação

* Ambiente em Tempo de Execução:: Customização do ambiente Maxima.
* Opções Diversas::             Opções com efeito global sobre o Maxima.
* Regras e Modelos::            Coincidência de expressões definidas pelo utilizador e regras de simplificação.
* Listas::                      Manipulação de listas.
* Conjuntos::                   Manipulação de conjuntos.
* Definição de Função::         Definindo funções.
* Fluxo de Programa::           Definindo programas do Maxima.
* Depurando::                   Depurando programas do Maxima.

Pacotes Adicionais

* augmented_lagrangian::        Pacote augmented_lagrangian.
* bode::                        Gráficos de ganho e fase de Bode.
* contrib_ode::                 Rotinas adicionais para EDOs
* descriptive::                 Estatística descritiva.
* diag::                        Matrizes de Jordan.
* distrib::                     Distribuições de probabilidade.
* draw::                        Uma interface Maxima-Gnuplot.
* dynamics::                    Gráficos para sistemas dinâmicos e fractais.
* eval_string::                 Expressões do Maxima como cadeias de texto.
* f90::                         Tradutor do Maxima para o fortran.
* ggf::                         Função geradora para sequências.
* grobner::                     Funções para trabalhar com as bases de Groebner.
* impdiff::                     Derivadas implícitas.
* implicit_plot::               Gráficos implítos.
* interpol::                    Pacote de interpolação.
* lbfgs::                       L-BFGS pacote de minimização não limitada.
* lindstedt::                   Pacote Lindstedt.
* linearalgebra::               Funções de álgebra linear.
* lsquares::                    Método dos mínimos quadrados.
* makeOrders::                  Expoentes de polinômios.
* mnewton::                     Método de Newton.
* numericalio::                 Leitura e escritura de arquivos.
* opsubst::                     Comandos para subsituições.
* orthopoly::                   Polinómios ortogonais.
* plotdf::                      Gráficos de campos de direcções.
* romberg::                     Método de Romberg para integração numerica.
* simplex::                     Programação linear.
* simplification::              Funções e regras de simplificação.
* solve_rec::                   Relações de recorrências lineares.
* stats::                       Pacote de inferências estatísticas.
* stirling::                    Fórmula de Stirling.
* stringproc::                  Manipulação de seqüências de caracteres.
* unit::                        Pacote de unidades e dimensões.
* zeilberger::                  Funções para somatórios hipergeométricos.


Índice

* Índice de Funções e Variáveis:: Índice::

 -- Listagem de Nodos Detalhada --

Introdução

* Introdução ao Maxima::

Ajuda

* Lisp e Maxima::
* Descartando::
* Documentação::
* Funções e Variáveis Definidas para Ajuda::

Linha de Comando

* Introdução a Linha de Comando::
* Funções e Variáveis Definidas para Linha de Comando::

Operadores

* N-Argumentos::
* Operador não fixado::
* Operador Pósfixado::
* Operador Préfixado::
* Operadores Aritméticos::
* Operadores Relacionais::
* Operadores Geral::

Expressões

* Introdução a Expressões::
* Complexo::
* Desigualdade::
* Sintaxe::
* Funções e Variáveis Definidas para Expressões::

Simplificação

* Funções e Variáveis Definidas para Simplificação::

Montando Gráficos

* Funções e Variáveis Definidas para Montagem de Gráficos::

Entrada e Saída

* Comentários::
* Arquivos::
* Funções e Variáveis Definidas para Entrada e Saída::

Ponto Flutuante

* Funções e Variáveis Definidas para ponto Flutuante::

Contextos

* Funções e Variáveis Definidas para Contextos::

Polinômios

* Introdução a Polinômios::
* Funções e Variáveis Definidas para Polinômios::

Constantes

* Funções e Variáveis Definidas para Constantes::

Logarítmos

* Funções e Variáveis Definidas para Logarítmos::

Trigonometria

* Introdução ao Pacote Trigonométrico::
* Funções e Variáveis Definidas para Trigonometria::

Funções Especiais

* Introdução a Funções Especiais::
* Funções e Variáveis Definidas para Funções Especiais::

Funções Elípticas

* Introdução a Funções Elípticas e Integrais::
* Funções e Variáveis Definidas para Funções Elípticas::
* Funções e Variáveis Definidas para Integrais Elípticas::

Limites

* Funções e Variáveis Definidas para Limites::

Diferenciação

* Funções e Variáveis Definidas para Diferenciação::

Integração

* Introdução a Integração::
* Funções e Variáveis Definidas para Integração::

Equações

* Funções e Variáveis Definidas para Equações::

Equações Diferenciais

* Introdução a Equações Diferenciais::
* Funções e Variáveis Definidas para Equações Diferenciais::

Numérico

* Introdução a Numérico::
* Pacotes de Fourier::
* Funções e Variáveis Definidas para Numérico::
* Funções e Variáveis Definidas para Séries de Fourier::

Arrays

* Funções e Variáveis Definidas para Arrays::

Matrizes e Álgebra Linear

* Introdução a Matrizes e Álgebra Linear::
* Ponto::
* Vetores::
* auto::
* Funções e Variáveis Definidas para Matrizes e Álgebra Linear::

Funções Afins

* Funções e Variáveis Definidas para Funções Afins::

itensor

* Introdução a itensor::
* Funções e Variáveis Definidas para itensor::

ctensor

* Introdução a ctensor::
* Funções e Variáveis Definidas para ctensor::

Pacote atensor

* Introdução ao Pacote atensor::
* Funções e Variáveis Definidas para o Pacote atensor::

Séries

* Introdução a Séries::
* Funções e Variáveis Definidas para Séries::

Teoria dos Números

* Funções e Variáveis Definidas para Teoria dos Números::

Simetrias

* Funções e Variáveis Definidas para Simetrias::

Grupos

* Funções e Variáveis Definidas para Grupos::

Ambiente em Tempo de Execução

* Introdução a Ambiente em Tempo de Execução::
* Interrupções::
* Funções e Variáveis Definidas para Ambiente em Tempo de Execução::

Opções Diversas

* Introdução a Opções Diversas::
* Compartilhado::
* Funções e Variáveis Definidas para Opções Diversas::

Regras e Modelos

* Introdução a Regras e Modelos::
* Funções e Variáveis Definidas para Regras e Modelos::

Listas

* Introdução a Listas::
* Funções e Variáveis Definidas para Listas::

Conjuntos

* Introdução a Conjuntos::
* Funções e Variáveis Definidas para Conjuntos::

Definição de Função

* Introdução a Definição de Função::
* Função::
* Macros::
* Funções e Variáveis para Definição de Função::

Fluxo de Programa

* Introdução a Fluxo de Programa::
* Funções e Variáveis Definidas para Fluxo de Programa::

Depurando

* Funções e Variáveis Definidas para Depuração::

augmented_lagrangian

* Funções e Variáveis Definidas para augmented_lagrangian::

bode

* Funções e Variáveis Definidas para bode::

contrib_ode

* Introdução a contrib_ode::
* Funções e Variáveis Definidas para contrib_ode::
* Possibilidades de melhorias em contrib_ode::
* Casos de teste para contrib_ode::
* Referências bibliográficas para contrib_ode::

descriptive

* Introdução ao pacote descriptive::
* Funções e Variáveis Definidas para manipulação da dados::
* Funções e Variáveis Definidas para estatística descritiva::
* Funções e Variáveis Definidas específicas para estatística descritiva de várias variáveis::
* Funções e Variáveis Definidas para gráficos estatísticos::

diag

* Funções e Variáveis Definidas para diag::

distrib

* Introdução a distrib::
* Funções e Variáveis Definidas para distribuições contínuas::
* Funções e Variáveis Definidas para distribuições discretas::

draw

* Introdução a draw::
* Funções e Variáveis Definidas para draw::

dynamics

* Introdução a dynamics::
* Funções e Variáveis Definidas para dynamics::

eval_string

* Funções e Variáveis Definidas para eval_string::

f90

* Funções e Variáveis Definidas para f90::

ggf

* Funções e Variáveis Definidas para ggf::

grobner

* Introdução a grobner::
* Funções e Variáveis Definidas para grobner::

impdiff

* Funções e Variáveis Definidas para impdiff::

implicit_plot

* Funções e Variáveis Definidas para implicit_plot::

interpol

* Introdução a interpol::
* Funções e Variáveis Definidas para interpol::

lbfgs

* Introdução a lbfgs::
* Funções e Variáveis Definidas para lbfgs::

lindstedt

* Funções e Variáveis Definidas para lindstedt::

linearalgebra

* Introdução a linearalgebra::
* Funções e Variáveis Definidas para linearalgebra::

lsquares

* Funções e Variáveis Definidas para lsquares::

makeOrders

* Funções e Variáveis Definidas para makeOrders::

mnewton

* Funções e Variáveis Definidas para mnewton::

numericalio

* Introdução a numericalio::
* Funções e Variáveis Definidas para numericalio::

opsubst

* Funções e Variáveis Definidas para opsubst::

orthopoly

* Introdução a polinômios ortogonais::
* Funções e Variáveis Definidas para polinômios ortogonais::

plotdf

* Introdução a plotdf::
* Funções e Variáveis Definidas para plotdf::

romberg

* Funções e Variáveis Definidas para romberg::

simplex

* Introdução a simplex::
* Funções e Variáveis Definidas para simplex::

simplification

* Introdução a simplification::
* Funções e Variáveis Definidas para simplification::

solve_rec

* Introdução a solve_rec::
* Funções e Variáveis Definidas para solve_rec::

stats

* Introdução a stats::
* Funções e Variáveis Definidas para inference_result::
* Funções e Variáveis Definidas para stats::
* Funções e Variáveis Definidas para distribuições especiais::

stirling

* Funções e Variáveis Definidas para stirling::

stringproc

* Introdução a manipulação de seqüências de caracteres::
* Funções e Variáveis para entrada e saída::
* Funções e Variáveis para caracteres::
* Funções e Variáveis para seqüências de caracteres::

unit

* Introdução a Units::
* Funções e Variáveis Definidas para Units::

zeilberger

* Introdução a zeilberger::
* Funções e Variáveis Definidas para zeilberger::


File: maxima.info,  Node: Introdução ao Maxima,  Next: Detecção e Relato de Erros,  Prev: Top,  Up: Top

1 Introdução ao Maxima
**********************

Inicie o Maxima com o comando "maxima".  Maxima mostrará a informação de
versão e uma linha de comando.  Termine cada comando Maxima com um ponto
e vírgula.  Termine uma sessão com o comando "quit();".  Aqui está um
exemplo de sessão:

     [wfs@chromium]$ maxima
     Maxima 5.9.1 http://maxima.sourceforge.net
     Using Lisp CMU Common Lisp 19a
     Distributed under the GNU Public License. See the file COPYING.
     Dedicated to the memory of William Schelter.
     This is a development version of Maxima. The function bug_report()
     provides bug reporting information.
     (%i1) factor(10!);
                                 8  4  2
     (%o1)                      2  3  5  7
     (%i2) expand ((x + y)^6);
            6        5       2  4       3  3       4  2      5      6
     (%o2) y  + 6 x y  + 15 x  y  + 20 x  y  + 15 x  y  + 6 x  y + x
     (%i3) factor (x^6 - 1);
                                   2            2
     (%o3)       (x - 1) (x + 1) (x  - x + 1) (x  + x + 1)
     (%i4) quit();
     [wfs@chromium]$

   Maxima pode procurar as páginas info.  Use o comando 'describe' para
mostrar informações sobre o comando ou todos os comandos e variáveis
contendo uma seqüência de caracteres.  O ponto de interrogação '?'
(busca exata) e o duplo ponto de interrogação '??' (busca inexata) são
abreviações para 'describe':

     (%i1) ?? integ
      0: Functions and Variables for Elliptic Integrals
      1: Functions and Variables for Integration
      2: Introduction to Elliptic Functions and Integrals
      3: Introduction to Integration
      4: askinteger  (Functions and Variables for Simplification)
      5: integerp  (Functions and Variables for Miscellaneous Options)
      6: integer_partitions  (Functions and Variables for Sets)
      7: integrate  (Functions and Variables for Integration)
      8: integrate_use_rootsof  (Functions and Variables for Integration)
      9: integration_constant_counter  (Functions and Variables for Integration)
      10: nonnegintegerp  (Functions and Variables for linearalgebra)
     Enter space-separated numbers, `all' or `none': 5 4

      -- Function: integerp (<expr>)
          Returns `true' if <expr> is a literal numeric integer, otherwise
          `false'.

          `integerp' returns false if its argument is a symbol, even if the
          argument is declared integer.

          Examples:

               (%i1) integerp (0);
               (%o1)                         true
               (%i2) integerp (1);
               (%o2)                         true
               (%i3) integerp (-17);
               (%o3)                         true
               (%i4) integerp (0.0);
               (%o4)                         false
               (%i5) integerp (1.0);
               (%o5)                         false
               (%i6) integerp (%pi);
               (%o6)                         false
               (%i7) integerp (n);
               (%o7)                         false
               (%i8) declare (n, integer);
               (%o8)                         done
               (%i9) integerp (n);
               (%o9)                         false

      -- Function: askinteger (<expr>, integer)
      -- Function: askinteger (<expr>)
      -- Function: askinteger (<expr>, even)
      -- Function: askinteger (<expr>, odd)
          `askinteger (<expr>, integer)' attempts to determine from the
          `assume' database whether <expr> is an integer.  `askinteger'
          prompts the user if it cannot tell otherwise, and attempt to
          install the information in the database if possible.  `askinteger
          (<expr>)' is equivalent to `askinteger (<expr>, integer)'.

          `askinteger (<expr>, even)' and `askinteger (<expr>, odd)'
          likewise attempt to determine if <expr> is an even integer or odd
          integer, respectively.

     (%o1)                                true

   Para usar um resultado em cálculos posteriores, você pode atribuir
esse valor a uma variável ou referir-se a esse mesmo valor através de
seu rótulo gerado automaticamente.  Adicionalmente, '%' refere-se ao
mais recente resultado calculado:

     (%i1) u: expand ((x + y)^6);
            6        5       2  4       3  3       4  2      5      6
     (%o1) y  + 6 x y  + 15 x  y  + 20 x  y  + 15 x  y  + 6 x  y + x
     (%i2) diff (u, x);
              5         4       2  3       3  2       4        5
     (%o2) 6 y  + 30 x y  + 60 x  y  + 60 x  y  + 30 x  y + 6 x
     (%i3) factor (%o2);
                                         5
     (%o3)                      6 (y + x)

   Maxima tem conhecimento sobre números complexos e constantes
numéricas:

     (%i1) cos(%pi);
     (%o1)                          - 1
     (%i2) exp(%i*%pi);
     (%o2)                          - 1

   Maxima pode fazer cálculos diferenciais e integrais:

     (%i1) u: expand ((x + y)^6);
            6        5       2  4       3  3       4  2      5      6
     (%o1) y  + 6 x y  + 15 x  y  + 20 x  y  + 15 x  y  + 6 x  y + x
     (%i2) diff (%, x);
              5         4       2  3       3  2       4        5
     (%o2) 6 y  + 30 x y  + 60 x  y  + 60 x  y  + 30 x  y + 6 x
     (%i3) integrate (1/(1 + x^3), x);
                                       2 x - 1
                     2            atan(-------)
                log(x  - x + 1)        sqrt(3)    log(x + 1)
     (%o3)    - --------------- + ------------- + ----------
                       6             sqrt(3)          3

   Maxima pode resolver sistemas lineares e equações cúbicas:

     (%i1) linsolve ([3*x + 4*y = 7, 2*x + a*y = 13], [x, y]);
                             7 a - 52        25
     (%o1)              [x = --------, y = -------]
                             3 a - 8       3 a - 8
     (%i2) solve (x^3 - 3*x^2 + 5*x = 15, x);
     (%o2)       [x = - sqrt(5) %i, x = sqrt(5) %i, x = 3]

   Maxima pode resolver sistemas de equações não lineares.  Note que se
você não quer um resultado impresso, você pode encerrar seu comando com
'$' em lugar de encerrar com ';'.

     (%i1) eq_1: x^2 + 3*x*y + y^2 = 0$
     (%i2) eq_2: 3*x + y = 1$
     (%i3) solve ([eq_1, eq_2]);
                   3 sqrt(5) + 7      sqrt(5) + 3
     (%o3) [[y = - -------------, x = -----------],
                         2                 2

                                    3 sqrt(5) - 7        sqrt(5) - 3
                               [y = -------------, x = - -----------]]
                                          2                   2

   Maxima pode gerar gráficos de uma ou mais funções:

     (%i1) eq_1: x^2 + 3*x*y + y^2 = 0$
     (%i2) eq_2: 3*x + y = 1$
     (%i3) solve ([eq_1, eq_2]);
                   3 sqrt(5) + 7      sqrt(5) + 3
     (%o3) [[y = - -------------, x = -----------],
                         2                 2

                                    3 sqrt(5) - 7        sqrt(5) - 3
                               [y = -------------, x = - -----------]]
                                          2                   2
     (%i4) kill(labels);
     (%o0)                         done
     (%i1) plot2d (sin(x)/x, [x, -20, 20]);
     (%o1)
     (%i2) plot2d ([atan(x), erf(x), tanh(x)], [x, -5, 5]);
     (%o2)
     (%i3) plot3d (sin(sqrt(x^2 + y^2))/sqrt(x^2 + y^2), [x, -12, 12], [y, -12, 12]);
     (%o3)


File: maxima.info,  Node: Detecção e Relato de Erros,  Next: Ajuda,  Prev: Introdução ao Maxima,  Up: Top

2 Detecção e Relato de Erros
****************************

* Menu:

* Definições para Detecção e Relato de Erros::


File: maxima.info,  Node: Definições para Detecção e Relato de Erros,  Up: Detecção e Relato de Erros

2.1 Definições para Detecção e Relato de Erros
==============================================

 -- Função: run_testsuite ()
 -- Função: run_testsuite (<boolean>)
 -- Função: run_testsuite (<boolean>, <boolean>)
 -- Função: run_testsuite (<boolean>, <boolean>, <list>)
     Executa o conjunto de testes do Maxima.  Testes que produzem a
     resposta desejada são considerados "passes," e testes que não
     produzem a resposta desejada, são marcados como erros conhecidos.

     'run_testsuite ()' mostra somente testes que não são aprovados.

     'run_testsuite (true)' mostra somente testes que são marcados como
     erros conhecidos, bem como as falhas.

     'run_testsuite (true, true)' mostra todos os testes.

     Se o terceiro argumento opcional for dado, um subconjunto de testes
     é executado.  O subconjunto de testes para executar é dado como uma
     lista de nomes dos testes.  O conjunto completo de testes é
     especificado por 'testsuite_files'.

     'run_testsuite' altera a variável de ambiente Maxima.  Tipicamente
     um script de teste executa 'kill' para estabelecer uma variável de
     ambiente (uma a saber sem funções definidas pelo usuário e
     variáveis) e então define funções e variáveis apropriadamente para
     o teste.

     'run_testsuite' retorna 'done'.

 -- Variável de opção: testsuite_files

     'testsuite_files' é o conjunto de testes a ser executado por
     'run_testsuite'.  Isso é uma lista de nomes de arquivos contendo os
     testes a executar.  Se alguns dos testes em um arquivo falha de
     forma conhecida, então em lugar de listar o nome do arquivo, uma
     lista contendo o nome do arquivo e o número dos testes que falharam
     é usada.

     por exemplo, a linha adinate é uma parte do conjunto de testes
     padrão:

           ["rtest13s", ["rtest14", 57, 63]]

     Essa linha especifica a suite de testes que consiste dos arquivos
     "rtest13s" e "rtest14", mas "rtest14" contém dois testes que falham
     de forma conhecida: 57 e 63.

 -- Função: bug_report ()
     Imprime os números de versão do Maxima e do Lisp, e chama o link
     para a página web de informação de erros do projeto Maxima.  A
     informação da versão é a mesma reportada por 'build_info'.

     Quando um erro é informado, é muito útil copiar a versão do Maxima
     e do Lisp dentro da informação do erro.

     'bug_report' retorna uma seqüência de caracteres vazia '""'.

 -- Função: build_info ()
     Imprime um sumário de parâmetros da compilação do Maxima.

     'build_info' retorna uma seqüência de caracteres vazia '""'.


File: maxima.info,  Node: Ajuda,  Next: Linha de Comando,  Prev: Detecção e Relato de Erros,  Up: Top

3 Ajuda
*******

* Menu:

* Lisp e Maxima::
* Descartando::
* Documentação::
* Funções e Variáveis Definidas para Ajuda::


File: maxima.info,  Node: Lisp e Maxima,  Next: Descartando,  Prev: Ajuda,  Up: Ajuda

3.1 Lisp e Maxima
=================

Maxima é escrito na liguagem de programação Lisp, e é fácil acessar
funções Lisp e variáveis a partir do Maxima e vice-versa.  Símbolos Lisp
e Maxima são distingüidos através de uma convenção de nome.  Um símbolo
Lisp que começa com um sinal de dólar '$' corresponde a um símbolo
Maxima sem o sinal de dólar.  Um símbolo Maxima que começa com um ponto
de interrogação '?' corresponde a um símbolo Lisp sem o ponto de
interrogação.  Por exemplo, o símbolo Maxima 'foo' corresponde ao
símbolo Lisp '$foo', enquanto o símbolo Maxima '?foo' corresponde ao
símbolo Lisp 'foo', Note que '?foo' é escrito sem um espaço entre '?' e
'foo'; de outra forma pode ser uma chamada errônea para 'describe
("foo")'.

   Hífen '-', asterisco '*', ou outro caractere especial em símbolos
Lisp deve ser precedido por uma barra invertida '\' onde ele aparecer no
código Maxima.  Por exemplo, o identificador Lisp '*foo-bar*' é escrito
'?\*foo\-bar\*' no Maxima.

   Código Lisp pode ser executado dentro de uma sessão Maxima.  Uma
linha simples de Lisp (contendo uma ou mais formas) pode ser executada
através do comando especial ':lisp'.  Por exemplo,

     (%i1) :lisp (foo $x $y)

chama a função Lisp 'foo' com variáveis Maxima 'x' e 'y' como
argumentos.  A constução ':lisp' pode aparecer na linha de comando
interativa ou em um arquivo processado por 'batch' ou 'demo', mas não em
um arquivo processado por 'load', 'batchload', 'translate_file', ou
'compile_file'.

   A função 'to_lisp()' abre uma sessão interativa Lisp.  Digitando
'(to-maxima)' fecha a sessão Lisp e retorna para o Maxima.

   Funções Lisp e variáveis que são para serem visíveis no Maxima como
funções e variáveis com nomes comuns (sem pontuação especial) devem ter
nomes Lisp começando com o sinal de dólar '$'.

   Maxima é sensível à caixa, distingue entre letras em caixa alta
(maiúsculas) e letras em caixa baixa (minúsculas) em identificadores,
enquanto Lisp não é sensível à caixa.  Existem algumas regras governando
a tradução de nomes entre o Lisp e o Maxima.

  1. Um identificador Lisp não contido entre barras verticais
     corresponde a um identificador Maxima em caixa baixa.  Se o
     identificador Lisp estiver em caixa alta, caixa baixa, ou caixa
     mista, é ignorado.  E.g., Lisp '$foo', '$FOO', e '$Foo' todos
     correspondem a Maxima 'foo'.
  2. Um identificador Lisp que está todo em caixa alta ou todo em caixa
     baixa e contido em barras verticais corresponde a um identificador
     Maxima com caixa invertida.  Isto é, caixa alta é alterada para
     caixa baixa e caixa baixa para caixa alta.  E.g., Lisp '|$FOO|' e
     '|$foo|' corresponde a Maxima 'foo' e 'FOO', respectivamente.
  3. Um identificador Lisp que é misto de caixa alta e caixa baixa e
     contido entre barras verticais corresponde a um identificador
     Maxima com o mesma caixa.  E.g., Lisp '|$Foo|' corresponde a Maxima
     'Foo'.

   A macro Lisp '#$' permite o uso de expressões Maxima em código Lisp.
'#$<expr>$' expande para uma expressão Lisp equivalente à expressão
Maxima <expr>.

     (msetq $foo #$[x, y]$)

Isso tem o mesmo efeito que digitar

     (%i1) foo: [x, y];

A função Lisp 'displa' imprime uma expressão em formato Maxima.

     (%i1) :lisp #$[x, y, z]$
     ((MLIST SIMP) $X $Y $Z)
     (%i1) :lisp (displa '((MLIST SIMP) $X $Y $Z))
     [x, y, z]
     NIL

   Funções definidas em Maxima não são funções comuns em Lisp.  A função
Lisp 'mfuncall' chama uma função Maxima.  Por exemplo:

     (%i1) foo(x,y) := x*y$
     (%i2) :lisp (mfuncall '$foo 'a 'b)
     ((MTIMES SIMP) A B)

   Algumas funções Lisp possuem o mesmo nome que no pacote Maxima, a
saber as seguintes.

   'complement', 'continue', '//', 'float', 'functionp', 'array', 'exp',
'listen', 'signum', 'atan', 'asin', 'acos', 'asinh', 'acosh', 'atanh',
'tanh', 'cosh', 'sinh', 'tan', 'break', e 'gcd'.


File: maxima.info,  Node: Descartando,  Next: Documentação,  Prev: Lisp e Maxima,  Up: Ajuda

3.2 Descartando
===============

Computação simbólica tende a criar um bom volume de arquivos
temporários, e o efetivo manuseio disso pode ser crucial para sucesso
completo de alguns programas.

   Sob GCL, nos sistemas UNIX onde a chamada de sistema mprotect (
controle de acessso autorizado a uma região de memória) está disponível
(incluindo SUN OS 4.0 e algumas variantes de BSD) uma organização de
arquivos temporários estratificada está disponível.  Isso limita a
organização para páginas que tenham sido recentemente escritas.  Veja a
documentação da GCL sob ALLOCATE e GBC. No ambiente Lisp fazendo (setq
si::*notify-gbc* t) irá ajudar você a determinar quais áreas podem
precisar de mais espaço.


File: maxima.info,  Node: Documentação,  Next: Funções e Variáveis Definidas para Ajuda,  Prev: Descartando,  Up: Ajuda

3.3 Documentação
================

O manual on-line de usuário do Maxima pode ser visto em diferentes
formas.  A partir da linha de comando interativa do Maxima, o manual de
usuário é visto em texto plano através do comando '?' (i.e., a função
'describe' ).  O manual de usuário é visto como hipertexto 'info'
através do programa visualizador 'info' e como uma web page através de
qualquer navegador web comum.

   'example' mostra exemplos de muitas funções do Maxima.  Por exemplo,

     (%i1) example (integrate);

   retorna

     (%i2) test(f):=block([u],u:integrate(f,x),ratsimp(f-diff(u,x)))
     (%o2) test(f) := block([u], u : integrate(f, x),

                                              ratsimp(f - diff(u, x)))
     (%i3) test(sin(x))
     (%o3)                           0
     (%i4) test(1/(x+1))
     (%o4)                           0
     (%i5) test(1/(x^2+1))
     (%o5)                           0

   e saída adicional.


File: maxima.info,  Node: Funções e Variáveis Definidas para Ajuda,  Prev: Documentação,  Up: Ajuda

3.4 Funções e Variáveis Definidas para Ajuda
============================================

 -- Função: demo (<nomearquivo>)
     Avalia expressões Maxima em <nomearquivo> e mostra os resultados.
     'demo' faz uma pausa após avaliar cada expressão e continua após a
     conclusão com um enter das entradas de usuário.  (Se executando em
     Xmaxima, 'demo' pode precisar ver um ponto e vírgula ';' seguido
     por um enter.)

     'demo' procura na lista de diretórios 'file_search_demo' para achar
     'nomearquivo'.  Se o arquivo tiver o sufixo 'dem', o sufixo pode
     ser omitido.  Veja também 'file_search'.

     'demo' avalia seus argumento.  'demo' retorna o nome do arquivo de
     demonstração.

     Exemplo:

          (%i1) demo ("disol");

          batching /home/wfs/maxima/share/simplification/disol.dem
           At the _ prompt, type ';' followed by enter to get next demo
          (%i2)                      load(disol)

          _
          (%i3)           exp1 : a (e (g + f) + b (d + c))
          (%o3)               a (e (g + f) + b (d + c))

          _
          (%i4)                disolate(exp1, a, b, e)
          (%t4)                         d + c

          (%t5)                         g + f

          (%o5)                   a (%t5 e + %t4 b)

          _
          (%i5) demo ("rncomb");

          batching /home/wfs/maxima/share/simplification/rncomb.dem
           At the _ prompt, type ';' followed by enter to get next demo
          (%i6)                     load(rncomb)

          _
                                       z         x
          (%i7)               exp1 : ----- + ---------
                                     y + x   2 (y + x)
                                    z         x
          (%o7)                   ----- + ---------
                                  y + x   2 (y + x)

          _
          (%i8)                     combine(exp1)
                                    z         x
          (%o8)                   ----- + ---------
                                  y + x   2 (y + x)

          _
          (%i9)                     rncombine(%)
                                       2 z + x
          (%o9)                       ---------
                                      2 (y + x)

          _
                                       d   c   b   a
          (%i10)                exp2 : - + - + - + -
                                       3   3   2   2
                                    d   c   b   a
          (%o10)                    - + - + - + -
                                    3   3   2   2

          _
          (%i11)                    combine(exp2)
                                2 d + 2 c + 3 (b + a)
          (%o11)                ---------------------
                                          6

          _
          (%i12)                   rncombine(exp2)
                                2 d + 2 c + 3 b + 3 a
          (%o12)                ---------------------
                                          6

          _
          (%i13)

 -- Função: describe (<string>)
 -- Função: describe (<string>, exact)
 -- Função: describe (<string>, inexact)

     'describe(<string>)' é equivalente a 'describe(<string>, exact)'.

     'describe(<string>, exact)' encontra um item com título igual
     (case-insensitive) a <string>, se existir tal item.

     'describe(<string>, inexact)' encontra todos os itens documentados
     que contiverem <string> em seus títulos.  Se existe mais de um de
     tal item, Maxima solicita ao usuário selecionar um item ou ítens
     para mostrar.

     Na linha de comando interativa, '? foo' (com um espaço entre '?' e
     'foo') é equivalente a 'describe("foo", exact)'.  e '?? foo' é
     equivalente a 'describe("foo", inexact)'.

     'describe("", inexact)' retorna uma lista de todos os tópicos
     documentados no manual on-line.

     'describe' não avalia seu argumento.  'describe' retorna 'true' se
     alguma documentação for encontrada, de outra forma retorna 'false'.

     Veja também *note Documentação::.

     Exemplo:

          (%i1) ?? integ
           0: Functions and Variables for Elliptic Integrals
           1: Functions and Variables for Integration
           2: Introduction to Elliptic Functions and Integrals
           3: Introduction to Integration
           4: askinteger  (Functions and Variables for Simplification)
           5: integerp  (Functions and Variables for Miscellaneous Options)
           6: integer_partitions  (Functions and Variables for Sets)
           7: integrate  (Functions and Variables for Integration)
           8: integrate_use_rootsof  (Functions and Variables for Integration)
           9: integration_constant_counter  (Functions and Variables for Integration)
           10: nonnegintegerp  (Functions and Variables for linearalgebra)
          Enter space-separated numbers, `all' or `none': 7 8

           -- Function: integrate (<expr>, <x>)
           -- Function: integrate (<expr>, <x>, <a>, <b>)
               Attempts to symbolically compute the integral of <expr> with
               respect to <x>.  `integrate (<expr>, <x>)' is an indefinite
               integral, while `integrate (<expr>, <x>, <a>, <b>)' is a definite
               integral, [...]

           -- Option variable: integrate_use_rootsof
               Default value: `false'

               When `integrate_use_rootsof' is `true' and the denominator of a
               rational function cannot be factored, `integrate' returns the
               integral in a form which is a sum over the roots (not yet known)
               of the denominator.
               [...]

     Nesse exemplo, ítens 7 e 8 foram selecionados (a saída foi
     encurtada por razões tipográficas e economico-financeiras como
     indicado por '[...]'.  Todos ou nenhum dos ítens poderia ter sido
     selecionado através da inserção de 'all' ou 'none', que podem ser
     abreviado para 'a' ou para 'n', respectivamente.

 -- Função: example (<tópico>)
 -- Função: example ()
     'example (<topic>)' mostra alguns exemplos de <tópico>, que é um
     símbolo (não uma seqüência de caracteres).  A maioria dos tópicos
     são nomes de função.  'example ()' retorna a lista de todos os
     tópicos reconhecidos.

     O nome do arquivo contendo os exemplos é dado pela variável global
     'manual_demo', cujo valor padrão é '"manual.demo"'.

     'example' não avalia seu argumento.  'example' retorna 'done' a
     menos que ocorra um erro ou não exista o argumento fornecido pelo
     usuário, nesse caso 'example' retorna uma lista de todos os tópicos
     reconhecidos.

     Exemplos:

          (%i1) example (append);
          (%i2) append([x+y,0,-3.2],[2.5E+20,x])
          (%o2)             [y + x, 0, - 3.2, 2.5E+20, x]
          (%o2)                         done
          (%i3) example (coeff);
          (%i4) coeff(b+tan(x)+2*a*tan(x) = 3+5*tan(x),tan(x))
          (%o4)                      2 a + 1 = 5
          (%i5) coeff(1+x*%e^x+y,x,0)
          (%o5)                         y + 1
          (%o5)                         done


File: maxima.info,  Node: Linha de Comando,  Next: Operadores,  Prev: Ajuda,  Up: Top

4 Linha de Comando
******************

* Menu:

* Introdução a Linha de Comando::
* Funções e Variáveis Definidas para Linha de Comando::


File: maxima.info,  Node: Introdução a Linha de Comando,  Next: Funções e Variáveis Definidas para Linha de Comando,  Prev: Linha de Comando,  Up: Linha de Comando

4.1 Introdução a Linha de Comando
=================================

 -- Operador: '
     O operador apóstrofo ''' evita avaliação.

     Aplicado a um símbolo, o apóstrofo evita avaliação do símbolo.

     Aplicado a uma chamada de função, o apóstrofo evita avaliação da
     chamada de função, embora os argumentos da função sejam ainda
     avaliados (se a avaliação não for de outra forma evitada).  O
     resultado é a forma substantiva da chamada de função.

     Aplicada a uma espressão com parêntesis, o apóstrofo evita
     avaliação de todos os símbolos e chamadas de função na expressão.
     E.g., ''(f(x))' significa não avalie a expressão 'f(x)'.  ''f(x)'
     (com apóstrofo aplicado a 'f' em lugar de 'f(x)') retorna a forma
     substantiva de 'f' aplicada a '[x]'.

     O apóstrofo nao evita simplificação.

     Quando o sinalizador global 'noundisp' for 'true', substantivos são
     mostrados com um apóstrofo.  Esse comutador é sempre 'true' quando
     mostrando definições de funções.

     Veja também operador apóstrofo-apóstrofo '''' e 'nouns'.

     Exemplos:

     Aplicado a um símbolo, o apóstrofo evita avaliação do símbolo.

          (%i1) aa: 1024;
          (%o1)                         1024
          (%i2) aa^2;
          (%o2)                        1048576
          (%i3) 'aa^2;
                                           2
          (%o3)                          aa
          (%i4) ''%;
          (%o4)                        1048576

     Aplicado a uma chamada de função, o apóstrofo evita avaliação da
     chamada de função.  O resultado é a forma substantiva da chamada de
     função.

          (%i1) x0: 5;
          (%o1)                           5
          (%i2) x1: 7;
          (%o2)                           7
          (%i3) integrate (x^2, x, x0, x1);
                                         218
          (%o3)                          ---
                                          3
          (%i4) 'integrate (x^2, x, x0, x1);
                                       7
                                      /
                                      [   2
          (%o4)                       I  x  dx
                                      ]
                                      /
                                       5
          (%i5) %, nouns;
                                         218
          (%o5)                          ---
                                          3

     Aplicado a uma expressão com parêntesis, o apóstrofo evita
     avaliação de todos os símbolos e chamadas de função na expressão.

          (%i1) aa: 1024;
          (%o1)                         1024
          (%i2) bb: 19;
          (%o2)                          19
          (%i3) sqrt(aa) + bb;
          (%o3)                          51
          (%i4) '(sqrt(aa) + bb);
          (%o4)                     bb + sqrt(aa)
          (%i5) ''%;
          (%o5)                          51

     O apóstrofo não evita simplificação.

          (%i1) sin (17 * %pi) + cos (17 * %pi);
          (%o1)                          - 1
          (%i2) '(sin (17 * %pi) + cos (17 * %pi));
          (%o2)                          - 1

 -- Operador: ''
     O operador apóstrofo-apóstrofo '''' (dois apóstrofost) modifica
     avaliação em expressões de entrada.

     Aplicado a uma expressão geral <expr>, apóstrofo-apóstrofo faz com
     que o valor de <expr> seja substituído por <expr> na expressão de
     entrada.

     Aplicado ao operadro de uma expressão, apóstrofo-apóstrofo modifica
     o operadro de um susbstantivo para um verbo (se esse operador não
     for já um verbo).

     O operador apóstrofo-apóstrofo é aplicado através do passador de
     entrada; o apóstrofo-apóstrofo não é armazenado como parte de uma
     expressão de entrada passada.  O operador apóstrofo-apóstrofo é
     sempre aplicado tão rapidamente quanto for passado, e não pode
     receber um terceiro apóstrofo.  Dessa forma faz com que ocorra
     avaliação quando essa avaliação for de outra forma suprimida, da
     mesma forma que em definições de função, definições de expressãoes
     lambda, e expressões que recebem um apóstrofo simples '''.

     Apóstrofo-apóstrofo é reconhecido por 'batch' e 'load'.

     Veja também o operador apóstrofo ''' e 'nouns'.

     Exemplos:

     Aplicado a uma expressão geral <expr>, apóstrofo-apóstrofo fazem
     com que o valor de <expr> seja substituido por <expr> na expressão
     de entrada.

          (%i1) expand ((a + b)^3);
                               3        2      2      3
          (%o1)               b  + 3 a b  + 3 a  b + a
          (%i2) [_, ''_];
                                   3    3        2      2      3
          (%o2)     [expand((b + a) ), b  + 3 a b  + 3 a  b + a ]
          (%i3) [%i1, ''%i1];
                                   3    3        2      2      3
          (%o3)     [expand((b + a) ), b  + 3 a b  + 3 a  b + a ]
          (%i4) [aa : cc, bb : dd, cc : 17, dd : 29];
          (%o4)                   [cc, dd, 17, 29]
          (%i5) foo_1 (x) := aa - bb * x;
          (%o5)                 foo_1(x) := aa - bb x
          (%i6) foo_1 (10);
          (%o6)                      cc - 10 dd
          (%i7) ''%;
          (%o7)                         - 273
          (%i8) ''(foo_1 (10));
          (%o8)                         - 273
          (%i9) foo_2 (x) := ''aa - ''bb * x;
          (%o9)                 foo_2(x) := cc - dd x
          (%i10) foo_2 (10);
          (%o10)                        - 273
          (%i11) [x0 : x1, x1 : x2, x2 : x3];
          (%o11)                    [x1, x2, x3]
          (%i12) x0;
          (%o12)                         x1
          (%i13) ''x0;
          (%o13)                         x2
          (%i14) '' ''x0;
          (%o14)                         x3

     Aplicado ao operador de uma expressão, apóstrofo-apóstrofo muda o
     operadro de um substantivo para um verbo (se esse operadro não for
     já um verbo).

          (%i1) sin (1);
          (%o1)                        sin(1)
          (%i2) ''sin (1);
          (%o2)                    0.8414709848079
          (%i3) declare (foo, noun);
          (%o3)                         done
          (%i4) foo (x) := x - 1729;
          (%o4)                 ''foo(x) := x - 1729
          (%i5) foo (100);
          (%o5)                       foo(100)
          (%i6) ''foo (100);
          (%o6)                        - 1629

     O operador apóstrofo-apóstrofo é aplicado por meio de um passador
     de entrada; operador-apóstrofo não é armazenado como parte da
     expressão de entrada.

          (%i1) [aa : bb, cc : dd, bb : 1234, dd : 5678];
          (%o1)                 [bb, dd, 1234, 5678]
          (%i2) aa + cc;
          (%o2)                        dd + bb
          (%i3) display (_, op (_), args (_));
                                     _ = cc + aa

                                   op(cc + aa) = +

                              args(cc + aa) = [cc, aa]

          (%o3)                         done
          (%i4) ''(aa + cc);
          (%o4)                         6912
          (%i5) display (_, op (_), args (_));
                                     _ = dd + bb

                                   op(dd + bb) = +

                              args(dd + bb) = [dd, bb]

          (%o5)                         done

     Apóstrofo apóstrofo faz com que ocorra avaliação quando a avaliação
     tiver sido de outra forma suprimida, da mesma forma que em
     definições de função, da mesma forma que em definições de função
     lambda expressions, E expressões que recebem o apóstrofo simples
     '''.

          (%i1) foo_1a (x) := ''(integrate (log (x), x));
          (%o1)               foo_1a(x) := x log(x) - x
          (%i2) foo_1b (x) := integrate (log (x), x);
          (%o2)           foo_1b(x) := integrate(log(x), x)
          (%i3) dispfun (foo_1a, foo_1b);
          (%t3)               foo_1a(x) := x log(x) - x

          (%t4)           foo_1b(x) := integrate(log(x), x)

          (%o4)                      [%t3, %t4]
          (%i4) integrate (log (x), x);
          (%o4)                     x log(x) - x
          (%i5) foo_2a (x) := ''%;
          (%o5)               foo_2a(x) := x log(x) - x
          (%i6) foo_2b (x) := %;
          (%o6)                    foo_2b(x) := %
          (%i7) dispfun (foo_2a, foo_2b);
          (%t7)               foo_2a(x) := x log(x) - x

          (%t8)                    foo_2b(x) := %

          (%o8)                      [%t7, %t8]
          (%i8) F : lambda ([u], diff (sin (u), u));
          (%o8)             lambda([u], diff(sin(u), u))
          (%i9) G : lambda ([u], ''(diff (sin (u), u)));
          (%o9)                  lambda([u], cos(u))
          (%i10) '(sum (a[k], k, 1, 3) + sum (b[k], k, 1, 3));
          (%o10)         sum(b , k, 1, 3) + sum(a , k, 1, 3)
                              k                  k
          (%i11) '(''(sum (a[k], k, 1, 3)) + ''(sum (b[k], k, 1, 3)));
          (%o11)             b  + a  + b  + a  + b  + a
                              3    3    2    2    1    1


File: maxima.info,  Node: Funções e Variáveis Definidas para Linha de Comando,  Prev: Introdução a Linha de Comando,  Up: Linha de Comando

4.2 Funções e Variáveis Definidas para Linha de Comando
=======================================================

 -- Função: alias (<new_name_1>, <old_name_1>, ..., <new_name_n>,
          <old_name_n>)
     provê um nome alternativo para uma função (de usuário ou de
     sistema), variável, array, etc.  Qualquer número de argumentos pode
     ser usado.

 -- Variável de opção: debugmode
     Valor padrão: 'false'

     Quando um erro do Maxima ocorre, Maxima iniciará o depurador se
     'debugmode' for 'true'.  O usuário pode informar comandos para
     examinar o histórico de chamadas, marcar pontos de parada,
     percorrer uma linha por vez o código do Maxima, e assim por diante.
     Veja 'debugging' para uma lista de opções do depurador.

     Habilitando 'debugmode' por meio da alteração de seu valor para
     'true', não serão capturados erros do Lisp.

 -- Função: ev (<expr>, <arg_1>, ..., <arg_n>)
     Avalia a expressão <expr> no ambiente especificado pelos argumentos
     <arg_1>, ..., <arg_n>.  Os argumentos são comutadores
     (sinalizadores Booleanos), atribuições, equações, e funções.  'ev'
     retorna o resultado (outra expressão) da avaliação.

     A avaliação é realizada em passos, como segue.

       1. Primeiro o ambiente é preparado examinando os argumentos que
          podem ser quaisquer ou todos os seguintes.

             * 'simp' faz com que <expr> seja simplificado
               independentemente da posição do comutador 'simp' que
               inibe simplificação se 'false'.
             * 'noeval' suprime a fase de avaliação de 'ev' (veja passo
               (4) adiante).  Isso é útil juntamente com outros
               comutadores e faz com que <expr> seja simplificado
               novamente sem ser reavaliado.
             * 'nouns' causa a avaliação de formas substantivas
               (tipicamente funções não avaliadas tais como ''integrate'
               ou ''diff') em <expr>.
             * 'expand' causa expansão.
             * 'expand (<m>, <n>)' causa expansão, alterando os valores
               de 'maxposex' e 'maxnegex' para <m> e <n>
               respectivamente.
             * 'detout' faz com que qualquer matriz inversa calculada em
               <expr> tenha seu determinante mantido fora da inversa ao
               invés de dividindo a cada elemento.
             * 'diff' faz com que todas as diferenciações indicadas em
               <expr> sejam executadas.
             * 'derivlist (<x>, <y>, <z>, ...)' causa somente
               diferenciações referentes às variáveis indicadas.
             * 'float' faz com que números racionais não inteiros sejam
               convertidos para ponto flutuante.
             * 'numer' faz com que algumas funções matemáticas
               (incluindo a exponenciação) com argumentos sejam valiadas
               em ponto flutuante.  Isso faz com que variávels em <expr>
               que tenham sido dados numervals (valores numéricos) sejam
               substituídas por seus valores.  Isso também modifica o
               comutador 'float' para ativado.
             * 'pred' faz com que predicados (expressões que podem ser
               avaliados em 'true' ou 'false') sejam avaliadas.
             * 'eval' faz com que uma avaliação posterior de <expr>
               ocorra.  (Veja passo (5) adiante.)  'eval' pode ocorrer
               multiplas vezes.  Para cada instância de 'eval', a
               expressão é avaliada novamente.
             * 'A' onde 'A' é um átomo declarado seja um sinalizador de
               avaliação (veja 'evflag') faz com que 'A' seja associado
               a 'true' durante a avaliação de <expr>.
             * 'V: expresão' (ou alternativamente 'V=expressão') faz com
               que 'V' seja associado ao valor de 'expressão' durante a
               avaliação de <expr>.  Note que se 'V' é uma opção do
               Maxima, então 'expression' é usada para seu valor durante
               a avaliação de <expr>.  Se mais que um argumento para
               'ev' é desse tipo então a associação termina em paralelo.
               Se 'V' é uma expressão não atômica então a substituição,
               ao invés de uma associação, é executada.
             * 'F' onde 'F', um nome de função, tenha sido declarado
               para ser uma função de avaliação (veja 'evfun') faz com
               que 'F' seja aplicado a <expr>.
             * Qualquer outro nome de função (e.g., 'sum') causa a
               avaliação de ocorrências desses nomes em <expr> mesmo que
               eles tenham sido verbos.
             * De forma adicional uma função ocorrendo em <expr>
               (digamos 'F(x)') pode ser definida localmente para o
               propósito dessa avaliação de <expr> dando 'F(x) :=
               expressão' como um argumento para 'ev'.
             * Se um átomo não mensionado acima ou uma variável
               subscrita ou expressão subscrita for dada como um
               argumento, isso é avaliado e se o resultado for uma
               equação ou uma atribuição então a associação indicada ou
               substituição é executada.  Se o resultado for uma lista
               então os membros da lista serão tratados como se eles
               fossem argumentos adicionais dados para 'ev'.  Isso
               permite que uma lista de equações seja dada (e.g.  '[X=1,
               Y=A**2]') ou que seja dado uma lista de nomes de equações
               (e.g., '[%t1, %t2]' onde '%t1' e '%t2' são equações) tais
               como aquelas listas retornadas por 'solve'.

          Os argumentos de 'ev' podem ser dados em qualquer ordem com
          exceção de substituições de equações que são manuseadas em
          seqüência, da esquerda para a direita, e funções de avaliação
          que são compostas, e.g., 'ev (<expr>, ratsimp, realpart)' são
          manuseadas como 'realpart (ratsimp (<expr>))'.

          Os comutadores 'simp', 'numer', 'float', e 'pred' podem também
          ser alterados localmente em um bloco, ou globalmente no Maxima
          dessa forma eles irã permanecer em efeito até serem resetados
          ao término da execução do bloco.

          Se <expr> for uma expressão racional canônica (CRE), então a
          expressão retornada por 'ev' é também uma CRE, contanto que os
          comutadores 'numer' e 'float' não sejam ambos 'true'.

       2. Durante o passo (1), é feito uma lista de variáveis não
          subscritas aparecendo do lado esquerdo das equações nos
          argumentos ou nos valores de alguns argumentos se o valor for
          uma equação.  As variáveis (variáveis subscritas que não
          possuem funções array associadas bem como variáveis não
          subscritas) na expressão <expr> são substituídas por seus
          valores globais, exceto para esse aparecendo nessa lista.
          Usualmente, <expr> é apenas um rótulo ou '%' (como em '%i2' no
          exemplo adiante), então esse passo simplesmente repete a
          expressão nomeada pelo rótulo, de modo que 'ev' possa
          trabalhar sobre isso.

       3. Se quaisquer substituições tiveem sido indicadas pelos
          argumentos, elas serão realizadas agora.

       4. A expressão resultante é então reavaliada (a menos que um dos
          argumentos seja 'noeval') e simplificada conforme os
          argumentos.  Note que qualquer chamada de função em <expr>
          será completada depois das variáveis nela serem avalidas e que
          'ev(F(x))' dessa forma possa comportar-se como 'F(ev(x))'.

       5. Para cada instância de 'eval' nos argumentos, os passos (3) e
          (4) são repetidos.

     Exemplos

          (%i1) sin(x) + cos(y) + (w+1)^2 + 'diff (sin(w), w);
                                               d                    2
          (%o1)              cos(y) + sin(x) + -- (sin(w)) + (w + 1)
                                               dw
          (%i2) ev (%, sin, expand, diff, x=2, y=1);
                                    2
          (%o2)           cos(w) + w  + 2 w + cos(1) + 1.909297426825682

     Uma sintaxe alternativa de alto nível tem sido provida por 'ev',
     por meio da qual se pode apenas digitar seus argumentos, sem o
     'ev()'.  Isto é, se pode escrever simplesmente

          <expr>, <arg_1>, ..., <arg_n>

     Isso não é permitido como parte de outra expressão, e.g., em
     funções, blocos, etc.

     Observe o processo de associação paralela no seguinte exemplo.

          (%i3) programmode: false;
          (%o3)                                false
          (%i4) x+y, x: a+y, y: 2;
          (%o4)                              y + a + 2
          (%i5) 2*x - 3*y = 3$
          (%i6) -3*x + 2*y = -4$
          (%i7) solve ([%o5, %o6]);
          Solution

                                                    1
          (%t7)                               y = - -
                                                    5

                                                   6
          (%t8)                                x = -
                                                   5
          (%o8)                            [[%t7, %t8]]
          (%i8) %o6, %o8;
          (%o8)                              - 4 = - 4
          (%i9) x + 1/x > gamma (1/2);
                                             1
          (%o9)                          x + - > sqrt(%pi)
                                             x
          (%i10) %, numer, x=1/2;
          (%o10)                      2.5 > 1.772453850905516
          (%i11) %, pred;
          (%o11)                               true

 -- Propriedade: evflag
     Quando um símbolo <x> tem a propriedade 'evflag', as expressões
     'ev(<expr>, <x>)' e '<expr>, <x>' (na linha de comando interativa)
     são equivalentes a 'ev(<expr>, <x> = true)'.  Isto é, <x> está
     associada a 'true' enquanto <expr> for avaliada.

     A expressão 'declare(<x>, evflag)' fornece a propriedade 'evflag'
     para a variável <x>.

     Os sinalizadores que possuem a propriedade 'evflag' por padrão são
     os seguintes: 'algebraic', 'cauchysum', 'demoivre', 'dotscrules',
     '%emode', '%enumer', 'exponentialize', 'exptisolate', 'factorflag',
     'float', 'halfangles', 'infeval', 'isolate_wrt_times', 'keepfloat',
     'letrat', 'listarith', 'logabs', 'logarc', 'logexpand',
     'lognegint', 'lognumer', 'm1pbranch', 'numer_pbranch',
     'programmode', 'radexpand', 'ratalgdenom', 'ratfac', 'ratmx',
     'ratsimpexpons', 'simp', 'simpsum', 'sumexpand', e 'trigexpand'.

     Exemplos:

          (%i1) sin (1/2);
                                           1
          (%o1)                        sin(-)
                                           2
          (%i2) sin (1/2), float;
          (%o2)                   0.479425538604203
          (%i3) sin (1/2), float=true;
          (%o3)                   0.479425538604203
          (%i4) simp : false;
          (%o4)                         false
          (%i5) 1 + 1;
          (%o5)                         1 + 1
          (%i6) 1 + 1, simp;
          (%o6)                           2
          (%i7) simp : true;
          (%o7)                         true
          (%i8) sum (1/k^2, k, 1, inf);
                                      inf
                                      ====
                                      \     1
          (%o8)                        >    --
                                      /      2
                                      ====  k
                                      k = 1
          (%i9) sum (1/k^2, k, 1, inf), simpsum;
                                           2
                                        %pi
          (%o9)                         ----
                                         6
          (%i10) declare (aa, evflag);
          (%o10)                        done
          (%i11) if aa = true then SIM else NÃO;
          (%o11)                         NÃO
          (%i12) if aa = true then SIM else NÃO, aa;
          (%o12)                         SIM

 -- Propriedade: evfun
     Quando uma função <F> tem a propriedade 'evfun', as expressões
     'ev(<expr>, <F>)' e '<expr>, <F>' (na linha de comando interativa)
     são equivalentes a '<F>(ev(<expr>))'.

     Se duas ou mais funções <F>, <G>, etc., que possuem a propriedade
     'evfun' forem especificadas, as funções serão aplicadas na ordem em
     que forem especificadas.

     A expressão 'declare(<F>, evfun)' fornece a propriedade 'evfun'
     para a função <F>.

     As funções que possuem a propriedade 'evfun' por padrão são as
     seguintes: 'bfloat', 'factor', 'fullratsimp', 'logcontract',
     'polarform', 'radcan', 'ratexpand', 'ratsimp', 'rectform',
     'rootscontract', 'trigexpand', e 'trigreduce'.

     Exemplos:

          (%i1) x^3 - 1;
                                        3
          (%o1)                        x  - 1
          (%i2) x^3 - 1, factor;
                                          2
          (%o2)                 (x - 1) (x  + x + 1)
          (%i3) factor (x^3 - 1);
                                          2
          (%o3)                 (x - 1) (x  + x + 1)
          (%i4) cos(4 * x) / sin(x)^4;
                                      cos(4 x)
          (%o4)                       --------
                                         4
                                      sin (x)
          (%i5) cos(4 * x) / sin(x)^4, trigexpand;
                           4           2       2         4
                        sin (x) - 6 cos (x) sin (x) + cos (x)
          (%o5)         -------------------------------------
                                          4
                                       sin (x)
          (%i6) cos(4 * x) / sin(x)^4, trigexpand, ratexpand;
                                     2         4
                                6 cos (x)   cos (x)
          (%o6)               - --------- + ------- + 1
                                    2          4
                                 sin (x)    sin (x)
          (%i7) ratexpand (trigexpand (cos(4 * x) / sin(x)^4));
                                     2         4
                                6 cos (x)   cos (x)
          (%o7)               - --------- + ------- + 1
                                    2          4
                                 sin (x)    sin (x)
          (%i8) declare ([F, G], evfun);
          (%o8)                         done
          (%i9) (aa : bb, bb : cc, cc : dd);
          (%o9)                          dd
          (%i10) aa;
          (%o10)                         bb
          (%i11) aa, F;
          (%o11)                        F(cc)
          (%i12) F (aa);
          (%o12)                        F(bb)
          (%i13) F (ev (aa));
          (%o13)                        F(cc)
          (%i14) aa, F, G;
          (%o14)                      G(F(cc))
          (%i15) G (F (ev (aa)));
          (%o15)                      G(F(cc))

 -- Variável de opção: infeval
     Habilita o modo "avaliação infinita".  'ev' repetidamente avalia
     uma expressão até que ela permaneça invariante.  Para prevenir uma
     variável, digamos 'X', seja demoradamente avaliada nesso modo,
     simplesmente inclua 'X='X' como um argumento para 'ev'.  Certamente
     expressões tais como 'ev (X, X=X+1, infeval)' irão gerar um ciclo
     infinito.

 -- Função: kill (<a_1>, ..., <a_n>)
 -- Função: kill (labels)
 -- Função: kill (inlabels, outlabels, linelabels)
 -- Função: kill (<n>)
 -- Função: kill ([<m>, <n>])
 -- Função: kill (values, functions, arrays, ...)
 -- Função: kill (all)
 -- Função: kill (allbut (<a_1>, ..., <a_n>))

     Remove todas as associações (valor, funções, array, ou regra) dos
     argumentos <a_1>, ..., <a_n>.  Um argumento <a_k> pode ser um
     símbolo ou um elemento de array simples.  Quando <a_k> for um
     elemento de array simples, 'kill' remove a associação daquele
     elemento sem afetar qualquer outro elemento do array.

     Muitos argumentos especiais são reconhecidos.  Diferentes famílias
     de argumentos podem ser combinadas, e.g., 'kill (inlabels,
     functions, allbut (foo, bar))'

     todos os rótulos de entrada, de saída, e de expressões
     intermediárias criados até então.  'kill (inlabels)' libera somente
     rótudos de entrada que começam com o valor corrente de 'inchar'.
     De forma semelhante, 'kill (outlabels)' libera somente rótulos de
     saída que começam com o valor corrente de 'outchar', e 'kill
     (linelabels)' libera somente rótulos de expressões intermediárias
     que começam com o valor corrente de 'linechar'.

     'kill (<n>)', onde <n> é um inteiro, libera os <n> mais recentes
     rótulos de entrada e saída.

     'kill ([<m>, <n>])' libera rótulos de entrada e saída de <m> até
     <n>.

     'kill (<infolist>)', onde <infolist> é um item em 'infolists' (tais
     como 'values', 'functions', ou 'arrays') libera todos os ítens em
     <infolist>.  Veja também 'infolists'.

     'kill (all)' liberar todos os ítens em todas as infolists.  'kill
     (all)' não retorna variáveis globais para seus valores padrões;
     Veja 'reset' sobre esse ponto.

     'kill (allbut (<a_1>, ..., <a_n>))' remove a associação de todos os
     itens sobre todas as infolistas exceto para <a_1>, ..., <a_n>.
     'kill (allbut (<infolist>))' libera todos os ítens exceto para si
     próprio em <infolist>, onde <infolist> é 'values', 'functions',
     'arrays', etc.

     A memória usada por uma propriedade de associação não será liberada
     até que todos os símbolos sejam liberados disso.  Em particular,
     para liberar a memória usada pelo valor de um símbolo, deve-se
     liberar o rótulo de saída que mosta o valor associado, bem como
     liberando o próprio símbolo.

     'kill' coloca um apóstro em seus argumentos (não os avalia).  O
     operador apóstrofo-apóstrofo, '''', faz com que ocorra avaliação.

     'kill (<símbolo>)' libera todas as propriedades de <símbolo>.  Em
     oposição, 'remvalue', 'remfunction', 'remarray', e 'remrule'
     liberam uma propriedade específica.

     'kill' sempre retorna 'done', igualmente se um argumento não tem
     associações.

 -- Função: labels (<símbolo>)
 -- Variável de sistema: labels
     Retorna a lista de rótulos de entradas, de saída, de expressões
     intermediárias que começam com <símbolo>.  Tipicamente <símbolo> é
     o valor de 'inchar', 'outchar', ou 'linechar'.  O caracter rótulo
     pode ser dado com ou sem o sinal de porcentagem, então, por
     exemplo, 'i' e '%i' retornam o mesmo resultado.

     Se nenhum rótulo começa com <símbolo>, 'labels' retorna uma lista
     vazia.

     A função 'labels' não avalia seu argumento.  O operador
     apóstrofo-apóstrofo '''' faz com que ocorra avaliação.  Por
     exemplo, 'labels (''inchar)' retorna os rótulos de entrada que
     começam com o caractere corrente do rótulo de entrada.

     A variável 'labels' é uma lista de rótulos de entrada, saída, e de
     expressões intermediárias, incluindo todos os rótulos anteriores se
     'inchar', 'outchar', ou 'linechar' que tiverem sido redefinidos.

     Por padrão, Maxima mostra o resultado de cada expressão de entrada
     do usuário, dando ao resultado um rótulo de saída.  A exibição da
     saída é suprimida pelo encerramento da entrada com '$' (sinal de
     dolar) em lugar de ';' (ponto e vírgula).  Um rótulo de saída é
     construido e associado ao resultado, mas não é mostrado, e o rótulo
     pode ser referenciado da mesma forma que rótulos de saída
     mostrados.  Veja também '%', '%%', e '%th'.

     Rótulos de expressões intermediárias podem ser gerados por algumas
     funções.  O sinalizador 'programmode' controla se 'solve' e algumas
     outras funções geram rótulos de expressões intermediárias em lugar
     de retornar uma lista de expressões.  Algumas outras funções, tais
     como 'ldisplay', sempre geram rótulos de expressões intermediárias.

     Veja também 'inchar', 'outchar', 'linechar', e 'infolists'.

 -- Variável de sistema: linenum
     Retorna o número da linha do par corrente de expressões de entrada
     e saída.

 -- Variável de sistema: myoptions
     Valor padrão: '[]'

     'myoptions' é a lista de todas as opções alguma vez alteradas pelo
     usuário, tenha ou não ele retornado a alteração para o seu valor
     padrão.

 -- Variável de opção: nolabels
     Valor padrão: 'false'

     Quando 'nolabels' for 'true', rótulos de entrada e saída ('%i' e
     '%o', respectivamente) são mostrados, mas os rótulos não são
     associados aos resultados, e os rótulos não são anexados ao final
     da lista 'labels'.  Uma vez que rótulos não são associados aos
     resultados, a reciclagem pode recuperar a memória tomada pelos
     resultados.

     De outra forma rótulos de entrada e saída são associados aos
     resultados, e os rótulos são anexados ao final da lista 'labels'.

     Veja também 'batch', 'batchload', e 'labels'.

 -- Variável de opção: optionset
     Valor padrão: 'false'

     Quando 'optionset' for 'true', Maxima mostrará uma mensagem sempre
     que uma opção do Maxima for alterada.  Isso é útil se o usuário
     está incerto sobre a ortografia de alguma opção e quer ter certeza
     que a variável por ele atribuído um valor foi realmente uma
     variável de opção.

 -- Função: playback ()
 -- Função: playback (<n>)
 -- Função: playback ([<m>, <n>])
 -- Função: playback ([<m>])
 -- Função: playback (input)
 -- Função: playback (slow)
 -- Função: playback (time)
 -- Função: playback (grind)
     Mostra expressões de entrada, de saída, e expressões
     intermediárias, sem refazer os cálculos.  'playback' somente mostra
     as expressões associadas a rótulos; qualquer outra saída (tais como
     textos impressos por 'print' ou 'describe', ou messagens de erro)
     não é mostrada.  Veja também 'labels'.

     'playback' não avalia seus argumentos.  O operador
     apóstrofo-apóstrofo, '''', sobrepõe-se às aspas.  'playback' sempre
     retorna 'done'.

     'playback ()' (sem argumentos) mostra todas as entradas, saídas e
     expressões intermediárias geradas até então.  Uma expressão de
     saída é mostrada mesmo se for suprimida pelo terminador '$' quando
     ela tiver sido originalmente calculada.

     'playback (<n>)' mostra as mais recentes <n> expressões.  Cada
     entrada, saída e expressão intermediária conta como um.

     'playback ([<m>, <n>])' mostra entradas, saídas e expressões
     intermediárias com os números de <m> até <n>, inclusive.

     'playback ([<m>])' é equivalente a 'playback ([<m>, <m>])'; isso
     usualmente imprime um par de expressões de entrada e saída.

     'playback (input)' mostra todas as expressões de entrada geradas
     até então.

     'playback (slow)' insere pausas entre expressões e espera que o
     usuário pressione 'enter'.  Esse comportamento é similar a 'demo'.
     'playback (slow)' é útil juntamente com 'save' ou 'stringout'
     quando criamos um arquivo secundário de armazenagem com a
     finalidade de capturar expressões úteis.

     'playback (time)' mostra o tempo de computação de cada expressão.

     'playback (grind)' mostra expressões de entrada no mesmo formato da
     função 'grind'.  Expressões de saída não são afetadas pela opção
     'grind'.  Veja 'grind'.

     Argumentos podem ser combinados, e.g., 'playback ([5, 10], grind,
     time, slow)'.

 -- Função: printprops (<a>, <i>)
 -- Função: printprops ([<a_1>, ..., <a_n>], <i>)
 -- Função: printprops (all, <i>)
     Mostra a propriedade como o indicador <i> associada com o átomo
     <a>.  <a> pode também ser uma lista de átomos ou o átomo 'all'
     nesse caso todos os átomos com a propriedade dada serão usados.
     Por exemplo, 'printprops ([f, g], atvalue)'.  'printprops' é para
     propriedades que não podem ser mostradas de outra forma, i.e.  para
     'atvalue', 'atomgrad', 'gradef', e 'matchdeclare'.

 -- Variável de opção: prompt
     Valor padrão: '_'

     'prompt' é o símbolo de linha de comando da função 'demo', modo
     'playback (slow)', e da interrupção de ciclos do Maxima (como
     invocado por 'break').

 -- Função: quit ()
     Encerra a sessão do Maxima.  Note que a função pode ser invocada
     como 'quit();' ou 'quit()$', não por sí mesma 'quit'.

     Para parar um cálculo muito longo, digite 'control-C'.  A ação
     padrão é retornar à linha de comando do Maxima.  Se
     '*debugger-hook*' é 'nil', 'control-C' abre o depurador Lisp.  Veja
     também 'debugging'.

 -- Função: remfunction (<f_1>, ..., <f_n>)
 -- Função: remfunction (all)
     Desassocia as definições de função dos síbolos <f_1>, ..., <f_n>.
     Os argumentos podem ser os nomes de funções comuns (criadas por
     meio de ':=' ou 'define') ou funções macro (criadas por meio de
     '::=').

     'remfunction (all)' desassocia todas as definições de funcção.

     'remfunction' coloca um ap'ostrofo em seus argumentos (não os
     avalia).

     'remfunction' retorna uma lista de símbolos para a qual a definição
     de função foi desassociada.  'false' é retornado em lugar de
     qualquer símbolo para o qual não exista definição de função.

 -- Função: reset ()
     Retorna muitas variáveis globais e opções, e algumas outras
     variáveis, para seus valores padrões.

     'reset' processa as variáveis na lista Lisp
     '*variable-initial-values*'.  A macro Lisp 'defmvar' coloca
     variáveis nessa lista (entre outras ações).  Muitas, mas não todas,
     variáveis globais e opções são definidas por 'defmvar', e algumas
     variáveis definidas por 'defmvar' não são variáveis globais ou
     variáveis de opção.

 -- Variável de opção: showtime
     Valor padrão: 'false'

     Quando 'showtime' for 'true', o tempo de computação e o tempo
     decorrido são impressos na tela com cada expressão de saída.

     O tempo de cálculo é sempre gravado, então 'time' e 'playback'
     podem mostrar o tempo de cálculo mesmo quando 'showtime' for
     'false'.

     Veja também 'timer'.

 -- Função: sstatus (<recurso>, <pacote>)
     Altera o status de <recurso> em <pacote>.  Após 'sstatus
     (<recurso>, <pacote>)' ser executado, 'status (<recurso>,
     <pacote>)' retorna 'true'.  Isso pode ser útil para quem escreve
     pacotes, para manter um registro de quais recursos os pacotes usam.

 -- Função: to_lisp ()
     Insere o sistema Lisp dentro do Maxima.  '(to-maxima)' retorna para
     o Maxima.

 -- Variável de sistema: values
     Valor inicial: '[]'

     'values' é uma lista de todas as varáveis de usuário associadas
     (não opções Maxima ou comutadores).  A lista compreende símbolos
     associados por ':' , '::', ou ':='.


File: maxima.info,  Node: Operadores,  Next: Expressões,  Prev: Linha de Comando,  Up: Top

5 Operadores
************

* Menu:

* N-Argumentos::
* Operador não fixado::
* Operador Pósfixado::
* Operador Préfixado::
* Operadores Aritméticos::
* Operadores Relacionais::
* Operadores Geral::


File: maxima.info,  Node: N-Argumentos,  Next: Operador não fixado,  Prev: Operadores,  Up: Operadores

5.1 N-Argumentos
================

Um operador 'nary' é usado para denotar uma função com qualquer número
de argumentos, cada um dos quais é separado por uma ocorrência do
operador, e.g.  A+B ou A+B+C. A função 'nary("x")' é uma função de
extensão sintática para declarar x como sendo um operador 'nary'.
Funções podem ser declaradas para serem 'nary'.  Se 'declare(j,nary);' é
concluída, diz ao simplicador para simplificar, e.g.  'j(j(a,b),j(c,d))'
para 'j(a, b, c, d)'.

   Veja também 'syntax'.


File: maxima.info,  Node: Operador não fixado,  Next: Operador Pósfixado,  Prev: N-Argumentos,  Up: Operadores

5.2 Operador não fixado
=======================

Operadores 'nofix' são usados para denotar funções sem argumentos.  A
mera presença de tal operador em um comando fará com que a função
correspondente seja avaliada.  Por exemplo, quando se digita "exit;"
para sair de uma parada do Maxima, "exit" tem comportamento similar a um
operador 'nofix'.  A função 'nofix("x")' é uma função de extensão
sintática que declara x como sendo um operador 'nofix'.

   Veja também 'syntax'.


File: maxima.info,  Node: Operador Pósfixado,  Next: Operador Préfixado,  Prev: Operador não fixado,  Up: Operadores

5.3 Operador Pósfixado
======================

Operadores 'postfix' como a variedade 'prefix' denotam funções de um
argumento simples, mas nesse caso o argumento sucede imediatamente uma
ocorrência do operador na seqüência de caracteres de entrada, e.g.  3!
.  Uma função 'postfix("x")' é uma função de extensão sintática que
declara x como sendo um operador 'postfix'.

   Veja também 'syntax'.


File: maxima.info,  Node: Operador Préfixado,  Next: Operadores Aritméticos,  Prev: Operador Pósfixado,  Up: Operadores

5.4 Operador Préfixado
======================

Um operador 'prefix' é um que significa uma função de um argumento, o
qual imediatamente segue uma ocorrência do operador.  'prefix("x")' é
uma função de extensão sintática que declara x como sendo um operador
'prefix'.

   Veja também 'syntax'.


File: maxima.info,  Node: Operadores Aritméticos,  Next: Operadores Relacionais,  Prev: Operador Préfixado,  Up: Operadores

5.5 Operadores Aritméticos
==========================

 -- Operador: +
 -- Operador: -
 -- Operador: *
 -- Operador: /
 -- Operador: ^

     Os símbolos '+' '*' '/' e '^' representam adição, multiplicação,
     divisão, e exponenciação, respectivamente.  O nome desses
     operadores são '"+"' '"*"' '"/"' e '"^"', os quais podem aparecer
     em lugares onde o nome da função ou operador é requerido.

     Os símbolos '+' e '-' representam a adição unária e a negação
     unária, respectivamente, e os nomes desses operadores são '"+"' e
     '"-"', respectivamente.

     A subtração 'a - b' é representada dentro do Maxima como a adição,
     'a + (- b)'.  Expressões tais como 'a + (- b)' são mostradas como
     subtração.  Maxima reconhece '"-"' somente como o nome do operador
     unário de negação, e não como o nome do operador binário de
     subração.

     A divisão 'a / b' é representada dentro do Maxima como
     multiplicação, 'a * b^(- 1)'.  Expressões tais como 'a * b^(- 1)'
     são mostradas como divisão.  Maxima reconhece '"/"' como o nome do
     operador de divisão.

     A adição e a multiplicação são operadores enários e comutativos.  a
     divisão e a exponenciação são operadores binários e não
     comutativos.

     Maxima ordena os operandos de operadores não comutativos para
     construir uma representação canônica.  Para armazenamento interno,
     a ordem é determinada por 'orderlessp'.  Para mostrar na tela, a
     ordem para adição é determinada por 'ordergreatp', e para a
     multiplicação, a ordem é a mesma da ordenação para armazenamento
     interno.

     Computações aritiméticas são realizadas sobre números literais
     (inteiro, racionais, números comuns em ponto flutuante, e grandes
     números em ponto flutuante de dupla precisão).  Execto a
     exponenciação, todas as operações aritméticas sobre números são
     simplificadas para números.  A exponenciação é simplificada para um
     número se ou o operando é um número comum em ponto flutuante ou um
     grande número em ponto flutuante de dupla precisão ou se o
     resultado for um inteiro exato ou um racional exato; de outra forma
     uma exponenciação pode ser simplificada para 'sqrt' ou outra
     exponenciação ou permanecer inalterada.

     A propagação de números em ponto flutuante aplica-se a computações
     aritiméticas: Se qualquer operando for um grande número em ponto
     flutuante, o resultado é um grande número em ponto flutuante; de
     outra forma, se qualquer operando for um número em ponto flutuante
     comum, o resultado é um número comum em ponto flutuante; de outra
     forma, se os operandos forem racioanis ou inteiros e o resultado
     será um racional ou inteiro.

     Computaçãoes aritiméticas são uma simplificação, não uma avaliação.
     Dessa forma a aritmética é realizada em expressões com apóstrofo
     (mas simplificadas).

     Operações aritméticas são aplicadas elemento-por-elemento para
     listas quando a variável global 'listarith' for 'true', e sempre
     aplicada elemento-por-elemento para matrizes.  Quando um operando
     for uma lista ou uma matriz e outro for um operando de algum outro
     tipo, o outro operando é combinado com cada um dos elementos da
     lista ou matriz.

     Exemplos:

     Adição e multiplicação são opeadores enários comutativos.  Maxima
     ordena os operandos para construir uma representação canônica.  Os
     nomes desses operadores são '"+"' e '"*"'.

          (%i1) c + g + d + a + b + e + f;
          (%o1)               g + f + e + d + c + b + a
          (%i2) [op (%), args (%)];
          (%o2)              [+, [g, f, e, d, c, b, a]]
          (%i3) c * g * d * a * b * e * f;
          (%o3)                     a b c d e f g
          (%i4) [op (%), args (%)];
          (%o4)              [*, [a, b, c, d, e, f, g]]
          (%i5) apply ("+", [a, 8, x, 2, 9, x, x, a]);
          (%o5)                    3 x + 2 a + 19
          (%i6) apply ("*", [a, 8, x, 2, 9, x, x, a]);
                                           2  3
          (%o6)                       144 a  x

     Divisão e exponenciação são operadores binários e não comutativos.
     Os nomes desses operadores são '"/"' e '"^"'.

          (%i1) [a / b, a ^ b];
                                        a   b
          (%o1)                        [-, a ]
                                        b
          (%i2) [map (op, %), map (args, %)];
          (%o2)              [[/, ^], [[a, b], [a, b]]]
          (%i3) [apply ("/", [a, b]), apply ("^", [a, b])];
                                        a   b
          (%o3)                        [-, a ]
                                        b

     Subtração e divisão são representados internamente em termos de
     adição e multiplicação, respectivamente.

          (%i1) [inpart (a - b, 0), inpart (a - b, 1), inpart (a - b, 2)];
          (%o1)                      [+, a, - b]
          (%i2) [inpart (a / b, 0), inpart (a / b, 1), inpart (a / b, 2)];
                                             1
          (%o2)                       [*, a, -]
                                             b

     Cálculos são realizados sobre números lterais.  A propagação de
     números em poto flutuante aplica-se.

          (%i1) 17 + b - (1/2)*29 + 11^(2/4);
                                                 5
          (%o1)                   b + sqrt(11) + -
                                                 2
          (%i2) [17 + 29, 17 + 29.0, 17 + 29b0];
          (%o2)                   [46, 46.0, 4.6b1]

     Computações aritméticas são uma simplificação, não uma avaliação.

          (%i1) simp : false;
          (%o1)                         false
          (%i2) '(17 + 29*11/7 - 5^3);
                                        29 11    3
          (%o2)                    17 + ----- - 5
                                          7
          (%i3) simp : true;
          (%o3)                         true
          (%i4) '(17 + 29*11/7 - 5^3);
                                          437
          (%o4)                         - ---
                                           7

     A aritmética é realizada elemento-por-elemento para listas lists
     (dependendo de 'listarith') e dependendo de matrizes.

          (%i1) matrix ([a, x], [h, u]) - matrix ([1, 2], [3, 4]);
                                  [ a - 1  x - 2 ]
          (%o1)                   [              ]
                                  [ h - 3  u - 4 ]
          (%i2) 5 * matrix ([a, x], [h, u]);
                                    [ 5 a  5 x ]
          (%o2)                     [          ]
                                    [ 5 h  5 u ]
          (%i3) listarith : false;
          (%o3)                         false
          (%i4) [a, c, m, t] / [1, 7, 2, 9];
                                    [a, c, m, t]
          (%o4)                     ------------
                                    [1, 7, 2, 9]
          (%i5) [a, c, m, t] ^ x;
                                                x
          (%o5)                     [a, c, m, t]
          (%i6) listarith : true;
          (%o6)                         true
          (%i7) [a, c, m, t] / [1, 7, 2, 9];
                                        c  m  t
          (%o7)                     [a, -, -, -]
                                        7  2  9
          (%i8) [a, c, m, t] ^ x;
                                    x   x   x   x
          (%o8)                   [a , c , m , t ]

 -- Operador: **

     Operador de exponenciação.  Maxima reconhece '**' como o mesmo
     operador que '^' em entrada, e '**' é mostrado como '^' em saída
     unidimensional, ou colocando o expoente como sobrescrito em saída
     bidimensional.

     A função 'fortran' mostra o operador de exponenciação com como
     '**', independente de a entrada ter sido na forma '**' ou a forma
     '^'.

     Exemplos:

          (%i1) is (a**b = a^b);
          (%o1)                         true
          (%i2) x**y + x^z;
                                        z    y
          (%o2)                        x  + x
          (%i3) string (x**y + x^z);
          (%o3)                        x^z+x^y
          (%i4) fortran (x**y + x^z);
                x**z+x**y
          (%o4)                         done


File: maxima.info,  Node: Operadores Relacionais,  Next: Operadores Geral,  Prev: Operadores Aritméticos,  Up: Operadores

5.6 Operadores Relacionais
==========================

 -- Operador: <
 -- Operador: <=
 -- Operador: >=
 -- Operador: >


File: maxima.info,  Node: Operadores Geral,  Prev: Operadores Relacionais,  Up: Operadores

5.7 Operadores Geral
====================

 -- Operador: ^^

 -- Operador: !
     O operador fatorial.  Para qualquer número complexo 'x' (incluíndo
     números inteiros, racionais, e reais) exceto para inteiros
     negativos, 'x!' é definido como 'gamma(x+1)'.

     Para um inteiro 'x', 'x!' simplifica para o produto de inteiros de
     1 a 'x' inclusive.  '0!' simplifica para 1.  Para um número em
     ponto flutuante 'x', 'x!' simplifica para o valor de 'gamma (x+1)'.
     Para 'x' igual a 'n/2' onde 'n' é um inteiro ímpar, 'x!' simplifica
     para um fator racional vezes 'sqrt (%pi)' (uma vez que 'gamma
     (1/2)' é igual a 'sqrt (%pi)').  Se 'x' for qualquer outra coisa,
     'x!' não é simplificado.

     As variáveis 'factlim', 'minfactorial', e 'factcomb' controlam a
     simplificação de expressões contendo fatoriais.

     As funções 'gamma', 'bffac', e 'cbffac' são variedades da função
     'gamma'.  'makegamma' substitui 'gamma' para funções relacionadas a
     fatoriais.

     Veja também 'binomial'.

     O fatorial de um inteiro, inteiro dividido por dois, ou argumento
     em ponto flutuante é simplificado a menos que o operando seja maior
     que 'factlim'.

          (%i1) factlim : 10;
          (%o1)                          10
          (%i2) [0!, (7/2)!, 4.77!, 8!, 20!];
          +            105 sqrt(%pi)
          +(%o2)   [1, -------------, 81.44668037931199, 40320, 20!]
          +                 16

     O fatorial de um número complexo, constante conhecida, ou expressão
     geral não é simplificado.  Ainda assim pode ser possível
     simplificar o fatorial após avaliar o operando.

          (%i1) [(%i + 1)!, %pi!, %e!, (cos(1) + sin(1))!];
          (%o1)      [(%i + 1)!, %pi!, %e!, (sin(1) + cos(1))!]
          (%i2) ev (%, numer, %enumer);
          (%o2) [(%i + 1)!, 7.188082728976037, 4.260820476357,
                                                         1.227580202486819]

     O fatorial de um símbolo não associado não é simplificado.

          (%i1) kill (foo);
          (%o1)                         done
          (%i2) foo!;
          (%o2)                         foo!

     Fatoriais são simplificados, não avaliados.  Dessa forma 'x!' pode
     ser substituído mesmo em uma expressão com apóstrofo.

          (%i1) '([0!, (7/2)!, 4.77!, 8!, 20!]);
                    105 sqrt(%pi)
          (%o1) [1, -------------, 81.44668037931199, 40320,
                         16
                                                       2432902008176640000]

 -- Operador: !!
     O operador de duplo fatorial.

     Para um número inteiro, número em ponto flutuante, ou número
     racional 'n', 'n!!' avalia para o produto 'n (n-2) (n-4) (n-6) ...
     (n - 2 (k-1))' onde 'k' é igual a 'entier (n/2)', que é, o maior
     inteiro menor que ou igual a 'n/2'.  Note que essa definição não
     coincide com outras definições publicadas para argumentos que não
     são inteiros.

     Para um inteiro par (ou ímpar) 'n', 'n!!' avalia para o produto de
     todos os inteiros consecutivos pares (ou ímpares) de 2 (ou 1) até
     'n' inclusive.

     Para um argumento 'n' que não é um número inteiro, um número em
     ponto flutuante, ou um número racional, 'n!!' retorna uma forma
     substantiva 'genfact (n, n/2, 2)'.

 -- Operador: #
     Representa a negação da igualdade sintática '='.

     Note que pelo fato de as regras de avaliação de expressões
     predicadas (em particular pelo fato de 'not <expr>' fazer com que
     ocorra a avaliação de <expr>), a forma 'not <a> = <b>' não é
     equivalente à forma '<a> # <b>' em alguns casos.

     Note que devido às regras para avaliação de expressões predicadas
     (em particular devido a 'not <expr>' fazer com que a avaliação de
     <expr> ocorra), 'not <a> = <b>' é equivalente a 'is(<a> # <b>)', em
     lugar de ser equivalente a '<a> # <b>'.

     Exemplos:
          (%i1) a = b;
          (%o1)                         a = b
          (%i2) é (a = b);
          (%o2)                         false
          (%i3) a # b;
          (%o3)                         a # b
          (%i4) not a = b;
          (%o4)                         true
          (%i5) é (a # b);
          (%o5)                         true
          (%i6) é (not a = b);
          (%o6)                         true

 -- Operador: .
     O operador ponto, para multiplicação (não comutativa) de matrizes.
     Quando "."  é usado com essa finalidade, espaços devem ser
     colocados em ambos os lados desse operador, e.g.  A .  B. Isso
     distingüe o operador ponto plenamente de um ponto decimal em um
     número em ponto flutuante.

     Veja também 'dot', 'dot0nscsimp', 'dot0simp', 'dot1simp',
     'dotassoc', 'dotconstrules', 'dotdistrib', 'dotexptsimp',
     'dotident', e 'dotscrules'.

 -- Operador: :
     O operador de atribuição.  E.g.  A:3 escolhe a variável A para 3.

 -- Operador: ::
     Operador de atribuição.  :: atribui o valor da expressão em seu
     lado direito para o valor da quantidade na sua esquerda, que pode
     avaliar para uma variável atômica ou variável subscrita.

 -- Operador: ::=
     Operador de definição de função de macro.  '::=' define uma função
     (chamada uma "macro" por razões históricas) que coloca um apóstrofo
     em seus argumentos (evitando avaliação), e a expressão que é
     retornada (chamada a "expansão de macro") é avaliada no contexto a
     partir do qual a macro foi chamada.  Uma função de macro é de outra
     forma o mesmo que uma função comum.

     'macroexpand' retorna uma expansão de macro (sem avaliar a
     expansão).  'macroexpand (foo (x))' seguida por '''%' é equivalente
     a 'foo (x)' quando 'foo' for uma função de macro.

     '::=' coloca o nome da nova função de macro dentro da lista global
     'macros'.  'kill', 'remove', e 'remfunction' desassocia definições
     de função de macro e remove nomes de 'macros'.

     'fundef' e 'dispfun' retornam respectivamente uma definição de
     função de macro e uma atribuição dessa definição a um rótulo,
     respectivamente.

     Funções de macro comumente possuem expressões 'buildq' e 'splice'
     para construir uma expressão, que é então avaliada.

     Exemplos

     Uma função de macro coloca um apóstrofo em seus argumentos evitando
     então a avaliação, então mensagem (1) mostra 'y - z', não o valor
     de 'y - z'.  A expansão de macro (a expressão com apóstrofo
     ''(print ("(2) x is equal to", x))' é avaliada no contexto a partir
     do qual a macro for chamada, mostrando a mensagem (2).

          (%i1) x: %pi;
          (%o1)                          %pi
          (%i2) y: 1234;
          (%o2)                         1234
          (%i3) z: 1729 * w;
          (%o3)                        1729 w
          (%i4) printq1 (x) ::= block (print ("(1) x é igual a", x), '(print ("(2) x é igual a", x)));
          (%o4) printq1(x) ::= block(print("(1) x é igual a", x),
                                          '(print("(2) x é igual a", x)))
          (%i5) printq1 (y - z);
          (1) x é igual a y - z
          (2) x é igual a %pi
          (%o5)                          %pi

     Uma função comum avalia seus argumentos, então message (1) mostra o
     valor de 'y - z'.  O valor de retorno não é avaliado, então
     mensagem (2) não é mostrada até a avaliação explícita '''%'.

          (%i1) x: %pi;
          (%o1)                          %pi
          (%i2) y: 1234;
          (%o2)                         1234
          (%i3) z: 1729 * w;
          (%o3)                        1729 w
          (%i4) printe1 (x) := block (print ("(1) x é igual a", x), '(print ("(2) x é igual a", x)));
          (%o4) printe1(x) := block(print("(1) x é igual a", x),
                                          '(print("(2) x é igual a", x)))
          (%i5) printe1 (y - z);
          (1) x é igual a 1234 - 1729 w
          (%o5)              print((2) x é igual a, x)
          (%i6) ''%;
          (2) x é igual a %pi
          (%o6)                          %pi

     'macroexpand' retorna uma expansão de macro.  'macroexpand (foo
     (x))' seguido por '''%' é equivalente a 'foo (x)' quando 'foo' for
     uma função de macro.

          (%i1) x: %pi;
          (%o1)                          %pi
          (%i2) y: 1234;
          (%o2)                         1234
          (%i3) z: 1729 * w;
          (%o3)                        1729 w
          (%i4) g (x) ::= buildq ([x], print ("x é igual a", x));
          (%o4)    g(x) ::= buildq([x], print("x é igual a", x))
          (%i5) macroexpand (g (y - z));
          (%o5)              print(x é igual a, y - z)
          (%i6) ''%;
          x é igual a 1234 - 1729 w
          (%o6)                     1234 - 1729 w
          (%i7) g (y - z);
          x é igual a 1234 - 1729 w
          (%o7)                     1234 - 1729 w

 -- Operador: :=
     O operador de definição de função.  E.g.  'f(x):=sin(x)' define uma
     função 'f'.

 -- Operador: =
     O operador de equação.

     Uma expressão '<a> = <b>', por si mesma, representa uma equação não
     avaliada, a qual pode ou não se manter.  Equações não avaliadas
     podem aparecer como argumentos para 'solve' e 'algsys' ou algumas
     outras funções.

     A função 'is' avalia '=' para um valor Booleano.  'is(<a> = <b>)'
     avalia '<a> = <b>' para 'true' quando <a> e <b> forem idênticos.
     Isto é, <a> e <b> forem átomos que são idênticos, ou se eles não
     forem átomos e seus operadores forem idênticos e seus argumentos
     forem idênticos.  De outra forma, 'is(<a> = <b>)' avalia para
     'false'; 'is(<a> = <b>)' nunca avalia para 'unknown'.  Quando
     'is(<a> = <b>)' for 'true', <a> e <b> são ditos para serem
     sintaticamente iguais, em contraste para serem expressões
     equivalentes, para as quais 'is(equal(<a>, <b>))' é 'true'.
     Expressões podem ser equivalentes e não sintáticamente iguais.

     A negação de '=' é representada por '#'.  Da mesma forma que com
     '=', uma expressão '<a> # <b>', por si mesma, não é avaliada.
     'is(<a> # <b>)' avalia '<a> # <b>' para 'true' ou 'false'.

     Complementando a função 'is', alguns outros operadores avaliam '='
     e '#' para 'true' ou 'false', a saber 'if', 'and', 'or', e 'not'.

     Note que pelo fato de as regras de avaliação de expressões
     predicadas (em particular pelo fato de 'not <expr>' fazer com que
     ocorra a avaliação de <expr>), a forma 'not <a> = <b>' é
     equivalente a 'is(<a> # <b>)', em lugar de ser equivalente a '<a> #
     <b>'.

     'rhs' e 'lhs' retornam o primeiro membro e o segundo membro de uma
     equação, respectivamente, de uma equação ou inequação.

     Veja também 'equal' e 'notequal'.

     Exemplos:

     Uma expressão '<a> = <b>', por si mesma, representa uma equação não
     avaliada, a qual pode ou não se manter.

          (%i1) eq_1 : a * x - 5 * y = 17;
          (%o1)                    a x - 5 y = 17
          (%i2) eq_2 : b * x + 3 * y = 29;
          (%o2)                    3 y + b x = 29
          (%i3) solve ([eq_1, eq_2], [x, y]);
                                  196         29 a - 17 b
          (%o3)          [[x = ---------, y = -----------]]
                               5 b + 3 a       5 b + 3 a
          (%i4) subst (%, [eq_1, eq_2]);
                   196 a     5 (29 a - 17 b)
          (%o4) [--------- - --------------- = 17,
                 5 b + 3 a      5 b + 3 a
                                            196 b     3 (29 a - 17 b)
                                          --------- + --------------- = 29]
                                          5 b + 3 a      5 b + 3 a
          (%i5) ratsimp (%);
          (%o5)                  [17 = 17, 29 = 29]

     'is(<a> = <b>)' avalia '<a> = <b>' para 'true' quando <a> e <b> são
     sintaticamente iguais (isto é, identicos).  Expressões podem ser
     equivalentes e não sintaticamente iguais.

          (%i1) a : (x + 1) * (x - 1);
          (%o1)                    (x - 1) (x + 1)
          (%i2) b : x^2 - 1;
                                        2
          (%o2)                        x  - 1
          (%i3) [is (a = b), is (a # b)];
          (%o3)                     [false, true]
          (%i4) [is (equal (a, b)), is (notequal (a, b))];
          (%o4)                     [true, false]

     Alguns operadores avaliam '=' e '#' para 'true' ou 'false'.

          (%i1) if expand ((x + y)^2) = x^2 + 2 * x * y + y^2 then FOO else BAR;
          (%o1)                          FOO
          (%i2) eq_3 : 2 * x = 3 * x;
          (%o2)                       2 x = 3 x
          (%i3) eq_4 : exp (2) = %e^2;
                                        2     2
          (%o3)                       %e  = %e
          (%i4) [eq_3 and eq_4, eq_3 or eq_4, not eq_3];
          (%o4)                  [false, true, true]

     Devido a 'not <expr>' fazer com que a avaliação de <expr> ocorra,
     'not <a> = <b>' é equivalente a 'is(<a> # <b>)'.

          (%i1) [2 * x # 3 * x, not (2 * x = 3 * x)];
          (%o1)                   [2 x # 3 x, true]
          (%i2) is (2 * x # 3 * x);
          (%o2)                         true

 -- Operador: and
     O operador lógico de conjunção.  'and' é um operador n-ário infixo;
     seus operandos são expressões Booleanas, e seu resultado é um valor
     Booleano.

     'and' força avaliação (como 'is') de um ou mais operandos, e pode
     forçar a avaliação de todos os operandos.

     Operandos são avaliados na ordem em que aparecerem.  'and' avalia
     somente quantos de seus operandos forem necessários para determinar
     o resultado.  Se qualquer operando for 'false', o resultado é
     'false' e os operandos restantes não são avaliados.

     O sinalizador global 'prederror' governa o comportamento de 'and'
     quando um operando avaliado não pode ser determinado como sendo
     'true' ou 'false'.  'and' imprime uma mensagem de erro quando
     'prederror' for 'true'.  De outra forma, operandos que não avaliam
     para 'true' ou para 'false' são aceitos, and o resultado é uma
     expressão Booleana.

     'and' não é comutativo: 'a and b' pode não ser igual a 'b and a'
     devido ao tratamento de operandos indeterminados.

 -- Operador: or
     O operador lógico de disjunção.  'or' é um operador n-ário infixo;
     seus operandos são expressões Booleanas, e seu resultado é um valor
     Booleano.

     'or' força avaliação (como 'is') de um ou mais operandos, e pode
     forçar a avaliação de todos os operandos.

     Operandos são avaliados na ordem em que aparecem.  'or' avalia
     somente quantos de seus operandos forem necessários para determinar
     o resultado.  Se qualquer operando for 'true', o resultado é 'true'
     e os operandos restantes não são avaliados.

     O sinalizador global 'prederror' governa o comportamento de 'or'
     quando um operando avaliado não puder ser determinado como sendo
     'true' ou 'false'.  'or' imprime uma mensagem de erro quando
     'prederror' for 'true'.  De outra forma, operandos que não avaliam
     para 'true' ou para 'false' são aceitos, E o resultado é uma
     expressão Booleana.

     'or' não é comutativo: 'a or b' pode não ser igual a 'b or a'
     devido ao tratamento de operando indeterminados.

 -- Operador: not
     O operador lógico de negação.  'not' é operador prefixado; Seu
     operando é uma expressão Booleana, e seu resultado é um valor
     Booleano.

     'not' força a avaliação (como 'is') de seu operando.

     O sinalizador global 'prederror' governa o comportamento de 'not'
     quando seu operando não pode ser determinado em termos de 'true' ou
     'false'.  'not' imprime uma mensagem de erro quando 'prederror' for
     'true'.  De outra forma, operandos que não avaliam para 'true' ou
     para 'false' são aceitos, e o resultado é uma expressão Booleana.

 -- Função: abs (<expr>)
     Retorna o valor absoluto de <expr>.  Se <expr> for um número
     complexo, retorna o módulo complexo de <expr>.

 -- Palavra chave: additive
     Se 'declare(f,additive)' tiver sido executado, então:

     (1) Se 'f' for uma função de uma única variável, sempre que o
     simplificador encontrar 'f' aplicada a uma adição, 'f' será
     distribuído sobre aquela adição.  I.e.  'f(y+x)' irá simplificar
     para 'f(y)+f(x)'.

     (2) Se 'f' for uma função de 2 ou mais argumentos, a adição é
     definida como adição no primeiro argumento para 'f', como no caso
     de 'sum' ou 'integrate', i.e.  'f(h(x)+g(x),x)' irá simplificar
     para 'f(h(x),x)+f(g(x),x)'.  Essa simplificação não ocorre quando
     'f' é aplicada para expressões da forma
     'sum(x[i],i,lower-limit,upper-limit)'.

 -- Palavra chave: allbut
     trabalha com os comandos 'part' (i.e.  'part', 'inpart',
     'substpart', 'substinpart', 'dpart', e 'lpart').  Por exemplo,

          (%i1) expr : e + d + c + b + a;
          (%o1)                   e + d + c + b + a
          (%i2) part (expr, [2, 5]);
          (%o2)                         d + a

     enquanto

          (%i1) expr : e + d + c + b + a;
          (%o1)                   e + d + c + b + a
          (%i2) part (expr, allbut (2, 5));
          (%o2)                       e + c + b

     'allbut' é também reconhecido por 'kill'.

          (%i1) [aa : 11, bb : 22, cc : 33, dd : 44, ee : 55];
          (%o1)                 [11, 22, 33, 44, 55]
          (%i2) kill (allbut (cc, dd));
          (%o0)                         done
          (%i1) [aa, bb, cc, dd];
          (%o1)                   [aa, bb, 33, 44]

     'kill(allbut(<a_1>, <a_2>, ...))' tem o mesmo efeito que
     'kill(all)' exceto que não elimina os símbolos <a_1>, <a_2>, ...  .

 -- Declaração: antisymmetric
     Se 'declare(h,antisymmetric)' é concluída, diz ao simplicador que
     'h' é uma função antisimétrica.  E.g.  'h(x,z,y)' simplificará para
     '- h(x, y, z)'.  Isto é, dará (-1)^n vezes o resultado dado por
     'symmetric' ou 'commutative', quando n for o número de
     interescolhas de dois argumentos necessários para converter isso
     naquela forma.

 -- Função: cabs (<expr>)
     Retorna o valor absoluto complexo (o módulo complexo) de <expr>.

 -- Função: ceiling (<x>)

     Quando <x> for um número real, retorna o último inteiro que é maior
     que ou igual a <x>.

     Se <x> for uma expressão constante ('10 * %pi', por exemplo),
     'ceiling' avalia <x> usando grandes números em ponto flutuante, e
     aplica 'ceiling' para o grande número em ponto flutuante
     resultante.  Porque 'ceiling' usa avaliação de ponto flutuante, é
     possível, embora improvável, que 'ceiling' possa retornar uma valor
     errôneo para entradas constantes.  Para prevenir erros, a avaliação
     de ponto flutuante é concluída usando três valores para 'fpprec'.

     Para entradas não constantes, 'ceiling' tenta retornar um valor
     simplificado.  Aqui está um exemplo de simplificações que 'ceiling'
     conhece:

          (%i1) ceiling (ceiling (x));
          (%o1)                      ceiling(x)
          (%i2) ceiling (floor (x));
          (%o2)                       floor(x)
          (%i3) declare (n, integer)$
          (%i4) [ceiling (n), ceiling (abs (n)), ceiling (max (n, 6))];
          (%o4)                [n, abs(n), max(n, 6)]
          (%i5) assume (x > 0, x < 1)$
          (%i6) ceiling (x);
          (%o6)                           1
          (%i7) tex (ceiling (a));
          $$\left \lceil a \right \rceil$$
          (%o7)                         false

     A função 'ceiling' não mapeia automaticamente sobre listas ou
     matrizes.  Finalmente, para todas as entradas que forem
     manifestamente complexas, 'ceiling' retorna uma forma substantiva.

     Se o intervalo de uma função é um subconjunto dos inteiros, o
     intervalo pode ser declarado 'integervalued'.  Ambas as funções
     'ceiling' e 'floor' podem usar essa informação; por exemplo:

          (%i1) declare (f, integervalued)$
          (%i2) floor (f(x));
          (%o2)                         f(x)
          (%i3) ceiling (f(x) - 1);
          (%o3)                       f(x) - 1

 -- Função: charfun (<p>)

     Retorna 0 quando o predicado <p> avaliar para 'false'; retorna 1
     quando o predicado avaliar para 'true'.  Quando o predicado avaliar
     para alguma coisa que não 'true' ou 'false' ('unknown'), retorna
     uma forma substantiva.

     Exemplos:

          (%i1) charfun (x < 1);
          (%o1)                    charfun(x < 1)
          (%i2) subst (x = -1, %);
          (%o2)                           1
          (%i3) e : charfun ('"and" (-1 < x, x < 1))$
          (%i4) [subst (x = -1, e), subst (x = 0, e), subst (x = 1, e)];
          (%o4)                       [0, 1, 0]

 -- Declaração: commutative
     Se 'declare(h,commutative)' é concluída, diz ao simplicador que 'h'
     é uma função comutativa.  E.g.  'h(x,z,y)' irá simplificar para
     'h(x, y, z)'.  Isto é o mesmo que 'symmetric'.

 -- Função: compare (<x>, <y>)

     Retorna um operador de comparação <op> ('<', '<=', '>', '>=', '=',
     ou '#') tal que 'is (<x> <op> <y>)' avalia para 'true'; quando ou
     <x> ou <y> dependendo de '%i' e '<x> # <y>', retorna
     'notcomparable'; Quando não existir tal operador ou Maxima não
     estiver apto a determinar o operador, retorna 'unknown'.

     Exemplos:

          (%i1) compare (1, 2);
          (%o1)                           <
          (%i2) compare (1, x);
          (%o2)                        unknown
          (%i3) compare (%i, %i);
          (%o3)                           =
          (%i4) compare (%i, %i + 1);
          (%o4)                     notcomparable
          (%i5) compare (1/x, 0);
          (%o5)                           #
          (%i6) compare (x, abs(x));
          (%o6)                          <=

     A função 'compare' não tenta de terminar se o domínio real de seus
     argumentos é não vazio; dessa forma

          (%i1) compare (acos (x^2 + 1), acos (x^2 + 1) + 1);
          (%o1)                           <

     O domínio real de 'acos (x^2 + 1)' é vazio.

 -- Função: entier (<x>)
     Retorna o último inteiro menor que ou igual a <x> onde <x> é
     numérico.  'fix' (como em 'fixnum') é um sinônimo disso, então
     'fix(<x>)' é precisamente o mesmo.

 -- Função: equal (<a>, <b>)

     Representa a equivalência, isto é, valor igual.

     Por si mesma, 'equal' não avalia ou simplifica.  A função 'is'
     tenta avaliar 'equal' para um valor Booleano.  'is(equal(<a>,
     <b>))' retorna 'true' (ou 'false') se e somente se <a> e <b> forem
     iguais (ou não iguais) para todos os possíveis valores de suas
     variáveis, como determinado através da avaliação de 'ratsimp(<a> -
     <b>)'; se 'ratsimp' retornar 0, as duas expressões são consideradas
     equivalentes.  Duas expressões podem ser equivalentes mesmo se
     mesmo se elas não forem sintaticamente iguais (i.e., identicas).

     Quando 'is' falhar em reduzir 'equal' a 'true' ou 'false', o
     resultado é governado através do sinalizador global 'prederror'.
     Quando 'prederror' for 'true', 'is' reclama com uma mensagem de
     erro.  De outra forma, 'is' retorna 'unknown'.

     Complementando 'is', alguns outros operadores avaliam 'equal' e
     'notequal' para 'true' ou 'false', a saber 'if', 'and', 'or', e
     'not'.

     A negação de 'equal' é 'notequal'.

     Exemplos:

     Por si mesmo, 'equal' não avalia ou simplifica.

          (%i1) equal (x^2 - 1, (x + 1) * (x - 1));
                                  2
          (%o1)            equal(x  - 1, (x - 1) (x + 1))
          (%i2) equal (x, x + 1);
          (%o2)                    equal(x, x + 1)
          (%i3) equal (x, y);
          (%o3)                      equal(x, y)

     A função 'is' tenta avaliar 'equal' para um valor Booleano.
     'is(equal(<a>, <b>))' retorna 'true' quando 'ratsimp(<a> - <b>)'
     retornar 0.  Duas expressões podem ser equivalentes mesmo se não
     forem sintaticamente iguais (i.e., identicas).

          (%i1) ratsimp (x^2 - 1 - (x + 1) * (x - 1));
          (%o1)                           0
          (%i2) is (equal (x^2 - 1, (x + 1) * (x - 1)));
          (%o2)                         true
          (%i3) is (x^2 - 1 = (x + 1) * (x - 1));
          (%o3)                         false
          (%i4) ratsimp (x - (x + 1));
          (%o4)                          - 1
          (%i5) is (equal (x, x + 1));
          (%o5)                         false
          (%i6) is (x = x + 1);
          (%o6)                         false
          (%i7) ratsimp (x - y);
          (%o7)                         x - y
          (%i8) is (equal (x, y));
          (%o8)                        unknown
          (%i9) is (x = y);
          (%o9)                         false

     Quando 'is' falha em reduzir 'equal' a 'true' ou 'false', o
     resultado é governado através do sinalizador global 'prederror'.

          (%i1) [aa : x^2 + 2*x + 1, bb : x^2 - 2*x - 1];
                              2             2
          (%o1)             [x  + 2 x + 1, x  - 2 x - 1]
          (%i2) ratsimp (aa - bb);
          (%o2)                        4 x + 2
          (%i3) prederror : true;
           (%o3)                         true
          (%i4) is (equal (aa, bb));
          Maxima was unable to evaluate the predicate:
                 2             2
          equal(x  + 2 x + 1, x  - 2 x - 1)
           -- an error.  Quitting.  To debug this try debugmode(true);
          (%i5) prederror : false;
          (%o5)                         false
          (%i6) is (equal (aa, bb));
          (%o6)                        unknown

     Alguns operadores avaliam 'equal' e 'notequal' para 'true' ou
     'false'.

          (%i1) if equal (y, y - 1) then FOO else BAR;
          (%o1)                          BAR
          (%i2) eq_1 : equal (x, x + 1);
          (%o2)                    equal(x, x + 1)
          (%i3) eq_2 : equal (y^2 + 2*y + 1, (y + 1)^2);
                                   2                   2
          (%o3)             equal(y  + 2 y + 1, (y + 1) )
          (%i4) [eq_1 and eq_2, eq_1 or eq_2, not eq_1];
          (%o4)                  [false, true, true]

     Devido a 'not <expr>' fazer com que ocorra a avaliação de <expr>,
     'not equal(<a>, <b>)' é equivalente a 'is(notequal(<a>, <b>))'.

          (%i1) [notequal (2*z, 2*z - 1), not equal (2*z, 2*z - 1)];
          (%o1)            [notequal(2 z, 2 z - 1), true]
          (%i2) is (notequal (2*z, 2*z - 1));
          (%o2)                         true

 -- Função: floor (<x>)

     Quando <x> for um número real, retorna o maior inteiro que é menor
     que ou igual a <x>.

     Se <x> for uma expressão constante ('10 * %pi', for exemplo),
     'floor' avalia <x> usando grandes números em ponto flutuante, e
     aplica 'floor' ao grande número em ponto flutuante resultante.
     Porque 'floor' usa avaliação em ponto flutuante, é possível, embora
     improvável, que 'floor' não possa retornar um valor errôneo para
     entradas constantes.  Para prevenir erros, a avaliação de ponto
     flutuante é concluída usando três valores para 'fpprec'.

     Para entradas não constantes, 'floor' tenta retornar um valor
     simplificado.  Aqui está exemplos de simplificações que 'floor'
     conhece:

          (%i1) floor (ceiling (x));
          (%o1)                      ceiling(x)
          (%i2) floor (floor (x));
          (%o2)                       floor(x)
          (%i3) declare (n, integer)$
          (%i4) [floor (n), floor (abs (n)), floor (min (n, 6))];
          (%o4)                [n, abs(n), min(n, 6)]
          (%i5) assume (x > 0, x < 1)$
          (%i6) floor (x);
          (%o6)                           0
          (%i7) tex (floor (a));
          $$\left \lfloor a \right \rfloor$$
          (%o7)                         false

     A função 'floor' não mapeia automaticamente sobre listas ou
     matrizes.  Finalmente, para todas as entradas que forem
     manifestamente complexas, 'floor' retorna uma forma substantiva.

     Se o intervalo de uma função for um subconjunto dos inteiros, o
     intervalo pode ser declarado 'integervalued'.  Ambas as funções
     'ceiling' e 'floor' podem usar essa informação; por exemplo:

          (%i1) declare (f, integervalued)$
          (%i2) floor (f(x));
          (%o2)                         f(x)
          (%i3) ceiling (f(x) - 1);
          (%o3)                       f(x) - 1

 -- Função: notequal (<a>, <b>)
     Represents the negation of 'equal(<a>, <b>)'.

     Exemplos:

          (%i1) equal (a, b);
          (%o1)                      equal(a, b)
          (%i2) maybe (equal (a, b));
          (%o2)                        unknown
          (%i3) notequal (a, b);
          (%o3)                    notequal(a, b)
          (%i4) not equal (a, b);
          (%o4)                    notequal(a, b)
          (%i5) maybe (notequal (a, b));
          (%o5)                        unknown
          (%i6) assume (a > b);
          (%o6)                        [a > b]
          (%i7) equal (a, b);
          (%o7)                      equal(a, b)
          (%i8) maybe (equal (a, b));
          (%o8)                         false
          (%i9) notequal (a, b);
          (%o9)                    notequal(a, b)
          (%i10) maybe (notequal (a, b));
          (%o10)                        true

 -- Operador: eval
     Como um argumento em uma chamada a 'ev (<expr>)', 'eval' causa uma
     avaliação extra de <expr>.  Veja 'ev'.

 -- Função: evenp (<expr>)
     Retorna 'true' se <expr> for um inteiro sempre.  'false' é
     retornado em todos os outros casos.

 -- Função: fix (<x>)
     Um sinônimo para 'entier (<x>)'.

 -- Função: fullmap (<f>, <expr_1>, ...)
     Similar a 'map', mas 'fullmap' mantém mapeadas para baixo todas as
     subexpressões até que os operadores principais não mais sejam os
     mesmos.

     'fullmap' é usada pelo simplificador do Maxima para certas
     manipulações de matrizes; dessa forma, Maxima algumas vezes gera
     uma mensagem de erro concernente a 'fullmap' mesmo apesar de
     'fullmap' não ter sido explicitamente chamada pelo usuário.

     Exemplos:

          (%i1) a + b * c;
          (%o1)                        b c + a
          (%i2) fullmap (g, %);
          (%o2)                   g(b) g(c) + g(a)
          (%i3) map (g, %th(2));
          (%o3)                     g(b c) + g(a)

 -- Função: fullmapl (<f>, <list_1>, ...)
     Similar a 'fullmap', mas 'fullmapl' somente mapeia sobre listas e
     matrizes.

     Exemplo:

          (%i1) fullmapl ("+", [3, [4, 5]], [[a, 1], [0, -1.5]]);
          (%o1)                [[a + 3, 4], [4, 3.5]]

 -- Função: is (<expr>)
     Tenta determinar se a <expr> predicada (expressões que avaliam para
     'true' ou 'false') é dedutível de fatos localizados na base de
     dados de 'assume'.

     Se a dedutibilidade do predicado for 'true' ou 'false', 'is'
     retorna 'true' ou 'false', respectivamente.  De outra forma, o
     valor de retorno é governado através do sinalizador global
     'prederror'.  Quando 'prederror' for 'true', 'is' reclama com uma
     mensagem de erro.  De outra forma, 'is' retorna 'unknown'.

     'ev(<expr>, pred)' (que pode ser escrita da forma '<expr>, pred' na
     linha de comando interativa) é equivalente a 'is(<expr>)'.

     Veja também 'assume', 'facts', e 'maybe'.

     Exemplos:

     'is' causa avaliação de predicados.

          (%i1) %pi > %e;
          (%o1)                       %pi > %e
          (%i2) é (%pi > %e);
          (%o2)                         true

     'is' tenta derivar predicados da base de dados do 'assume'.

          (%i1) assume (a > b);
          (%o1)                        [a > b]
          (%i2) assume (b > c);
          (%o2)                        [b > c]
          (%i3) é (a < b);
          (%o3)                         false
          (%i4) é (a > c);
          (%o4)                         true
          (%i5) é (equal (a, c));
          (%o5)                         false

     Se 'is' não puder nem comprovar nem refutar uma forma predicada a
     partir da base de dados de 'assume', o sinalizador global
     'prederror' governa o comportamento de 'is'.

          (%i1) assume (a > b);
          (%o1)                        [a > b]
          (%i2) prederror: true$
          (%i3) é (a > 0);
          Maxima was unable to evaluate the predicate:
          a > 0
           -- an error.  Quitting.  To debug this try debugmode(true);
          (%i4) prederror: false$
          (%i5) é (a > 0);
          (%o5)                        unknown

 -- Função: maybe (<expr>)
     Tenta determinar se a <expr> predicada é dedutível dos fatos na
     base de dados de 'assume'.

     Se a dedutibilidade do predicado for 'true' ou 'false', 'maybe'
     retorna 'true' ou 'false', respectivamente.  De outra forma,
     'maybe' retorna 'unknown'.

     'maybe' é funcinalmente equivalente a 'is' com 'prederror: false',
     mas o resultado é computado sem atualmente atribuir um valor a
     'prederror'.

     Veja também 'assume', 'facts', e 'is'.

     Exemplos:

          (%i1) maybe (x > 0);
          (%o1)                        unknown
          (%i2) assume (x > 1);
          (%o2)                        [x > 1]
          (%i3) maybe (x > 0);
          (%o3)                         true

 -- Função: isqrt (<x>)
     Retorna o "inteiro raíz quadrada" do valor absoluto de <x>, que é
     um inteiro.

 -- Função: lmax (<L>)

     Quando <L> for uma lista ou um conjunto, retorna 'apply ('max, args
     (<L>))'.  Quando <L> não for uma lista ou também não for um
     conjunto, sinaliza um erro.

 -- Função: lmin (<L>)

     Quando <L> for uma lista ou um conjunto, retorna 'apply ('min, args
     (<L>))'.  Quando <L> não for uma lista ou ou também não for um
     conjunto, sinaliza um erro.

 -- Função: max (<x_1>, ..., <x_n>)

     Retorna um valor simplificado para o máximo entre as expressões
     <x_1> a <x_n>.  Quando 'get (trylevel, maxmin)', for dois ou mais,
     'max' usa a simplificação 'max (e, -e) --> |e|'.  Quando 'get
     (trylevel, maxmin)' for 3 ou mais, <max> tenta eliminar expressões
     que estiverem entre dois outros argumentos; por exemplo, 'max (x,
     2*x, 3*x) --> max (x, 3*x)'.  Para escolher o valor de 'trylevel'
     para 2, use 'put (trylevel, 2, maxmin)'.

 -- Função: min (<x_1>, ..., <x_n>)

     Retorna um valor simplificado para o mínimo entre as expressões
     'x_1' até 'x_n'.  Quando 'get (trylevel, maxmin)', for 2 ou mais,
     'min' usa a simplificação 'min (e, -e) --> -|e|'.  Quando 'get
     (trylevel, maxmin)' for 3 ou mais, 'min' tenta eliminar expressões
     que estiverem entre dois outros argumentos; por exemplo, 'min (x,
     2*x, 3*x) --> min (x, 3*x)'.  Para escolher o valor de 'trylevel'
     para 2, use 'put (trylevel, 2, maxmin)'.

 -- Função: polymod (<p>)
 -- Função: polymod (<p>, <m>)
     Converte o polinômio <p> para uma representação modular com relação
     ao módulo corrente que é o valor da variável 'modulus'.

     'polymod (<p>, <m>)' especifica um módulo <m> para ser usado em
     lugar do valor corrente de 'modulus'.

     Veja 'modulus'.

 -- Função: mod (<x>, <y>)

     Se <x> e <y> forem números reais e <y> for não nulo, retorna '<x> -
     <y> * floor(<x> / <y>)'.  Adicionalmente para todo real <x>, nós
     temos 'mod (<x>, 0) = <x>'.  Para uma discursão da definição 'mod
     (<x>, 0) = <x>', veja a Seção 3.4, de "Concrete Mathematics," por
     Graham, Knuth, e Patashnik.  A função 'mod (<x>, 1)' é uma função
     dente de serra com período 1 e com 'mod (1, 1) = 0' e 'mod (0, 1) =
     0'.

     Para encontrar o argumento (um número no intervalo '(-%pi, %pi]')
     de um número complexo, use a função '<x> |-> %pi - mod (%pi - <x>,
     2*%pi)', onde <x> é um argumento.

     Quando <x> e <y> forem expressões constantes ('10 * %pi', por
     exemplo), 'mod' usa o mesmo esquema de avaliação em ponto flutuante
     que 'floor' e 'ceiling' usam.  Novamente, é possível, embora
     improvável, que 'mod' possa retornar um valor errôneo nesses casos.

     Para argumentos não numéricos <x> ou <y>, 'mod 'conhece muitas
     regras de simplificação:

          (%i1) mod (x, 0);
          (%o1)                           x
          (%i2) mod (a*x, a*y);
          (%o2)                      a mod(x, y)
          (%i3) mod (0, x);
          (%o3)                           0

 -- Função: oddp (<expr>)
     é 'true' se <expr> for um inteiro ímpar.  'false' é retornado em
     todos os outros casos.

 -- Operador: pred
     Como um argumento em uma chamada a 'ev (<expr>)', 'pred' faz com
     que predicados (expressões que avaliam para 'true' ou 'false')
     sejam avaliados.  Veja 'ev'.

 -- Função: make_random_state (<n>)
 -- Função: make_random_state (<s>)
 -- Função: make_random_state (true)
 -- Função: make_random_state (false)
     Um objeto de estado randômico representa o estado do gerador de
     números randômicos (aleatórios).  O estado compreende 627 palavras
     de 32 bits.

     'make_random_state (<n>)' retorna um novo objeto de estado
     randômico criado de um valor inteiro semente igual a <n> modulo
     2^32.  <n> pode ser negativo.

     'make_random_state (<s>)' retorna uma copia do estado randômico
     <s>.

     'make_random_state (true)' retorna um novo objeto de estado
     randômico, usando a hora corrente do relógio do computador como
     semente.

     'make_random_state (false)' retorna uma cópia do estado corrente do
     gerador de números randômicos.

 -- Função: set_random_state (<s>)
     Copia <s> para o estado do gerador de números randômicos.

     'set_random_state' sempre retorna 'done'.

 -- Função: random (<x>)
     Retorna um número pseudorandômico.  Se <x> é um inteiro, 'random
     (<x>)' retorna um inteiro de 0 a '<x> - 1' inclusive.  Se <x> for
     um número em ponto flutuante, 'random (<x>)' retorna um número não
     negativo em ponto flutuante menor que <x>.  'random' reclama com um
     erro se <x> não for nem um inteiro nem um número em ponto
     flutuante, ou se <x> não for positivo.

     As funções 'make_random_state' e 'set_random_state' mantém o estado
     do gerador de números randômicos.

     O gerador de números randômicos do Maxima é uma implementação do
     algorítmo de Mersenne twister MT 19937.

     Exemplos:

          (%i1) s1: make_random_state (654321)$
          (%i2) set_random_state (s1);
          (%o2)                         done
          (%i3) random (1000);
          (%o3)                          768
          (%i4) random (9573684);
          (%o4)                        7657880
          (%i5) random (2^75);
          (%o5)                11804491615036831636390
          (%i6) s2: make_random_state (false)$
          (%i7) random (1.0);
          (%o7)                   .2310127244107132
          (%i8) random (10.0);
          (%o8)                   4.394553645870825
          (%i9) random (100.0);
          (%o9)                   32.28666704056853
          (%i10) set_random_state (s2);
          (%o10)                        done
          (%i11) random (1.0);
          (%o11)                  .2310127244107132
          (%i12) random (10.0);
          (%o12)                  4.394553645870825
          (%i13) random (100.0);
          (%o13)                  32.28666704056853

 -- Função: rationalize (<expr>)

     Converte todos os números em ponto flutuante de precisão dupla e
     grandes números em ponto flutuante na expressão do Maxima <expr>
     para seus exatos equivalentes racionais.  Se você não estiver
     faminilarizado com a representação binária de números em ponto
     flutuante, você pode se surpreender que 'rationalize (0.1)' não
     seja igual a 1/10.  Esse comportamento não é especial para o Maxima
     - o número 1/10 tem uma representação binária repetitiva e não
     terminada.

          (%i1) rationalize (0.5);
                                          1
          (%o1)                           -
                                          2
          (%i2) rationalize (0.1);
                                         1
          (%o2)                          --
                                         10
           (%i3) fpprec : 5$
          (%i4) rationalize (0.1b0);
                                       209715
          (%o4)                        -------
                                       2097152
          (%i5) fpprec : 20$
          (%i6) rationalize (0.1b0);
                               236118324143482260685
          (%o6)                ----------------------
                               2361183241434822606848
          (%i7) rationalize (sin (0.1*x + 5.6));
                                        x    28
          (%o7)                     sin(-- + --)
                                        10   5

     Exemplo de utilização:

          (%i1) unitfrac(r) := block([uf : [], q],
              if not(ratnump(r)) then error("The input to 'unitfrac' must be a rational number"),
              while r # 0 do (
                  uf : cons(q : 1/ceiling(1/r), uf),
                  r : r - q),
              reverse(uf));
          (%o1) unitfrac(r) := block([uf : [], q],
          if not ratnump(r) then error("The input to 'unitfrac' must be a rational number"
                                               1
          ), while r # 0 do (uf : cons(q : ----------, uf), r : r - q),
                                                   1
                                           ceiling(-)
                                                   r
          reverse(uf))
          (%i2) unitfrac (9/10);
                                      1  1  1
          (%o2)                      [-, -, --]
                                      2  3  15
          (%i3) apply ("+", %);
                                         9
          (%o3)                          --
                                         10
          (%i4) unitfrac (-9/10);
                                            1
          (%o4)                       [- 1, --]
                                            10
          (%i5) apply ("+", %);
                                          9
          (%o5)                         - --
                                          10
          (%i6) unitfrac (36/37);
                                  1  1  1  1    1
          (%o6)                  [-, -, -, --, ----]
                                  2  3  8  69  6808
          (%i7) apply ("+", %);
                                         36
          (%o7)                          --
                                         37

 -- Função: sign (<expr>)
     Tenta determinar o sinal de <expr> a partir dos fatos na base de
     dados corrente.  Retorna uma das seguintes respostar: 'pos'
     (positivo), 'neg' (negativo), 'zero', 'pz' (positivo ou zero), 'nz'
     (negativo ou zero), 'pn' (positivo ou negativo), ou 'pnz'
     (positivo, negativo, ou zero, i.e.  nada se sabe sobre o sinal da
     epressão).

 -- Função: signum (<x>)
     Para um <x> numérico retorna 0 se <x> for 0, de outra forma retorna
     -1 ou +1 à medida que <x> seja menor ou maior que 0,
     respectivamente.

     Se <x> não for numérico então uma forma simplificada mas
     equivalente é retornada.  Por exemplo, 'signum(-x)' fornece
     '-signum(x)'.

 -- Função: sort (<L>, <P>)
 -- Função: sort (<L>)
     Organiza uma lista <L> coforme o predicado 'P' de dois argumentos,
     de forma que '<P> (<L>[k], <L>[k + 1])' seja 'true' para qualquer
     dois elementos sucessivos.  O predicado pode ser especificado como
     o nome de uma função ou operador binário infixo, ou como uma
     expressão 'lambda'.  Se especificado como o nome de um operador, o
     nome deve ser contido entre "aspas duplas".

     A lista ordenada é retornada como novo objeto; o argumento <L> não
     é modificado.  Para construir o valor de retorno, 'sort' faz uma
     cópia superficial dos elementos de <L>.  Se o predicado <P> não for
     uma ordem total sobre os elementos de <L>, então 'sort'
     possivelvente pode executar para concluir sem error, mas os
     resultados são indefinidos.  'sort' reclama se o predicado avaliar
     para alguma outra coisa que não seja 'true' ou 'false'.

     'sort (<L>)' é equivalente a 'sort (<L>, orderlessp)'.  Isto é, a
     ordem padrão de organização é ascendente, como determinado por
     'orderlessp'.  Todos os átomos do Maxima e expressões são
     comparáveis sob 'orderlessp', embora exista exemplos isolados de
     expressões para as quais 'orderlessp' não é transitiva; isso é uma
     falha.

     Exemplos:

          (%i1) sort ([11, -17, 29b0, 7.55, 3, -5/2, b + a, 9 * c, 19 - 3 * x]);
                         5
          (%o1) [- 17, - -, 3, 7.55, 11, 2.9b1, b + a, 9 c, 19 - 3 x]
                         2
          (%i2) sort ([11, -17, 29b0, 7.55, 3, -5/2, b + a, 9 * c, 19 - 3 * x], ordergreatp);
                                                             5
          (%o2) [19 - 3 x, 9 c, b + a, 2.9b1, 11, 7.55, 3, - -, - 17]
                                                             2
          (%i3) sort ([%pi, 3, 4, %e, %gamma]);
          (%o3)                [3, 4, %e, %gamma, %pi]
          (%i4) sort ([%pi, 3, 4, %e, %gamma], "<");
          (%o4)                [%gamma, %e, 3, %pi, 4]
          (%i5) my_list : [[aa, hh, uu], [ee, cc], [zz, xx, mm, cc], [%pi, %e]];
          (%o5) [[aa, hh, uu], [ee, cc], [zz, xx, mm, cc], [%pi, %e]]
          (%i6) sort (my_list);
          (%o6) [[%pi, %e], [aa, hh, uu], [ee, cc], [zz, xx, mm, cc]]
          (%i7) sort (my_list, lambda ([a, b], orderlessp (reverse (a), reverse (b))));
          (%o7) [[%pi, %e], [ee, cc], [zz, xx, mm, cc], [aa, hh, uu]]

 -- Função: sqrt (<x>)
     A raíz quadrada de <x>.  É representada internamente por
     '<x>^(1/2)'.  Veja também 'rootscontract'.

     'radexpand' se 'true' fará com que n-ésimas raízes de fatores de um
     produto que forem potências de n sejam colocados fora do radical,
     e.g.  'sqrt(16*x^2)' retonará '4*x' somente se 'radexpand' for
     'true'.

 -- Variável de opção: sqrtdispflag
     Valor padrão: 'true'

     Quando 'sqrtdispflag' for 'false', faz com que 'sqrt' seja mostrado
     como expoente 1/2.

 -- Função: sublis (<lista>, <expr>)
     Faz multiplas substituições paralelas dentro de uma expressão.

     A variável 'sublis_apply_lambda' controla a simplificação após
     'sublis'.

     Exemplo:


 -- Função: sublist (<lista>, <p>)
     Retorna a lista de elementos da <lista> da qual o predicado 'p'
     retornar 'true'.

     Exemplo:

          (%i1) L: [1, 2, 3, 4, 5, 6];
          (%o1)                  [1, 2, 3, 4, 5, 6]
          (%i2) sublist (L, evenp);
          (%o2)                       [2, 4, 6]

 -- Variável de opção: sublis_apply_lambda
     Valor padrão: 'true' - controla se os substitutos de 'lambda' são
     aplicados na simplificação após as 'sublis' serem usadas ou se você
     tem que fazer um 'ev' para pegar coisas para aplicar.  'true'
     significa faça a aplicação.

 -- Função: subst (<a>, <b>, <c>)
     Substitue <a> por <b> em <c>.  <b> deve ser um átomo ou uma
     subexpressão completa de <c>.  Por exemplo, 'x+y+z' é uma
     subexpressão completa de '2*(x+y+z)/w' enquanto 'x+y' não é.
     Quando <b> não tem essas características, pode-se algumas vezes
     usar 'substpart' ou 'ratsubst' (veja abaixo).  Alternativamente, se
     <b> for da forma de 'e/f' então se poderá usar 'subst (a*f, e, c)'
     enquanto se <b> for da forma 'e^(1/f)' então se poderá usar 'subst
     (a^f, e, c)'.  O comando 'subst' também discerne o 'x^y' de 'x^-y'
     de modo que 'subst (a, sqrt(x), 1/sqrt(x))' retorna '1/a'.  <a> e
     <b> podem também ser operadores de uma expressão contida entre
     aspas duplas '"' ou eles podem ser nomes de função.  Se se desejar
     substituir por uma variável independente em formas derivadas então
     a função 'at' (veja abaixo) poderá ser usada.

     'subst' é um álias para 'substitute'.

     'subst (<eq_1>, <expr>)' ou 'subst ([<eq_1>, ..., <eq_k>], <expr>)'
     são outras formas permitidas.  As <eq_i> são equações indicando
     substituições a serem feitas.  Para cada equação, o lado direito
     será substituído pelo lado esquerdo na expressão <expr>.

     'exptsubst' se 'true' permite que substituições como 'y' por '%e^x'
     em '%e^(a*x)' ocorram.

     Quando 'opsubst' for 'false', 'subst' tentará substituir dentro do
     operador de uma expressão.  E.g.  '(opsubst: false, subst (x^2, r,
     r+r[0]))' trabalhará.

     Exemplos:

          (%i1) subst (a, x+y, x + (x+y)^2 + y);
                                              2
          (%o1)                      y + x + a
          (%i2) subst (-%i, %i, a + b*%i);
          (%o2)                       a - %i b

     Para exemplos adicionais, faça 'example (subst)'.

 -- Função: substinpart (<x>, <expr>, <n_1>, ..., <n_k>)
     Similar a 'substpart', mas 'substinpart' trabalha sobre a
     representação interna de <expr>.

     Exemplos:

          (%i1) x . 'diff (f(x), x, 2);
                                        2
                                       d
          (%o1)                   x . (--- (f(x)))
                                         2
                                       dx
          (%i2) substinpart (d^2, %, 2);
                                            2
          (%o2)                        x . d
          (%i3) substinpart (f1, f[1](x + 1), 0);
          (%o3)                       f1(x + 1)

     Se o último argumento para a função 'part' for uma lista de índices
     então muitas subexpressões são escolhidas, cada uma correspondendo
     a um índice da lista.  Dessa forma

          (%i1) part (x + y + z, [1, 3]);
          (%o1)                         z + x

     'piece' recebe o valor da última expressão selecionada quando
     usando as funções 'part'.  'piece' é escolhida durante a execução
     da função e dessa forma pode ser referenciada para a própria função
     como mostrado abaixo.  Se 'partswitch' for escolhida para 'true'
     então 'end' é retornado quando uma parte selecionada de uma
     expressão não existir, de outra forma uma mensagem de erro é
     fornecida.

          (%i1) expr: 27*y^3 + 54*x*y^2 + 36*x^2*y + y + 8*x^3 + x + 1;
                        3         2       2            3
          (%o1)     27 y  + 54 x y  + 36 x  y + y + 8 x  + x + 1
          (%i2) part (expr, 2, [1, 3]);
                                            2
          (%o2)                         54 y
          (%i3) sqrt (piece/54);
          (%o3)                        abs(y)
          (%i4) substpart (factor (piece), expr, [1, 2, 3, 5]);
                                         3
          (%o4)               (3 y + 2 x)  + y + x + 1
          (%i5) expr: 1/x + y/x - 1/z;
                                       1   y   1
          (%o5)                      - - + - + -
                                       z   x   x
          (%i6) substpart (xthru (piece), expr, [2, 3]);
                                      y + 1   1
          (%o6)                       ----- - -
                                        x     z

     Também, escolhendo a opção 'inflag' para 'true' e chamando 'part'
     ou 'substpart' é o mesmo que chamando 'inpart' ou 'substinpart'.

 -- Função: substpart (<x>, <expr>, <n_1>, ..., <n_k>)
     Substitue <x> para a subexpressão selecionada pelo resto dos
     argumentos como em 'part'.  Isso retorna o novo valor de <expr>.
     <x> pode ser algum operador a ser substituído por um operador de
     <expr>.  Em alguns casos <x> precisa ser contido em aspas duplas
     '"' (e.g.  'substpart ("+", a*b, 0)' retorna 'b + a').

          (%i1) 1/(x^2 + 2);
                                         1
          (%o1)                        ------
                                        2
                                       x  + 2
          (%i2) substpart (3/2, %, 2, 1, 2);
                                         1
          (%o2)                       --------
                                       3/2
                                      x    + 2
          (%i3) a*x + f (b, y);
          (%o3)                     a x + f(b, y)
          (%i4) substpart ("+", %, 1, 0);
          (%o4)                    x + f(b, y) + a

     Também, escolhendo a opção 'inflag' para 'true' e chamando 'part'
     ou 'substpart' é o mesmo que chamando 'inpart' ou 'substinpart'.

 -- Função: subvarp (<expr>)
     Retorna 'true' se <expr> for uma variável subscrita (i.e.  que
     possui índice ou subscrito em sua grafia), por exemplo 'a[i]'.

 -- Função: symbolp (<expr>)
     Retorna 'true' se <expr> for um símbolo, de outra forma retorna
     'false'.  com efeito, 'symbolp(x)' é equivalente ao predicado
     'atom(x) and not numberp(x)'.

     Veja também *note Identificadores::

 -- Função: unorder ()
     Disabilita a ação de alias criada pelo último uso dos comandos de
     ordenação 'ordergreat' e 'orderless'.  'ordergreat' e 'orderless'
     não podem ser usados mais que uma vez cada sem chamar 'unorder'.
     Veja também 'ordergreat' e 'orderless'.

     Exemplos:

          (%i1) unorder();
          (%o1)                          []
          (%i2) b*x + a^2;
                                             2
          (%o2)                       b x + a
          (%i3) ordergreat (a);
          (%o3)                         done
          (%i4) b*x + a^2;
           %th(1) - %th(3);
                                       2
          (%o4)                       a  + b x
          (%i5) unorder();
                                        2    2
          (%o5)                        a  - a

 -- Função: vectorpotential (<givencurl>)
     Retorna o potencial do vetor de um dado vetor de torção, no sistema
     de coordenadas corrente.  'potentialzeroloc' tem um papel similar
     ao de 'potential', mas a ordem dos lados esquerdos das equações
     deve ser uma permutação cíclica das variáveis de coordenadas.

 -- Função: xthru (<expr>)
     Combina todos os termos de <expr> (o qual pode ser uma adição)
     sobre um denominador comum sem produtos e somas exponenciadas como
     'ratsimp' faz.  'xthru' cancela fatores comuns no numerador e
     denominador de expressões racionais mas somente se os fatores são
     explícitos.

     Algumas vezes é melhor usar 'xthru' antes de 'ratsimp' em uma
     expressão com o objetivo de fazer com que fatores explicitos do
     máximo divisor comum entre o numerador e o denominador seja
     cancelado simplificando dessa forma a expressão a ser aplicado o
     'ratsimp'.

          (%i1) ((x+2)^20 - 2*y)/(x+y)^20 + (x+y)^(-19) - x/(x+y)^20;
                                          20
                           1       (x + 2)   - 2 y       x
          (%o1)        --------- + --------------- - ---------
                              19             20             20
                       (y + x)        (y + x)        (y + x)
          (%i2) xthru (%);
                                           20
                                    (x + 2)   - y
          (%o2)                     -------------
                                             20
                                      (y + x)

 -- Função: zeroequiv (<expr>, <v>)
     Testa se a expressão <expr> na variável <v> é equivalente a zero,
     retornando 'true', 'false', ou 'dontknow' (não sei).

     'zeroequiv' Tem essas restrições:
       1. Não use funções que o Maxima não sabe como diferenciar e
          avaliar.
       2. Se a expressão tem postes sobre o eixo real, podem existir
          erros no resultado (mas isso é improvável ocorrer).
       3. Se a expressão contem funções que não são soluções para
          equações diferenciais de primeira ordem (e.g.  funções de
          Bessel) pode ocorrer resultados incorretos.
       4. O algorítmo usa avaliação em pontos aleatóriamente escolhidos
          para subexpressões selecionadas cuidadosamente.  Isso é sempre
          negócio um tanto quanto perigoso, embora o algorítmo tente
          minimizar o potencial de erro.

     Por exemplo 'zeroequiv (sin(2*x) - 2*sin(x)*cos(x), x)' retorna
     'true' e 'zeroequiv (%e^x + x, x)' retorna 'false'.  Por outro lado
     'zeroequiv (log(a*b) - log(a) - log(b), a)' retorna 'dontknow'
     devido à presença de um parâmetro extra 'b'.


File: maxima.info,  Node: Expressões,  Next: Simplificação,  Prev: Operadores,  Up: Top

6 Expressões
************

* Menu:

* Introdução a Expressões::
* Complexo::
* Substantivos e Verbos::
* Identificadores::
* Seqüências de caracteres::
* Desigualdade::
* Sintaxe::
* Funções e Variáveis Definidas para Expressões::


File: maxima.info,  Node: Introdução a Expressões,  Next: Complexo,  Prev: Expressões,  Up: Expressões

6.1 Introdução a Expressões
===========================

Existe um conjunto de palavras reservadas que não pode ser usado como
nome de variável.  Seu uso pode causar um possível erro crítico de
sintaxe.

     integrate            next           from                 diff
     in                   at             limit                sum
     for                  and            elseif               then
     else                 do             or                   if
     unless               product        while                thru
     step

   Muitas coisas em Maxima são expressões.  Uma seqüência de expressões
pode ser feita dentro de uma expressão maior através da separação dessas
através de vírgulas e colocando parêntesis em torno dela.  Isso é
similar ao C expressão com vírgula.

     (%i1) x: 3$
     (%i2) (x: x+1, x: x^2);
     (%o2)                          16
     (%i3) (if (x > 17) then 2 else 4);
     (%o3)                           4
     (%i4) (if (x > 17) then x: 2 else y: 4, y+x);
     (%o4)                          20

   Mesmo ciclos em Maxima são expressões, embora o valor de retorno
desses ciclos não seja muito útil (eles retornam sempre 'done').

     (%i1) y: (x: 1, for i from 1 thru 10 do (x: x*i))$
     (%i2) y;
     (%o2)                         done

   contanto que o que você realmente queira seja provavelmente incluir
um terceiro termo na expressão com vírgula que fornece de volta o valor
atualizado.

     (%i3) y: (x: 1, for i from 1 thru 10 do (x: x*i), x)$
     (%i4) y;
     (%o4)                        3628800


File: maxima.info,  Node: Complexo,  Next: Substantivos e Verbos,  Prev: Introdução a Expressões,  Up: Expressões

6.2 Complexo
============

Uma expressão complexa é especificada no Maxima através da adição da
parte real da expressão a '%i' vezes a parte imaginária.  Dessa forma as
raízes da equação 'x^2 - 4*x + 13 = 0' são '2 + 3*%i' e '2 - 3*%i'.
Note que produtos de simplificação de expressões complexas podem ser
efetuadas através da expansão do produto.  Simplificação de quocientes,
raízes, e outras funções de expressões complexas podem usualmente serem
realizadas através do uso das funções 'realpart', 'imagpart',
'rectform', 'polarform', 'abs', 'carg'.


File: maxima.info,  Node: Substantivos e Verbos,  Next: Identificadores,  Prev: Complexo,  Up: Expressões

6.3 Substantivos e Verbos
=========================

Maxima distingue entre operadores que são "substantivos" e operadores
que são "verbos".  Um verbo é um operador que pode ser executado.  Um
substantivo é um operador que aparece como um símbolo em uma expressão,
sem ser executado.  Por padrão, nomes de função são verbos.  Um verbo
pode ser mudado em um substantivo através da adição de um apóstrofo no
início do nome da função ou aplicando a função 'nounify'.  Um
substantivo pode ser mudado em um verbo através da aplicação da função
'verbify'.  O sinalizador de avaliação 'nouns' faz com que 'ev' avalie
substantivos em uma expressão.

   A forma verbal é distinguida através de um sinal de dólar '$' no
início do símbolo Lisp correspondente.  De forma oposta, a forma
substantiva é distinguida através de um sinal de '%' no início do
símbolo Lisp correspondente.  Alguns substantivos possuem propriedades
especiais de exibição, tais como ''integrate' e ''derivative' (retornado
por 'diff'), mas muitos não.  Por padrão, as formas substantiva e verbal
de uma função são idênticas quando mostradas.  O sinalizador global
'noundisp' faz com que Maxima mostre substantivos com um apóstrofo no
início '''.

   Veja também 'noun', 'nouns', 'nounify', e 'verbify'.

   Exemplos:

     (%i1) foo (x) := x^2;
                                          2
     (%o1)                     foo(x) := x
     (%i2) foo (42);
     (%o2)                         1764
     (%i3) 'foo (42);
     (%o3)                        foo(42)
     (%i4) 'foo (42), nouns;
     (%o4)                         1764
     (%i5) declare (bar, noun);
     (%o5)                         done
     (%i6) bar (x) := x/17;
                                          x
     (%o6)                    ''bar(x) := --
                                          17
     (%i7) bar (52);
     (%o7)                        bar(52)
     (%i8) bar (52), nouns;
                                    52
     (%o8)                          --
                                    17
     (%i9) integrate (1/x, x, 1, 42);
     (%o9)                        log(42)
     (%i10) 'integrate (1/x, x, 1, 42);
                                  42
                                 /
                                 [   1
     (%o10)                      I   - dx
                                 ]   x
                                 /
                                  1
     (%i11) ev (%, nouns);
     (%o11)                       log(42)


File: maxima.info,  Node: Identificadores,  Next: Seqüências de caracteres,  Prev: Substantivos e Verbos,  Up: Expressões

6.4 Identificadores
===================

Identificadores do Maxima podem compreender caracteres alfabéticos, mais
os numerais de 0 a 9, mais qualquer caractere especial precedido por um
caractere contra-barra '\'.

   Um numeral pode ser o primeiro caractere de um identificador se esse
numeral for precedido por uma contra-barra.  Numerais que forem o
segundo ou o último caractere não precisam ser precedidos por uma contra
barra.

   Caracteres podem ser declarados para serem alfabéticos por meio da
função 'declare'.  Se então declarados alfabéticos, eles não precisam
serem precedidos de uma contrabarra em um identificador.  Os caracteres
alfabéticos vão inicialmente de 'A' a 'Z', de 'a' a 'z', '%', e '_'.

   Maxima é sensível à caixa .  Os identificadores 'algumacoisa',
'ALGUMACOISA', e 'Algumacoisa' são distintos.  Veja *note Lisp e
Maxima:: para mais sobre esse ponto.

   Um identificador Maxima é um símbolo Lisp que começa com um sinal de
dólar '$'.  Qualquer outro símbolo Lisp é precedido por um ponto de
interrogação '?' quando aparecer no Maxima.  Veja *note Lisp e Maxima::
para maiores detalhes sobre esse ponto.

   Exemplos:

     (%i1) %an_ordinary_identifier42;
     (%o1)               %an_ordinary_identifier42
     (%i2) embedded\ spaces\ in\ an\ identifier;
     (%o2)           embedded spaces in an identifier
     (%i3) symbolp (%);
     (%o3)                         true
     (%i4) [foo+bar, foo\+bar];
     (%o4)                 [foo + bar, foo+bar]
     (%i5) [1729, \1729];
     (%o5)                     [1729, 1729]
     (%i6) [symbolp (foo\+bar), symbolp (\1729)];
     (%o6)                     [true, true]
     (%i7) [is (foo\+bar = foo+bar), is (\1729 = 1729)];
     (%o7)                    [false, false]
     (%i8) baz\~quux;
     (%o8)                       baz~quux
     (%i9) declare ("~", alphabetic);
     (%o9)                         done
     (%i10) baz~quux;
     (%o10)                      baz~quux
     (%i11) [is (foo = FOO), is (FOO = Foo), is (Foo = foo)];
     (%o11)                [false, false, false]
     (%i12) :lisp (defvar *my-lisp-variable* '$foo)
     *MY-LISP-VARIABLE*
     (%i12) ?\*my\-lisp\-variable\*;
     (%o12)                         foo


File: maxima.info,  Node: Seqüências de caracteres,  Next: Desigualdade,  Prev: Identificadores,  Up: Expressões

6.5 Seqüências de caracteres
============================

Strings (seqüências de caracteres) são contidas entre aspas duplas '"'
em entradas de dados usados pelo Maxima, e mostradas com ou sem as aspas
duplas, dependendo do valor escolhido para a variável global
'stringdisp'.

   Seqüências de caracteres podem conter quaisquer caracteres, incluindo
tabulações (tab), nova linha (ou fim de linha), e caracteres de retorno
da cabeça de impressão (carriage return).  A seqüência '\"' é
reconhecida com uma aspa dupla literal, e '\\' como uma contrabarra
literal.  Quando a contrabarra aparecer no final de uma linha, a
contrabarra e a terminação de linha (ou nova linha ou retorno de carro e
nova linha) são ignorados, de forma que a seqüência de caracteres
continue na próxima linha.  Nenhuma outra combinação especial de
contrabarra com outro caractere é reconhecida; quando a contrabarra
aparecer antes de qualquer outro caractere que não seja '"', '\', ou um
fim de linha, a contrabarra é ignorada.  Não exite caminho para
representar um caractere especial (tal como uma tabulação, nova linha,
ou retorno da cabeça de impressão) exceto através de encaixar o
caractere literal na seqüência de caracteres.

   Não existe tipo de caractere no Maxima; um caractere simples é
representado como uma seqüência de caracteres de um único caractere.

   Seqüências de caracteres no Maxima são implementadas como símbolos do
Lisp, não como seqüencias de caracteres do not Lisp; o que pode mudar em
futuras versões do Maxima.  Maxima pode mostrar seqüências de caracteres
do Lisp e caracteres do Lisp, embora algumas outras operações (por
exemplo, testes de igualdade) possam falhar.

   O pacote adicional 'stringproc' contém muitas funções que trabalham
com seqüências de caracteres.

   Exemplos:

     (%i1) s_1 : "Isso é uma seqüência de caracteres  do Maxima.";
     (%o1)               Isso é uma seqüência de caracteres  do Maxima.
     (%i2) s_2 : "Caracteres \"aspas duplas\" e contrabarras \\ encaixados em uma seqüência de caracteres.";
     (%o2) Caracteres "aspas duplas" e contrabarra \ encaixados em uma seqüência de caracteres.
     (%i3) s_3 : "Caractere de fim de linha encaixado
     nessa seqüência de caracteres.";
     (%o3) Caractere de fim de linha encaixado
     nessa seqüência de caracteres.
     (%i4) s_4 : "Ignore o \
     caractere de \
     fim de linha nessa \
     seqüência de caracteres.";
     (%o4) Ignore o caractere de fim de linha nessa seqüência de caracteres.
     (%i5) stringdisp : false;
     (%o5)                         false
     (%i6) s_1;
     (%o6)               Isso é uma seqüência de caracteres  do Maxima.
     (%i7) stringdisp : true;
     (%o7)                         true
     (%i8) s_1;
     (%o8)              "Isso é uma seqüência de caracteres  do Maxima."


File: maxima.info,  Node: Desigualdade,  Next: Sintaxe,  Prev: Seqüências de caracteres,  Up: Expressões

6.6 Desigualdade
================

Maxima tem os operadores de desigualdade '<', '<=', '>=', '>', '#', e
'notequal'.  Veja 'if' para uma descrição de expressões condicionais.


File: maxima.info,  Node: Sintaxe,  Next: Funções e Variáveis Definidas para Expressões,  Prev: Desigualdade,  Up: Expressões

6.7 Sintaxe
===========

É possível definir novos operadores com precedência especificada,
remover a definição de operadores existentes, ou redefinir a precedência
de operadores existentes.  Um operador pode ser unário prefixado ou
unário pósfixado, binario infixado, n-ário infixado, matchfix, ou nofix.
"Matchfix" significa um par de símbolos que abraçam seu argumento ou
seus argumentos, e "nofix" significa um operador que não precisa de
argumentos.  Como exemplos dos diferentes tipos de operadores, existe o
seguinte.

unário prefixado
     negação '- a'
unário posfixado
     fatorial 'a!'
binário infixado
     exponenciação 'a^b'
n-ário infixado
     adição 'a + b'
matchfix
     construção de lista '[a, b]'

   (Não existe operadores internos nofix; para um exemplo de tal
operador, veja 'nofix'.)

   O mecanismo para definir um novo operador é direto.  Somente é
necessário declarar uma função como um operador; a função operador pode
ou não estar definida previamente.

   Um exemplo de operadores definidos pelo usuário é o seguinte.  Note
que a chamada explícita de função '"dd" (a)' é equivalente a 'dd a', da
mesma forma '"<-" (a, b)' é equivalente a 'a <- b'.  Note também que as
funções '"dd"' e '"<-"' são indefinidas nesse exemplo.

     (%i1) prefix ("dd");
     (%o1)                          dd
     (%i2) dd a;
     (%o2)                         dd a
     (%i3) "dd" (a);
     (%o3)                         dd a
     (%i4) infix ("<-");
     (%o4)                          <-
     (%i5) a <- dd b;
     (%o5)                      a <- dd b
     (%i6) "<-" (a, "dd" (b));
     (%o6)                      a <- dd b

   As funções máxima que definem novos operadores estão sumarizadas
nessa tabela, equilibrando expoente associado esquerdo (padrão) e o
expoente associado direito ("eae" e "ead", respectivamente).
(Associação de expoentes determina a precedência do operador.  todavia,
uma vez que os expoentes esquerdo e direito podem ser diferentes,
associação de expoentes é até certo ponto mais complicado que
precedência.)  Alguma das funções de definição de operações tomam
argumentos adicionais; veja as descrições de função para maiores
detalhes.

'prefixado'
     ead=180
'posfixado'
     eae=180
'infixado'
     eae=180, ead=180
'nário'
     eae=180, ead=180
'matchfix'
     (associação de expoentes não é aplicável)
'nofix'
     (associação de expoentes não é aplicável)

   Para comparação, aqui está alguns operadores internos e seus
expoentes associados esquerdo e direito.

     Operador   eae     ead

       :        180     20
       ::       180     20
       :=       180     20
       ::=      180     20
       !        160
       !!       160
       ^        140     139
       .        130     129
       *        120
       /        120     120
       +        100     100
       -        100     134
       =        80      80
       #        80      80
       >        80      80
       >=       80      80
       <        80      80
       <=       80      80
       not              70
       and      65
       or       60
       ,        10
       $        -1
       ;        -1

   'remove' e 'kill' removem propriedades de operador de um átomo.
'remove ("<a>", op)' remove somente as propriedades de operador de <a>.
'kill ("<a>")' remove todas as propriedades de <a>, incluindo as
propriedades de operador.  Note que o nome do operador dever estar
abraçado por aspas duplas.

     (%i1) infix ("##");
     (%o1)                          ##
     (%i2) "##" (a, b) := a^b;
                                          b
     (%o2)                     a ## b := a
     (%i3) 5 ## 3;
     (%o3)                          125
     (%i4) remove ("##", op);
     (%o4)                         done
     (%i5) 5 ## 3;
     Incorrect syntax: # is not a prefix operator
     5 ##
       ^
     (%i5) "##" (5, 3);
     (%o5)                          125
     (%i6) infix ("##");
     (%o6)                          ##
     (%i7) 5 ## 3;
     (%o7)                          125
     (%i8) kill ("##");
     (%o8)                         done
     (%i9) 5 ## 3;
     Incorrect syntax: # is not a prefix operator
     5 ##
       ^
     (%i9) "##" (5, 3);
     (%o9)                       ##(5, 3)


File: maxima.info,  Node: Funções e Variáveis Definidas para Expressões,  Prev: Sintaxe,  Up: Expressões

6.8 Funções e Variáveis Definidas para Expressões
=================================================

 -- Função: at (<expr>, [<eqn_1>, ..., <eqn_n>])
 -- Função: at (<expr>, <eqn>)
     Avalia a expressão <expr> com as variáveis assumindo os valores
     como especificado para elas na lista de equações '[<eqn_1>, ...,
     <eqn_n>]' ou a equação simples <eqn>.

     Se uma subexpressão depender de qualquer das variáveis para a qual
     um valor foi especificado mas não existe 'atvalue' especificado e
     essa subexpressão não pode ser avaliada de outra forma, então uma
     forma substantiva de 'at' é retornada que mostra em uma forma
     bidimensional.

     'at' realiza múltiplas substituições em série, não em paralelo.

     Veja também 'atvalue'.  Para outras funções que realizam
     substituições, veja também 'subst' e 'ev'.

     Exemplos:

          (%i1) atvalue (f(x,y), [x = 0, y = 1], a^2);
                                          2
          (%o1)                          a
          (%i2) atvalue ('diff (f(x,y), x), x = 0, 1 + y);
          (%o2)                        @2 + 1
          (%i3) printprops (all, atvalue);
                                          !
                            d             !
                           --- (f(@1, @2))!       = @2 + 1
                           d@1            !
                                          !@1 = 0

                                               2
                                    f(0, 1) = a

          (%o3)                         done
          (%i4) diff (4*f(x, y)^2 - u(x, y)^2, x);
                            d                          d
          (%o4)  8 f(x, y) (-- (f(x, y))) - 2 u(x, y) (-- (u(x, y)))
                            dx                         dx
          (%i5) at (%, [x = 0, y = 1]);
                                                   !
                        2              d           !
          (%o5)     16 a  - 2 u(0, 1) (-- (u(x, y))!            )
                                       dx          !
                                                   !x = 0, y = 1

 -- Função: box (<expr>)
 -- Função: box (<expr>, <a>)
     Retorna <expr> dentro de uma caixa.  O valor de retorno é uma
     expressão com 'box' como o operador e <expr> como o argumento.  Uma
     caixa é desenhada sobre a tela quando 'display2d' for 'true'.

     'box (<expr>, <a>)' Empacota <expr> em uma caixa rotulada pelo
     símbolo <a>.  O rótulo é truncado se for maior que a largura da
     caixa.

     'box' avalia seu argumento.  Todavia, uma expressão dentro de uma
     caixa não avalia para seu conteúdo, então expressões dentro de
     caixas são efetivamente excluídas de cálculos.

     'boxchar' é o caractere usado para desenhar a caixa em 'box' e nas
     funções 'dpart' e 'lpart'.

     Exemplos:

          (%i1) box (a^2 + b^2);
                                      """""""""
                                      " 2    2"
          (%o1)                       "b  + a "
                                      """""""""
          (%i2) a : 1234;
          (%o2)                         1234
          (%i3) b : c - d;
          (%o3)                         c - d
          (%i4) box (a^2 + b^2);
                                """"""""""""""""""""
                                "       2          "
          (%o4)                 "(c - d)  + 1522756"
                                """"""""""""""""""""
          (%i5) box (a^2 + b^2, term_1);
                                term_1""""""""""""""
                                "       2          "
          (%o5)                 "(c - d)  + 1522756"
                                """"""""""""""""""""
          (%i6) 1729 - box (1729);
                                           """"""
          (%o6)                     1729 - "1729"
                                           """"""
          (%i7) boxchar: "-";
          (%o7)                           -
          (%i8) box (sin(x) + cos(y));
                                  -----------------
          (%o8)                   -cos(y) + sin(x)-
                                  -----------------

 -- Variável de opção: boxchar
     Valor padrão: '"'

     'boxchar' é o caractere usado para desenhar a caixa por 'box' e nas
     funções 'dpart' e 'lpart'.

     Todas as caixas em uma expressão são desenhadas com o valor atual
     de 'boxchar'; o caractere de desenho não é armazenado com a
     expressão de caixa.  Isso quer dizer que se você desenhar uma caixa
     e em seguida mudar o caractere de desenho a caixa anteriormente
     desenhada será redesenhada com o caractere mudado caso isso seja
     solicitado.

 -- Função: carg (<z>)
     Retorna o argumento complexo de <z>.  O argumento complexo é um
     ângulo 'theta' no intervalo de '(-%pi, %pi]' tal que 'r exp (theta
     %i) = <z>' onde 'r' é o módulo de <z>.

     'carg' é uma função computacional, não uma função de simplificação.

     'carg' ignora a declaração 'declare (<x>, complex)', e trata <x>
     como uma variável real.  Isso é um erro.

     Veja também 'abs' (módulo de número complexo), 'polarform',
     'rectform', 'realpart', e 'imagpart'.

     Exemplos:

          (%i1) carg (1);
          (%o1)                           0
          (%i2) carg (1 + %i);
                                         %pi
          (%o2)                          ---
                                          4
          (%i3) carg (exp (%i));
          (%o3)                           1
          (%i4) carg (exp (%pi * %i));
          (%o4)                          %pi
          (%i5) carg (exp (3/2 * %pi * %i));
                                          %pi
          (%o5)                         - ---
                                           2
          (%i6) carg (17 * exp (2 * %i));
          (%o6)                           2

 -- Opereador especial: constant
     'declare (<a>, constant)' declara <a> para ser uma constante.  Veja
     'declare'.

 -- Função: constantp (<expr>)
     Retorna 'true' se <expr> for uma expressão constante, de outra
     forma retorna 'false'.

     Uma expressão é considerada uma expressão constante se seus
     argumentos forem números (incluindo números racionais, como
     mostrado com '/R/'), constantes simbólicas como '%pi', '%e', e
     '%i', variáveis associadas a uma constante ou constante declarada
     através de 'declare', ou funções cujos argumentos forem constantes.

     'constantp' avalia seus argumentos.

     Exemplos:

          (%i1) constantp (7 * sin(2));
          (%o1)                                true
          (%i2) constantp (rat (17/29));
          (%o2)                                true
          (%i3) constantp (%pi * sin(%e));
          (%o3)                                true
          (%i4) constantp (exp (x));
          (%o4)                                false
          (%i5) declare (x, constant);
          (%o5)                                done
          (%i6) constantp (exp (x));
          (%o6)                                true
          (%i7) constantp (foo (x) + bar (%e) + baz (2));
          (%o7)                                false
          (%i8)

 -- Função: declare (<a_1>, <p_1>, <a_2>, <p_2>, ...)
     Atribui aos átomos ou lista de átomos <a_i> a propriedade ou lista
     de propriedades <p_i>.  Quando <a_i> e/ou <p_i> forem listas, cada
     um dos átomos recebe todas as propriedades.

     'declare' não avalia seus argumentos.  'declare' sempre retorna
     'done'.

     Como colocado na descrição para cada sinalizador de declaração,
     para alguns sinalizadores 'featurep(<objeto>, <recurso>)' retorna
     'true' se <objeto> tiver sido declarado para ter <recurso>.
     Todavia, 'featurep' não reconhece alguns sinalizadores; isso é um
     erro.

     Veja também 'features'.

     'declare' reconhece as seguintes propriedades:

     'evfun'
          Torna <a_i> conhecido para 'ev' de forma que a função nomeada
          por <a_i> é aplicada quando <a_i> aparece como um sinalizador
          argumento de 'ev'.  Veja 'evfun'.

     'evflag'
          Torna <a_i> conhecido para a função 'ev' de forma que <a_i> é
          associado a 'true' durante a execução de 'ev' quando <a_i>
          aparece como um sinalizador argumento de 'ev'.  Veja 'evflag'.

     'bindtest'
          Diz ao Maxima para disparar um erro quando <a_i> for avaliado
          como sendo livre de associação.

     'noun'
          Diz ao Maxima para passar <a_i> como um substantivo.  O efeito
          disso é substituir intâncias de <a_i> com ''<a_i>' ou
          'nounify(<a_i>)', ependendo do contexto.

     'constant'
          Diz ao Maxima para considerar <a_i> uma constante simbólica.

     'scalar'
          Diz ao Maxima para considerar <a_i> uma variável escalar.

     'nonscalar'
          Diz ao Maxima para considerar <a_i> uma variável não escalar.
          The usual application is to declare a variable as a symbolic
          vector or matrix.

     'mainvar'
          Diz ao Maxima para considerar <a_i> uma "variável principal"
          ('mainvar').  'ordergreatp' determina a ordenação de átomos
          como segue:

          (variáveis principais) > (outras variáveis) > (variáveis
          escalares) > (constantes) > (números)

     'alphabetic'
          Diz ao Maxima para reconhecer todos os caracteres em <a_i>
          (que deve ser uma seqüência de caracteres) como caractere
          alfabético.

     'feature'
          Diz ao Maxima para reconhecer <a_i> como nome de um recurso.
          Other atoms may then be declared to have the <a_i> property.

     'rassociative', 'lassociative'
          Diz ao Maxima para reconhecer <a_i> como uma funcão
          associativa a direita ou associativa a esquerda.

     'nary'
          Diz ao Maxima para reconhecer <a_i> como uma função n-ária
          (com muitos argumentos).

          A declaração 'nary' não tem o mesmo objetivo que uma chamada à
          função 'nary'.  O único efeito de 'declare(foo, nary)' é para
          instruir o simplificador do Maxima a melhorar as próximas
          expressões, por exemplo, para simplificar 'foo(x, foo(y, z))'
          para 'foo(x, y, z)'.

     'symmetric', 'antisymmetric', 'commutative'
          Diz ao Maxima para reconhecer <a_i> como uma função simétrica
          ou antisimétrica.  'commutative' é o mesmo que 'symmetric'.

     'oddfun', 'evenfun'
          Diz ao Maxima para reconhecer <a_i> como uma função par ou uma
          função ímpar.

     'outative'
          Diz ao Maxima para simplificar expressões <a_i> colocando
          fatores constantes em evidência no primeiro argumento.

          Quando <a_i> tiver um argumento, um fator é onsiderado
          constante se for um literal ou se for declarado como sendo
          constante.

          Quando <a_i> tiver dois ou mais argumentos, um fator é
          considerado constante se o segundo argumento for um símbolo e
          o fator estiver livre do segundo argumento.

     'multiplicative'
          Diz ao Maxima para simplificar expressões do tipo <a_i>
          através da substituição '<a_i>(x * y * z * ...)'  '-->'
          '<a_i>(x) * <a_i>(y) * <a_i>(z) * ...'.  A substituição é
          realizada no primeiro argumento somente.

     'additive'
          Diz ao Maxima para simplificar expressões do tipo <a_i>
          através da substituição '<a_i>(x + y + z + ...)'  '-->'
          '<a_i>(x) + <a_i>(y) + <a_i>(z) + ...'.  A substituição é
          realizada no primeiro argumento somente.

     'linear'
          Equivalente a declarar <a_i> ao mesmo tempo 'outative' e
          'additive'.

     'integer', 'noninteger'
          Diz ao Maxima para reconhecer <a_i> como como uma variável
          inteira ou como uma variável não inteira.

          Maxima reconhece os seguintes recursos de objetos:

     'even', 'odd'
          Diz ao Maxima para reconhecer <a_i> como uma variável inteira
          par ou como uma variável inteira ímpar.

     'rational', 'irrational'
          Diz ao Maxima para reconhecer <a_i> como uma variável real e
          racional ou como uma variável real e irracional.

     'real', 'imaginary', 'complex'
          Dia ao Maxima para reconhecer <a_i> como uma variável real,
          imaginária pura ou complexa.

     'increasing', 'decreasing'
          Dia ao Maxima para reconhecer <a_i> como uma função de
          incremento ou decremento.

     'posfun'
          Diz ao Maxima para reconhecer <a_i> como uma função positiva.

     'integervalued'
          Diz ao Maxima para reconhecer <a_i> como uma função de valores
          inteiros.

     Exemplos:

     Declarações 'evfun' e 'evflag'.
          (%i1) declare (expand, evfun);
          (%o1)                         done
          (%i2) (a + b)^3;
                                             3
          (%o2)                       (b + a)
          (%i3) (a + b)^3, expand;
                               3        2      2      3
          (%o3)               b  + 3 a b  + 3 a  b + a
          (%i4) declare (demoivre, evflag);
          (%o4)                         done
          (%i5) exp (a + b*%i);
                                       %i b + a
          (%o5)                      %e
          (%i6) exp (a + b*%i), demoivre;
                                a
          (%o6)               %e  (%i sin(b) + cos(b))

     Declaração 'bindtest'.
          (%i1) aa + bb;
          (%o1)                        bb + aa
          (%i2) declare (aa, bindtest);
          (%o2)                         done
          (%i3) aa + bb;
          aa unbound variable
           -- an error.  Quitting.  To debug this try debugmode(true);
          (%i4) aa : 1234;
          (%o4)                         1234
          (%i5) aa + bb;
          (%o5)                       bb + 1234

     Declaração 'noun'.
          (%i1) factor (12345678);
                                       2
          (%o1)                     2 3  47 14593
          (%i2) declare (factor, noun);
          (%o2)                         done
          (%i3) factor (12345678);
          (%o3)                   factor(12345678)
          (%i4) ''%, nouns;
                                       2
          (%o4)                     2 3  47 14593

     Declarações 'constant', 'scalar', 'nonscalar', e 'mainvar'.

     Declaração 'alphabetic'.
          (%i1) xx\~yy\`\@ : 1729;
          (%o1)                         1729
          (%i2) declare ("~`@", alphabetic);
          (%o2)                         done
          (%i3) xx~yy`@ + @yy`xx + `xx@@yy~;
          (%o3)               `xx@@yy~ + @yy`xx + 1729
          (%i4) listofvars (%);
          (%o4)                  [@yy`xx, `xx@@yy~]

     Declaração 'feature'.
          (%i1) declare (FOO, feature);
          (%o1)                         done
          (%i2) declare (x, FOO);
          (%o2)                         done
          (%i3) featurep (x, FOO);
          (%o3)                         true

     Declarações 'rassociative' e 'lassociative'.

     Declaração 'nary'.
          (%i1) H (H (a, b), H (c, H (d, e)));
          (%o1)               H(H(a, b), H(c, H(d, e)))
          (%i2) declare (H, nary);
          (%o2)                         done
          (%i3) H (H (a, b), H (c, H (d, e)));
          (%o3)                   H(a, b, c, d, e)

     Declarações 'symmetric' e 'antisymmetric'.
          (%i1) S (b, a);
          (%o1)                        S(b, a)
          (%i2) declare (S, symmetric);
          (%o2)                         done
          (%i3) S (b, a);
          (%o3)                        S(a, b)
          (%i4) S (a, c, e, d, b);
          (%o4)                   S(a, b, c, d, e)
          (%i5) T (b, a);
          (%o5)                        T(b, a)
          (%i6) declare (T, antisymmetric);
          (%o6)                         done
          (%i7) T (b, a);
          (%o7)                       - T(a, b)
          (%i8) T (a, c, e, d, b);
          (%o8)                   T(a, b, c, d, e)

     Declarações 'oddfun' e 'evenfun'.
          (%i1) o (- u) + o (u);
          (%o1)                     o(u) + o(- u)
          (%i2) declare (o, oddfun);
          (%o2)                         done
          (%i3) o (- u) + o (u);
          (%o3)                           0
          (%i4) e (- u) - e (u);
          (%o4)                     e(- u) - e(u)
          (%i5) declare (e, evenfun);
          (%o5)                         done
          (%i6) e (- u) - e (u);
          (%o6)                           0

     Declaração 'outative'.
          (%i1) F1 (100 * x);
          (%o1)                       F1(100 x)
          (%i2) declare (F1, outative);
          (%o2)                         done
          (%i3) F1 (100 * x);
          (%o3)                       100 F1(x)
          (%i4) declare (zz, constant);
          (%o4)                         done
          (%i5) F1 (zz * y);
          (%o5)                       zz F1(y)

     Declaração 'multiplicative'.
          (%i1) F2 (a * b * c);
          (%o1)                       F2(a b c)
          (%i2) declare (F2, multiplicative);
          (%o2)                         done
          (%i3) F2 (a * b * c);
          (%o3)                   F2(a) F2(b) F2(c)

     Declaração 'additive'.
          (%i1) F3 (a + b + c);
          (%o1)                     F3(c + b + a)
          (%i2) declare (F3, additive);
          (%o2)                         done
          (%i3) F3 (a + b + c);
          (%o3)                 F3(c) + F3(b) + F3(a)

     Declaração 'linear'.
          (%i1) 'sum (F(k) + G(k), k, 1, inf);
                                 inf
                                 ====
                                 \
          (%o1)                   >    (G(k) + F(k))
                                 /
                                 ====
                                 k = 1
          (%i2) declare (nounify (sum), linear);
          (%o2)                         done
          (%i3) 'sum (F(k) + G(k), k, 1, inf);
                               inf          inf
                               ====         ====
                               \            \
          (%o3)                 >    G(k) +  >    F(k)
                               /            /
                               ====         ====
                               k = 1        k = 1

 -- Função: disolate (<expr>, <x_1>, ..., <x_n>)
     é similar a 'isolate (<expr>, <x>)' exceto que essa função habilita
     ao usuário isolar mais que uma variável simultâneamente.  Isso pode
     ser útil, por exemplo, se se tiver tentado mudar variáveis em uma
     integração múltipla, e em mudança de variável envolvendo duas ou
     mais das variáveis de integração.  Essa função é chamada
     automaticamente de 'simplification/disol.mac'.  Uma demostração
     está disponível através de 'demo("disol")$'.

 -- Função: dispform (<expr>)
     Retorna a representação externa de <expr> com relação a seu
     principal operador.  Isso pode ser útil em conjunção com 'part' que
     também lida com a representação externa.  Suponha que <expr> seja
     -A .  Então a representação interna de <expr> é "*"(-1,A), enquanto
     que a representação externa é "-"(A). 'dispform (<expr>, all)'
     converte a expressão inteira (não apenas o nível mais alto) para o
     formato externo.  Por exemplo, se 'expr: sin (sqrt (x))', então
     'freeof (sqrt, expr)' e 'freeof (sqrt, dispform (expr))' fornece
     'true', enquanto 'freeof (sqrt, dispform (expr, all))' fornece
     'false'.

 -- Função: distrib (<expr>)
     Distribue adições sobre produtos.  'distrib' difere de 'expand' no
     fato de que 'distrib' trabalha em somente no nível mais alto de uma
     expressão, i.e., 'distrib' não é recursiva e 'distrib' é mais
     rápida que 'expand'.  'distrib' difere de 'multthru' no que
     'distrib' expande todas as adições naquele nível.

     Exemplos:

          (%i1) distrib ((a+b) * (c+d));
          (%o1)                 b d + a d + b c + a c
          (%i2) multthru ((a+b) * (c+d));
          (%o2)                 (b + a) d + (b + a) c
          (%i3) distrib (1/((a+b) * (c+d)));
                                          1
          (%o3)                    ---------------
                                   (b + a) (d + c)
          (%i4) expand (1/((a+b) * (c+d)), 1, 0);
                                          1
          (%o4)                 ---------------------
                                b d + a d + b c + a c

 -- Função: dpart (<expr>, <n_1>, ..., <n_k>)
     Seleciona a mesma subexpressão que 'part', mas em lugar de apenas
     retornar aquela subexpressão como seu valor, isso retorna a
     expressão completa com a subexpressão selecionada mostrada dentro
     de uma caixa.  A caixa é atualmente parte da expressão.

          (%i1) dpart (x+y/z^2, 1, 2, 1);
                                       y
          (%o1)                       ---- + x
                                         2
                                      """
                                      "z"
                                      """

 -- Função: exp (<x>)
     Representa função exponencial.  Instâncias de 'exp (<x>)' em uma
     entrada são simplificadas para '%e^<x>'; 'exp' não aparece em
     expressões simplificadas.

     'demoivre' se 'true' faz com que '%e^(a + b %i)' simplificar para
     '%e^(a (cos(b) + %i sin(b)))' se 'b' for livre de '%i'.  veja
     'demoivre'.

     '%emode', quando 'true', faz com que '%e^(%pi %i x)' seja
     simplificado.  Veja '%emode'.

     '%enumer', quando 'true' faz com que '%e' seja substituído por
     2.718...  quando 'numer' for 'true'.  Veja '%enumer'.

 -- Variável de opção: %emode
     Valor padrão: 'true'

     Quando '%emode' for 'true', '%e^(%pi %i x)' é simplificado como
     segue.

     '%e^(%pi %i x)' simplifica para 'cos (%pi x) + %i sin (%pi x)' se
     'x' for um inteiro ou um multiplo de 1/2, 1/3, 1/4, ou 1/6, e então
     é adicionalmente simplificado.

     Para outro 'x' numérico, '%e^(%pi %i x)' simplifica para '%e^(%pi
     %i y)' onde 'y' é 'x - 2 k' para algum inteiro 'k' tal que 'abs(y)
     < 1'.

     Quando '%emode' for 'false', nenhuma simplificação adicional de
     '%e^(%pi %i x)' é realizada.

 -- Variável de opção: %enumer
     Valor padrão: 'false'

     Quando '%enumer' for 'true', '%e' é substituido por seu valor
     numérico 2.718...  mesmo que 'numer' seja 'true'.

     Quando '%enumer' for 'false', essa substituição é realizada somente
     se o expoente em '%e^x' avaliar para um número.

     Veja também 'ev' e 'numer'.

 -- Variável de opção: exptisolate
     Valor padrão: 'false'

     'exptisolate', quando 'true', faz com que 'isolate (expr, var)'
     examine expoentes de átomos (tais como '%e') que contenham 'var'.

 -- Variável de opção: exptsubst
     Valor padrão: 'false'

     'exptsubst', quando 'true', permite substituições tais como 'y'
     para '%e^x' em '%e^(a x)'.

 -- Função: freeof (<x_1>, ..., <x_n>, <expr>)
     'freeof (<x_1>, <expr>)' Retorna 'true' se nenhuma subexpressão de
     <expr> for igual a <x_1> ou se <x_1> ocorrer somente uma variável
     que não tenha associação fora da expressão <expr>, e retorna
     'false' de outra forma.

     'freeof (<x_1>, ..., <x_n>, <expr>)' é equivalente a 'freeof
     (<x_1>, <expr>) and ... and freeof (<x_n>, <expr>)'.

     Os argumentos <x_1>, ..., <x_n> podem ser nomes de funções e
     variáveis, nomes subscritos, operadores (empacotados em aspas
     duplas), ou expressões gerais.  'freeof' avalia seus argumentos.

     'freeof' opera somente sobre <expr> como isso representa (após
     simplificação e avaliação) e não tenta determinar se alguma
     expressão equivalente pode fornecer um resultado diferente.  Em
     particular, simplificação pode retornar uma expressão equivalente
     mas diferente que compreende alguns diferentes elementos da forma
     original de <expr>.

     Uma variável é uma variável dummy em uma expressão se não tiver
     associação fora da expressão.  Variáveis dummy recoreconhecidas
     através de 'freeof' são o índice de um somatório ou produtório, o
     limite da variável em 'limit', a variável de integração na forma de
     integral definida de 'integrate', a variável original em 'laplace',
     variáveis formais em expressoes 'at', e argumentos em expressões
     'lambda'.  Variáveis locais em 'block' não são reconhecidas por
     'freeof' como variáveis dummy; isso é um bug.

     A forma indefinida de 'integrate' not é livre de suas variáveis de
     integração.

        * Argumentos são nomes de funções, variáveis, nomes subscritos,
          operadores, e expressões.  'freeof (a, b, expr)' é equivalente
          a 'freeof (a, expr) and freeof (b, expr)'.

               (%i1) expr: z^3 * cos (a[1]) * b^(c+d);
                                                d + c  3
               (%o1)                   cos(a ) b      z
                                            1
               (%i2) freeof (z, expr);
               (%o2)                         false
               (%i3) freeof (cos, expr);
               (%o3)                         false
               (%i4) freeof (a[1], expr);
               (%o4)                         false
               (%i5) freeof (cos (a[1]), expr);
               (%o5)                         false
               (%i6) freeof (b^(c+d), expr);
               (%o6)                         false
               (%i7) freeof ("^", expr);
               (%o7)                         false
               (%i8) freeof (w, sin, a[2], sin (a[2]), b*(c+d), expr);
               (%o8)                         true

        * 'freeof' avalia seus argumentos.

               (%i1) expr: (a+b)^5$
               (%i2) c: a$
               (%i3) freeof (c, expr);
               (%o3)                         false

        * 'freeof' não considera expressões equivalentes.  Simplificação
          pode retornar uma expressão equivalente mas diferente.

               (%i1) expr: (a+b)^5$
               (%i2) expand (expr);
                         5        4       2  3       3  2      4      5
               (%o2)    b  + 5 a b  + 10 a  b  + 10 a  b  + 5 a  b + a
               (%i3) freeof (a+b, %);
               (%o3)                         true
               (%i4) freeof (a+b, expr);
               (%o4)                         false
               (%i5) exp (x);
                                                x
               (%o5)                          %e
               (%i6) freeof (exp, exp (x));
               (%o6)                         true

        * Um somatório ou uma integral definida está livre de uma
          variável dummy.  Uma integral indefinida não é livre de suas
          variáveis de integração.

               (%i1) freeof (i, 'sum (f(i), i, 0, n));
               (%o1)                         true
               (%i2) freeof (x, 'integrate (x^2, x, 0, 1));
               (%o2)                         true
               (%i3) freeof (x, 'integrate (x^2, x));
               (%o3)                         false

 -- Função: genfact (<x>, <y>, <z>)
     Retorna o fatorial generalizado, definido como 'x (x-z) (x - 2 z)
     ... (x - (y - 1) z)'.  Dessa forma, para integral <x>, 'genfact (x,
     x, 1) = x!' e 'genfact (x, x/2, 2) = x!!'.

 -- Função: imagpart (<expr>)
     Retorna a parte imaginária da expressão <expr>.

     'imagpart' é uma função computacional, não uma função de
     simplificação.

     Veja também 'abs', 'carg', 'polarform', 'rectform', e 'realpart'.

 -- Função: infix (<op>)
 -- Função: infix (<op>, <lbp>, <rbp>)
 -- Função: infix (<op>, <lbp>, <rbp>, <lpos>, <rpos>, <pos>)
     Declara <op> para ser um operador infixo.  Um operador infixo é uma
     função de dois argumentos, com o nome da função escrito entre os
     argumentos.  Por exemplo, o operador de subtração '-' é um operador
     infixo.

     'infix (<op>)' declara <op> para ser um operador infixo com
     expoentes associados padrão (esquerdo e direito ambos iguais a 180)
     e podendo ser qualquer entre prefixado, infixado, posfixado, nário,
     matchfix e nofix (esquerdo e direito ambos iguais a 'any').

     'infix (<op>, <lbp>, <rbp>)' declara <op> para ser um operador
     infixo com expoentes associados esquerdo e diretio equilibrados e
     podendo ser qualquer entre prefixado, infixado, posfixado, nário,
     matchfix e nofix (esquerdo e direito ambos iguais a 'any').

     'infix (<op>, <lbp>, <rbp>, <lpos>, <rpos>, <pos>)' declara <op>
     para ser um operdor infixo com expoentes associados padrão e
     podendo ser um entre prefixado, infixado, posfixado, nário,
     matchfix e nofix.

     A precedência de <op> com relação a outros operadores derivam dos
     expoentes associados diretiro e esquerdo dos operadores em questão.
     Se os expoentes associados esquerdo e direito de <op> forem ambos
     maiores que o expoente associado esquerdo e o direito de algum
     outro operador, então <op> tem prededência sobre o outro operador.
     Se os expoentes associados não forem ambos maior ou menor, alguma
     relação mais complicada ocorre.

     A associatividade de <op> depende de seus expoentes associados.
     Maior expoente associado esquerdo (<eae>) implica uma instância de
     <op> é avaliadas antes de outros operadores para sua esquerda em
     uma expressão, enquanto maior expoente associado direito (<ead>)
     implica uma instância de <op> é avaliada antes de outros operadores
     para sua direita em uma expressão.  Dessa forma maior <eae> torna
     <op> associativo à direita, enquanto maior <ead> torna <op>
     associativa à esquerda.  Se <eae> for igual a <ead>, <op> é
     associativa à esquerda.

     Veja também 'Syntax'.

     Exemplos:

     Se os expoentes associados esquerdo e direito de <op> forem ambos
     maiores que os expoentes associados à direita e à esquerda de algum
     outro operador, então <op> tem precedência sobre o outro operador.

          (%i1) :lisp (get '$+ 'lbp)
          100
          (%i1) :lisp (get '$+ 'rbp)
          100
          (%i1) infix ("##", 101, 101);
          (%o1)                          ##
          (%i2) "##"(a, b) := sconcat("(", a, ",", b, ")");
          (%o2)       (a ## b) := sconcat("(", a, ",", b, ")")
          (%i3) 1 + a ## b + 2;
          (%o3)                       (a,b) + 3
          (%i4) infix ("##", 99, 99);
          (%o4)                          ##
          (%i5) 1 + a ## b + 2;
          (%o5)                       (a+1,b+2)

     grande <eae> torna <op> associativa à direita, enquanto grande
     <ead> torna <op> associativa à esquerda.

          (%i1) infix ("##", 100, 99);
          (%o1)                          ##
          (%i2) "##"(a, b) := sconcat("(", a, ",", b, ")")$
          (%i3) foo ## bar ## baz;
          (%o3)                    (foo,(bar,baz))
          (%i4) infix ("##", 100, 101);
          (%o4)                          ##
          (%i5) foo ## bar ## baz;
          (%o5)                    ((foo,bar),baz)

 -- Variável de opção: inflag
     Velor padrão: 'false'

     Quando 'inflag' for 'true', funções para extração de partes
     inspecionam a forma interna de 'expr'.

     Note que o simplificador re-organiza expressões.  Dessa forma
     'first (x + y)' retorna 'x' se 'inflag' for 'true' e 'y' se
     'inflag' for 'false'.  ('first (y + x)' fornece os mesmos
     resultados.)

     Também, escolhendo 'inflag' para 'true' e chamando 'part' ou
     'substpart' é o mesmo que chamar 'inpart' ou 'substinpart'.

     As funções afetadas pela posição do sinalizador 'inflag' são:
     'part', 'substpart', 'first', 'rest', 'last', 'length', a estrutura
     'for' ...  'in', 'map', 'fullmap', 'maplist', 'reveal' e
     'pickapart'.

 -- Função: inpart (<expr>, <n_1>, ..., <n_k>)
     É similar a 'part' mas trabalha sobre a representação interna da
     expressão em lugar da forma de exibição e dessa forma pode ser mais
     rápida uma vez que nenhuma formatação é realizada.  Cuidado deve
     ser tomado com relação à ordem de subexpressões em adições e
     produtos (uma vez que a ordem das variáveis na forma interna é
     muitas vezes diferente daquela na forma mostrada) e no manuseio com
     menos unário, subtração, e divisão (uma vez que esses operadores
     são removidos da expressão).  'part (x+y, 0)' ou 'inpart (x+y, 0)'
     retorna '+', embora com o objetivo de referirse ao operador isso
     deva ser abraçado por aspas duplas.  Por exemplo '... if inpart
     (%o9,0) = "+" then ...'.

     Exemplos:

          (%i1) x + y + w*z;
          (%o1)                      w z + y + x
          (%i2) inpart (%, 3, 2);
          (%o2)                           z
          (%i3) part (%th (2), 1, 2);
          (%o3)                           z
          (%i4) 'limit (f(x)^g(x+1), x, 0, minus);
                                            g(x + 1)
          (%o4)                 limit   f(x)
                                x -> 0-
          (%i5) inpart (%, 1, 2);
          (%o5)                       g(x + 1)

 -- Função: isolate (<expr>, <x>)
     Retorna <expr> com subexpressões que são adições e que não possuem
     <x> substituido por rótulos de expressão intermediária (esses sendo
     símbolos atômicos como '%t1', '%t2', ...).  Isso é muitas vezes
     útil para evitar expansões desnecessárias de subexpressões que não
     possuam a variável de interesse.  Uma vez que os rótulos
     intermediários são associados às subexpressões eles podem todos ser
     substituídos de volta por avaliação da expressão em que ocorrerem.

     'exptisolate' (valor padrão: 'false') se 'true' fará com que
     'isolate' examine expoentes de átomos (como '%e') que contenham
     <x>.

     'isolate_wrt_times' se 'true', então 'isolate' irá também isolar
     com relação a produtos.  Veja 'isolate_wrt_times'.

     Faça 'example (isolate)' para exemplos.

 -- Variável de opção: isolate_wrt_times
     Valor padrão: 'false'

     Quando 'isolate_wrt_times' for 'true', 'isolate' irá também isolar
     com relação a produtos.  E.g.  compare ambas as escolhas do
     comutador em

          (%i1) isolate_wrt_times: true$
          (%i2) isolate (expand ((a+b+c)^2), c);

          (%t2)                          2 a


          (%t3)                          2 b


                                    2            2
          (%t4)                    b  + 2 a b + a

                               2
          (%o4)               c  + %t3 c + %t2 c + %t4
          (%i4) isolate_wrt_times: false$
          (%i5) isolate (expand ((a+b+c)^2), c);
                               2
          (%o5)               c  + 2 b c + 2 a c + %t4

 -- Variável de opção: listconstvars
     Valor padrão: 'false'

     Quando 'listconstvars' for 'true', isso fará com que 'listofvars'
     inclua '%e', '%pi', '%i', e quaisquer variáveis declaradas
     contantes na lista seja retornado se aparecer na expressão que
     chamar 'listofvars'.  O comportamento padrão é omitir isso.

 -- Variável de opção: listdummyvars
     Valor padrão: 'true'

     Quando 'listdummyvars' for 'false', "variáveis dummy" na expressão
     não serão incluídas na lista retornada por 'listofvars'.  (O
     significado de "variável dummy" é o mesmo que em 'freeof'.
     "Variáveis dummy" são conceitos matemáticos como o índice de um
     somatório ou produtório, a variável limite, e a variável da
     integral definida.)  Exemplo:

          (%i1) listdummyvars: true$
          (%i2) listofvars ('sum(f(i), i, 0, n));
          (%o2)                        [i, n]
          (%i3) listdummyvars: false$
          (%i4) listofvars ('sum(f(i), i, 0, n));
          (%o4)                          [n]

 -- Função: listofvars (<expr>)
     Retorna uma lista de variáveis em <expr>.

     'listconstvars' se 'true' faz com que 'listofvars' inclua '%e',
     '%pi', '%i', e quaisquer variáveis declaradas constantes na lista é
     retornada se aparecer em <expr>.  O comportamento padrão é omitir
     isso.

          (%i1) listofvars (f (x[1]+y) / g^(2+a));
          (%o1)                     [g, a, x , y]
                                            1

 -- Função: lfreeof (<lista>, <expr>)
     Para cada um dos membros <m> de lista, chama 'freeof (<m>,
     <expr>)'.  Retorna 'false' se qualquer chamada a 'freeof' for feita
     e 'true' de outra forma.

 -- Função: lopow (<expr>, <x>)
     Retorna o menor expoente de <x> que explicitamente aparecer em
     <expr>.  Dessa forma

          (%i1) lopow ((x+y)^2 + (x+y)^a, x+y);
          (%o1)                       min(a, 2)

 -- Função: lpart (<rótulo>, <expr>, <n_1>, ..., <n_k>)
     é similar a 'dpart' mas usa uma caixa rotulada.  Uma moldura
     rotulada é similar à que é produzida por 'dpart' mas a produzida
     por 'lpart' tem o nome na linha do topo.

 -- Função: multthru (<expr>)
 -- Função: multthru (<expr_1>, <expr_2>)
     Multiplica um fator (que pode ser uma adição) de <expr> pelos
     outros fatores de <expr>.  Isto é, <expr> é '<f_1> <f_2> ... <f_n>'
     onde ao menos um fator, digamos <f_i>, é uma soma de termos.  Cada
     termo naquela soma é multiplicado por outros fatores no produto.
     (A saber todos os fatores exceto <f_i>).  'multthru' não expande
     somas exponenciais.  Essa função é o caminho mais rápido para
     distribuir produtos (comutativos ou não) sobre adições.  Uma vez
     que quocientes são representados como produtos 'multthru' podem ser
     usados para dividir adições por produtos também.

     'multthru (<expr_1>, <expr_2>)' multiplica cada termo em <expr_2>
     (que pode ser uma adição ou uma equção) por <expr_1>.  Se <expr_1>
     não for por si mesmo uma adição então essa forma é equivalente a
     'multthru (<expr_1>*<expr_2>)'.

          (%i1) x/(x-y)^2 - 1/(x-y) - f(x)/(x-y)^3;
                                1        x         f(x)
          (%o1)             - ----- + -------- - --------
                              x - y          2          3
                                      (x - y)    (x - y)
          (%i2) multthru ((x-y)^3, %);
                                     2
          (%o2)             - (x - y)  + x (x - y) - f(x)
          (%i3) ratexpand (%);
                                     2
          (%o3)                   - y  + x y - f(x)
          (%i4) ((a+b)^10*s^2 + 2*a*b*s + (a*b)^2)/(a*b*s^2);
                                  10  2              2  2
                           (b + a)   s  + 2 a b s + a  b
          (%o4)            ------------------------------
                                            2
                                       a b s
          (%i5) multthru (%);  /* note que isso não expande (b+a)^10 */
                                                  10
                                 2   a b   (b + a)
          (%o5)                  - + --- + ---------
                                 s    2       a b
                                     s
          (%i6) multthru (a.(b+c.(d+e)+f));
          (%o6)            a . f + a . c . (e + d) + a . b
          (%i7) expand (a.(b+c.(d+e)+f));
          (%o7)         a . f + a . c . e + a . c . d + a . b

 -- Função: nounify (<f>)
     Retorna a forma substantiva do nome da função <f>.  Isso é
     necessário se se quer referir ao nome de uma função verbo como se
     esse nome fosse um substantivo.  Note que algumas funções verbos
     irão retornar sua forma substantiva senão puderem ser avaliadas
     para certos argumentos.  A forma substantiva é também a forma
     retornada se uma chamada de função é precedida por um apóstrofo.

 -- Função: nterms (<expr>)
     Retorna o número de termos que <expr> pode ter se for completamente
     expandida e nenhum cancelamento ou combinação de termos acontecer.
     Note expressões como 'sin (<expr>)', 'sqrt (<expr>)', 'exp
     (<expr>)', etc.  contam como apenas um termo independentemente de
     quantos termos <expr> tenha (se <expr> for uma adição).

 -- Função: op (<expr>)
     Retorna o operador principal da expressão <expr>.  'op (<expr>)' é
     equivalente a 'part (<expr>, 0)'.

     'op' retorna uma seqüência de caracteres se o operador principal
     for uma operador interno ou definido pelo usuário como prefixado,
     binário ou n-ário infixo, posfixado, matchfix ou nofix.  De outra
     forma, se <expr> for uma expressão de função subscrita, 'op'
     retorna uma função subscrita; nesse caso o valor de retorno não é
     um átomo.  De outro modo, <expr> é uma função de array ou uma
     expressão de função comum, e 'op' retorna um símbolo.

     'op' observa o valor do sinalizador global 'inflag'.

     'op' avalia seus argumentos.

     Veja também 'args'.

     Exemplos:

          (%i1) stringdisp: true$
          (%i2) op (a * b * c);
          (%o2)                          "*"
          (%i3) op (a * b + c);
          (%o3)                          "+"
          (%i4) op ('sin (a + b));
          (%o4)                          sin
          (%i5) op (a!);
          (%o5)                          "!"
          (%i6) op (-a);
          (%o6)                          "-"
          (%i7) op ([a, b, c]);
          (%o7)                          "["
          (%i8) op ('(if a > b then c else d));
          (%o8)                         "if"
          (%i9) op ('foo (a));
          (%o9)                          foo
          (%i10) prefix (foo);
          (%o10)                        "foo"
          (%i11) op (foo a);
          (%o11)                        "foo"
          (%i12) op (F [x, y] (a, b, c));
          (%o12)                        F
                                         x, y
          (%i13) op (G [u, v, w]);
          (%o13)                          G

 -- Função: operatorp (<expr>, <op>)
 -- Função: operatorp (<expr>, [<op_1>, ..., <op_n>])

     'operatorp (<expr>, <op>)' retorna 'true' se <op> for igual ao
     operador de <expr>.

     'operatorp (<expr>, [<op_1>, ..., <op_n>])' retorna 'true' se algum
     elementos de <op_1>, ..., <op_n> for igual ao operador de <expr>.

 -- Função: optimize (<expr>)
     Retorna uma expressão que produz o mesmo valor e efeito que <expr>
     mas faz de forma mais eficientemente por evitar a recomputação de
     subexpressões comuns.  'optimize' também tem o mesmo efeito de
     "colapsar" seus argumentos de forma que todas as subexpressões
     comuns são compartilhadas.  Faça 'example (optimize)' para
     exemplos.

 -- Variável de opção: optimprefix
     Valor padrão: '%'

     'optimprefix' é o prefixo usado para símbolos gerados pelo comando
     'optimize'.

 -- Função: ordergreat (<v_1>, ..., <v_n>)
     Escolhe aliases para as variáveis <v_1>, ..., <v_n> tais que <v_1>
     > <v_2> > ...  > <v_n>, e <v_n> > qualquer outra variável não
     mencionada como um argumento.

     Veja também 'orderless'.

 -- Função: ordergreatp (<expr_1>, <expr_2>)
     Retorna 'true' se <expr_2> precede <expr_1> na ordenação escolhida
     com a função 'ordergreat'.

 -- Função: orderless (<v_1>, ..., <v_n>)
     Escolhe aliases para as variáveis <v_1>, ..., <v_n> tais que <v_1>
     < <v_2> < ...  < <v_n>, and <v_n> < qualquer outra variável não
     mencionada como um argumento.

     Dessa forma a escala de ordenação completa é: constantes numéricas
     < constantes declaradas < escalares declarados < primeiro argumento
     para 'orderless' < ...  < último argumento para 'orderless' <
     variáveis que começam com A < ...  < variáveis que começam com Z <
     último argumento para 'ordergreat' < ...  < primeiro argumento para
     'ordergreat' < 'mainvar's - variáveis principais declaradas.

     Veja também 'ordergreat' e 'mainvar'.

 -- Função: orderlessp (<expr_1>, <expr_2>)
     Retorna 'true' se <expr_1> precede <expr_2> na ordenação escolhida
     pelo comando 'orderless'.

 -- Função: part (<expr>, <n_1>, ..., <n_k>)
     Retorna partes da forma exibida de 'expr'.  Essa função obtém a
     parte de 'expr' como especificado pelos índices <n_1>, ..., <n_k>.
     A primeira parte <n_1> de 'expr' é obtida, então a parte <n_2>
     daquela é obtida, etc.  O resultado é parte <n_k> de ...  parte
     <n_2> da parte <n_1> da 'expr'.

     'part' pode ser usada para obter um elemento de uma lista, uma
     linha de uma matriz, etc.

     Se o último argumento para uma função 'part' for uma lista de
     índices então muitas subexpressões serão pinçadas, cada uma
     correspondendo a um índice da lista.  Dessa forma 'part (x + y + z,
     [1, 3])' é 'z+x'.

     'piece' mantém a última expressão selecionada quando usando as
     funções 'part'.  Isso é escolhido durante a execução da função e
     dessa forma pode referir-se à função em si mesma como mostrado
     abaixo.

     Se 'partswitch' for escolhido para 'true' então 'end' é retornado
     quando uma parte selecionada de uma expressão não existir, de outra
     forma uma mensagem de erro é forncecida.

     Exemplo: 'part (z+2*y, 2, 1)' retorna 2.

     'example (part)' mostra exemplos adicionais.

 -- Função: partition (<expr>, <x>)
     Retorna uma lista de duas expressões.  Elas são (1) os fatores de
     <expr> (se essa expressão for um produto), os termos de <expr> (se
     isso for uma adição), ou a lista (se isso for uma lsita) que não
     contiver 'var' e, (2) os fatores, termos, ou lista que faz.

          (%i1) partition (2*a*x*f(x), x);
          (%o1)                     [2 a, x f(x)]
          (%i2) partition (a+b, x);
          (%o2)                      [b + a, 0]
          (%i3) partition ([a, b, f(a), c], a);
          (%o3)                  [[b, c], [a, f(a)]]

 -- Variável de opção: partswitch
     Valor padrão: 'false'

     Quando 'partswitch' for 'true', 'end' é retornado quando uma parte
     selecionada de uma expressão não existir, de outra forma uma
     mensagem de erro é fornecida.

 -- Função: pickapart (<expr>, <n>)
     Atribui rótulos de expressão intermediária a subexpressões de
     <expr> de comprimento <n>, um inteiro.  A subexpressões maiores ou
     menores não são atribuidos rótulos.  'pickapart' retorna uma
     expressão em termos de expressões intermediárias equivalentes à
     expressão original <expr>.

     Veja também 'part', 'dpart', 'lpart', 'inpart', e 'reveal'.

     Exemplos:

          (%i1) expr: (a+b)/2 + sin (x^2)/3 - log (1 + sqrt(x+1));
                                                    2
                                               sin(x )   b + a
          (%o1)       - log(sqrt(x + 1) + 1) + ------- + -----
                                                  3        2
          (%i2) pickapart (expr, 0);

                                                    2
                                               sin(x )   b + a
          (%t2)       - log(sqrt(x + 1) + 1) + ------- + -----
                                                  3        2

          (%o2)                          %t2
          (%i3) pickapart (expr, 1);

          (%t3)                - log(sqrt(x + 1) + 1)


                                            2
                                       sin(x )
          (%t4)                        -------
                                          3


                                        b + a
          (%t5)                         -----
                                          2

          (%o5)                    %t5 + %t4 + %t3
          (%i5) pickapart (expr, 2);

          (%t6)                 log(sqrt(x + 1) + 1)


                                            2
          (%t7)                        sin(x )


          (%t8)                         b + a

                                   %t8   %t7
          (%o8)                    --- + --- - %t6
                                    2     3
          (%i8) pickapart (expr, 3);

          (%t9)                    sqrt(x + 1) + 1


                                          2
          (%t10)                         x

                            b + a              sin(%t10)
          (%o10)            ----- - log(%t9) + ---------
                              2                    3
          (%i10) pickapart (expr, 4);

          (%t11)                     sqrt(x + 1)

                                2
                           sin(x )   b + a
          (%o11)           ------- + ----- - log(%t11 + 1)
                              3        2
          (%i11) pickapart (expr, 5);

          (%t12)                        x + 1

                             2
                        sin(x )   b + a
          (%o12)        ------- + ----- - log(sqrt(%t12) + 1)
                           3        2
          (%i12) pickapart (expr, 6);
                            2
                       sin(x )   b + a
          (%o12)       ------- + ----- - log(sqrt(x + 1) + 1)
                          3        2

 -- Variável de sistema: piece
     Mantém a ultima expressão selecionada quando usando funções 'part'.
     Isso é escolhido durante a execução da função e dessa forma pode
     referir-se à função em si mesma.

 -- Função: polarform (<expr>)
     Retorna uma expressão 'r %e^(%i theta)' equivalente a <expr>, tal
     que 'r' e 'theta' sejam puramente reais.

 -- Função: powers (<expr>, <x>)
     Fornece os expoentes de <x> que ocorrem em expressão <expr>.

     'load (powers)' chama essa função.

 -- Função: product (<expr>, <i>, <i_0>, <i_1>)
     Representa um produto dos velores de 'expr' com o índice <i>
     variando de <i_0> a <i_1>.  A forma substantiva ''product' é
     mostrada como um pi maiísculo.

     'product' avalia <expr> e os limites inferior e superior <i_0> e
     <i_1>, 'product' coloca um apóstrofo (não avalia) o índice <i>.

     Se os limites superiores e inferiores diferirem por um inteiro,
     <expr> é avaliada para cada valor do índice <i>, e o resultado um
     produto explícito.

     de outra forma, o intervalo do índice é indefinido.  Algumas regras
     são aplicads para simplificar o produto.  Quando a variável global
     'simpproduct' for 'true', regras adicionais são aplicadas.  Em
     alguns casos, simplificação um resultado que não é um produto; de
     outra forma, o resultado é uma forma substantiva ''product'.

     Veja também 'nouns' e 'evflag'.

     Exemplos:

          (%i1) product (x + i*(i+1)/2, i, 1, 4);
          (%o1)           (x + 1) (x + 3) (x + 6) (x + 10)
          (%i2) product (i^2, i, 1, 7);
          (%o2)                       25401600
          (%i3) product (a[i], i, 1, 7);
          (%o3)                 a  a  a  a  a  a  a
                                 1  2  3  4  5  6  7
          (%i4) product (a(i), i, 1, 7);
          (%o4)          a(1) a(2) a(3) a(4) a(5) a(6) a(7)
          (%i5) product (a(i), i, 1, n);
                                       n
                                     /===\
                                      ! !
          (%o5)                       ! !  a(i)
                                      ! !
                                     i = 1
          (%i6) product (k, k, 1, n);
                                         n
                                       /===\
                                        ! !
          (%o6)                         ! !  k
                                        ! !
                                       k = 1
          (%i7) product (k, k, 1, n), simpproduct;
          (%o7)                          n!
          (%i8) product (integrate (x^k, x, 0, 1), k, 1, n);
                                       n
                                     /===\
                                      ! !    1
          (%o8)                       ! !  -----
                                      ! !  k + 1
                                     k = 1
          (%i9) product (if k <= 5 then a^k else b^k, k, 1, 10);
                                        15  40
          (%o9)                        a   b

 -- Função: realpart (<expr>)
     Retorna a parte real de <expr>.  'realpart' e 'imagpart' irão
     trabalhar sobre expressões envolvendo funções trigonométricas e
     hiperbólicas, bem como raízes quadradas, logarítmos, e
     exponenciação.

 -- Função: rectform (<expr>)
     Retorna uma expressão 'a + b %i' equivalente a <expr>, tal que <a>
     e <b> sejam puramente reais.

 -- Função: rembox (<expr>, unlabelled)
 -- Função: rembox (<expr>, <rótulo>)
 -- Função: rembox (<expr>)
     Remove caixas de <expr>.

     'rembox (<expr>, unlabelled)' remove todas as caixas sem rótulos de
     <expr>.

     'rembox (<expr>, <rótulo>)' remove somente caixas contendo
     <rótulo>.

     'rembox (<expr>)' remove todas as caixas, rotuladas e nã rotuladas.

     Caixas são desenhadas pelas funções 'box', 'dpart', e 'lpart'.

     Exemplos:

          (%i1) expr: (a*d - b*c)/h^2 + sin(%pi*x);
                                            a d - b c
          (%o1)                sin(%pi x) + ---------
                                                2
                                               h
          (%i2) dpart (dpart (expr, 1, 1), 2, 2);
                                  """""""    a d - b c
          (%o2)               sin("%pi x") + ---------
                                  """""""      """"
                                               " 2"
                                               "h "
                                               """"
          (%i3) expr2: lpart (BAR, lpart (FOO, %, 1), 2);
                            FOO"""""""""""   BAR""""""""
                            "    """"""" "   "a d - b c"
          (%o3)             "sin("%pi x")" + "---------"
                            "    """"""" "   "  """"   "
                            """"""""""""""   "  " 2"   "
                                             "  "h "   "
                                             "  """"   "
                                             """""""""""
          (%i4) rembox (expr2, unlabelled);
                                            BAR""""""""
                             FOO"""""""""   "a d - b c"
          (%o4)              "sin(%pi x)" + "---------"
                             """"""""""""   "    2    "
                                            "   h     "
                                            """""""""""
          (%i5) rembox (expr2, FOO);
                                            BAR""""""""
                                 """""""    "a d - b c"
          (%o5)              sin("%pi x") + "---------"
                                 """""""    "  """"   "
                                            "  " 2"   "
                                            "  "h "   "
                                            "  """"   "
                                            """""""""""
          (%i6) rembox (expr2, BAR);
                             FOO"""""""""""
                             "    """"""" "   a d - b c
          (%o6)              "sin("%pi x")" + ---------
                             "    """"""" "     """"
                             """"""""""""""     " 2"
                                                "h "
                                                """"
          (%i7) rembox (expr2);
                                            a d - b c
          (%o7)                sin(%pi x) + ---------
                                                2
                                               h

 -- Função: sum (<expr>, <i>, <i_0>, <i_1>)
     Representa um somatório dos valores de <expr> com o índice <i>
     variando de <i_0> a <i_1>.  A forma substantiva ''sum' é mostrada
     com uma letra sigma maiúscula.  'sum' avalia seu somando <expr> e
     limites inferior e superior <i_0> e <i_1>, 'sum' coloca apóstrofo
     (não avalia) o índice <i>.

     Se os limites superiores e inferiores diferirem de um número
     inteiro, o somatoriando <expr> é avaliado para cada valor do índice
     do somatório <i>, e o resultado é uma adição explícita.

     De outra forma, o intervalo dos índices é indefinido.  Algumas
     regras são aplicadas para simplificar o somatório.  Quando a
     variável global 'simpsum' for 'true', regras adicionais são
     aplicadas.  Em alguns casos, simplificações retornam um resultado
     que não é um somatório; de outra forma, o resultado é uma forma
     substantiva ''sum'.

     Quando o 'evflag' (sinalizador de avaliação) 'cauchysum' for
     'true', um produto de somatórios é mostrado como um produto de
     Cauchy, no qual o índice do somatório mais interno é uma função de
     índice de um nível acima, em lugar de variar independentemente.

     A variável global 'genindex' é o prefixo alfabético usado para
     gerar o próximo índice do somatório, quando um índice
     automaticamente gerado for necessário.

     'gensumnum' é o sufixo numérico usando para gerar o próximo índice
     do somatório, quando um índice gerado automaticamente for
     necessário.  Quando 'gensumnum' for 'false', um índice gerado
     automaticamente é somente 'genindex' sem sufixo numérico.

     Veja também 'sumcontract', 'intosum', 'bashindices', 'niceindices',
     'nouns', 'evflag', e 'zeilberger'.

     Exemplos:

          (%i1) sum (i^2, i, 1, 7);
          (%o1)                          140
          (%i2) sum (a[i], i, 1, 7);
          (%o2)           a  + a  + a  + a  + a  + a  + a
                           7    6    5    4    3    2    1
          (%i3) sum (a(i), i, 1, 7);
          (%o3)    a(7) + a(6) + a(5) + a(4) + a(3) + a(2) + a(1)
          (%i4) sum (a(i), i, 1, n);
                                      n
                                     ====
                                     \
          (%o4)                       >    a(i)
                                     /
                                     ====
                                     i = 1
          (%i5) sum (2^i + i^2, i, 0, n);
                                    n
                                   ====
                                   \       i    2
          (%o5)                     >    (2  + i )
                                   /
                                   ====
                                   i = 0
          (%i6) sum (2^i + i^2, i, 0, n), simpsum;
                                        3      2
                             n + 1   2 n  + 3 n  + n
          (%o6)             2      + --------------- - 1
                                            6
          (%i7) sum (1/3^i, i, 1, inf);
                                      inf
                                      ====
                                      \     1
          (%o7)                        >    --
                                      /      i
                                      ====  3
                                      i = 1
          (%i8) sum (1/3^i, i, 1, inf), simpsum;
                                          1
          (%o8)                           -
                                          2
          (%i9) sum (i^2, i, 1, 4) * sum (1/i^2, i, 1, inf);
                                        inf
                                        ====
                                        \     1
          (%o9)                      30  >    --
                                        /      2
                                        ====  i
                                        i = 1
          (%i10) sum (i^2, i, 1, 4) * sum (1/i^2, i, 1, inf), simpsum;
                                            2
          (%o10)                       5 %pi
          (%i11) sum (integrate (x^k, x, 0, 1), k, 1, n);
                                      n
                                     ====
                                     \       1
          (%o11)                      >    -----
                                     /     k + 1
                                     ====
                                     k = 1
          (%i12) sum (if k <= 5 then a^k else b^k, k, 1, 10));
          Incorrect syntax: Too many )'s
          else b^k, k, 1, 10))
                            ^
          (%i12) linenum:11;
          (%o11)                         11
          (%i12) sum (integrate (x^k, x, 0, 1), k, 1, n);
                                      n
                                     ====
                                     \       1
          (%o12)                      >    -----
                                     /     k + 1
                                     ====
                                     k = 1
          (%i13) sum (if k <= 5 then a^k else b^k, k, 1, 10);
                    10    9    8    7    6    5    4    3    2
          (%o13)   b   + b  + b  + b  + b  + a  + a  + a  + a  + a

 -- Função: lsum (<expr>, <x>, <L>)
     Representas a adição de <expr> a cada elemento <x> em <L>.

     Uma forma substantiva ''lsum' é retornada se o argumento <L> não
     avaliar para uma lista.

     Exemplos:

          (%i1) lsum (x^i, i, [1, 2, 7]);
                                      7    2
          (%o1)                      x  + x  + x
          (%i2) lsum (i^2, i, rootsof (x^3 - 1, x));
                               ====
                               \      2
          (%o2)                 >    i
                               /
                               ====
                                             3
                               i in rootsof(x  - 1, x)

 -- Função: verbify (<f>)
     Retorna a forma verbal da função chamada <f>.

     Veja também 'verb', 'noun', e 'nounify'.

     Exemplos:

          (%i1) verbify ('foo);
          (%o1)                          foo
          (%i2) :lisp $%
          $FOO
          (%i2) nounify (foo);
          (%o2)                          foo
          (%i3) :lisp $%
          %FOO


File: maxima.info,  Node: Simplificação,  Next: Montando Gráficos,  Prev: Expressões,  Up: Top

7 Simplificação
***************

* Menu:

* Funções e Variáveis Definidas para Simplificação::


File: maxima.info,  Node: Funções e Variáveis Definidas para Simplificação,  Prev: Simplificação,  Up: Simplificação

7.1 Funções e Variáveis Definidas para Simplificação
====================================================

 -- Variável de sistema: askexp
     Quando 'asksign' é chamada, 'askexp' é a expressão que 'asksign'
     está testando.

     Antigamente, era possível para um usuário inspecionar 'askexp'
     entrando em uma parada do Maxima com control-A.

 -- Função: askinteger (<expr>, integer)
 -- Função: askinteger (<expr>)
 -- Função: askinteger (<expr>, even)
 -- Função: askinteger (<expr>, odd)

     'askinteger (<expr>, integer)' tenta determinar a partir da base de
     dados do 'assume' se <expr> é um inteiro.  'askinteger' pergunta ao
     usuário pela linha de comando se isso não puder ser feito de outra
     forma, e tenta instalar a informação na base de dados do 'assume'
     se for possível.  'askinteger (<expr>)' é equivalente a 'askinteger
     (<expr>, integer)'.

     'askinteger (<expr>, even)' e 'askinteger (<expr>, odd)' da mesma
     forma tentam determinar se <expr> é um inteiro par ou inteiro
     ímpar, respectivamente.

 -- Função: asksign (<expr>)
     Primeiro tenta determinar se a expressão especificada é positiva,
     negativa, ou zero.  Se isso não for possível, 'asksign' pergunta ao
     usuário pelas questões necessárias para completar a sua dedução.
     As respostas do usuário são guardadas na base de dados pelo tempo
     que durar a computação corrente.  O valor de retorno de 'asksign' é
     um entre 'pos', 'neg', ou 'zero'.

 -- Função: demoivre (<expr>)
 -- Variável de opção: demoivre

     A função 'demoivre (expr)' converte uma expressão sem escolher a
     variável global 'demoivre'.

     Quando a variável 'demoivre' for 'true', exponenciais complexas são
     convertidas em expressões equivalentes em termos de funções
     circulares: 'exp (a + b*%i)' simplifica para '%e^a * (cos(b) +
     %i*sin(b))' se 'b' for livre de '%i'.  'a' e 'b' não são
     expandidos.

     O valor padrão de 'demoivre' é 'false'.

     'exponentialize' converte funções circulares e hiperbólicas para a
     forma exponencial.  'demoivre' e 'exponentialize' não podem ambas
     serem 'true' ao mesmo tempo.

 -- Variável de opção: domain
     Valor padrão: 'real'

     Quando 'domain' for escolhida para 'complex', 'sqrt (x^2)'
     permanecerá 'sqrt (x^2)' em lugar de retornar 'abs(x)'.

 -- Função: expand (<expr>)
 -- Função: expand (<expr>, <p>, <n>)
     Expande a expressão <expr>.  Produtos de somas e somas
     exponenciadas são multiplicadas para fora, numeradores de
     expressões racionais que são adições são quebradas em suas
     respectivas parcelas, e multiplicação (comutativa e não comutativa)
     é distribuída sobre a adição em todos os níveis de <expr>.

     Para polinômios se pode usar freqüêntemente 'ratexpand' que possui
     um algorítmo mais eficiente.

     'maxnegex' e 'maxposex' controlam o máximo expoente negativo e o
     máximo expoente positivo, respectivamente, que irão expandir.

     'expand (<expr>, <p>, <n>)' expande <expr>, usando <p> para
     'maxposex' e <n> para 'maxnegex'.  Isso é útil com o objetivo de
     expandir partes mas não tudo em uma expressão.

     'expon' - o expoente da maior potência negativa que é
     automaticamente expandida (independente de chamadas a 'expand').
     Por Exemplo se 'expon' for 4 então '(x+1)^(-5)' não será
     automaticamente expandido.

     'expop' - o maior expoente positivo que é automaticamente
     expandido.  Dessa forma '(x+1)^3', quando digitado, será
     automaticamente expandido somente se 'expop' for maior que ou igual
     a 3.  Se for desejado ter '(x+1)^n' expandido onde 'n' é maior que
     'expop' então executando 'expand ((x+1)^n)' trabalhará somente se
     'maxposex' não for menor que 'n'.

     O sinalizador 'expand' usado com 'ev' causa expansão.

     O arquivo 'simplification/facexp.mac' contém muitas funções
     relacionadas (em particular 'facsum', 'factorfacsum' e
     'collectterms', que são chamadas automaticamente) e variáveis
     ('nextlayerfactor' e 'facsum_combine') que fornecem ao usuário com
     a habilidade para estruturar expressões por expansão controlada.
     Descrições breves de função estão disponível em
     'simplification/facexp.usg'.  Um arquivo demonstrativo está
     disponível fazendo 'demo("facexp")'.

 -- Função: expandwrt (<expr>, <x_1>, ..., <x_n>)
     Expande a expressão 'expr' com relação às variáveis <x_1>, ...,
     <x_n>.  Todos os produtos envolvendo as variáveis aparecem
     explicitamente.  A forma retornada será livre de produtos de somas
     de expressões que não estão livres das variáveis.  <x_1>, ...,
     <x_n> podem ser variáveis, operadores, ou expressões.

     Por padrão, denominadores não são expandidos, mas isso pode ser
     controlado através do comutador 'expandwrt_denom'.

     Essa função, 'expandwrt', não é automaticamente chamada a partir de
     'simplification/stopex.mac'.

 -- Variável de opção: expandwrt_denom
     Valor padrão: 'false'

     'expandwrt_denom' controla o tratamento de expressões racionais por
     'expandwrt'.  Se 'true', então ambos o numerador e o denominador da
     expressão serão expandidos conforme os argumentos de 'expandwrt',
     mas se 'expandwrt_denom' for 'false', então somente o numerador
     será expandido por aquele caminho.

 -- Função: expandwrt_factored (<expr>, <x_1>, ..., <x_n>)
     é similar a 'expandwrt', mas trata expressões que são produtos um
     tanto quanto diferentemente.  'expandwrt_factored' expande somente
     sobre esses fatores de 'expr' que contiverem as variáveis <x_1>,
     ..., <x_n>.

     Essa função é automaticamente chamada a aprtir de
     'simplification/stopex.mac'.

 -- Variável de opção: expon
     Valor padrão: 0

     'expon' é o expoente da maior potência negativa que é
     automaticamente expandido (independente de chamadas a 'expand').
     Por exemplo, se 'expon' for 4 então '(x+1)^(-5)' não será
     automaticamente expandido.

 -- Função: exponentialize (<expr>)
 -- Variável de opção: exponentialize

     A função 'exponentialize (expr)' converte funções circulares e
     hiperbólicas em <expr> para exponenciais, sem escolher a variável
     global 'exponentialize'.

     Quando a variável 'exponentialize' for 'true', todas as funções
     circulares e hiperbólicas são convertidas para a forma exponencial.
     O valor padrão é 'false'.

     'demoivre' converte exponenciais complexas em funções circulares.
     'exponentialize' e 'demoivre' não podem ambas serem 'true' ao mesmo
     tempo.

 -- Variável de opção: expop
     Valor padrão: 0

     'expop' - o maior expoente positivo que é automaticamente
     expandido.  Dessa forma '(x+1)^3', quando digitado, será
     automaticamente expandido somente se 'expop' for maior que ou igual
     a 3.  Se for desejado ter '(x+1)^n' expandido onde 'n' é maior que
     'expop' então executando 'expand ((x+1)^n)' trabalhará somente se
     'maxposex' não for menor que 'n'.

 -- Variável de opção: factlim
     Valor padrão: -1

     'factlim' especifica o maior fatorial que é automaticamente
     expandido.  Se for -1 então todos os inteiros são expandidos.

 -- Função: intosum (<expr>)
     Move fatores multiplicativos fora de um somatório para dentro.  Se
     o índice for usado na expressão de fora, então a função tentará
     achar um índice razoável, o mesmo que é feito para 'sumcontract'.
     Isso é essencialmente a idéia inversa da propriedade 'outative' de
     somatórios, mas note que isso não remove essa propriedade, somente
     pula sua verificação.

     Em alguns casos, um 'scanmap (multthru, <expr>)' pode ser
     necessário antes de 'intosum'.

 -- Declaração: lassociative
     'declare (g, lassociative)' diz ao simplificador do Maxima que 'g'
     é associativa à esquerda.  E.g., 'g (g (a, b), g (c, d))' irá
     simplificar para 'g (g (g (a, b), c), d)'.

 -- Declaração: linear
     Uma das propriedades operativas do Maxima.  Para funções de uma
     única variável 'f' então declarada, a "expansão" 'f(x + y)' retorna
     'f(x) + f(y)', 'f(a*x)' retorna 'a*f(x)' tomando lugar onde 'a' for
     uma "constante".  para funções de dois ou mais argumentos,
     "linearidade" é definida para ser como no caso de 'sum' ou
     'integrate', i.e., 'f (a*x + b, x)' retorna 'a*f(x,x) + b*f(1,x)'
     para 'a' e 'b' livres de 'x'.

     'linear' é equivalente a 'additive' e 'outative'.  Veja também
     'opproperties'.

 -- Declaração: mainvar
     Você pode declarar variáveis para serem 'mainvar' (variável
     principal).  A escala de ordenação para átomos é essencialmente:
     números < constantes (e.g., '%e', '%pi') < escalares < outras
     variáveis < mainvars.  E.g., compare 'expand ((X+Y)^4)' com
     '(declare (x, mainvar), expand ((x+y)^4))'.  (Nota: Cuidado deve
     ser tomado se você eleger o uso desse recurso acima.  E.g., se você
     subtrair uma expressão na qual 'x' for uma 'mainvar' de uma na qual
     'x' não seja uma 'mainvar', resimplificação e.g.  com 'ev (expr,
     simp)' pode ser necessária se for para ocorrer um cancelamento.
     Também, se você grava uma expressão na qual 'x' é uma 'mainvar',
     você provavelmente pode também gravar 'x'.)

 -- Variável de opção: maxapplydepth
     Valor padrão: 10000

     'maxapplydepth' é a máxima definição para a qual 'apply1' e
     'apply2' irão pesquisar.

 -- Variável de opção: maxapplyheight
     Valor padrão: 10000

     'maxapplyheight' é a elevação máxima a qual 'applyb1' irá alcançar
     antes de abandonar.

 -- Variável de opção: maxnegex
     Valor padrão: 1000

     'maxnegex' é o maior expoente negativo que será expandido pelo
     comando 'expand' (veja também 'maxposex').

 -- Variável de opção: maxposex
     Valor padrão: 1000

     'maxposex' é o maior expoente que será expandido com o comando
     'expand' (veja também 'maxnegex').

 -- Declaração: multiplicative
     'declare (f, multiplicative)' diz ao simplificador do Maxima que
     'f' é multiplicativa.

       1. Se 'f' for uma função de uma única variável, sempre que o
          simplificador encontrar 'f' aplicada a um produto, 'f'
          distribue sobre aquele produto.  E.g., 'f(x*y)' simplifica
          para 'f(x)*f(y)'.
       2. Se 'f' é uma função de 2 ou mais argumentos,
          multiplicatividade é definida como multiplicatividade no
          primeiro argumento para 'f', e.g., 'f (g(x) * h(x), x)'
          simplifica para 'f (g(x) ,x) * f (h(x), x)'.

     Essa simplificação não ocorre quando 'f' é aplicada a expressões da
     forma 'product (x[i], i, m, n)'.

 -- Variável de opção: negdistrib
     Valor padrão: 'true'

     Quando 'negdistrib' for 'true', -1 distribue sobre uma expressão.
     E.g., '-(x + y)' transforma-se em '- y - x'.  Mudando o valor de
     'negdistrib' para 'false' permitirá que '- (x + y)' seja mostrado
     como foi escrito.  Isso algumas vezes é útil mas seja muito
     cuidadoso: como o sinalizador 'simp', isso é um sinalizador que
     você pode não querer escolher para 'false' como algo natural ou
     necessário com excessão de usar localmente no seu Maxima.

 -- Variável de opção: negsumdispflag
     Valor padrão: 'true'

     Quando 'negsumdispflag' for 'true', 'x - y' é mostrado como 'x - y'
     em lugar de como '- y + x'.  Escolhendo isso para 'false' faz com
     que a verificação especial em visualização para a diferença das
     duas expressões não seja concluída.  Uma aplicação é que dessa
     forma 'a + %i*b' e 'a - %i*b' podem ambos serem mostrados pelo
     mesmo caminho.

 -- Símbolo especial: noeval
     'noeval' suprime a fase de avaliação de 'ev'.  Isso é útil em
     conjunção com outros comutadores e para fazer com que expressões
     sejam resimplificadas sem serem reavaliadas.

 -- Declaração: noun
     'noun' é uma das opções do comando 'declare'.  Essa opção faz com
     que um função seja declarada como "noun" (substantivo),
     significando que ela não deve ser avaliada automaticamente.

 -- Variável de opção: noundisp
     Valor padrão: 'false'

     Quando 'noundisp' for 'true', substantivos (nouns) são mostrados
     com um apóstrofo.  Esse comutador é sempre 'true' quando mostrando
     definições de função.

 -- Símbolo especial: nouns
     'nouns' é um 'evflag' (sinalizador de avaliação).  Quando usado
     como uma opção para o comando 'ev', 'nouns' converte todas as
     formas substantivas ("noun") que ocorrem na expressão que está
     sendo avaliada para verbos ("verbs"), i.e., avalia essas
     expressões.  Veja também 'noun', 'nounify', 'verb', e 'verbify'.

 -- Símbolo especial: numer
     'numer' faz com que algumas funções matemáticas (incluindo
     exponenciação) com argumentos numéricos sejam avaliados em ponto
     flutuante.  Isso faz com que variáveis em 'expr' às quais tenham
     sido dados valores numéricos a elas sejam substituídas pelos seus
     valores correspondentes.  'numer' também escolhe o sinalizador
     'float' para 'on'.

 -- Função: numerval (<x_1>, <expr_1>, ..., <var_n>, <expr_n>)
     Declara as variáveis 'x_1', ..., <x_n> para terem valores numéricos
     iguais a 'expr_1', ..., 'expr_n'.  O valor numérico é avaliado e
     substituido para a variável em quaisquer expressões na qual a
     variável ocorra se o sinalizador 'numer' for 'true'.  Veja também
     'ev'.

     As expressões 'expr_1', ..., 'expr_n' podem ser quaisquer
     expressões, não necessariamente numéricas.

 -- Variável de sistema: opproperties

     'opproperties' é a lista de propriedades de operadores especiais
     reconhecidas pelo simplificador do Maxima: 'linear', 'additive',
     'multiplicative', 'outative' (veja logo abaixo), 'evenfun',
     'oddfun', 'commutative', 'symmetric', 'antisymmetric', 'nary',
     'lassociative', 'rassociative'.

 -- Variável de opção: opsubst
     Valor padrão: 'true'

     Quando 'opsubst' for 'false', 'subst' não tenta substituir dentro
     de um operador de uma expressão.  E.g., '(opsubst: false, subst
     (x^2, r, r+r[0]))' irá trabalhar.

 -- Declaração: outative
     'declare (f, outative)' diz ao simplificador do Maxima que fatores
     constantes no argumento de 'f' podem ser puxados para fora.

       1. Se 'f' for uma função de uma única variável, sempre que o
          simplificador encontrar 'f' aplicada a um produto, aquele
          produto será particionado em fatores que são constantes e
          fatores que não são e os fatores constantes serão puxados para
          fora.  E.g., 'f(a*x)' simplificará para 'a*f(x)' onde 'a' é
          uma constante.  Fatores de constantes não atômicas não serão
          puxados para fora.
       2. Se 'f' for uma função de 2 ou mais argumentos, a colocação
          para fora é definida como no caso de 'sum' ou 'integrate',
          i.e., 'f (a*g(x), x)' irá simplificar para 'a * f(g(x), x)'
          sendo 'a' livre de 'x'.

     'sum', 'integrate', e 'limit' são todas 'outative'.

 -- Declaração: posfun
     'declare (f, posfun)' declara 'f' para ser uma função positiva.
     'is (f(x) > 0)' retorna 'true'.

 -- Função: radcan (<expr>)
     Simplifica <expr>, que pode conter logarítmos, exponenciais, e
     radicais, convertendo essa expressão em uma forma que é canônica
     sobre uma ampla classe de expressões e uma dada ordenação de
     variáveis; isto é, todas formas funcionalmente equivalentes são
     mapeadas em uma única forma.  Para uma classe um tanto quanto ampla
     de expressões, 'radcan' produz uma forma regular.  Duas expressões
     equivalentes nessa classe não possuem necessáriamente a mesma
     aparência, mas suas diferenças podem ser simplificadas por 'radcan'
     para zero.

     Para algumas expressões 'radcan' é que consome inteiramente o
     tempo.  Esse é o custo de explorar certos relacionamentos entre os
     componentes da expressão para simplificações baseadas sobre
     fatoração e expansões de fração-parcial de expoentes.

     Quando '%e_to_numlog' for 'true', '%e^(r*log(expr))' simplifica
     para 'expr^r' se 'r' for um número racional.

     Quando 'radexpand' for 'false', certas transformações são inibidas.
     'radcan (sqrt (1-x))' permanece 'sqrt (1-x)' e não é simplificada
     para '%i sqrt (x-1)'.  'radcan (sqrt (x^2 - 2*x + 11))' permanece
     'sqrt (x^2 - 2*x + 1)' e não é simplificada para 'x - 1'.

     'example (radcan)' mostra alguns exemplos.

 -- Variável de opção: radexpand
     Valor padrão: 'true'

     'radexpand' controla algumas simplificações de radicais.

     Quando 'radexpand' for 'all', faz com que n-ésimas raízes de
     fatores de um produto que são potências de n sejam puxados para
     fora do radical.  E.g.  Se 'radexpand' for 'all', 'sqrt (16*x^2)'
     simplifica para '4*x'.

     Mais particularmente, considere 'sqrt (x^2)'.
        * Se 'radexpand' for 'all' or 'assume (x > 0)' tiver sido
          executado, 'sqrt(x^2)' simplifica para 'x'.
        * Se 'radexpand' for 'true' e 'domain' for 'real' (isso é o
          padrão), 'sqrt(x^2)' simplifica para 'abs(x)'.
        * Se 'radexpand' for 'false', ou 'radexpand' for 'true' e
          'domain' for 'complex', 'sqrt(x^2)' não é simplificado.

     Note que 'domain' somente interessa quando 'radexpand' for 'true'.

 -- Variável de opção: radsubstflag
     Valor padrão: 'false'

     'radsubstflag', se 'true', permite a 'ratsubst' fazer substituições
     tais como 'u' por 'sqrt (x)' em 'x'.

 -- Declaração: rassociative
     'declare (g, rassociative)' diz ao simplificador do Maxima que 'g'
     é associativa à direita.  E.g., 'g(g(a, b), g(c, d))' simplifica
     para 'g(a, g(b, g(c, d)))'.

 -- Função: scsimp (<expr>, <rule_1>, ..., <rule_n>)
     Simplificação Seqüêncial Comparativa (método devido a Stoute).
     'scsimp' tenta simplificar <expr> conforme as regras <rule_1>, ...,
     <rule_n>.  Se uma expressão pequena for obtida, o processo
     repete-se.  De outra forma após todas as simplificações serem
     tentadas, 'scsimp' retorna a resposta original.

     'example (scsimp)' mostra alguns exemplos.

 -- Variável de opção: simpsum
     Valor padrão: 'false'

     Quando 'simpsum' for 'true', o resultado de uma 'sum' é
     simplificado.  Essa simplificação pode algumas vezes estar apta a
     produzir uma forma fechada.  Se 'simpsum' for 'false' ou se a forma
     com apóstrofo ''sum' for usada, o valor é uma forma substantiva
     aditiva que é uma representação da notação sigma usada em
     matemática.

 -- Função: sumcontract (<expr>)
     Combina todas as parcelas de um somatório que possuem limites
     superiores e inferiores que diferem por constantes.  O resultado é
     uma expressão contendo um somatório para cada escolha de cada tais
     somatórios adicionados a todos os termos extras apropriados que
     tiveram de ser extraídos para a forma dessa adição.  'sumcontract'
     combina todas as somas compatíveis e usa os indices de uma as somas
     se puder, e então tenta formar um índice razoável se não for usar
     qualquer dos fornecidos.

     Isso pode ser necessário fazer um 'intosum (<expr>)' antes de
     'sumcontract'.

 -- Variável de opção: sumexpand
     Valor padrão: 'false'

     Quando 'sumexpand' for 'true', produtos de somas e somas
     exponeciadas simplificam para somas aninhadas.

     Veja também 'cauchysum'.

     Exemplos:

          (%i1) sumexpand: true$
          (%i2) sum (f (i), i, 0, m) * sum (g (j), j, 0, n);
                               m      n
                              ====   ====
                              \      \
          (%o2)                >      >     f(i1) g(i2)
                              /      /
                              ====   ====
                              i1 = 0 i2 = 0
          (%i3) sum (f (i), i, 0, m)^2;
                               m      m
                              ====   ====
                              \      \
          (%o3)                >      >     f(i3) f(i4)
                              /      /
                              ====   ====
                              i3 = 0 i4 = 0

 -- Variável de opção: sumsplitfact
     Valor padrão: 'true'

     Quando 'sumsplitfact' for 'false', 'minfactorial' é aplicado após
     um 'factcomb'.

 -- Declaração: symmetric
     'declare (h, symmetric)' diz ao simplificador do Maxima que 'h' é
     uma função simétrica.  E.g., 'h (x, z, y)' simplifica para 'h (x,
     y, z)'.

     'commutative' é sinônimo de 'symmetric'.

 -- Função: unknown (<expr>)
     Retorna 'true' se e somente se <expr> contém um operador ou função
     não reconhecida pelo simplificador do Maxima.


File: maxima.info,  Node: Montando Gráficos,  Next: Entrada e Saída,  Prev: Simplificação,  Up: Top

8 Montando Gráficos
*******************

* Menu:

* Funções e Variáveis Definidas para Montagem de Gráficos::


File: maxima.info,  Node: Funções e Variáveis Definidas para Montagem de Gráficos,  Prev: Montando Gráficos,  Up: Montando Gráficos

8.1 Funções e Variáveis Definidas para Montagem de Gráficos
===========================================================

 -- Função: contour_plot (<expr>, <x_range>, <y_range>, <opções>, ...)

     Monta gráficos de contorno (curvas de nível) de <expr> sobre a
     região <x_range> por <y_range>.  Quaisquer argumentos adicionals
     são tratados da mesma forma que em 'plot3d'.

     'contour_plot' somente trabalha quando o formato do gráfico for
     'gnuplot' ou 'gnuplot_pipes'.

     Veja também 'implicit_plot'.

     Exemplos:

          (%i1) contour_plot (x^2 + y^2, [x, -4, 4], [y, -4, 4]);
          (%o1)
          (%i2) contour_plot (sin(y) * cos(x)^2, [x, -4, 4], [y, -4, 4]);
          (%o2)
          (%i3) F(x, y) := x^3 + y^2;
                                             3    2
          (%o3)                  F(x, y) := x  + y
          (%i4) contour_plot (F, [u, -4, 4], [v, -4, 4]);
          (%o4)
          (%i5) contour_plot (F, [u, -4, 4], [v, -4, 4], [gnuplot_preamble, "set size ratio -1"]);
          (%o5)
          (%i6) set_plot_option ([gnuplot_preamble, "set cntrparam levels 12"])$

          (%i7) contour_plot (F, [u, -4, 4], [v, -4, 4]);

 -- Variável: in_netmath
     Valor padrão: 'false'

     Quando 'in_netmath' é 'true', 'plot3d' imprime uma saída OpenMath
     para o console se 'plot_format' é 'openmath'; caso contrário
     'in_netmath' (mesmo se 'true') não tem efeito.  'in_netmath' não
     tem efeito sobre 'plot2d'.

 -- Função: plot2d (<expr>, <x_range>, ..., <opções>, ...)
 -- Função: plot2d ([<expr_1>, ..., <expr_n>], ..., <opções>, ...)
 -- Função: plot2d ([<expr_1>, ..., <expr_n>], <x_range>,..., <opções>,
          ...)

     onde <expr>, <expr_1>, ..., <expr_n> pode ser uma entre expressões,
     ou funções do Lisp ou do Maxima ou operadores, ou uma lista com
     qualquer das formas: '[discrete, [<x1>, ..., <xn>], [<y1>, ...,
     <yn>]]', '[discrete, [[<x1>, <y1>], ..., [<xn>, ..., <yn>]]' ou
     '[parametric, <x_expr>, <y_expr>, <t_range>]'.

     Mostra um gráfico de uma ou mais expressões como uma função de uma
     variável.

     'plot2d' monta o gráfico da expressão <expr> ou muitas expressões
     '[<name_1>, ..., <name_n>]'.  As expressões que não forem
     paramétricas ou discretas podem todas depender somente de uma
     variável <var> e isso torna obrigatório o uso de <x_range> para
     nome daquela variável e fornece seus valores de máximo e de mínimo,
     usando a sintaxe: '[<variable>, <min>, <max>]'.  O gráfico irá
     mostrar o eixo horizontal associado aos valores de <min> e de
     <max>.

     Uma expressão a ser montado o gráfico pode também ser fornecida na
     forma discreta ou na forma paramétrica.  A saber, como uma lista
     iniciando-se com a palavra "discrete" ou a palavra "parametric".  A
     palavra chave <discrete> deve ser seguida por duas listas de
     valores, ambas com o mesmo comprimento, que são as coodenadas
     horizontais e as coordenadas verticais de um conjunto de pontos;
     alternativamente, as coordenadas de cada ponto pode ser colocada
     dentro de uma lista com dois valores, e todas as coordenadas dos
     pontos podem estar dentro de outra lista.  A palavra chave
     <parametric> deve ser seguida por douas expressões <x_expr> e
     <y_expr>, e um intervalo da forma '[<param>, <min>, <max>]'.  As
     duas expressões devem depender somente do parâmetro <param>, e o
     gráfico irá mostrar o caminho percorrido pelo ponto com coordenadas
     (<x_expr>, <y_expr>) com <param> variando de <min> a <max>.

     O intervalo do eixo vertical não é obrigatório.  É somente mais uma
     das opções para o comando, com a sintaxe: '[y, <min>, <max>]'.  Se
     aquela opção for usada, o gráfico irá mostrar aquele intervalo
     completo, mesmo se a expressão não ocupe todo aquele intervalo.  De
     outra forma, se um intervalo vertical não for especificado através
     de 'set_plot_option', as extremidade do eixo vertical serão
     encontrada automaticamente.

     Todas as outras opções podem também serem listas, iniciando-se com
     o nome da opção.  A opção <xlabel> pode ser usada para fornecer um
     ótulo para o eixo horizontal; se aquela opção não for usada, o eixo
     horizontal irá ser rotulado com o nome da variável especificada em
     <x_range>, ou com a expressão <x_expr> no caso de apenas uma
     expressão paramétrica, ou isso irá ser deichado em branco de outra
     forma.

     Um rótulo para o eixo vertical pode ser fornecido com a opção
     <ylabel>.  Se existir somente uma expressão a ser montado o gráfico
     e a opção <ylabel> não tiver sido usada, o eixo vertical irá ser
     rotulado com aquela expressão, a menos que ela seja muito larga, ou
     com a expressão <y_expr> se a expressão for paramétrica, ou com o
     texto "discrete data" se a expressão for discreta.

     As opções '[logx]' e '[logy]' não precisam de quaisquer parâmetros.
     Elas irão tornar os eixos horizontal e vertical sejam escritos em
     escala logarítmica.

     Se houverem muitas expressões para serem montados os gráficos
     respectivos, uma legenda irá ser escrita para identificar cada uma
     das expressões.  Os rótulos que podem ser usados naquela legenda
     podem ser fornecidos com a opção <legend>.  Se a opção <legend> não
     for usada, Maxima irá criar rótulos a partir das expressões.

     Por padrão, as expressões terão seus gráficos montados como um
     conjunto de segmentos de reta saltando pontos adjacentes dentro de
     um conjunt de pontos que é um dos fornecidos entre a forma
     <discrete>, ou calculado automaticamente a partir da expressão
     fornecida, usando um algorítmo que automaticamente adapta os passos
     entre os pontos usando como uma estimativa inicial do total número
     de pontos o conjunto de valores com a opção <nticks>.  A opção
     <style> pode ser usada para fazer uma das expressões serem
     representadas como um conjunto de pontos isolados, ou como pontos e
     segmentos de reta.

     Existem muitas opções globais armazenadas na lsita <plot_options>
     que pode ser modificada com a função 'set_plot_option'; qualque
     daquelas opções globais pode ser sobrescrita com opções fornecidas
     no comando <plot2d>.

     Uma função a ter seu gráfico montado pode ser especificada como o
     nome de uma função do Maxima ou do Lisp ou um operador, uma
     expressão lambda do Maxima, ou uma expressão geral do Maxima.  Se
     especificado como um nome ou uma expressão lambda, a função deve
     ser uma função de um argumento.

     Exemplos:

     Gráficos de funções comuns.

          (%i1) plot2d (sin(x), [x, -%pi, %pi])$

          (%i1) plot2d (sec(x), [x, -2, 2], [y, -20, 20])$

     Montando gráfico de funções pelo nome.

          (%i1) F(x) := x^2 $
          (%i2) :lisp (defun |$g| (x) (m* x x x))
          $g
          (%i2) H(x) := if x < 0 then x^4 - 1 else 1 - x^5 $
          (%i3) plot2d ([F, G, H], [u, -1, 1], [y, -1.5, 1.5])$

     Podemos montar o gráfico de um círculo usando um gráfico
     paramétrico com um parâmetro <t>.  Não é necessário fornecer um
     intervalo para intervalo horizontal, uma vez que o intervalo do
     parâmetro <t> determina o domínio.  Todavia, usaremos a opção
     <same_xy> para obter a mesma escala em ambos os eixos:

          (%i1) plot2d([[parametric, cos(t), sin(t), [t,0,2*%pi]], -abs(x)],
                   [x, -sqrt(2), sqrt(2)], same_xy)$

     Exemplo de um gráfico logarítmico:
          (%i1) plot2d (exp(3*s), [s, -2, 2], logy)$

     Exemplo de gráfico discreto, definindo as coordenadas x e y por
     separado:

          (%i1) plot2d ([discrete, makelist(i*%pi, i, 1, 5),
                                      [0.6, 0.9, 0.2, 1.3, 1]])$

     O gráfico de pontos pode ser mostrado juntamente com um gráfico da
     função teorética/doutrinária/estética que prevê as coordenads dos
     pontos:

          (%i1) xy: [[10, .6], [20, .9], [30, 1.1], [40, 1.3], [50, 1.4]]$
          (%i2) plot2d([[discrete, xy], 2*%pi*sqrt(l/980)], [l,0,50],
                  [style, points, lines], [color, red, blue],
                  [point_type, asterisk],
                  [legend, "experiment", "theory"],
                  [xlabel, "pendulum's length (cm)"],
                  [ylabel, "period (s)"])$

     Veja também 'plot_options', que descreve opções de montagem de
     gráfico e tem mais exemplos.

 -- Variável de sistema: plot_options
     Elementos dessa lista estabelecem as opções padrão para a montagem
     do gráfico.  Se uma opção está presente em uma chamada a 'plot2d'
     ou 'plot3d', esse valor tem precedência sobre a opção padrão.  De
     outra forma, o valor em 'plot_options' é usado.  Opções padrão são
     atribuídas por 'set_plot_option'.

     Cada elemento de 'plot_options' é uma lista de dois ou mais ítens.
     O primeiro item é o nome de uma opção, e os restantes compreendem o
     valor ou valores atribuídos à opção.  Em alguns casos, o valor
     atribuído é uma lista, que pode compreender muitos ítens.

     As opções de montagem de gráfico que são reconhecidas por 'plot2d'
     e 'plot3d' são as seguintes:

        * Opção: 'plot_format'

          Determina qual interface gráfica é usada por 'plot2d' e por
          'plot3d'.

             * Valor: 'gnuplot' padrão para windows

               Gnuplot é o mais avançado pacote de montagem de gráficos
               entre os pacotes disponíveis no Maxima.  Esse valor
               requer uma instalação externa do gnuplot.
             * Valor: 'gnuplot_pipes' padrão nas plantaformas não
               windows

               Similar ao formato 'gnuplot' exceto que a comunicação com
               o gnuplot é realizada através de um pipe.  Esse valor
               pode ser usado para montar um gráfico na tela, para
               redirecionar a saída do gráfico para um arquivos é melhor
               usar o formato 'gnuplot'.
             * Valor: 'mgnuplot'

               Mgnuplot é um ambiente montado em volta do gnuplot
               baseado no Tk.  Esse ambiente está incluído na
               distribuíção do Maxima.  Mgnuplot oferece uma GUI
               rudimentar para o gnuplot, mas tem menos recursos em
               geral que a interface plana do gnuplot.  Mgnuplot requer
               uma instalação externa do gnuplot e Tcl/Tk.
             * Valor: 'openmath'

               Openmath é um programa gráfico escrito em Tcl/Tk.  Este
               formato é fornecido pelo pacote Xmaxima, que é
               distribuído junto com Maxima; com o objetivo de usar esse
               formato você pode instalar o pacote Xmaxima, e o Openmath
               irá trabalhar não somente a partir do Xmaxima em si
               mesmo, mas também a apartir da linha de comando e outras
               GUI's para o Maxima.

        * Opção: 'run_viewer'

          Controla se o visualizador apropriado para o formato da
          montagem do gráfico pode ou não ser executado.

             * Valor padrão: 'true'

               Executa o programa visualizador.
             * Valor: 'false'

               Não executa o programa visualizador.

        * Opção: 'y'

          O intervalo vertical do gráfico.

          Exemplo:

               [y, - 3, 3]
          Especifica intervalo vertical para [-3, 3].

        * Opção: 'plot_realpart'

          Quando 'plot_realpart' for 'true', a parte real de um valor
          complexo <x> é mostrada; isso é equivalente a mostrar
          'realpart(<x>)' em lugar de <x>.  De outra forma, somente
          valores com a parte imaginária igual a 0 são mostrados na
          tela, e valores complexos são ignorados.

          Exemplo:

               plot2d (log(x), [x, -5, 5], [plot_realpart, false]);
               plot2d (log(x), [x, -5, 5], [plot_realpart, true]);
          O valor padrão é 'false'.

        * Opção: 'nticks'

          Em plot2d, essa opção é fornece o número inicial de pontos
          usado pela rotina adaptativa de montagem de gráficos para
          funções de montagem de gráfico.  Ess número inicial de pontos
          é também o número de pontos que isrá ser mostrado em um
          gráfico paramétrico.

          Exemplo:

               [nticks, 20]
          O padrão para 'nticks' é 10.

        * Opção: 'adapt_depth'

          O número maximo de quebras usada pela rotina adaptativa de
          montagem do gráfico.

          Exemplo:

               [adapt_depth, 5]
          O padrão para 'adapt_depth' é 10.

        * Opção: 'xlabel'

          O rótulo para o eixo horizontal em um gráfico bidimensional.

          Exemplo:
               [xlabel, "Time in seconds"]

        * Opção: 'ylabel'

          O rótulo do eixo vertical em gráficos bidimensionais.

          Exemplo:
               [ylabel, "Temperatura"]

        * Opção: 'logx'

          Essa opção faz com que o eixo horizontal de um gráfico
          bidimensional seja desenhado em proporção logarítmica.  Essa
          opção não precisa de quaisquer parâmetros adicionais.

        * Opção: 'logy'

          Essa opção faz com que o eixo vertical de um gráfico
          bidimensional seja desenhado em proporção logarítmica.  Essa
          opção não precisa de quaisquer parâmetros adicionais.

        * Opção: 'legend'

          Os rótulos para várias expressões em um gráfico bidimensional
          com muitas expressões.  Se houverem mais expressões que o
          número de rótulos fornecidos, eles irão ser repetidos.  Por
          padrão, os nomes das expressões ou funçõe irão ser usados, ou
          as palavras discrete1, discrete2, ..., para conjuntos
          discretos de pontos.

          Exemplo:
               [legend, "Conj 1", "Conj 2", "Conj 3"]

        * Opção: 'style'

          Os estilos que irão ser usados para várias funções ou
          conjuntos de dados em um gráfico bidimensional.  A palavra
          <style> deve ser seguida por um ou mais estilos.  Se houverem
          mais funções e conjuntos de pontos que estilos fornecidos, os
          estilos irão ser repetidos.  Cada estilo pode ser um entre os
          seguintes <lines> para segmentos de reta, <points> para pontos
          isolados, <linespoints> para segmentos e pontos, ou <dots>
          para pequenos pontos isolados.  Gnuplot aceita também o estilo
          <impulses>.

          Cada um dos estilos pode também ser fechado dentro de uma
          lista com alguns parâmetros adicionais.  <lines> aceita um ou
          dois números: a largura da linha e um inteiro que identifica
          uma cor.  <points> aceita um ou dois parâmetros; o primeiro
          parâmetro é o raio dos pontos e o segundo parâmetro é um
          inteiro que para o Gnuplot seleciona diferentes ajustes e
          cores para os ponots e em Openmath modifica a cor usada para
          os pontos.  <linesdots> aceita até quatro parâmetros; os
          primerios dois possuem o mesmo significado que em <lines> e os
          últimos dois possuem o mesmo significado que em <points>.

          Exemplo:
               [style,[lines,2,3],[points,1,4]]

          No Gnuplot, esse exemplo irá montar o gráfico da primeira (e
          terceira, quinta, etc) expressão com segmentos de retas azuis
          de largura 2, ea segunda (e quarta, sexta, etc) expressão com
          quadrados verdes de tamanho 1.  No Openmath, a primeira
          expressão irá ser mostrada com segmentos da cor magenta de
          largura 2, e o segundo com pontos alaranjados de raio 1; note
          que openmath_color(3) openmath_color(4) retornam "magenta" e
          "orange" (alaranjado).

          O padrão para a opção de estilo é <lines> com largura 1, e
          diferentes cores.

        * Opção: 'grid'

          Escolhe o número de pontos da grade para usar nas direções x e
          y para montagem de gráficos tridimensionais.

          Exemplo:
               [grid, 50, 50]
          Escolhe a grade para 50 por 50 pontos.  A grade padrão é 30
          por 30.

        * Opção: 'transform_xy'

          Permite que transformações sejam aplicadas à montagem de
          gráficos tridimensionais.

          Exemplo:
               [transform_xy, false]
          O valor padrão de 'transform_xy' é 'false'.  Se o valor padrão
          de 'transform_xy' não é 'false', pode ser a saída de

               make_transform ([x, y, z], f1(x, y, z), f2(x, y, z), f3(x, y, z))$
          A transformação 'polar_xy' é previamente definida no Maxima.
          Isso fornece a mesma transformação que
               make_transform ([r, th, z], r*cos(th), r*sin(th), z)$

     Opções do Gnuplot:

     Existem muitas opções de montagem de gráfico específicas para
     gnuplot.  Algumas dessas opções são naturais do gnuplot,
     especificados como seqüências de caracteres.  Consulte a
     documentação do gnuplot para mais detalhes.

        * Opção: 'gnuplot_term'

          Escolhe a saída para o tipo terminal para o gnuplot.
             * Valor padrão: 'default'

               A saída do Gnuplot é mostrada em uma janela gráfica
               separada.

             * Valor: 'dumb'

               A sída do Gnuplot é mostrada no console do Maxima por
               meio de uma "concepção artística em ASCII" aproximada
               para gráficos.

             * Valor: 'ps'

               Gnuplot gera comandos na linguagem PostScript de
               descrição de página.  Se a opção 'gnuplot_out_file' for
               escolhida para <nomearquivo>, gnuplot escreve os comandos
               PostScript em <nomearquivo>.  De outra forma, Esse
               arquivo é salvo com o nome 'maxplot.ps'.

             * Valor: qualquer outra especificação válida do terminal
               'term' do gnuplot

               Gnuplot pode gerar saídas em muitos outros formatos
               gráficos tais como png, jpeg, svg etc.  Paa criar
               gráficos em todos esses formatos a opção 'gnuplot_term'
               pode ser escolhida para qualquer terminalsuportado pelo
               gnuplot (símbolo) ou mesmo especificação completa de
               terminal do gnuplot com quaisquer opções (seqüência de
               caracteres).  Por exemplo '[gnuplot_term,png]' cria
               saídas no formato PNG (Portable +Network Graphics)
               enquanto '[gnuplot_term,"png size 1000,1000"]' cria PNG
               de tamanho 1000x1000 pixels.  Se a opção
               'gnuplot_out_file' for escolhida para <nomearquivo>,
               gnuplot escreve a saída para <nomearquivo>.  De outra
               forma, esse arquivo é gravado com o nome de
               'maxplot.<term>', onde <term> é o nome do terminal do
               gnuplot .

        * Opção: 'gnuplot_out_file'

          Escreve a saída do gnuplot para um arquivo.

             * Valor padrão: 'false'

               Nenhum arquivo de saída especificado.
             * Valor: <nomearquivo>

               Exemplo: '[gnuplot_out_file, "meugrafico.ps"]' Esse
               exemplo envia a saída PostScript para o arquivo
               'meugrafico.ps' quando usada conjuntamente com o terminal
               PostScript do gnuplot.

        * Opção: 'gnuplot_pm3d'

          Controla o uso do modo PM3D, que tem recursos avançados em 3D.
          PM3D está somente disponível no gnuplot em versões após a 3.7.
          O valor padrão para 'gnuplot_pm3d' é 'false'.

          Exemplo:

               [gnuplot_pm3d, true]

        * Opção: 'gnuplot_preamble'

          Insere comandos antes que o gráfico seja desenhado.  Quaisquer
          comandos válidos para o gnuplot podem ser usados.  Multiplos
          comandos podem ser separados com um ponto e vírgula.  O
          exemplo mostrado produz uma escala numérica na montagem do
          gráfico.  O valor padrão para 'gnuplot_preamble' é uma
          seqüência de caracteres vazia '""'.

          Exemplo:

               [gnuplot_preamble, "set log y"]

        * Opção: 'gnuplot_curve_titles'

          Controla os títulos dados na chave da montagem do gráfico.  O
          valor padrão é '[default]', que automaticamente escolhe o
          título de cada curva para a função cujo gráfico está sendo
          construído.  Se não contiver '[default]',
          'gnuplot_curve_titles' pode conter uma lista de seqüências de
          caracteres, cada uma das quais é '"title '<title_string>'"'.
          (Para disabilitar a chave de impressão de gráfico, adicione
          '"set nokey"' a 'gnuplot_preamble'.)

          Exemplo:

               [gnuplot_curve_titles,
               ["title 'Minha primeira função'", "title 'Minha segunda função'"]]

        * Opção: 'gnuplot_curve_styles'

          Uma lista de seqüências de caracteres controlando a aparência
          das curvas, i.e., cor, largura, brilho, etc., para serem
          enviadas para o comando de montagem do gráfico do gnuplot.  O
          valor padrão é '["with lines 3", "with lines 1", "with lines
          2", "with lines 5", "with lines 4", "with lines 6", "with
          lines 7"]', que circula através de diferentes cores.  Veja a
          documentação do gnuplot de 'plot' para maiores informações.

          Exemplo:

               [gnuplot_curve_styles, ["with lines 7", "with lines 2"]]

        * Opção: 'gnuplot_default_term_command'

          O comando gnuplot para escolher o tipo de terminal para o
          terminal padrão.  O valor padrão é 'set term windows "Verdana"
          15' em sistemas windows, e 'set term x11 font "Helvetica,16"'
          em sistemas de janelas do X11.

          Exemplo:

               [gnuplot_default_term_command, "set term x11"]

        * Opção: 'gnuplot_dumb_term_command'

          O comando gnuplot para escolher o tipo de terminal para o
          terminal dumb.  O valor padrão é '"set term dumb 79 22"', que
          faz a saída texto com 79 caracteres por 22 caracteres.

          Exemplo:

               [gnuplot_dumb_term_command, "set term dumb 132 50"]

        * Opção: 'gnuplot_ps_term_command'

          O comando gnuplot para escolher o tipo de terminal para o
          terminal PostScript.  O valor padrão é '"set size 1.5, 1.5;set
          term postscript eps enhanced color solid 24"', que escolhe o
          tamanho para 1.5 vezes o padrão do gnuplot, e o tamanho da
          fonte para 24, além de outras coisas.  Veja a documentação do
          gnuplot de 'set term postscript' para mais informação.

          Exemplo:

          Todos os números nos exemplos para a função <plot2d> nesse
          manual foram obtidos de arquivos Postscript que foram gerados
          após escolher 'gnuplot_ps_term_command' como:

               [gnuplot_ps_term_command,
               "set size 1.3, 1.3; set term postscript eps color solid lw 2.5 30"]

 -- Função: plot3d ([<expr_1>, <expr_2>, <expr_3>], <x_range>,
          <y_range>, ..., <opções>, ...)
 -- Função: plot3d (<expr>, <x_range>, <y_range>, ..., <opções>, ...)
 -- Função: plot3d (<name>, <x_range>, <y_range>, ..., <opções>, ...)
 -- Função: plot3d ([<expr_1>, <expr_2>, <expr_3>], <x_rge>, <y_rge>)
 -- Função: plot3d ([<nome_1>, <nome_2>, <nome_3>], <x_range>,
          <y_range>, ..., <opções>, ...)

     Mostra um gráfico de uma ou três expressões como funções de duas
     variáveis.

          (%i1) plot3d (u^2 - v^2, [u, -2, 2], [v, -3, 3], [grid, 100, 100],
                  [mesh_lines_color,false])$

     monta o gráfico de 'u^2-v^2' com 'u' e 'v' variando no intervalo
     fechado [-2,2] e no intervalo fechado de [-3,3] respectivamente, e
     com <u> sobre o eixo x, e 'v' sobre o eixo y.

     Outro exemplo é uma superfície de Klein:

          (%i1) expr_1: 5*cos(x)*(cos(x/2)*cos(y)+sin(x/2)*sin(2*y)+3)-10$
          (%i2) expr_2: -5*sin(x)*(cos(x/2)*cos(y)+sin(x/2)*sin(2*y)+3)$
          (%i3) expr_3: 5*(-sin(x/2)*cos(y)+cos(x/2)*sin(2*y))$
          (%i4) plot3d ([expr_1, expr_2, expr_3], [x, -%pi, %pi],
                  [y, -%pi, %pi], [grid, 50, 50])$

     Algumas vezes isso é necessário para definir uma função para montar
     o graico da expressão.  Todos os argumentos para plot3d são
     avaliados antes de serem passados para plot3d.  Tentar fazer um
     expressão que faz apenas o que é preciso pode ser difícil e pode
     ser mais fácil fazer uma função.

          (%i1) M: matrix([1,2,3,4], [1,2,3,2], [1,2,3,4], [1,2,3,3])$
          (%i2) f(x, y) := float('M [round(x), round(y)])$
          (%i3) plot3d (f(x,y), [x,1,4],[y,1,4],[grid,3,3],[legend,false])$

     Veja 'plot_options' para mais exemplos.

 -- Função: make_transform (<vars>, <fx>, <fy>, <fz>)
     Retorna uma função adequada para a função transformação em plot3d.
     Use com a opção de montagem de gráfico 'transform_xy'.
          make_transform ([r, th, z], r*cos(th), r*sin(th), z)$
     é uma transformação para coordenadas polares.

 -- Função: set_plot_option (<opção>)
     Atribui uma das varáveis globais para impressão.  <opção> é
     especificada como uma lista de dois ou mais elementos, na qual o
     primeiro elemento é uma das palavras chave dentro da lista
     'plot_options'.

     'set_plot_option' avalia seu argumento e retorna a liasta completa
     'plot_options' (após modificar um de seus elementos).

     Veja também 'plot_options', 'plot2d', e 'plot3d'.

     Exemplos:

     Modifica a malha ('grid') e valores de 'x'.  Quando uma palavra
     chave em 'plot_options' tem um valor atribuído, colocar um
     apóstrofo evita avaliação.

          (%i1) set_plot_option ([grid, 30, 40]);
          (%o1) [[x, - 1.755559702014E+305, 1.755559702014E+305],
          [y, - 1.755559702014E+305, 1.755559702014E+305], [t, - 3, 3],
          [grid, 30, 40], [transform_xy, false], [run_viewer, true],
          [plot_format, gnuplot], [gnuplot_term, default],
          [gnuplot_out_file, false], [nticks, 10], [adapt_depth, 10],
          [gnuplot_pm3d, false], [gnuplot_preamble, ],
          [gnuplot_curve_titles, [default]],
          [gnuplot_curve_styles, [with lines 3, with lines 1,
          with lines 2, with lines 5, with lines 4, with lines 6,
          with lines 7]], [gnuplot_default_term_command, ],
          [gnuplot_dumb_term_command, set term dumb 79 22],
          [gnuplot_ps_term_command, set size 1.5, 1.5;set term postscript #
          eps enhanced color solid 24]]
          (%i2) x: 42;
          (%o2)                          42
          (%i3) set_plot_option (['x, -100, 100]);
          (%o3) [[x, - 100.0, 100.0], [y, - 1.755559702014E+305,
          1.755559702014E+305], [t, - 3, 3], [grid, 30, 40],
          [transform_xy, false], [run_viewer, true],
          [plot_format, gnuplot], [gnuplot_term, default],
          [gnuplot_out_file, false], [nticks, 10], [adapt_depth, 10],
          [gnuplot_pm3d, false], [gnuplot_preamble, ],
          [gnuplot_curve_titles, [default]],
          [gnuplot_curve_styles, [with lines 3, with lines 1,
          with lines 2, with lines 5, with lines 4, with lines 6,
          with lines 7]], [gnuplot_default_term_command, ],
          [gnuplot_dumb_term_command, set term dumb 79 22],
          [gnuplot_ps_term_command, set size 1.5, 1.5;set term postscript #
          eps enhanced color solid 24]]

8.1.1 Funções para trabalhar com o formato 'gnuplot_pipes'
----------------------------------------------------------

 -- Função: gnuplot_start ()

     Abre o pipe para o gnuplot usado para montar um gráfico com o
     formato 'gnuplot_pipes'.  Não é necessário abrir manualmente o pipe
     antes de montar o gráfico.

 -- Função: gnuplot_close ()

     Fecha o pipe para o gnuplot que está sendo usado com o formato
     'gnuplot_pipes'.

 -- Função: gnuplot_restart ()

     Fecha o pipe para o gnuplot que é usado com o formato
     'gnuplot_pipes' e abre um novo pipe.

 -- Função: gnuplot_replot ()
 -- Função: gnuplot_replot (<s>)

     Atualiza a janela gráfica do gnuplot.  Se 'gnuplot_replot' for
     chamado com um comando gnuplot em uma seqüência de caracteres <s>,
     então 's' é enviado para o gnuplot antes de atualizar a janela.

 -- Função: gnuplot_reset ()

     Restaura o estado inicial padrão do gnuplot usado com o formato
     'gnuplot_pipes'.  Para atualizar a janela do gnuplot chama
     'gnuplot_replot' após 'gnuplot_reset'.


File: maxima.info,  Node: Entrada e Saída,  Next: Ponto Flutuante,  Prev: Montando Gráficos,  Up: Top

9 Entrada e Saída
*****************

* Menu:

* Comentários::
* Arquivos::
* Funções e Variáveis Definidas para Entrada e Saída::


File: maxima.info,  Node: Comentários,  Next: Arquivos,  Prev: Entrada e Saída,  Up: Entrada e Saída

9.1 Comentários
===============

Um comentário na entrada do Maxima é qualquer texto entre '/*' e '*/'.

   O analisador do Maxima trata um comentário como espação em branco
para o propósito de encontrar indicações no fluxo de entrada; uma
indicação sempre termina um comentário.  Uma entrada tal como 'a/* foo
*/b' contém duas indicações, 'a' e 'b', e não uma indicação simples
'ab'.  Comentários são de outra ignorados pelo Maxima; nem o conteúdo
nem a localização dos comentários são armazenados pelo analisador de
expressões de entrada.

   Comentários podem ser aninhados de forma a terem um nível de
estratificação arbitrario.  O delimitador '/*' e o delimitador '*/'
formam pares.  A quantidade de '/*' deve ser a mesma quantidade de '*/'.

   Exemplos:

     (%i1) /* aa is a variable of interest */  aa : 1234;
     (%o1)                         1234
     (%i2) /* Value of bb depends on aa */  bb : aa^2;
     (%o2)                        1522756
     (%i3) /* User-defined infix operator */  infix ("b");
     (%o3)                           b
     (%i4) /* Parses same as a b c, not abc */  a/* foo */b/* bar */c;
     (%o4)                         a b c
     (%i5) /* Comments /* can be nested /* to arbitrary depth */ */ */  1 + xyz;
     (%o5)                        xyz + 1


File: maxima.info,  Node: Arquivos,  Next: Funções e Variáveis Definidas para Entrada e Saída,  Prev: Comentários,  Up: Entrada e Saída

9.2 Arquivos
============

Um arquivo é simplesmente uma área sobre um dispositivo particular de
armazenagem que contém dados ou texto.  Arquivos em disco são
figurativamente agrupados dentro de "diretórios".  Um diretório é apenas
uma lista de arquivos.  Comandos que lidam com arquivos são: 'save',
'load', 'loadfile', 'stringout', 'batch', 'demo', 'writefile',
'closefile', e 'appendfile'.


File: maxima.info,  Node: Funções e Variáveis Definidas para Entrada e Saída,  Prev: Arquivos,  Up: Entrada e Saída

9.3 Funções e Variáveis Definidas para Entrada e Saída de Dados
===============================================================

 -- Variável de sistema: __
     '__' é a expressão de entrada atualmente sendo avaliada.  Isto é,
     enquanto um expressão de entrada <expr> está sendo avaliada, '__' é
     <expr>.

     '__' é atribuída à expressão de entrada antes de a entrada ser
     simplificada ou avaliada.  Todavia, o valor de '__' é simplificado
     (mas não avaliado) quando for mostrado.

     '__' é reconhecido por 'batch' e 'load'.  Em um arquivo processado
     por 'batch', '__' tem o mesmo significado que na linha de comando
     interativa.  Em um arquivo processado por 'load', '__' está
     associado à expressão de entrada mais recentemente informada no
     prompt interativo ou em um arquivo de lote (batch); '__' não é
     associado à expressões de entrada no arquivo que está sendo
     processado.  Em particular, quando 'load (<nomearquivo>)' for
     chamado a partir da linha de comando interativa, '__' é associado a
     'load (<nomearquivo>)' enquanto o arquivo está sendo processado.

     Veja também '_' e '%'.

     Exemplos:

          (%i1) print ("Eu fui chamada como", __);
          Eu fui chamada como print(Eu fui chamada como, __)
          (%o1)              print(Eu fui chamada como, __)
          (%i2) foo (__);
          (%o2)                     foo(foo(__))
          (%i3) g (x) := (print ("Expressão atual de entrada =", __), 0);
          (%o3) g(x) := (print("Expressão atual de entrada =", __), 0)
          (%i4) [aa : 1, bb : 2, cc : 3];
          (%o4)                       [1, 2, 3]
          (%i5) (aa + bb + cc)/(dd + ee + g(x));
                                         cc + bb + aa
          Expressão atual de entrada = --------------
                                        g(x) + ee + dd
                                          6
          (%o5)                        -------
                                       ee + dd

 -- Variável de sistema: _

     '_' é a mais recente expressão de entrada (e.g., '%i1', '%i2',
     '%i3', ...).

     A '_' é atribuída à expressão de entrada antes dela ser
     simplificada ou avaliada.  Todavia, o valor de '_' é simplificado
     (mas não avaliado) quando for mostrado.

     '_' é reconhecido por 'batch' e 'load'.  Em um arquivo processado
     por 'batch', '_' tem o mesmo significado que na linha de comando
     interativa.  Em um arquivo processado por load 'load', '_' está
     associado à expressão de entrada mais recentemente avaliada na
     linha de comando interativa ou em um arquivo de lote; '_' não está
     associada a expressões de entrada no arquivo que está sendo
     processado.

     Veja também '__' e '%'.

     Exemplos:

          (%i1) 13 + 29;
          (%o1)                          42
          (%i2) :lisp $_
          ((MPLUS) 13 29)
          (%i2) _;
          (%o2)                          42
          (%i3) sin (%pi/2);
          (%o3)                           1
          (%i4) :lisp $_
          ((%SIN) ((MQUOTIENT) $%PI 2))
          (%i4) _;
          (%o4)                           1
          (%i5) a: 13$
          (%i6) b: 29$
          (%i7) a + b;
          (%o7)                          42
          (%i8) :lisp $_
          ((MPLUS) $A $B)
          (%i8) _;
          (%o8)                         b + a
          (%i9) a + b;
          (%o9)                          42
          (%i10) ev (_);
          (%o10)                         42

 -- Variável de sistema: %
     '%' é a expressão de saída (e.g., '%o1', '%o2', '%o3', ...)  mais
     recentemente calculada pelo Maxima, pode ou não ser mostrada.

     '%' é reconhecida por 'batch' e 'load'.  Em um arquivo processado
     por 'batch', '%' tem o mesmo significado que na linha de comando
     interativa.  Em um arquivo processado por 'load', '%' é associado à
     expressão de entrada mais recentemente calculada na linha de
     comando interativa ou em um arquivo de lote; '%' não está associada
     a expressões de saída no arquivo que está sendo processado.

     Veja também '_', '%%', e '%th'

 -- Variável de sistema: %%
     Em declaração composta, a saber 'block', 'lambda', ou '(<s_1>, ...,
     <s_n>)', '%%' é os valor da declaração anterior.  Por exemplo,

          block (integrate (x^5, x), ev (%%, x=2) - ev (%%, x=1));
          block ([prev], prev: integrate (x^5, x), ev (prev, x=2) - ev (prev, x=1));

     retornam o mesmo resultado, a saber '21/2'.

     Uma declaração composta pode compreender outras declarações
     compostas.  Pode uma declaração ser simples ou composta, '%%' é o
     valor da declaração anterior.  Por exemplo,

          block (block (a^n, %%*42), %%/6)

     retorna '7*a^n'.

     Dentro da declaração composta, o valor de '%%' pode ser
     inspecionado em uma parada de linha de comando, que é aberta pela
     execução da função 'break'.  Por exemplo, na parada de linha de
     comando aberta por

          block (a: 42, break ())$

     digitando '%%;' retorna '42'.

     Na primeira declaração em uma declaração composta, ou fora de uma
     declaração composta, '%%' é indefinido.

     '%%' reconhecido por 'batch' e 'load', e possem o mesmo significao
     que na linha de comando interativa.

     Veja também '%'.

 -- Variável de opção: %edispflag
     Valor padrão: 'false'

     Quando '%edispflag' for 'true', Maxima mostra '%e' para um expoente
     negativo como um quociente.  Por exemplo, '%e^-x' é mostrado como
     '1/%e^x'.

 -- Função: %th (<i>)
     O valor da <i>'ésima expressão prévia de saída.  Isto é, se a
     próxima expressão a ser calculada for a <n>'ésima saída, '%th
     (<m>)' será a (<n> - <m>)'ésima saída.

     '%th' é útil em arquivos 'batch' ou para referir-se a um grupo de
     expressões de saída.  Por exemplo,

          block (s: 0, for i:1 thru 10 do s: s + %th (i))$

     atribui à variável 's' a soma das últimas dez expressões de saída.

     '%th' é reconhecido por 'batch' e 'load'.  Em um arquivo processado
     por 'batch', '%th' possue o mesmo significado que na linha de
     comando interativa.  Em um arquivo processado por 'load', '%th'
     refere-se a expressões de saída mais recentemente calculadas na
     linha de comando interativa ou em um arquivo de lote; '%th' não se
     refere a expressões de saída no arquivo que está sendo processado.

     Veja também '%'.

 -- Símbolo especial: ?
     Como prefixo para uma função ou nome de variável, '?' significa que
     o nome é um nome Lisp, não um nome Maxima.  Por exemplo, '?round'
     significa a função Lisp 'ROUND'.  Veja *note Lisp e Maxima:: para
     mais sobre esse ponto.

     A notação '? palavra' (um ponto de interrogação seguido de uma
     palavra e separado desta por um espaço em branco) é equivalente a
     'describe("palavra")'.  O ponto de interrogação deve aparecer no
     início de uma linha de entrada; de outra forma o ponto de
     interrogação não é reconhecido com um pedido de documentação.

 -- Símbolo especial: ??

     A notação '?? palavra' ('??' seguido de um espaço em branco e uma
     palavra) é equivalente a 'describe("palavra", inexact)'.  O ponto
     de interrogação deve ocorrer no início de uma linha de entrada; de
     outra forma não é reconhecido com um pedido de documentação.

 -- Variável de opção: absboxchar
     Valor padrão: '!'

     'absboxchar' é o caracter usado para para desenhar o sinal de valor
     absoluto em torno de expressões que são maiores que uma linha de
     altura.

 -- Variável de opção: file_output_append
     Valor padrão: 'false'

     'file_output_append' governa se funções de saída de arquivo anexam
     ao final ou truncam seu arquivo de saída.  Quando
     'file_output_append' for 'true', tais funções anexam ao final de
     seu arquivo de saída.  De outra forma, o arquivo de saída é
     truncado.

     'save', 'stringout', e 'with_stdout' respeitam
     'file_output_append'.  Outras funções que escrevem arquivos de
     saída não respeitam 'file_output_append'.  Em particular, montagem
     de gráficos e traduções de funções sempre truncam seu arquivo de
     saída, e 'tex' e 'appendfile' sempre anexam ao final.

 -- Função: appendfile (<nomearquivo>)
     Adiciona ao final de <nomearquivo> uma transcrição do console.
     'appendfile' é o mesmo que 'writefile', exceto que o arquivo
     transcrito, se já existe, terá sempre alguma coisa adicionada ao
     seu final.

     'closefile' fecha o arquivo transcrito que foi aberto anteriormente
     por 'appendfile' ou por 'writefile'.

 -- Função: batch (<nomearquivo>)
     Lê expressões Maxima do arquivo <nomearquivo> e as avalia.  'batch'
     procura pelo arquivo <nomearquivo> na lista 'file_search_maxima'.
     Veja 'file_search'.

     <nomearquivo> compreende uma seqüência de expressões Maxima, cada
     uma terminada com ';' ou '$'.  A varável especial '%' e a função
     '%th' referem-se a resultados prévios dentro do arquivo.  O arquivo
     pode incluir construções ':lisp'.  Espaços, tabulações, e o
     caracter de nova linha no arquivo serão ignorados.  um arquivo de
     entrada conveniente pode ser criado por um editor de texto ou pela
     função 'stringout'.

     'batch' lê cada expressão de entrada de <nomearquivo>, mostra a
     entrada para o console, calcula a correspondente expressão de
     saída, e mostra a expressão de saída.  Rótulos de entrada são
     atribuídos para expressões de entrada e rótulos de saída são
     atribuídos para expressões de saída.  'batch' avalia toda expressão
     de entrada no arquivo a menos que exista um erro.  Se uma entrada
     de usuário for requisitada (por 'asksign' ou por 'askinteger', por
     exemplo) 'batch' interrompe para coletar a entrada requisitada e
     então continua.

     O recurso de requisição de entrada ao usuário possibilita
     interromper 'batch' pela digitação de 'control-C' no console.  O
     efeito de 'control-C' depende da subjacente implementação do Lisp.

     'batch' tem muitos usos, tais como fornecer um reservatório para
     trabalhar linhas de comando, para fornecer demonstrações livres de
     erros, ou para ajudar a organizar alguma coisa na solução de
     problemas complexos.

     'batch' avalia seu argumento.  'batch' não possui valor de retorno.

     Veja também 'load', 'batchload', e 'demo'.

 -- Função: batchload (<nomearquivo>)
     Lê expressões Maxima de <nomearquivo> e as avalia, sem mostrar a
     entrada ou expressões de saída e sem atribuir rótulos para
     expressões de saída.  Saídas impressas (tais como produzidas por
     'print' ou 'describe') são mostradas, todavia.

     A variável especial '%' e a função '%th' referem-se a resultados
     anteriores do interpretador interativo, não a resultados dentro do
     arquivo.  O arquivo não pode incluir construções ':lisp'.

     'batchload' retorna o caminho de <nomearquivo>, como uma seqüência
     de caracteres.  'batchload' avalia seu argumento.

     Veja também 'batch' e 'load'.

 -- Função: closefile ()
     Fecha o arquivo transcrito aberto por 'writefile' ou 'appendfile'.

 -- Função: collapse (<expr>)
     Reduz <expr> fazendo com que todas as suas subexpressões comuns
     (i.e., iguais) sejam compartilhadas (i.e., usam a mesma células),
     dessa forma economizando espaço.  ('collapse' é uma subrotina usada
     pelo comando 'optimize'.)  Dessa forma, chamar 'collapse' pode ser
     útil após um 'save' arquivo.  Você pode diminuir muitas expressões
     juntas pelo uso de 'collapse ([<expr_1>, ..., <expr_n>])'.
     Similarmente, você pode diminuir os elementos de um array 'A'
     fazendo 'collapse (listarray ('A))'.

 -- Função: concat (<arg_1>, <arg_2>, ...)
     Concatena seus argumentos.  Os argumentos devem obrigatóriamente
     serem avaliados para atomos.  O valor de retorno ou é um símbolo se
     o primeiro argumento for um símbolo ou é uma seqüência de
     caracteres no formato do Maxima em caso contrário.

     'concat' avalia seus argumentos.  O apóstrofo ''' evita avaliação.

          (%i1) y: 7$
          (%i2) z: 88$
          (%i3) concat (y, z/2);
          (%o3)                          744
          (%i4) concat ('y, z/2);
          (%o4)                          y44

     Um símbolo construído por 'concat' pode ser atribuído a um valor e
     aparecer em expressões.  O operador de atribuição '::' (duplo dois
     pontos) avalia seu lado esquerdo.

          (%i5) a: concat ('y, z/2);
          (%o5)                          y44
          (%i6) a:: 123;
          (%o6)                          123
          (%i7) y44;
          (%o7)                          123
          (%i8) b^a;
                                         y44
          (%o8)                         b
          (%i9) %, numer;
                                         123
          (%o9)                         b

     Note que embora 'concat (1, 2)' seja visto como números no console,
     na realidade é uma seqüência de caracteres no formato do Maxima.

          (%i10) concat (1, 2) + 3;
          (%o10)                       12 + 3

 -- Função: sconcat (<arg_1>, <arg_2>, ...)

     Concatena seus argumentos em uma seqüência de caracteres.  Ao
     contrário de 'concat', os argumentos arrumados não precisam ser
     atômicos.

     O resultado é uma seqüência de caracteres no format do Lisp.

          (%i1) sconcat ("xx[", 3, "]:", expand ((x+y)^3));
          (%o1)               xx[3]:y^3+3*x*y^2+3*x^2*y+x^3

 -- Função: disp (<expr_1>, <expr_2>, ...)
     é como 'display' mas somente os valores dos argumentos são
     mostrados em lugar de equações.  A função 'disp' é útil para
     argumentos complicados que não possuem nomes ou onde somente o
     valor do argumento é de interesse e não o nome.

 -- Função: dispcon (<tensor_1>, <tensor_2>, ...)
 -- Função: dispcon (all)
     Mostra as propriedades de contração de seus argumentos da forma que
     foram dadas para 'defcon'.  'dispcon (all)' mostra todas as
     propriedades de contração que foram definidas.

 -- Função: display (<expr_1>, <expr_2>, ...)
     Mostra equações cujo lado esquerdo é <expr_i> não avaliado, e cujo
     lado direito é o valor da expressão centrada na linha.  Essa função
     é útil em blocos e em 'for' declarações com o objetivo de ter
     resultados intermediários mostrados.  Os argumentos para 'display'
     são usualmente átomos, variáveis com subscritos, ou chamadas de
     função.  Veja também 'disp'.

          (%i1) display(B[1,2]);
                                                2
                                   B     = X - X
                                    1, 2
          (%o1)                            done

 -- Variável de opção: display2d
     Valor padrão: 'true'

     Quando 'display2d' for 'false', O console visualizador é da forma
     de uma seqüência de caracteres (unidimensional) ao invés da forma
     bidimensional.

 -- Variável de opção: display_format_internal
     Valor padrão: 'false'

     Quando 'display_format_internal' é 'true', expressões são mostradas
     sem ser por caminhos que escondam a representação matemática
     interna.  O visualizador então corresponde ao que 'inpart' retorna
     em lugar de 'part'.

     Exemplos:

          User     part       inpart
          a-b;      A - B     A + (- 1) B

                     A            - 1
          a/b;       -         A B
                     B
                                 1/2
          sqrt(x);   sqrt(X)    X

                    4 X        4
          X*4/3;    ---        - X
                     3         3

 -- Função: dispterms (<expr>)
     Mostra <expr> em partes uma abaixo da outra.  Isto é, primeiro o
     operador de <expr> é mostrado, então cada parcela em uma adição, ou
     fatores em um produto, ou parte de uma expressão mais geral é
     mostrado separadamente.  Isso é útil se <expr> é muito larga para
     ser mostrada de outra forma.  Por exemplo se 'P1', 'P2', ...  são
     expressões muito largas então o programa visualizador pode sair
     fora do espaço de armazenamento na tentativa de mostrar 'P1 + P2 +
     ...' tudo de uma vez.  Todavia, 'dispterms (P1 + P2 + ...)' mostra
     'P1', então abaixo disso 'P2', etc.  Quando não usando 'dispterms',
     se uma expressão exponencial é muito alta para ser mostrada como
     'A^B' isso aparece como 'expt (A, B)' (ou como 'ncexpt (A, B)' no
     caso de 'A^^B').

 -- Variável de opção: error_size
     Valor padrão: 10

     'error_size' modifica mensagens de erro conforme o tamanho das
     expressões que aparecem nelas.  Se o tamanho de uma expressão (como
     determinado pela função Lisp 'ERROR-SIZE') é maior que
     'error_size', a expressão é substituída na mensagem por um símbolo,
     e o o símbolo é atribuído à expressão.  Os símbolos são obtidos da
     lista 'error_syms'.

     De outra forma, a expressão é menor que 'error_size', e a expressão
     é mostrada na mensagem.

     Veja também 'error' e 'error_syms'.

     Exemplo:

     O tamanho de 'U', como determinado por 'ERROR-SIZE', é 24.

          (%i1) U: (C^D^E + B + A)/(cos(X-1) + 1)$

          (%i2) error_size: 20$

          (%i3) error ("Expressão exemplo é", U);

          Expressão exemplo é errexp1
           -- an error.  Quitting.  To debug this try debugmode(true);
          (%i4) errexp1;
                                      E
                                     D
                                    C   + B + A
          (%o4)                    --------------
                                   cos(X - 1) + 1
          (%i5) error_size: 30$

          (%i6) error ("Expressão exemplo é", U);

                                     E
                                    D
                                   C   + B + A
          Expressão exemplo é --------------
                                  cos(X - 1) + 1
           -- an error.  Quitting.  To debug this try debugmode(true);

 -- Variável de opção: error_syms
     Valor padrão: '[errexp1, errexp2, errexp3]'

     Em mensagens de erro, expressões mais largas que 'error_size' são
     substituídas por símbolos, e os símbolos são escolhidos para as
     expressões.  Os símbolos são obtidos da lista 'error_syms'.  A
     primeira expressão muito larga é substituída por 'error_syms[1]', a
     segunda por 'error_syms[2]', e assim por diante.

     Se houverem mais expressões muito largas que há elementos em
     'error_syms', símbolos são construídos automaticamente, com o
     <n>-ésimo símbolo equivalente a 'concat ('errexp, <n>)'.

     Veja também 'error' e 'error_size'.

 -- Função: expt (<a>, <b>)
     Se uma expressão exponencial é muito alta para ser mostrada cmo
     '<a>^<b>' isso aparece como 'expt (<a>, <b>)' (ou como 'ncexpt
     (<a>, <b>)' no caso de '<a>^^<b>').

     'expt' e 'ncexpt' não são reconhecidas em entradas.

 -- Variável de opção: exptdispflag
     Valor padrão: 'true'

     Quando 'exptdispflag' é 'true', Maxima mostra expressões com
     expoente negativo usando quocientes, e.g., 'X^(-1)' como '1/X'.

 -- Função: filename_merge (<path>, <nomearquivo>)
     Constroem um caminho modificado de <path> e <nomearquivo>.  Se o
     componente final de <path> é da forma '###.<algumacoisa>', o
     componente é substituído com '<nomearquivo>.<algumacoisa>'.  De
     outra forma, o componente final é simplesmente substituído por
     <nomearquivo>.

 -- Função: file_search (<nomearquivo>)
 -- Função: file_search (<nomearquivo>, <listacaminho>)

     'file_search' procura pelo arquivo <nomearquivo> e retorna o
     caminho para o arquivo (como uma seqüência de caracteres) se ele
     for achado; de outra forma 'file_search' retorna 'false'.
     'file_search (<nomearquivo>)' procura nos diretórios padrões de
     busca, que são especificados pelas variáveis 'file_search_maxima',
     'file_search_lisp', e 'file_search_demo'.

     'file_search' primeiro verifica se o nome atual passado existe,
     antes de tentar coincidir esse nome atual com o modelo "coringa" de
     busca do arquivo.  Veja 'file_search_maxima' concernente a modelos
     de busca de arquivos.

     O argumento <nomearquivo> pode ser um caminho e nome de arquivo, ou
     apenas um nome de arquivo, ou, se um diretório de busca de arquivo
     inclui um modelo de busca de arquivo, apenas a base do nome de
     arquivo (sem uma extensão).  Por exemplo,

          file_search ("/home/wfs/special/zeta.mac");
          file_search ("zeta.mac");
          file_search ("zeta");

     todos encontram o mesmo arquivo, assumindo que o arquivo exista e
     '/home/wfs/special/###.mac' está em 'file_search_maxima'.

     'file_search (<nomearquivo>, <listacaminho>)' procura somente
     nesses diretórios especificados por <listacaminho>, que é uma lista
     de seqüências de caracteres.  O argumento <listacaminho> substitui
     os diretórios de busca padrão, então se a lista do caminho é dada,
     'file_search' procura somente nesses especificados, e não qualquer
     dos diretórios padrão de busca.  Mesmo se existe somente um
     diretório em <listacaminho>, esse deve ainda ser dado como uma
     lista de um único elemento.

     O usuário pode modificar o diretório de busca padrão.  Veja
     'file_search_maxima'.

     'file_search' é invocado por 'load' com 'file_search_maxima' e
     'file_search_lisp' como diretórios de busca.

 -- Variável de opção: file_search_maxima
 -- Variável de opção: file_search_lisp
 -- Variável de opção: file_search_demo
     Essas variáveis especificam listas de diretórios a serem procurados
     por 'load', 'demo', e algumas outras funções do Maxima.  O valor
     padrão dessas variáveis nomeia vários diretórios na instalaçã
     padrão do Maxima.

     O usuáro pode modificar essas variáveis, quer substituindo os
     valores padrão ou colocando no final diretórios adicionais.  Por
     exemplo,

          file_search_maxima: ["/usr/local/foo/###.mac",
              "/usr/local/bar/###.mac"]$

     substitui o valor padrão de 'file_search_maxima', enquanto

          file_search_maxima: append (file_search_maxima,
              ["/usr/local/foo/###.mac", "/usr/local/bar/###.mac"])$

     adiciona no final da lista dois diretórios adicionais.  Isso pode
     ser conveniente para colocar assim uma expressão no arquivo
     'maxima-init.mac' de forma que o caminho de busca de arquivo é
     atribuído automaticamente quando o Maxima inicia.

     Multiplas extensões de arquivo e e multiplos caminhos podem ser
     especificados por construções "coringa" especiais.  A seqüência de
     caracteres '###' expande a busca para além do nome básico, enquanto
     uma lista separada por vírgulas e entre chaves '{foo,bar,baz}'
     expande em multiplas seqüências de caracteres.  Por exemplo,
     supondo que o nome básico a ser procurado seja 'neumann',

          "/home/{wfs,gcj}/###.{lisp,mac}"

     expande em '/home/wfs/neumann.lisp', '/home/gcj/neumann.lisp',
     '/home/wfs/neumann.mac', e '/home/gcj/neumann.mac'.

 -- Função: file_type (<nomearquivo>)
     Retorna uma suposta informação sobre o conteúdo de <nomearquivo>,
     baseada na extensão do arquivo.  <nomearquivo> não precisa
     referir-se a um arquivo atual; nenhuma tentativa é feita para abrir
     o arquivo e inspecionar seu conteúdo.

     O valor de retorno é um símbolo, qualquer um entre 'object',
     'lisp', ou 'maxima'.  Se a extensão começa com 'm' ou 'd',
     'file_type' retorna 'maxima'.  Se a extensão começa om 'l',
     'file_type' retorna 'lisp'.  Se nenhum dos acima, 'file_type'
     retorna 'object'.

 -- Função: grind (<expr>)
 -- Variável de opção: grind
     A função 'grind' imprime <expr> para o console em uma forma
     adequada de entrada para Maxima.  'grind' sempre retorna 'done'.

     Quando <expr> for um nome de uma função ou o nome de uma macro,
     'grind' mostra na tela a definição da função ou da macro em lugar
     de apenas o nome.

     Veja também 'string', que retorna uma seqüência de caracteres em
     lugar de imprimir sua saída.  'grind' tenta imprimir a expressão de
     uma maneira que a faz levemente mais fácil para ler que a saída de
     'string'.

     Quando a variável 'grind' é 'true', a saída de 'string' e
     'stringout' tem o mesmo formato que 'grind'; de outra forma nenhuma
     tentativa é feita para formatar especialmente a saída dessas
     funções.  O valor padrão da variável 'grind' é 'false'.

     'grind' pode também ser especificado como um argumento de
     'playback'.  Quando 'grind' está presente, 'playback' imprime
     expressões de entrada no mesmo formato que a função 'grind'.  De
     outra forma, nenhuma tentativa é feita para formatar especialmente
     as expressões de entrada.

     'grind' avalia seus argumentos.

     Exemplos:

          (%i1) aa + 1729;
          (%o1)                       aa + 1729
          (%i2) grind (%);
          aa+1729$
          (%o2)                         done
          (%i3) [aa, 1729, aa + 1729];
          (%o3)                 [aa, 1729, aa + 1729]
          (%i4) grind (%);
          [aa,1729,aa+1729]$
          (%o4)                         done
          (%i5) matrix ([aa, 17], [29, bb]);
                                     [ aa  17 ]
          (%o5)                      [        ]
                                     [ 29  bb ]
          (%i6) grind (%);
          matrix([aa,17],[29,bb])$
          (%o6)                         done
          (%i7) set (aa, 17, 29, bb);
          (%o7)                   {17, 29, aa, bb}
          (%i8) grind (%);
          {17,29,aa,bb}$
          (%o8)                         done
          (%i9) exp (aa / (bb + 17)^29);
                                          aa
                                      -----------
                                               29
                                      (bb + 17)
          (%o9)                     %e
          (%i10) grind (%);
          %e^(aa/(bb+17)^29)$
          (%o10)                        done
          (%i11) expr: expand ((aa + bb)^10);
                   10           9        2   8         3   7         4   6
          (%o11) bb   + 10 aa bb  + 45 aa  bb  + 120 aa  bb  + 210 aa  bb
                   5   5         6   4         7   3        8   2
           + 252 aa  bb  + 210 aa  bb  + 120 aa  bb  + 45 aa  bb
                  9        10
           + 10 aa  bb + aa
          (%i12) grind (expr);
          bb^10+10*aa*bb^9+45*aa^2*bb^8+120*aa^3*bb^7+210*aa^4*bb^6
               +252*aa^5*bb^5+210*aa^6*bb^4+120*aa^7*bb^3+45*aa^8*bb^2
               +10*aa^9*bb+aa^10$
          (%o12)                        done
          (%i13) string (expr);
          (%o13) bb^10+10*aa*bb^9+45*aa^2*bb^8+120*aa^3*bb^7+210*aa^4*bb^6\
          +252*aa^5*bb^5+210*aa^6*bb^4+120*aa^7*bb^3+45*aa^8*bb^2+10*aa^9*\
          bb+aa^10
          (%i14) cholesky (A):= block ([n : length (A), L : copymatrix (A),
          p : makelist (0, i, 1, length (A))], for i thru n do for j : i thru n do
          (x : L[i, j], x : x - sum (L[j, k] * L[i, k], k, 1, i - 1), if i = j then
          p[i] : 1 / sqrt(x) else L[j, i] : x * p[i]), for i thru n do L[i, i] : 1 / p[i],
          for i thru n do for j : i + 1 thru n do L[i, j] : 0, L)$
          (%i15) grind (cholesky);
          cholesky(A):=block(
                   [n:length(A),L:copymatrix(A),
                    p:makelist(0,i,1,length(A))],
                   for i thru n do
                       (for j from i thru n do
                            (x:L[i,j],x:x-sum(L[j,k]*L[i,k],k,1,i-1),
                             if i = j then p[i]:1/sqrt(x)
                                 else L[j,i]:x*p[i])),
                   for i thru n do L[i,i]:1/p[i],
                   for i thru n do (for j from i+1 thru n do L[i,j]:0),L)$
          (%o15)                        done
          (%i16) string (fundef (cholesky));
          (%o16) cholesky(A):=block([n:length(A),L:copymatrix(A),p:makelis\
          t(0,i,1,length(A))],for i thru n do (for j from i thru n do (x:L\
          [i,j],x:x-sum(L[j,k]*L[i,k],k,1,i-1),if i = j then p[i]:1/sqrt(x\
          ) else L[j,i]:x*p[i])),for i thru n do L[i,i]:1/p[i],for i thru \
          n do (for j from i+1 thru n do L[i,j]:0),L)

 -- Variável de opção: ibase
     Valor padrão: 10

     Inteiros fornecidos dentro do Maxima são interpretados com respeito
     à base 'ibase'.

     A 'ibase' pode ser atribuído qualquer inteiro entre 2 e 35
     (decimal), inclusive.  Quando 'ibase' é maior que 10, os numerais
     compreendem aos numerais decimais de 0 até 9 mais as letras
     maiúsculas do alfabeto A, B, C, ..., como necessário.  Os numerais
     para a base 35, a maior base aceitável, compreendem de 0 até 9 e de
     A até Y.

     Veja também 'obase'.

 -- Variável de opção: inchar
     Valor padrão: '%i'

     'inchar' é o prefixo dos rótulos de expressões fornecidas pelo
     usuário.  Maxima automaticamente constrói um rótulo para cada
     expressão de entrada por concatenação de 'inchar' e 'linenum'.  A
     'inchar' pode ser atribuído qualquer seqüência de caracteres ou
     símbolo, não necessariamente um caracter simples.

          (%i1) inchar: "input";
          (%o1)                                input
          (input1) expand ((a+b)^3);
                                      3        2      2      3
          (%o1)                      b  + 3 a b  + 3 a  b + a
          (input2)

     Veja também 'labels'.

 -- Função: ldisp (<expr_1>, ..., <expr_n>)
     Mostra expressões <expr_1>, ..., <expr_n> para o console como saída
     impressa na tela.  'ldisp' atribue um rótulo de expressão
     intermediária a cada argumento e retorna a lista de rótulos.

     Veja também 'disp'.

          (%i1) e: (a+b)^3;
                                             3
          (%o1)                       (b + a)
          (%i2) f: expand (e);
                               3        2      2      3
          (%o2)               b  + 3 a b  + 3 a  b + a
          (%i3) ldisp (e, f);
                                             3
          (%t3)                       (b + a)

                               3        2      2      3
          (%t4)               b  + 3 a b  + 3 a  b + a

          (%o4)                      [%t3, %t4]
          (%i4) %t3;
                                             3
          (%o4)                       (b + a)
          (%i5) %t4;
                               3        2      2      3
          (%o5)               b  + 3 a b  + 3 a  b + a

 -- Função: ldisplay (<expr_1>, ..., <expr_n>)
     Mostra expressões <expr_1>, ..., <expr_n> para o console como saída
     impressa na tela.  Cada expressão é impressa como uma equação da
     forma 'lhs = rhs' na qual 'lhs' é um dos argumentos de 'ldisplay' e
     'rhs' é seu valor.  Tipicamente cada argumento é uma variável.
     'ldisp' atribui um rótulo de expressão intermediáia a cada equação
     e retorna a lista de rótulos.

     Veja também 'display'.

          (%i1) e: (a+b)^3;
                                             3
          (%o1)                       (b + a)
          (%i2) f: expand (e);
                               3        2      2      3
          (%o2)               b  + 3 a b  + 3 a  b + a
          (%i3) ldisplay (e, f);
                                               3
          (%t3)                     e = (b + a)

                                 3        2      2      3
          (%t4)             f = b  + 3 a b  + 3 a  b + a

          (%o4)                      [%t3, %t4]
          (%i4) %t3;
                                               3
          (%o4)                     e = (b + a)
          (%i5) %t4;
                                 3        2      2      3
          (%o5)             f = b  + 3 a b  + 3 a  b + a

 -- Variável de opção: linechar
     Valor padrão: '%t'

     'linechar' é o refixo de rótulos de expressões intermediárias
     gerados pelo Maxima.  Maxima constrói um rótulo para cada expressão
     intermediária (se for mostrada) pela concatenação de 'linechar' e
     'linenum'.  A 'linechar' pode ser atribuído qualquer seqüência de
     caracteres ou símbolo, não necessáriamente um caractere simples.

     Expressões intermediárias podem ou não serem mostradas.  See
     'programmode' e 'labels'.

 -- Variável de opção: linel
     Valor padrão: 79

     'linel' é a largura assumida (em caracteres) do console para o
     propósito de mostrar expressões.  A 'linel' pode ser atribuído
     qualquer valor pelo usuário, embora valores muio pequenos ou muito
     grandes possam ser impraticáveis.  Textos impressos por funções
     internas do Maxima, tais como mensagens de erro e a saída de
     'describe', não são afetadas por 'linel'.

 -- Variável de opção: lispdisp
     Valor padrão: 'false'

     Quando 'lispdisp' for 'true', símbolos Lisp são mostrados com um
     ponto de interrogação '?' na frente.  De outra forma, símbolos Lisp
     serão mostrados sem o ponto de interrogaçõ na frente.

     Exemplos:

          (%i1) lispdisp: false$
          (%i2) ?foo + ?bar;
          (%o2)                       foo + bar
          (%i3) lispdisp: true$
          (%i4) ?foo + ?bar;
          (%o4)                      ?foo + ?bar

 -- Função: load (<nomearquivo>)
     Avalia expressões em <nomearquivo>, dessa forma conduzindo
     variáveis, funções, e outros objetos dentro do Maxima.  A
     associação de qualquer objeto existente é substituída pela
     associação recuperada de <nomearquivo>.  Para achar o arquivo,
     'load' chama 'file_search' com 'file_search_maxima' e
     'file_search_lisp' como diretórios de busca.  Se 'load' obtém
     sucesso, isso retorna o nome do arquivo.  De outra forma 'load'
     imprime uma mensagem e erro.

     'load' trabalha igualmente bem para códigos Lisp e códigos Maxima.
     Arquivos criados por 'save', 'translate_file', e 'compile_file',
     que criam códigos Lisp, e 'stringout', que criam códigos Maxima,
     podem ser processadas por 'load'.  'load' chama 'loadfile' para
     carregar arquivos Lisp e 'batchload' para carregar arquivos Maxima.

     'load' não reconhece construções ':lisp' em arquivos do Maxima, e
     quando processando <nomearquivo>, as variáveis globais '_', '__',
     '%', e '%th' possuem as mesmas associações que possuiam quando
     'load' foi chamada.

     Veja também 'loadfile', 'batch', 'batchload', e 'demo'.  'loadfile'
     processa arquivos Lisp; 'batch', 'batchload', e 'demo' processam
     arquivos Maxima.

     Veja 'file_search' para mais detalhes sobre o mecanismo de busca de
     arquivos.

     'load' avalia seu argumento.

 -- Função: loadfile (<nomearquivo>)
     Avalia expressões Lisp em <nomearquivo>.  'loadfile' não invoca
     'file_search', então 'nomearquivo' deve obrigatóriamente incluir a
     extensão do arquivo e tanto quanto o caminho como necessário para
     achar o arquivo.

     'loadfile' pode processar arquivos criados por 'save',
     'translate_file', e 'compile_file'.  O usuário pode achar isso mais
     conveniente para usar 'load' em lugar de 'loadfile'.

 -- Variável de opção: loadprint
     Valor padrão: 'true'

     'loadprint' diz se deve imprimir uma mensagem quando um arquivo é
     chamado.

        * Quando 'loadprint' é 'true', sempre imprime uma mensagem.
        * Quando 'loadprint' é ''loadfile', imprime uma mensagem somente
          se um arquivo é chamado pela função 'loadfile'.
        * Quando 'loadprint' é ''autoload', imprime uma mensagem somente
          se um arquivo é automaticamente carregado.  Veja
          'setup_autoload'.
        * Quando 'loadprint' é 'false', nunca imprime uma mensagem.

 -- Variável de opção: obase
     Valor padrão: 10

     'obase' é a base para inteiros mostrados pelo Maxima.

     A 'obase' poode ser atribuído qualquer inteiro entre 2 e 35
     (decimal), inclusive.  Quando 'obase' é maior que 10, os numerais
     compreendem os numerais decimais de 0 até 9 e letras maiúsulas do
     alfabeto A, B, C, ..., quando necessário.  Os numerais para a base
     35, a maior base aceitável, compreendem de 0 até 9, e de A até Y.

     Veja também 'ibase'.

 -- Variável de opção: outchar
     Valor padrão: '%o'

     'outchar' é o prefixo dos rótulos de expressões calculadas pelo
     Maxima.  Maxima automaticamente constrói um rótulo para cada
     expressão calculada pela concatenação de 'outchar' e 'linenum'.  A
     'outchar' pode ser atribuído qualquer seqüência de caracteres ou
     símbolo, não necessáriamente um caractere simples.

          (%i1) outchar: "output";
          (output1)                           output
          (%i2) expand ((a+b)^3);
                                      3        2      2      3
          (output2)                  b  + 3 a b  + 3 a  b + a
          (%i3)

     Veja também 'labels'.

 -- Variável de opção: packagefile
     Valor padrão: 'false'

     Projetistas de pacotes que usam 'save' ou 'translate' para criar
     pacotes (arquivos) para outros usarem podem querer escolher
     'packagefile: true' para prevenir qu informações sejam
     acrescentadas à lista de informações do Maxima (e.g.  'values',
     'funções') exceto onde necessário quando o arquivo é carregado.
     Nesse caminho, o conteúdo do pacote não pegará no caminho do
     usuário quando ele adicionar seus próprios dados.  Note que isso
     não resolve o problema de possíveis conflitos de nome.  Também note
     que o sinalizador simplesmente afeta o que é saída para o arquivo
     pacote.  Escolhendo o sinalizador para 'true' é também útil para
     criar arquivos de init do Maxima.

 -- Variável de opção: pfeformat
     Valor padrão: 'false'

     Quando 'pfeformat' é 'true', uma razão de inteiros é mostrada com o
     caractere sólido (barra normal), e um denominador inteiro 'n' é
     mostrado como um termo multiplicativo em primeiro lugar '1/n'.

          (%i1) pfeformat: false$
          (%i2) 2^16/7^3;
                                        65536
          (%o2)                         -----
                                         343
          (%i3) (a+b)/8;
                                        b + a
          (%o3)                         -----
                                          8
          (%i4) pfeformat: true$
          (%i5) 2^16/7^3;
          (%o5)                       65536/343
          (%i6) (a+b)/8;
          (%o6)                      1/8 (b + a)

 -- Função: print (<expr_1>, ..., <expr_n>)
     Avalia e mostra <expr_1>, ..., <expr_n> uma após a outra, da
     esquerda para a direita, iniciando no lado esquerdo do console.

     O valor retornado por 'print' é o valor de seu último argumento.
     'print' não gera rótulos de expressão intermediária.

     Veja também 'display', 'disp', 'ldisplay', e 'ldisp'.  Essas
     funções mostram uma expressão por linha, enquanto 'print' tenta
     mostrar duas ou mais expressões por linha.

     Para mostrar o conteúdo de um arquivo, veja 'printfile'.

          (%i1) r: print ("(a+b)^3 is", expand ((a+b)^3), "log (a^10/b) is", radcan (log (a^10/b)))$
                      3        2      2      3
          (a+b)^3 is b  + 3 a b  + 3 a  b + a  log (a^10/b) is

                                                        10 log(a) - log(b)
          (%i2) r;
          (%o2)                  10 log(a) - log(b)
          (%i3) disp ("(a+b)^3 is", expand ((a+b)^3), "log (a^10/b) is", radcan (log (a^10/b)))$
                                     (a+b)^3 is

                               3        2      2      3
                              b  + 3 a b  + 3 a  b + a

                                   log (a^10/b) is

                                 10 log(a) - log(b)

 -- Função: tcl_output (<list>, <i0>, <skip>)
 -- Função: tcl_output (<list>, <i0>)
 -- Função: tcl_output ([<list_1>, ..., <list_n>], <i>)

     Imprime os elementos de uma lista entre chaves '{ }', conveniente
     como parte de um programa na linguagem Tcl/Tk.

     'tcl_output (<list>, <i0>, <skip>)' imprime <list>, começando com o
     elemento <i0> e imprimindo elementos '<i0> + <skip>', '<i0> + 2
     <skip>', etc.

     'tcl_output (<list>, <i0>)' é equivalente a 'tcl_output (<list>,
     <i0>, 2)'.

     'tcl_output ([<list_1>, ..., <list_n>], <i>)' imprime os <i>'ésimos
     elementos de <list_1>, ..., <list_n>.

     Exemplos:

          (%i1) tcl_output ([1, 2, 3, 4, 5, 6], 1, 3)$

           {1.000000000     4.000000000
           }
          (%i2) tcl_output ([1, 2, 3, 4, 5, 6], 2, 3)$

           {2.000000000     5.000000000
           }
          (%i3) tcl_output ([3/7, 5/9, 11/13, 13/17], 1)$

           {((RAT SIMP) 3 7) ((RAT SIMP) 11 13)
           }
          (%i4) tcl_output ([x1, y1, x2, y2, x3, y3], 2)$

           {$Y1 $Y2 $Y3
           }
          (%i5) tcl_output ([[1, 2, 3], [11, 22, 33]], 1)$

           {SIMP 1.000000000     11.00000000
           }

 -- Função: read (<expr_1>, ..., <expr_n>)
     Imprime <expr_1>, ..., <expr_n>, então lê uma expressão do console
     e retorna a expressão avaliada.  A expressão é terminada com um
     ponto e vírgula ';' ou o sinal de dólar '$'.

     Veja também 'readonly'.

          (%i1) foo: 42$
          (%i2) foo: read ("foo is", foo, " -- enter new value.")$
          foo is 42  -- enter new value.
          (a+b)^3;
          (%i3) foo;
                                               3
          (%o3)                         (b + a)

 -- Função: readonly (<expr_1>, ..., <expr_n>)
     Imprime <expr_1>, ..., <expr_n>, então lê uma expressão do console
     e retorna a expressão (sem avaliação).  A expressão é terminada com
     um ';' (ponto e vírgula) ou '$' (sinal de dólar).

          (%i1) aa: 7$
          (%i2) foo: readonly ("Forneça uma expressão:");
          Enter an expressão:
          2^aa;
                                            aa
          (%o2)                            2
          (%i3) foo: read ("Forneça uma expressão:");
          Enter an expressão:
          2^aa;
          (%o3)                            128

     Veja também 'read'.

 -- Função: reveal (<expr>, <depth>)
     Substitue partes de <expr> no inteiro especificado <depth> com
     sumário descritivo.

        * Somas e diferenças são substituídas por 'sum(<n>)' onde <n> é
          o número de operandos do produto.
        * Produtos são substituídos por 'product(<n>)' onde <n> é o
          número de operandos da multiplicação.
        * Exponenciais são substituídos por 'expt'.
        * Quocientes são substituídos por 'quotient'.
        * Negação unária é substituída por 'negterm'.

     Quando <depth> é maior que ou igual à máxima intensidade de <expr>,
     'reveal (<expr>, <depth>)' retornam <expr> sem modificações.

     'reveal' avalia seus argumentos.  'reveal' retorna expressão
     sumarizada.

     Exemplo:

          (%i1) e: expand ((a - b)^2)/expand ((exp(a) + exp(b))^2);
                                    2            2
                                   b  - 2 a b + a
          (%o1)               -------------------------
                                  b + a     2 b     2 a
                              2 %e      + %e    + %e
          (%i2) reveal (e, 1);
          (%o2)                       quotient
          (%i3) reveal (e, 2);
                                       sum(3)
          (%o3)                        ------
                                       sum(3)
          (%i4) reveal (e, 3);
                               expt + negterm + expt
          (%o4)               ------------------------
                              product(2) + expt + expt
          (%i5) reveal (e, 4);
                                 2                 2
                                b  - product(3) + a
          (%o5)         ------------------------------------
                                   product(2)     product(2)
                        2 expt + %e           + %e
          (%i6) reveal (e, 5);
                                   2            2
                                  b  - 2 a b + a
          (%o6)              --------------------------
                                 sum(2)     2 b     2 a
                             2 %e       + %e    + %e
          (%i7) reveal (e, 6);
                                    2            2
                                   b  - 2 a b + a
          (%o7)               -------------------------
                                  b + a     2 b     2 a
                              2 %e      + %e    + %e

 -- Variável de opção: rmxchar
     Valor padrão: ']'

     'rmxchar' é the caractere desenhado lado direito de uma matriz.

     Veja também 'lmxchar'.

 -- Função: save (<nomearquivo>, <nome_1>, <nome_2>, <nome_3>, ...)
 -- Função: save (<nomearquivo>, values, functions, labels, ...)
 -- Função: save (<nomearquivo>, [<m>, <n>])
 -- Função: save (<nomearquivo>, <nome_1>=<expr_1>, ...)
 -- Função: save (<nomearquivo>, all)
 -- Função: save (<nomearquivo>, <nome_1>=<expr_1>, <nome_2>=<expr_2>,
          ...)

     Armazena os valores correntes de <nome_1>, <nome_2>, <nome_3>, ...,
     em <nomearquivo>.  Os argumentos são os nomes das variáveis,
     funções, ou outros objetos.  Se um nome não possui valore ou função
     associada a ele, esse nome sem nenhum valor ou função associado
     será ignorado.  'save' retorna <nomearquivo>.

     'save' armazena dados na forma de expressões Lisp.  Os dados
     armazenados por 'save' podem ser recuperados por 'load
     (<nomearquivo>)'.

     O sinalizador global 'file_output_append' governa se 'save' anexa
     ao final ou trunca o arquivo de saída.  Quando 'file_output_append'
     for 'true', 'save' anexa ao final doarquivo de saída.  De outra
     forma, 'save' trunca o arquivo de saída.  Nesse caso, 'save' cria o
     arquivo se ele não existir ainda.

     A forma especial 'save (<nomearquivo>, values, functions, labels,
     ...)' armazena os ítens nomeados por 'values', 'funções', 'labels',
     etc.  Os nomes podem ser quaisquer especificados pela variável
     'infolists'.  'values' compreende todas as variáveis definidas pelo
     usuário.

     A forma especial 'save (<nomearquivo>, [<m>, <n>])' armazena os
     valores de rótulos de entrada e saída de <m> até <n>.  Note que <m>
     e <n> devem obrigatóriamente ser inteiros literais.  Rótulos de
     entrada e saída podem também ser armazenados um a um, e.g., 'save
     ("foo.1", %i42, %o42)'.  'save (<nomearquivo>, labels)' armazena
     todos os rótulos de entrada e saída.  Quando rótulos armazenados
     são recuperados, eles substituem rótulos existentes.

     A forma especial 'save (<nomearquivo>, <nome_1>=<expr_1>,
     <nome_2>=<expr_2>, ...)' armazena os valores de <expr_1>, <expr_2>,
     ..., com nomes <nome_1>, <nome_2>, ....  Isso é útil para aplicar
     essa forma para rótulos de entrada e saída, e.g., 'save ("foo.1",
     aa=%o88)'.  O lado direito dessa igualdade nessa forma pode ser
     qualquer expressão, que é avaliada.  Essa forma não introduz os
     novos nomes no ambiente corrente do Maxima, mas somente armazena-os
     em <nomearquivo>.

     Essa forma especial e a forma geral de 'save' podem ser misturados.
     Por exemplo, 'save (<nomearquivo>, aa, bb, cc=42, funções, [11,
     17])'.

     A forma especial 'save (<nomearquivo>, all)' armazena o estado
     corrente do Maxima.  Isso inclui todas as variáveis definidas pelo
     usuário, funções, arrays, etc., bem como alguns ítens definidos
     automaticamente.  Os ítes salvos incluem variáveis de sistema, tais
     como 'file_search_maxima' ou 'showtime', se a elas tiverem sido
     atribuídos novos valores pelo usuário; veja 'myoptions'.

     'save' avalia <nomearquivo> e não avalia todos os outros
     argumentos.

 -- Variável de opção: savedef
     Valor padrão: 'true'

     Quando 'savedef' é 'true', a vesão Maxima de uma função de usuário
     é preservada quando a função é traduzida.  Isso permite que a
     definição seja mostrada por 'dispfun' e autoriza a função a ser
     editada.

     Quando 'savedef' é 'false', os nomes de funções traduzidas são
     removidos da lista de 'funções'.

 -- Função: show (<expr>)
     Mostra 'expr' com os objetos indexados tendo índices covariantes
     como subscritos, índices contravariantes como sobrescritos.  Os
     índices derivativos são mostrados como subscritos, separados dos
     índices covariantes por uma vírgula.

 -- Função: showratvars (<expr>)
     Retorna uma lista de variáveis expressão racional canônica (CRE) na
     expressão 'expr'.

     Veja também 'ratvars'.

 -- Variável de opção: stardisp
     Valor padrão: 'false'

     Quando 'stardisp' é 'true', multiplicação é mostrada com um
     asterisco '*' entre os operandos.

 -- Função: string (<expr>)
     Converte 'expr' para a notação linear do Maxima apenas como se
     tivesse sido digitada.

     O valor de retorno de 'string' é uma seqüência de caracteres, e
     dessa forma não pode ser usada em um cálculo.

 -- Variãvel de opção: stringdisp
     Valor padrão: 'false'

     Quando 'stringdisp' for 'true', seqüências de caracteres serão
     mostradas contidas em aspas duplas.  De outra forma, aspas não são
     mostradas.

     'stringdisp' é sempre 'true' quando mostrando na tela uma definição
     de função.

     Exemplos:

          (%i1) stringdisp: false$
          (%i2) "This is an example string.";
          (%o2)              This is an example string.
          (%i3) foo () := print ("This is a string in a function definition.");
          (%o3) foo() :=
                        print("This is a string in a function definition.")
          (%i4) stringdisp: true$
          (%i5) "This is an example string.";
          (%o5)             "This is an example string."

 -- Função: stringout (<nomearquivo>, <expr_1>, <expr_2>, <expr_3>, ...)
 -- Função: stringout (<nomearquivo>, [<m>, <n>])
 -- Função: stringout (<nomearquivo>, input)
 -- Função: stringout (<nomearquivo>, functions)
 -- Função: stringout (<nomearquivo>, values)

     'stringout' escreve expressões para um arquivo na mesma forma de
     expressões que foram digitadas para entrada.  O arquivo pode então
     ser usado como entrada para comandos 'batch' ou 'demo', e isso pode
     ser editado para qualquer propósito.  'stringout' pode ser
     executado enquanto 'writefile' está em progresso.

     O sinalizador global 'file_output_append' governa se 'stringout'
     anexa ao final ou trunca o arquivo de saída.  Quando
     'file_output_append' for 'true', 'stringout' anexa ao final do
     arquivo de sad'a.  De outra forma, 'stringout' trunca o arquivo de
     saída.  Nesse caso, 'stringout' cria o arquivo de saída se ele não
     existir ainda.

     A forma geral de 'stringout' escreve os valores de um ou mais
     expressões para o arquivo de saída.  Note que se uma expressão é
     uma variável, somente o valor da variável é escrito e não o nome da
     variável.  Como um útil caso especial, as expressões podem ser
     rótulos de entrada ('%i1', '%i2', '%i3', ...)  ou rótulos de saída
     ('%o1', '%o2', '%o3', ...).

     Se 'grind' é 'true', 'stringout' formata a saída usando o formato
     'grind'.  De outra forma o formato 'string' é usado.  Veja 'grind'
     e 'string'.

     A forma especial 'stringout (<nomearquivo>, [<m>, <n>])' escreve os
     valores dos rótulos de entrada de m até n, inclusive.

     A forma especial 'stringout (<nomearquivo>, input)' escreve todos
     os rótulos de entrada para o arquivo.

     A forma especial 'stringout (<nomearquivo>, functions)' escreve
     todas as funções definidas pelo usuário (nomeadas pela lista global
     'functions') para o arquivo.

     A forma especial 'stringout (<nomearquivo>, values)' escreve todas
     as variáveis atribuídas pelo usuário (nomeadas pela lista global
     'values') para o arquivo.  Cada variável é impressa como uma
     declaração de atribuição, com o nome da variável seguida de dois
     pontos, e seu valor.  Note que a forma geral de 'stringout' não
     imprime variáveis como declarações de atribuição.

 -- Função: tex (<expr>)
 -- Função: tex (<rótulo>)
 -- Função: tex (<expr>, <momearquivo>)
 -- Função: tex (<label>, <nomearquivo>)

     Imprime uma representação de uma expressão adequada para o sistema
     TeX de preparação de documento.  O resultado é um fragmento de um
     documento, que pode ser copiado dentro de um documento maior Esse
     fragmento não pode ser processado de forma direta e isolada.

     'tex (<expr>)' imprime uma representação TeX da <expr> no console.

     'tex (<rótulo>)' imprime uma representação TeX de uma expressão
     chamada <rótulo> e atribui a essa um rótulo de equação (a ser
     mostrado à esquerda da expressão).  O rótulo de equação TeX é o
     mesmo que o rótulo da equação no Maxima.

     'tex (<expr>, <nomearquivo>)' anexa ao final uma representação TeX
     de <expr> no arquivo <nomearquivo>.

     'tex (<rótulo>, <nomearquivo>)' anexa ao final uma representação
     TeX da expressão chamada de <rótulo>, com um rótulo de equação, ao
     arquivo <nomearquivo>.

     'tex' avalia seu primeiro argumento após testar esse argumento para
     ver se é um rótulo.  duplo apóstrofo '''' força a avaliação do
     argumento, desse modo frustrando o teste e prevenindo o rótulo.

     Veja também 'texput'.

     Exemplos:

          (%i1) integrate (1/(1+x^3), x);
                                              2 x - 1
                            2            atan(-------)
                       log(x  - x + 1)        sqrt(3)    log(x + 1)
          (%o1)      - --------------- + ------------- + ----------
                              6             sqrt(3)          3
          (%i2) tex (%o1);
          $$-{{\log \left(x^2-x+1\right)}\over{6}}+{{\arctan \left({{2\,x-1
           }\over{\sqrt{3}}}\right)}\over{\sqrt{3}}}+{{\log \left(x+1\right)
           }\over{3}}\leqno{\tt (\%o1)}$$
          (%o2)                          (\%o1)
          (%i3) tex (integrate (sin(x), x));
          $$-\cos x$$
          (%o3)                           false
          (%i4) tex (%o1, "foo.tex");
          (%o4)                          (\%o1)

 -- Função: texput (<a>, <s>)
 -- Função: texput (<a>, <s>, <operator_type>)
 -- Função: texput (<a>, [<s_1>, <s_2>], matchfix)
 -- Função: texput (<a>, [<s_1>, <s_2>, <s_3>], matchfix)

     Atribui a saída TeX para o átomo <a>, que pode ser um símbolo ou o
     nome de um operador.

     'texput (<a>, <s>)' faz com que a função 'tex' interpole a
     seqüência de caracteres <s> dentro da saída TeX em lugar de <a>.

     'texput (<a>, <s>, <operator_type>)', onde <operator_type> é
     'prefix', 'infix', 'postfix', 'nary', ou 'nofix', faz com que a
     função 'tex' interpole <s> dentro da saída TeX em lugar de <a>, e
     coloca o texto interpolado na posição apropriada.

     'texput (<a>, [<s_1>, <s_2>], matchfix)' faz com que a função 'tex'
     interpole <s_1> e <s_2> dentro da saída TeX sobre qualquer lado dos
     argumentos de <a>.  Os argumentos (se mais de um) são separados por
     vírgulas.

     'texput (<a>, [<s_1>, <s_2>, <s_3>], matchfix)' faz com que a
     função 'tex' interpole <s_1> e <s_2> dentro da saída TeX sobre
     qualquer lado dos argumentos de <a>, com <s_3> separando os
     argumentos.

     Exemplos:

     Atribui saída TeX a uma variável.

          (%i1) texput (me,"\\mu_e");
          (%o1)                         \mu_e
          (%i2) tex (me);
          $$\mu_e$$
          (%o2)                         false

     Atribui saída TeX a uma função comum (não a um operador).

          (%i1) texput (lcm, "\\mathrm{lcm}");
          (%o1)                     \mathrm{lcm}
          (%i2) tex (lcm (a, b));
          $$\mathrm{lcm}\left(a , b\right)$$
          (%o2)                         false

     Atribui saída TeX a um operador prefixado.

          (%i1) prefix ("grad");
          (%o1)                         grad
          (%i2) texput ("grad", " \\nabla ", prefix);
          (%o2)                        \nabla
          (%i3) tex (grad f);
          $$ \nabla f$$
          (%o3)                         false

     Atribui saída TeX a um operador infixado.

          (%i1) infix ("~");
          (%o1)                           ~
          (%i2) texput ("~", " \\times ", infix);
          (%o2)                        \times
          (%i3) tex (a ~ b);
          $$a \times b$$
          (%o3)                         false

     Atribui saída TeX a um operadro pósfixado.

          (%i1) postfix ("##");
          (%o1)                          ##
          (%i2) texput ("##", "!!", postfix);
          (%o2)                          !!
          (%i3) tex (x ##);
          $$x!!$$
          (%o3)                         false

     Atribui saída TeX a um operador n-ário.

          (%i1) nary ("@@");
          (%o1)                          @@
          (%i2) texput ("@@", " \\circ ", nary);
          (%o2)                         \circ
          (%i3) tex (a @@ b @@ c @@ d);
          $$a \circ b \circ c \circ d$$
          (%o3)                         false

     Atribui saída TeX a um operador nofix.

          (%i1) nofix ("foo");
          (%o1)                          foo
          (%i2) texput ("foo", "\\mathsc{foo}", nofix);
          (%o2)                     \mathsc{foo}
          (%i3) tex (foo);
          $$\mathsc{foo}$$
          (%o3)                         false

     Atribui saída TeX a um operadro matchfix.

          (%i1) matchfix ("<<", ">>");
          (%o1)                          <<
          (%i2) texput ("<<", [" \\langle ", " \\rangle "], matchfix);
          (%o2)                [ \langle ,  \rangle ]
          (%i3) tex (<<a>>);
          $$ \langle a \rangle $$
          (%o3)                         false
          (%i4) tex (<<a, b>>);
          $$ \langle a , b \rangle $$
          (%o4)                         false
          (%i5) texput ("<<", [" \\langle ", " \\rangle ", " \\, | \\,"], matchfix);
          (%o5)           [ \langle ,  \rangle ,  \, | \,]
          (%i6) tex (<<a>>);
          $$ \langle a \rangle $$
          (%o6)                         false
          (%i7) tex (<<a, b>>);
          $$ \langle a \, | \,b \rangle $$
          (%o7)                         false

 -- Função: system (<comando>)
     Executa <comando> como um processo separado.  O comando é passado
     ao shell padraõ para execução.  'system' não é suportado por todos
     os sistemas operacionais, mas geralmente existe em ambientes Unix e
     Unix-like.

     Supondo que '_hist.out' é uma lista de freqüência que você deseja
     imprimir como um gráfico em barras usando 'xgraph'.

          (%i1) (with_stdout("_hist.out",
                     for i:1 thru length(hist) do (
                       print(i,hist[i]))),
                 system("xgraph -bar -brw .7 -nl < _hist.out"));

     Com o objetivo de fazer com que a impressão do gráfico seja
     concluída em segundo plano (retornando o controle para o Maxima) e
     remover o arquivo temporário após isso ter sido concluído faça:

          system("(xgraph -bar -brw .7 -nl < _hist.out;  rm -f _hist.out)&")

 -- Variável de opção: ttyoff
     Valor padrão: 'false'

     Quando 'ttyoff' é 'true', expressões de saída não são mostradas.
     Expressões de saída são ainda calculadas e atribuídas rótulos.
     Veja 'labels'.

     Textos impresso por funções internas do Maxima, tais como mensagens
     de erro e a saída de 'describe', não são afetadas por 'ttyoff'.

 -- Função: with_stdout (<nomearquivo>, <expr_1>, <expr_2>, <expr_3>,
          ...)
     Abre <nomearquivo> e então avalia <expr_1>, <expr_2>, <expr_3>,
     ....  Os valores dos argumentos não são armazenados em
     <nomearquivo>, mas qualquer saída impressa gerada pela avaliação
     dos argumentos (de 'print', 'display', 'disp', ou 'grind', por
     exemplo) vai para <nomearquivo> em lugar do console.

     O sinalizador global 'file_output_append' governa se 'with_stdout'
     anexa ao final ou trunca o arquivo de saída.  Quando
     'file_output_append' for 'true', 'with_stdout' anexa ao final do
     arquivo de saída.  De outra forma, 'with_stdout' trunca o arquivo
     de saída.  Nesse caso, 'with_stdout' cria o arquivo se ele não
     existir ainda.

     'with_stdout' retorna o valor do seu argumento final.

     Veja também 'writefile'.

          (%i1) with_stdout ("tmp.out", for i:5 thru 10 do print (i, "! yields", i!))$
          (%i2) printfile ("tmp.out")$
          5 ! yields 120
          6 ! yields 720
          7 ! yields 5040
          8 ! yields 40320
          9 ! yields 362880
          10 ! yields 3628800

 -- Função: writefile (<nomearquivo>)
     Começa escrevendo uma transcrição da sessão Maxima para
     <nomearquivo>.  Toda interação entre o usuário e Maxima é então
     gravada nesse arquivo, da mesma forma que aparece no console.

     Como a transcrição é impressa no formato de saída do console, isso
     não pode ser reaproveitado pelo Maxima.  Para fazer um arquivo
     contendo expressões que podem ser reaproveitadas, veja 'save' e
     'stringout'.  'save' armazena expressões no formato Lisp, enquanto
     'stringout' armazena expressões no formato Maxima.

     O efeito de executar 'writefile' quando <nomearquivo> ainda existe
     depende da implementação Lisp subjacente; o arquivo transcrito pode
     ser substituído, ou o arquivo pode receber um anexo.  'appendfile'
     sempre anexa para o arquivo transcrito.

     Isso pode ser conveniente para executar 'playback' após 'writefile'
     para salvar a visualização de interações prévias.  Como 'playback'
     mostra somente as variáveis de entrada e saída ('%i1', '%o1',
     etc.), qualquer saída gerada por uma declaração de impressão em uma
     função (como oposição a um valor de retorno) não é mostrada por
     'playback'.

     'closefile' fecha o arquivo transcrito aberto por 'writefile' ou
     'appendfile'.


File: maxima.info,  Node: Ponto Flutuante,  Next: Contextos,  Prev: Entrada e Saída,  Up: Top

10 Ponto Flutuante
******************

* Menu:

* Funções e Variáveis Definidas para ponto Flutuante::


File: maxima.info,  Node: Funções e Variáveis Definidas para ponto Flutuante,  Prev: Ponto Flutuante,  Up: Ponto Flutuante

10.1 Funções e Variáveis Definidas para ponto Flutuante
=======================================================

 -- Função: bffac (<expr>, <n>)
     Versão para grandes números em ponto flutuante da função
     'factorial' (usa o artifício gamma).  O segundo argumento informa
     quantos dígitos reter e retornar, isso é uma boa idéia para
     requisitar precisão adicional.

     'load ("bffac")' chama essa função.

 -- Variável de Opção: algepsilon
     Valor padrão: 10^8

     'algepsilon' é usada por 'algsys'.

 -- Função: bfloat (<expr>)
     Converte todos os números e funções de números em <expr> para
     grandes números em ponto flutuante (bigfloat).  O número de
     algarismos significativos no grande número em ponto flutuante
     resultante é especificado através da variável global 'fpprec'.

     Quando 'float2bf' for 'false' uma mensagem de alerta é mostrada
     quando uma número em ponto flutuante (float) é convertido em um
     grande número em ponto flutuante (bigfloat - uma vez que isso pode
     resultar em perda de precisão).

 -- Função: bfloatp (<expr>)
     Retorna 'true' se a avaliação da <expr> resultar em um grande
     número em ponto flutuante, de outra forma retorna 'false'.

 -- Função: bfpsi (<n>, <z>, <fpprec>)
 -- Função: bfpsi0 (<z>, <fpprec>)
     'bfpsi' é a função 'polygamma' de argumentos reais <z> e ordem de
     inteiro <n>.  'bfpsi0' é a função 'digamma'.  'bfpsi0 (<z>,
     <fpprec>)' é equivalente a 'bfpsi (0, <z>, <fpprec>)'.

     Essas funções retornam valores em grandes números em ponto
     flutuante.  <fpprec> é a precisão do valor de retorno dos grandes
     números em ponto flutuante.

     'load ("bffac")' chama essas funções.

 -- Variável de Opção: bftorat
     Valor padrão: 'false'

     'bftorat' controla a conversão de 'bfloats' para números racionais.
     Quando 'bftorat' for 'false', 'ratepsilon' será usada para
     controlar a conversão (isso resulta em números racionais
     relativametne pequenos).  Quando 'bftorat' for 'true', o número
     racional gerado irá representar precisamente o 'bfloat'.

 -- Variável de Opção: bftrunc
     Valor padrão: 'true'

     'bftrunc' faz com que tilhas de zeros em grandes números em ponto
     flutuante diferentes de zero sejam ocultadas.  Desse modo, se
     'bftrunc' for 'false', 'bfloat (1)' será mostrado como
     '1.000000000000000B0'.  De outra forma, será mostrado como '1.0B0'.

 -- Função: cbffac (<z>, <fpprec>)
     Fatorial complexo de grandes números em ponto flutuante.

     'load ("bffac")' chama essa função.

 -- Função: float (<expr>)
     Converte inteiros, números racionais e grandes números em ponto
     flutuante em <expr> para números em ponto flutuante.  Da mesma
     forma um 'evflag', 'float' faz com que números racionais
     não-inteiros e grandes números em ponto flutuante sejam convertidos
     para ponto flutuante.

 -- Variável de Opção: float2bf
     Valor padrão: 'false'

     Quando 'float2bf' for 'false', uma mensagem de alerta é mostrada
     quando um número em ponto flutuante é convertido em um grande
     número em ponto flutuante (uma vez que isso pode resultar em perda
     de precisão).

 -- Função: floatnump (<expr>)
     Retorna 'true' se <expr> for um número em ponto flutuante, de outra
     forma retorna 'false'.

 -- Variável de Opção: fpprec
     Valor padrão: 16

     'fpprec' é o número de algarismos significativos para aritmética
     sobre grandes números em ponto flutuante 'fpprec' não afeta
     cálculos sobre números em ponto flutuante comuns.

     Veja também 'bfloat' e 'fpprintprec'.

 -- Variável de Opção: fpprintprec
     Valor padrão: 0

     'fpprintprec' é o n;umero de dígitos a serem mostrados na tela
     quando no caso de nuúmeros em ponto flutuante e no caso de grandes
     números em ponto flutuante.

     Para números em ponto flutuante comuns, quando 'fpprintprec' tiver
     um valor entre 2 e 16 (inclusive), o n;umero de dígitos mostrado na
     tela é igual a 'fpprintprec'.  De outra forma, 'fpprintprec' é 0,
     ou maior que 16, e o número de dígitos mostrados é 16.

     Para grandes números em ponto flutuante, quando 'fpprintprec' tiver
     um valor entre 2 e 'fpprec' (inclusive), o n;umero de dígitos
     mostrados é giaul a 'fpprintprec'.  De outra forma, 'fpprintprec' é
     0, ou maior que 'fpprec', e o n;umero de dígitos mostrados é igual
     a 'fpprec'.

     'fpprintprec' não pode ser 1.


File: maxima.info,  Node: Contextos,  Next: Polinômios,  Prev: Ponto Flutuante,  Up: Top

11 Contextos
************

* Menu:

* Funções e Variáveis Definidas para Contextos::


File: maxima.info,  Node: Funções e Variáveis Definidas para Contextos,  Prev: Contextos,  Up: Contextos

11.1 Funções e Variáveis Definidas para Contextos
=================================================

 -- Função: activate (<context_1>, ..., <context_n>)
     Ativa os contextos <context_1>, ..., <context_n>.  Os fatos nesses
     contextos estão então disponíveis para fazer deduções e recuperar
     informação.  Os fatos nesses contextos não são listadas através de
     'facts ()'.

     A variável 'activecontexts' é a lista de contextos que estão ativos
     pelo caminho da função 'activate'.

 -- Variável de sistema: activecontexts
     Valor padrão: '[]'

     'activecontexts' é a lista de contextos que estão ativos pelo
     caminho da função 'activate', em oposição a sendo ativo porque eles
     são subcontextos do contexto corrente.

 -- Função: assume (<pred_1>, ..., <pred_n>)
     Adiciona predicados <pred_1>, ..., <pred_n> ao contexto corrente.
     Se um predicado for incossistente ou redundante com os predicados
     no contexto corrente, esses predicados não são adicionados ao
     contexto.  O contexto acumula predicados de cada chamada a
     'assume'.

     'assume' retorna uma lista cujos elementos são os predicados
     adicionados ao contexto ou os átomos 'redundant' ou 'inconsistent'
     onde for aplicável.

     Os predicados <pred_1>, ..., <pred_n> podem somente ser expressões
     com os operadores relacionais '< <= equal notequal >=' e '>'.
     Predicados não podem ser expressões de igualdades literais '=' ou
     expressões de desigualdades literais '#', nem podem elas serem
     funções de predicado tais como 'integerp'.

     Predicados combinados da forma '<pred_1> and ... and <pred_n>' são
     reconhecidos, mas não '<pred_1> or ... or <pred_n>'.  'not
     <pred_k>' é reconhecidos se <pred_k> for um predicado relacional.
     Expressões da forma 'not (<pred_1> e <pred_2>)' and 'not (<pred_1>
     or <pred_2>)' não são reconhecidas.

     O mecanismo de dedução do Maxima não é muito forte; exitem
     conseqüências muito óbvias as quais não podem ser determinadas por
     meio de 'is'.  Isso é uma fraqueza conhecida.

     'assume' avalia seus argumentos.

     Veja também 'is', 'facts', 'forget', 'context', e 'declare'.

     Exemplos:

          (%i1) assume (xx > 0, yy < -1, zz >= 0);
          (%o1)              [xx > 0, yy < - 1, zz >= 0]
          (%i2) assume (aa < bb and bb < cc);
          (%o2)                  [bb > aa, cc > bb]
          (%i3) facts ();
          (%o3)     [xx > 0, - 1 > yy, zz >= 0, bb > aa, cc > bb]
          (%i4) is (xx > yy);
          (%o4)                         true
          (%i5) is (yy < -yy);
          (%o5)                         true
          (%i6) is (sinh (bb - aa) > 0);
          (%o6)                         true
          (%i7) forget (bb > aa);
          (%o7)                       [bb > aa]
          (%i8) prederror : false;
          (%o8)                         false
          (%i9) is (sinh (bb - aa) > 0);
          (%o9)                        unknown
          (%i10) is (bb^2 < cc^2);
          (%o10)                       unknown

 -- Variável de opção: assumescalar
     Valor padrão: 'true'

     'assumescalar' ajuda a governar se expressões 'expr' para as quais
     'nonscalarp (expr)' for 'false' são assumidas comportar-se como
     escalares para certas transformações.

     Tomemos 'expr' representando qualquer expressão outra que não uma
     lista ou uma matriz, e tomemos '[1, 2, 3]' representando qualquer
     lista ou matriz.  Então 'expr . [1, 2, 3]' retorna '[expr, 2 expr,
     3 expr]' se 'assumescalar' for 'true', ou 'scalarp (expr)' for
     'true', ou 'constantp (expr)' for 'true'.

     Se 'assumescalar' for 'true', tais expressões irão comportar-se
     como escalares somente para operadores comutativos, mas não para
     multiplicação não comutativa '.'.

     Quando 'assumescalar' for 'false', tais expressões irão
     comportar-se como não escalares.

     Quando 'assumescalar' for 'all', tais expressões irão comportar-se
     como escalares para todos os operadores listados acima.

 -- Variável de opção: assume_pos
     Valor padrão: 'false'

     Quando 'assume_pos' for 'true' e o sinal de um parâmetro <x> não
     pode ser determinado a partir do contexto corrente ou outras
     considerações, 'sign' e 'asksign (<x>)' retornam 'true'.  Isso pode
     impedir algum questionamento de 'asksign' gerado automaticamente,
     tal como pode surgir de 'integrate' ou de outros cálculos.

     Por padrão, um parâmetro é <x> tal como 'symbolp (<x>)' or 'subvarp
     (<x>)'.  A classe de expressões consideradas parâmetros pode ser
     modificada para alguma abrangência através da variável
     'assume_pos_pred'.

     'sign' e 'asksign' tentam deduzir o sinal de expressões a partir de
     sinais de operandos dentro da expressão.  Por exemplo, se 'a' e 'b'
     são ambos positivos, então 'a + b' é também positivo.

     Todavia, não existe caminho para desviar todos os questionamentos
     de 'asksign'.  Particularmente, quando o argumento de 'asksign' for
     uma diferença '<x> - <y>' ou um logarítmo 'log(<x>)', 'asksign'
     sempre solicita uma entrada ao usuário, mesmo quando 'assume_pos'
     for 'true' e 'assume_pos_pred' for uma função que retorna 'true'
     para todos os argumentos.

 -- Variável de opção: assume_pos_pred
     Valor padrão: 'false'

     Quando 'assume_pos_pred' for atribuído o nome de uma função ou uma
     expressão lambda de um argumento <x>, aquela função é chamada para
     determinar se <x> é considerado um parâmetro para o propósito de
     'assume_pos'.  'assume_pos_pred' é ignorado quando 'assume_pos' for
     'false'.

     A função 'assume_pos_pred' é chamada através de 'sign' e de
     'asksign' com um argumento <x> que é ou um átomo, uma variável
     subscrita, ou uma expressão de chamada de função.  Se a função
     'assume_pos_pred' retorna 'true', <x> é considerado um parâmetro
     para o propósito de 'assume_pos'.

     Por padrão, um parâmetro é <x> tal que 'symbolp (x)' ou 'subvarp
     (x)'.

     Veja também 'assume' e 'assume_pos'.

     Exemplos:

          (%i1) assume_pos: true$
          (%i2) assume_pos_pred: symbolp$
          (%i3) sign (a);
          (%o3)                          pos
          (%i4) sign (a[1]);
          (%o4)                          pnz
          (%i5) assume_pos_pred: lambda ([x], display (x), true)$
          (%i6) asksign (a);
                                        x = a

          (%o6)                          pos
          (%i7) asksign (a[1]);
                                       x = a
                                            1

          (%o7)                          pos
          (%i8) asksign (foo (a));
                                     x = foo(a)

          (%o8)                          pos
          (%i9) asksign (foo (a) + bar (b));
                                     x = foo(a)

                                     x = bar(b)

          (%o9)                          pos
          (%i10) asksign (log (a));
                                        x = a

          Is  a - 1  positive, negative, or zero?

          p;
          (%o10)                         pos
          (%i11) asksign (a - b);
                                        x = a

                                        x = b

                                        x = a

                                        x = b

          Is  b - a  positive, negative, or zero?

          p;
          (%o11)                         neg

 -- Variável de opção: context
     Valor padrão: 'initial'

     'context' nomeia a coleção de fatos mantida através de 'assume' e
     'forget'.  'assume' adiciona fatos à coleção nomeada através de
     'context', enquanto 'forget' remove fatos.

     Associando 'context' para um nome <foo> altera o contexto corrente
     para <foo>.  Se o contexto especificado <foo> não existe ainda, ele
     é criado automaticamente através de uma chamada a 'newcontext'.  O
     contexto especificado é ativado automaticamente.

     Veja 'contexts' para uma descrição geral do mecanismo de contexto.

 -- Variável de opção: contexts
     Valor padrão: '[initial, global]'

     'contexts' é uma lista dos contextos que existem atualmente,
     incluindo o contexto ativo atualmente.

     O mecanismo de contexto torna possível para um usuário associar e
     nomear uma porção selecionada de fatos, chamada um contexto.  Assim
     que isso for concluído, o usuário pode ter o Maxima assumindo ou
     esquecendo grande quantidade de fatos meramente através da ativação
     ou desativação seu contexto.

     Qualquer átomo simbólico pode ser um contexto, e os fatos contidos
     naquele contexto irão ser retidos em armazenamento até que sejam
     destruídos um por um através de chamadas a 'forget' ou destruídos
     com um conjunto através de uma chamada a 'kill' para destruir o
     contexto que eles pertencem.

     Contextos existem em uma hierarquía, com o raíz sempre sendo o
     contexto 'global', que contém informações sobre Maxima que alguma
     função precisa.  Quando em um contexto dado, todos os fatos naquele
     contexto estão "ativos" (significando que eles são usados em
     deduções e recuperados) como estão também todos os fatos em
     qualquer contexto que for um subcontexto do contexto ativo.

     Quando um novo Maxima for iniciado, o usuário está em um contexto
     chamado 'initial', que tem 'global' como um subcontexto.

     Veja também 'facts', 'newcontext', 'supcontext', 'killcontext',
     'activate', 'deactivate', 'assume', e 'forget'.

 -- Função: deactivate (<context_1>, ..., <context_n>)
     Desativa os contextos especificados <context_1>, ..., <context_n>.

 -- Função: facts (<item>)
 -- Função: facts ()
     Se <item> for o nome de um contexto, 'facts (<item>)' retorna uma
     lista de fatos no contexto especificado.

     Se <item> não for o nome de um contexto, 'facts (<item>)' retorna
     uma lista de fatos conhecidos sobre <item> no contexto atual.
     Fatos que estão atuvos, mas em um diferente contexto, não são
     listados.

     'facts ()' (i.e., sem argumento) lista o contexto atual.

 -- Declaração: features
     Maxima recnhece ceertas propriedades matemáticas de funções e
     variáveis.  Essas são chamadas "recursos".

     'declare (<x>, <foo>)' fornece a propriedade <foo> para a função ou
     variável <x>.

     'declare (<foo>, recurso)' declara um novo recurso <foo>.  Por
     exemplo, 'declare ([red, green, blue], feature)' declara três novos
     recursos, 'red', 'green', e 'blue'.

     O predicado 'featurep (<x>, <foo>)' retorna 'true' se <x> possui a
     propriedade <foo>, e 'false' de outra forma.

     A infolista 'features' é uma lista de recursos conhecidos.  São
     esses 'integer', 'noninteger', 'even', 'odd', 'rational',
     'irrational', 'real', 'imaginary', 'complex', 'analytic',
     'increasing', 'decreasing', 'oddfun', 'evenfun', 'posfun',
     'commutative', 'lassociative', 'rassociative', 'symmetric', e
     'antisymmetric', mais quaisquer recursos definidos pelo usuário.

     'features' é uma lista de recursos matemáticos.  Existe também uma
     lista de recursos não matemáticos, recursos dependentes do sistema.
     Veja 'status'.

 -- Função: forget (<pred_1>, ..., <pred_n>)
 -- Função: forget (<L>)
     Remove predicados estabelecidos através de 'assume'.  Os predicados
     podem ser expressões equivalentes a (mas não necessáriamente
     idênticas a) esses prevamentes assumidos.

     'forget (<L>)', onde <L> é uma lista de predicados, esquece cada
     item da lista.

 -- Função: killcontext (<context_1>, ..., <context_n>)
     Mata os contextos <context_1>, ..., <context_n>.

     Se um dos contextos estiver for o contexto atual, o novo contexto
     atual irá tornar-se o primeiro subcontexto disponível do contexto
     atual que não tiver sido morto.  Se o primeiro contexto disponível
     não morto for 'global' então 'initial' é usado em seu lugar.  Se o
     contexto 'initial' for morto, um novo, porém vazio contexto
     'initial' é criado.

     'killcontext' recusa-se a matar um contexto que estiver ativo
     atualmente, ou porque ele é um subcontexto do contexto atual, ou
     através do uso da função 'activate'.

     'killcontext' avalia seus argumentos.  'killcontext' retorna
     'done'.

 -- Função: newcontext (<nome>)
     Cria um novo contexto, porém vazio, chamado <nome>, que tem
     'global' como seu único subcontexto.  O contexto recentemente
     criado torna-se o contexto ativo atualmente.

     'newcontext' avalia seu argumento.  'newcontext' retorna <nome>.

 -- Função: supcontext (<nome>, <context>)
 -- Função: supcontext (<nome>)
     Cria um novo contexto, chamado <nome>, que tem <context> como um
     subcontexto.  <context> deve existir.

     Se <context> não for especificado, o contexto atual é assumido.


File: maxima.info,  Node: Polinômios,  Next: Constantes,  Prev: Contextos,  Up: Top

12 Polinômios
*************

* Menu:

* Introdução a Polinômios::
* Funções e Variáveis Definidas para Polinômios::


File: maxima.info,  Node: Introdução a Polinômios,  Next: Funções e Variáveis Definidas para Polinômios,  Prev: Polinômios,  Up: Polinômios

12.1 Introdução a Polinômios
============================

Polinômios são armazenados no Maxima ou na forma geral ou na forma de
Expressões Racionais Canônicas (CRE). Essa última é uma forma padrão, e
é usada internamente por operações tais como 'factor', 'ratsimp', e
assim por diante.

   Expressões Racionais Canônicas constituem um tipo de representação
que é especialmente adequado para polinômios expandidos e funções
racionais (também para polinômios parcialmente fatorados e funções
racionais quando RATFAC for escolhida para 'true').  Nessa forma CRE uma
ordenação de variáveis (da mais para a menos importante) é assumida para
cada expressão.  Polinômios são representados recursivamente por uma
lista consistindo da variável principal seguida por uma série de pares
de expressões, uma para cada termo do polinômio.  O primeiro membro de
cada par é o expoente da variável principal naquele termo e o segundo
membro é o coeficiente daquele termo que pode ser um número ou um
polinômio em outra variável novamente respresentado nessa forma.  Sendo
assim a parte principal da forma CRE de 3*X^2-1 é (X 2 3 0 -1) e que a
parte principal da forma CRE de 2*X*Y+X-3 é (Y 1 (X 1 2) 0 (X 1 1 0 -3))
assumindo Y como sendo a variável principal, e é (X 1 (Y 1 2 0 1) 0 -3)
assumindo X como sendo a variável principal.  A variável principal é
usualmente determineda pela ordem alfabética reversa.  As "variáveis" de
uma expressão CRE não necessariamente devem ser atômicas.  De fato
qualquer subexpressão cujo principal operador não for + - * / or ^ com
expoente inteiro será considerado uma "variável" da expressão (na forma
CRE) na qual essa ocorrer.  Por exemplo as variáveis CRE da expressão
X+SIN(X+1)+2*SQRT(X)+1 são X, SQRT(X), e SIN(X+1).  Se o usuário não
especifica uma ordem de variáveis pelo uso da função RATVARS Maxima
escolherá a alfabética por conta própria.  Em geral, CREs representam
expressões racionais, isto é, razões de polinômios, onde o numerador e o
denominador não possuem fatores comuns, e o denominador for positivo.  A
forma interna é essencialmente um par de polinômios (o numerador e o
denominador) precedidos pela lista de ordenação de variável.  Se uma
expressão a ser mostrada estiver na forma CRE ou se contiver quaisquer
subexpressões na forma CRE, o símbolo /R/ seguirá o rótulo da linha.
Veja a função RAT para saber como converter uma expressão para a forma
CRE. Uma forma CRE extendida é usada para a representação de séries de
Taylor.  A noção de uma expressão racional é extendida de modo que os
expoentes das variáveis podem ser números racionais positivos ou
negativos em lugar de apenas inteiros positivos e os coeficientes podem
eles mesmos serem expressões racionais como descrito acima em lugar de
apenas polinômios.  Estes são representados internamente por uma forma
polinomial recursiva que é similar à forma CRE e é a generalização dessa
mesma forma CRE, mas carrega informação adicional tal com o grau de
truncação.  Do mesmo modo que na forma CRE, o símbolo /T/ segue o rótulo
de linha que contém as tais expressões.


File: maxima.info,  Node: Funções e Variáveis Definidas para Polinômios,  Prev: Introdução a Polinômios,  Up: Polinômios

12.2 Funções e Variáveis Definidas para Polinômios
==================================================

 -- Variável de opção: algebraic
     Valor Padrão: 'false'

     'algebraic' deve ser escolhida para 'true' com o objetivo de que a
     simplificação de inteiros algébricos tenha efeito.

 -- Variável de opção: berlefact
     Valor Padrão: 'true'

     Quando 'berlefact' for 'false' então o algorítmo de fatoração de
     Kronecker será usado.  De outra forma o algorítmo de Berlekamp, que
     é o padrão, será usado.

 -- Função: bezout (<p1>, <p2>, <x>)
     uma alternativa para o comando 'resultant'.  Isso retorna uma
     matriz.  'determinant' dessa matriz é o resultante desejado.

 -- Função: bothcoef (<expr>, <x>)
     Retorna uma lista da qual o primeiro membro é o coeficiente de <x>
     em <expr> (como achado por 'ratcoef' se <expr> está na forma CRE de
     outro modo por 'coeff') e cujo segundo membro é a parte restante de
     <expr>.  Isto é, '[A, B]' onde '<expr> = A*<x> + B'.

     Exemplo:

          (%i1) islinear (expr, x) := block ([c],
                  c: bothcoef (rat (expr, x), x),
                  é (freeof (x, c) and c[1] # 0))$
          (%i2) islinear ((r^2 - (x - r)^2)/x, x);
          (%o2)                         true

 -- Função: coeff (<expr>, <x>, <n>)
     Retorna o coeficiente de '<x>^<n>' em <expr>.  <n> pode ser omitido
     se for 1.  <x> pode ser um átomo, ou subexpressão completa de
     <expr> e.g., 'sin(x)', 'a[i+1]', 'x + y', etc.  (No último caso a
     expressão '(x + y)' pode ocorrer em <expr>).  Algumas vezes isso
     pode ser necessário para expandir ou fatorar <expr> com o objetivo
     de fazer '<x>^<n>' explicito.  Isso não é realizado por 'coeff'.

     Exemplos:

          (%i1) coeff (2*a*tan(x) + tan(x) + b = 5*tan(x) + 3, tan(x));
          (%o1)                      2 a + 1 = 5
          (%i2) coeff (y + x*%e^x + 1, x, 0);
          (%o2)                         y + 1

 -- Função: combine (<expr>)
     Simplifica a adição <expr> por termos combinados com o mesmo
     denominador dentro de um termo simples.

 -- Função: content (<p_1>, <x_1>, ..., <x_n>)
     Retorna uma lista cujo primeiro elemento é o máximo divisor comum
     dos coeficientes dos termos do polinômio <p_1> na variável <x_n>
     (isso é o conteúdo) e cujo segundo elemento é o polinômio <p_1>
     dividido pelo conteúdo.

     Exemplos:

          (%i1) content (2*x*y + 4*x^2*y^2, y);
                                             2
          (%o1)                   [2 x, 2 x y  + y]

 -- Função: denom (<expr>)
     Retorna o denominador da expressão racional <expr>.

 -- Função: divide (<p_1>, <p_2>, <x_1>, ..., <x_n>)
     calcula o quocietne e o resto do polinômio <p_1> dividido pelo
     polinômio <p_2>, na variável principal do polinômio, <x_n>.  As
     outras variáveis são como na função 'ratvars'.  O resultado é uma
     lista cujo primeiro elemento é o quociente e cujo segundo elemento
     é o resto.

     Exemplos:

          (%i1) divide (x + y, x - y, x);
          (%o1)                       [1, 2 y]
          (%i2) divide (x + y, x - y);
          (%o2)                      [- 1, 2 x]

     Note que 'y' é a variável principal no segundo exemplo.

 -- Função: eliminate ([<eqn_1>, ..., <eqn_n>], [<x_1>, ..., <x_k>])
     Elimina variáveis de equações (ou expressões assumidas iguais a
     zero) pegando resultantes sucessivos.  Isso retorna uma lista de
     '<n> - <k>' expressões com <k> variáveis <x_1>, ..., <x_k>
     eliminadas.  Primeiro <x_1> é eliminado retornando '<n> - 1'
     expressões, então 'x_2' é eliminado, etc.  Se '<k> = <n>' então uma
     expressão simples em uma lista é retornada livre das variáveis
     <x_1>, ..., <x_k>.  Nesse caso 'solve' é chamado para resolver a
     última resultante para a última variável.

     Exemplo:

          (%i1) expr1: 2*x^2 + y*x + z;
                                                2
          (%o1)                    z + x y + 2 x
          (%i2) expr2: 3*x + 5*y - z - 1;
          (%o2)                  - z + 5 y + 3 x - 1
          (%i3) expr3: z^2 + x - y^2 + 5;
                                    2    2
          (%o3)                    z  - y  + x + 5
          (%i4) eliminate ([expr3, expr2, expr1], [y, z]);
                       8         7         6          5          4
          (%o4) [7425 x  - 1170 x  + 1299 x  + 12076 x  + 22887 x

                                              3         2
                                      - 5154 x  - 1291 x  + 7688 x + 15376]

 -- Função: ezgcd (<p_1>, <p_2>, <p_3>, ...)
     Retorna uma lista cujo primeiro elemento é o m.d.c.  dos polinômios
     <p_1>, <p_2>, <p_3>, ...  e cujos restantes elementos são os
     polinômios divididos pelo mdc.  Isso sempre usa o algorítmo
     'ezgcd'.

 -- Variável de opção: facexpand
     Valor Padrão: 'true'

     'facexpand' controla se os fatores irredutíveis retornados por
     'factor' estão na forma expandida (o padrão) ou na forma recursiva
     (CRE normal).

 -- Função: factcomb (<expr>)
     Tenta combinar os coeficientes de fatoriais em <expr> com os
     próprios fatoriais convertendo, por exemplo, '(n + 1)*n!' em '(n +
     1)!'.

     'sumsplitfact' se escolhida para 'false' fará com que
     'minfactorial' seja aplicado após um 'factcomb'.

 -- Função: factor (<expr>)
 -- Função: factor (<expr>, <p>)

     Fatora a expressão <expr>, contendo qualquer número de variáveis ou
     funções, em fatores irredutíveis sobre os inteiros.  'factor
     (<expr>, <p>)' fatora <expr> sobre o campo dos inteiros com um
     elemento adjunto cujo menor polinômio é <p>.

     'factor' usa a função 'ifactors' para fatorar inteiros.

     'factorflag' se 'false' suprime a fatoração de fatores inteiros de
     expressões racionais.

     'dontfactor' pode ser escolhida para uma lista de variáveis com
     relação à qual fatoração não é para ocorrer.  (Essa é inicialmente
     vazia).  Fatoração também não acontece com relação a quaisquer
     variáveis que são menos importantes (usando a ordenação de variável
     assumida pela forma CRE) como essas na lista 'dontfactor'.

     'savefactors' se 'true' faz com que os fatores de uma expressão que
     é um produto de fatores seja guardada por certas funções com o
     objetivo de aumentar a velocidade de futuras fatorações de
     expressões contendo alguns dos mesmos fatores.

     'berlefact' se 'false' então o algorítmo de fatoração de Kronecker
     será usado de outra forma o algorítmo de Berlekamp, que é o padrão,
     será usado.

     'intfaclim' se 'true' maxima irá interromper a fatoração de
     inteiros se nenhum fator for encontrado após tentar divisões e o
     método rho de Pollard.  Se escolhida para 'false' (esse é o caso
     quando o usuário chama 'factor' explicitamente), a fatoração
     completa do inteiro será tentada.  A escolha do usuário para
     'intfaclim' é usada para chamadas internas a 'factor'.  Dessa
     forma, 'intfaclim' pode ser resetada para evitar que o Maxima gaste
     um tempo muito longo fatorando inteiros grandes.

     Exemplos:

          (%i1) factor (2^63 - 1);
                              2
          (%o1)              7  73 127 337 92737 649657
          (%i2) factor (-8*y - 4*x + z^2*(2*y + x));
          (%o2)               (2 y + x) (z - 2) (z + 2)
          (%i3) -1 - 2*x - x^2 + y^2 + 2*x*y^2 + x^2*y^2;
                          2  2        2    2    2
          (%o3)          x  y  + 2 x y  + y  - x  - 2 x - 1
          (%i4) block ([dontfactor: [x]], factor (%/36/(1 + 2*y + y^2)));
                                 2
                               (x  + 2 x + 1) (y - 1)
          (%o4)                ----------------------
                                     36 (y + 1)
          (%i5) factor (1 + %e^(3*x));
                                x         2 x     x
          (%o5)              (%e  + 1) (%e    - %e  + 1)
          (%i6) factor (1 + x^4, a^2 - 2);
                              2              2
          (%o6)             (x  - a x + 1) (x  + a x + 1)
          (%i7) factor (-y^2*z^2 - x*z^2 + x^2*y^2 + x^3);
                                 2
          (%o7)              - (y  + x) (z - x) (z + x)
          (%i8) (2 + x)/(3 + x)/(b + x)/(c + x)^2;
                                       x + 2
          (%o8)               ------------------------
                                                     2
                              (x + 3) (x + b) (x + c)
          (%i9) ratsimp (%);
                          4                  3
          (%o9) (x + 2)/(x  + (2 c + b + 3) x

               2                       2             2                   2
           + (c  + (2 b + 6) c + 3 b) x  + ((b + 3) c  + 6 b c) x + 3 b c )
          (%i10) partfrac (%, x);
                     2                   4                3
          (%o10) - (c  - 4 c - b + 6)/((c  + (- 2 b - 6) c

               2              2         2                2
           + (b  + 12 b + 9) c  + (- 6 b  - 18 b) c + 9 b ) (x + c))

                           c - 2
           - ---------------------------------
               2                             2
             (c  + (- b - 3) c + 3 b) (x + c)

                                   b - 2
           + -------------------------------------------------
                       2             2       3      2
             ((b - 3) c  + (6 b - 2 b ) c + b  - 3 b ) (x + b)

                                   1
           - ----------------------------------------------
                       2
             ((b - 3) c  + (18 - 6 b) c + 9 b - 27) (x + 3)
          (%i11) map ('factor, %);
                        2
                       c  - 4 c - b + 6                 c - 2
          (%o11) - ------------------------- - ------------------------
                          2        2                                  2
                   (c - 3)  (c - b)  (x + c)   (c - 3) (c - b) (x + c)

                                 b - 2                        1
                      + ------------------------ - ------------------------
                                       2                          2
                        (b - 3) (c - b)  (x + b)   (b - 3) (c - 3)  (x + 3)
          (%i12) ratsimp ((x^5 - 1)/(x - 1));
                                 4    3    2
          (%o12)                x  + x  + x  + x + 1
          (%i13) subst (a, x, %);
                                 4    3    2
          (%o13)                a  + a  + a  + a + 1
          (%i14) factor (%th(2), %);
                                 2        3        3    2
          (%o14)   (x - a) (x - a ) (x - a ) (x + a  + a  + a + 1)
          (%i15) factor (1 + x^12);
                                 4        8    4
          (%o15)               (x  + 1) (x  - x  + 1)
          (%i16) factor (1 + x^99);
                           2            6    3
          (%o16) (x + 1) (x  - x + 1) (x  - x  + 1)

             10    9    8    7    6    5    4    3    2
           (x   - x  + x  - x  + x  - x  + x  - x  + x  - x + 1)

             20    19    17    16    14    13    11    10    9    7    6
           (x   + x   - x   - x   + x   + x   - x   - x   - x  + x  + x

              4    3            60    57    51    48    42    39    33
           - x  - x  + x + 1) (x   + x   - x   - x   + x   + x   - x

              30    27    21    18    12    9    3
           - x   - x   + x   + x   - x   - x  + x  + 1)

 -- Variável de opção: factorflag
     Valor Padrão: 'false'

     Quando 'factorflag' for 'false', suprime a fatoração de fatores
     inteiros em expressões racionais.

 -- Função: factorout (<expr>, <x_1>, <x_2>, ...)
     Rearranja a adição <expr> em uma adição de parcelas da forma 'f
     (<x_1>, <x_2>, ...)*g' onde 'g' é um produto de expressões que não
     possuem qualquer <x_i> e 'f' é fatorado.

 -- Função: factorsum (<expr>)
     Tenta agrupar parcelas em fatores de <expr> que são adições em
     grupos de parcelas tais que sua adição é fatorável.  'factorsum'
     pode recuperar o resultado de 'expand ((x + y)^2 + (z + w)^2)' mas
     não pode recuperar 'expand ((x + 1)^2 + (x + y)^2)' porque os
     termos possuem variáveis em comum.

     Exemplo:

          (%i1) expand ((x + 1)*((u + v)^2 + a*(w + z)^2));
                     2      2                            2      2
          (%o1) a x z  + a z  + 2 a w x z + 2 a w z + a w  x + v  x

                                               2        2    2            2
                                  + 2 u v x + u  x + a w  + v  + 2 u v + u
          (%i2) factorsum (%);
                                             2          2
          (%o2)            (x + 1) (a (z + w)  + (v + u) )

 -- Função: fasttimes (<p_1>, <p_2>)
     Retorna o produto dos polinômios <p_1> e <p_2> usando um algorítmo
     especial para a multiplicação de polinômios.  'p_1' e 'p_2' podem
     ser de várias variáveis, densos, e aproximadamente do mesmo
     tamanho.  A multiplicação clássica é de ordem 'n_1 n_2' onde 'n_1'
     é o grau de 'p_1' and 'n_2' é o grau de 'p_2'.  'fasttimes' é da
     ordem 'max (n_1, n_2)^1.585'.

 -- Função: fullratsimp (<expr>)
     'fullratsimp' aplica repetidamente 'ratsimp' seguido por
     simplificação não racional a uma expressão até que nenhuma mudança
     adicional ocorra, e retorna o resultado.

     Quando expressões não racionais estão envolvidas, uma chamada a
     'ratsimp' seguida como é usual por uma simplificação não racional
     ("geral") pode não ser suficiente para retornar um resultado
     simplificado.  Algumas vezes, mais que uma tal chamada pode ser
     necessária.  'fullratsimp' faz esse processo convenientemente.

     'fullratsimp (<expr>, <x_1>, ..., <x_n>)' pega um ou mais
     argumentos similar a 'ratsimp' e 'rat'.

     Exemplo:

          (%i1) expr: (x^(a/2) + 1)^2*(x^(a/2) - 1)^2/(x^a - 1);
                                 a/2     2   a/2     2
                               (x    - 1)  (x    + 1)
          (%o1)                -----------------------
                                        a
                                       x  - 1
          (%i2) ratsimp (expr);
                                    2 a      a
                                   x    - 2 x  + 1
          (%o2)                    ---------------
                                        a
                                       x  - 1
          (%i3) fullratsimp (expr);
                                        a
          (%o3)                        x  - 1
          (%i4) rat (expr);
                                 a/2 4       a/2 2
                               (x   )  - 2 (x   )  + 1
          (%o4)/R/             -----------------------
                                        a
                                       x  - 1

 -- Função: fullratsubst (<a>, <b>, <c>)
     é o mesmo que 'ratsubst' exceto que essa chama a si mesma
     recursivamente sobre esse resultado até que o resultado para de
     mudar.  Essa função é útil quando a expressão de substituição e a
     expressão substituída tenham uma ou mais variáveis em comum.

     'fullratsubst' irá também aceitar seus argumentos no formato de
     'lratsubst'.  Isto é, o primeiro argumento pode ser uma
     substituição simples de equação ou uma lista de tais equações,
     enquanto o segundo argumento é a expressão sendo processada.

     'load ("lrats")' chama 'fullratsubst' e 'lratsubst'.

     Exemplos:

          (%i1) load ("lrats")$
        * 'subst' pode realizar multiplas substituições.  'lratsubst' é
          analogo a 'subst'.
          (%i2) subst ([a = b, c = d], a + c);
          (%o2)                         d + b
          (%i3) lratsubst ([a^2 = b, c^2 = d], (a + e)*c*(a + c));
          (%o3)                (d + a c) e + a d + b c
        * Se somente uma substituição é desejada, então uma equação
          simples pode ser dada como primeiro argumento.
          (%i4) lratsubst (a^2 = b, a^3);
          (%o4)                          a b
        * 'fullratsubst' é equivalente a 'ratsubst' exceto que essa
          executa recursivamente até que seu resultado para de mudar.
          (%i5) ratsubst (b*a, a^2, a^3);
                                         2
          (%o5)                         a  b
          (%i6) fullratsubst (b*a, a^2, a^3);
                                           2
          (%o6)                         a b
        * 'fullratsubst' também aceita uma lista de equações ou uma
          equação simples como primeiro argumento.
          (%i7) fullratsubst ([a^2 = b, b^2 = c, c^2 = a], a^3*b*c);
          (%o7)                           b
          (%i8) fullratsubst (a^2 = b*a, a^3);
                                           2
          (%o8)                         a b
        * 'fullratsubst' pode causar uma recursão infinita.
          (%i9) errcatch (fullratsubst (b*a^2, a^2, a^3));

          *** - Lisp stack overflow. RESET

 -- Função: gcd (<p_1>, <p_2>, <x_1>, ...)
     Retorna o máximo divisor comum entre <p_1> e <p_2>.  O sinalizador
     'gcd' determina qual algorítmo é empregado.  Escolhendo 'gcd' para
     'ez', 'subres', 'red', ou 'spmod' seleciona o algorítmo 'ezgcd',
     subresultante 'prs', reduzido, ou modular, respectivamente.  Se
     'gcd' for 'false' então 'gcd (<p_1>, <p_2>, <x>)' sempre retorna 1
     para todo <x>.  Muitas funções (e.g.  'ratsimp', 'factor', etc.)
     fazem com que mdc's sejam feitos implicitamente.  Para polinômios
     homogêneos é recomendado que 'gcd' igual a 'subres' seja usado.
     Para pegar o mdc quando uma expressão algébrica está presente, e.g.
     'gcd (<x>^2 - 2*sqrt(2)*<x> + 2, <x> - sqrt(2))', 'algebraic' deve
     ser 'true' e 'gcd' não deve ser 'ez'.  'subres' é um novo
     algorítmo, e pessoas que tenham estado usando a opção 'red' podem
     provavelmente alterar isso para 'subres'.

     O sinalizador 'gcd', padrão: 'subres', se 'false' irá também evitar
     o máximo divisor comum de ser usado quando expressões são
     convertidas para a forma de expressão racional canônica (CRE). Isso
     irá algumas vezes aumentar a velocidade dos cálculos se mdc's não
     são requeridos.

 -- Função: gcdex (<f>, <g>)
 -- Função: gcdex (<f>, <g>, <x>)
     Retornam uma lista '[<a>, <b>, <u>]' onde <u> é o máximo divisor
     comum (mdc) entre <f> e <g>, e <u> é igual a '<a> <f> + <b> <g>'.
     Os argumentos <f> e <g> podem ser polinômios de uma variável, ou de
     outra forma polinômios em <x> uma main(principal) variável suprida
     desde que nós precisamos estar em um domínio de ideal principal
     para isso trabalhar.  O mdc significa o mdc considerando <f> e <g>
     como polinômios de uma única variável com coeficientes sendo
     funções racionais em outras variáveis.

     'gcdex' implementa o algorítmo Euclideano, onde temos a seqüência
     of 'L[i]: [a[i], b[i], r[i]]' que são todos perpendiculares a '[f,
     g, -1]' e o próximo se é construído como se 'q =
     quotient(r[i]/r[i+1])' então 'L[i+2]: L[i] - q L[i+1]', e isso
     encerra em 'L[i+1]' quando o resto 'r[i+2]' for zero.

          (%i1) gcdex (x^2 + 1, x^3 + 4);
                                 2
                                x  + 4 x - 1  x + 4
          (%o1)/R/           [- ------------, -----, 1]
                                     17        17
          (%i2) % . [x^2 + 1, x^3 + 4, -1];
          (%o2)/R/                        0

     Note que o mdc adiante é '1' uma vez que trabalhamos em 'k(y)[x]',
     o 'y+1' não pode ser esperado em 'k[y, x]'.

          (%i1) gcdex (x*(y + 1), y^2 - 1, x);
                                         1
          (%o1)/R/                 [0, ------, 1]
                                        2
                                       y  - 1

 -- Função: gcfactor (<n>)
     Fatora o inteiro Gaussiano <n> sobre os inteiros Gaussianos, i.e.,
     números da forma '<a> + <b> %i' onde <a> e <b> são inteiros
     raconais (i.e., inteiros comuns).  Fatorações são normalizadas
     fazendo <a> e <b> não negativos.

 -- Função: gfactor (<expr>)
     Fatora o polinômio <expr> sobre os inteiros de Gauss (isto é, os
     inteiros com a unidade imaginária '%i' adjunta).  Isso é como
     'factor (<expr>, <a>^2+1)' trocando <a> por '%i'.

     Exemplo:

          (%i1) gfactor (x^4 - 1);
          (%o1)           (x - 1) (x + 1) (x - %i) (x + %i)

 -- Função: gfactorsum (<expr>)
     é similar a 'factorsum' mas aplica 'gfactor' em lugar de 'factor'.

 -- Função: hipow (<expr>, <x>)
     Retorna o maior expoente explícito de <x> em <expr>.  <x> pode ser
     uma variável ou uma expressão geral.  Se <x> não aparece em <expr>,
     'hipow' retorna '0'.

     'hipow' não considera expressões equivalentes a 'expr'.  Em
     particular, 'hipow' não expande 'expr', então 'hipow (<expr>, <x>)'
     e 'hipow (expand (<expr>, <x>))' podem retornar diferentes
     resultados.

     Exemplos:

          (%i1) hipow (y^3 * x^2 + x * y^4, x);
          (%o1)                           2
          (%i2) hipow ((x + y)^5, x);
          (%o2)                           1
          (%i3) hipow (expand ((x + y)^5), x);
          (%o3)                           5
          (%i4) hipow ((x + y)^5, x + y);
          (%o4)                           5
          (%i5) hipow (expand ((x + y)^5), x + y);
          (%o5)                           0

 -- Variável de opção: intfaclim
     Valor padrão: true

     Se 'true', maxima irá interromper a fatoração de inteiros se nenhum
     fator for encontrado após tentar divisões e o método rho de Pollard
     e a fatoração não será completada.

     Quando 'intfaclim' for 'false' (esse é o caso quando o usuário
     chama 'factor' explicitamente), a fatoração completa será tentada.
     'intfaclim' é escolhida para 'false' quando fatores são calculados
     em 'divisors', 'divsum' e 'totient'.

     Chamadas internas a 'factor' respeitam o valor especificado pelo
     usuário para 'intfaclim'.  Setting 'intfaclim' to 'true' may reduce
     'intfaclim'.  Escolhendo 'intfaclim' para 'true' podemos reduzir o
     tempo gasto fatorando grandes inteiros.

 -- Variável de opção: keepfloat
     Valor Padrão: 'false'

     Quando 'keepfloat' for 'true', evitamos que números em ponto
     flutuante sejam racionalizados quando expressões que os possuem são
     então convertidas para a forma de expressão racional canônica
     (CRE).

 -- Função: lratsubst (<L>, <expr>)
     é análogo a 'subst (<L>, <expr>)' exceto que esse usa 'ratsubst' em
     lugar de 'subst'.

     O primeiro argumento de 'lratsubst' é uma equação ou uma lista de
     equações idênticas em formato para que sejam aceitas por 'subst'.
     As substituições são feitas na ordem dada pela lista de equações,
     isto é, da esquerda para a direita.

     'load ("lrats")' chama 'fullratsubst' e 'lratsubst'.

     Exemplos:

          (%i1) load ("lrats")$
        * 'subst' pode realizar multiplas substituições.  'lratsubst' é
          analoga a 'subst'.
          (%i2) subst ([a = b, c = d], a + c);
          (%o2)                         d + b
          (%i3) lratsubst ([a^2 = b, c^2 = d], (a + e)*c*(a + c));
          (%o3)                (d + a c) e + a d + b c
        * Se somente uma substituição for desejada, então uma equação
          simples pode ser dada como primeiro argumento.
          (%i4) lratsubst (a^2 = b, a^3);
          (%o4)                          a b

 -- Variável de opção: modulus
     Valor Padrão: 'false'

     Quando 'modulus' for um número positivo <p>, operações sobre os
     números racionais (como retornado por 'rat' e funções relacionadas)
     são realizadas módulo <p>, usando o então chamado sistema de módulo
     "balanceado" no qual '<n> módulo <p>' é definido como um inteiro
     <k> em '[-(<p>-1)/2, ..., 0, ..., (<p>-1)/2]' quando <p> for ímpar,
     ou '[-(<p>/2 - 1), ..., 0, ...., <p>/2]' quando <p> for par, tal
     que '<a> <p> + <k>' seja igual a <n> para algum inteiro <a>.

     Se <expr> já estiver na forma de expressão racional canônica (CRE)
     quando 'modulus' for colocado em seu valor original, então você
     pode precisar repetir o rat <expr>, e.g., 'expr: rat (ratdisrep
     (expr))', com o objetivo de pegar resultados corretos.

     Tipicamente 'modulus' é escolhido para um número primo.  Se
     'modulus' for escolhido para um inteiro não primo positivo, essa
     escolha é aceita, mas uma mensagem de alerta é mostrada.  Maxima
     permitirá que zero ou um inteiro negativo seja atribuído a
     'modulus', embora isso não seja limpo se aquele tiver quaisquer
     conseqüências úteis.

 -- Função: num (<expr>)
     Retorna o numerador de <expr> se isso for uma razão.  Se <expr> não
     for uma razão, <expr> é retornado.

     'num' avalia seu argumento.

 -- Função: polydecomp (<p>, <x>)

     Decompões o polinômio <p> na variável <x> em uma composição
     funcional de polinômios em <x>.  'polydecomp' retorna uma lista
     '[<p_1>, ..., <p_n>]' tal que

          lambda ([x], p_1) (lambda ([x], p_2) (... (lambda ([x], p_n) (x)) ...))

     seja igual a <p>.  O grau de <p_i> é maior que 1 para <i> menor que
     <n>.

     Tal decomposição não é única.

     Exemplos:

          (%i1) polydecomp (x^210, x);
                                    7   5   3   2
          (%o1)                   [x , x , x , x ]
          (%i2) p : expand (subst (x^3 - x - 1, x, x^2 - a));
                          6      4      3    2
          (%o2)          x  - 2 x  - 2 x  + x  + 2 x - a + 1
          (%i3) polydecomp (p, x);
                                  2       3
          (%o3)                 [x  - a, x  - x - 1]

     As seguintes funções compõem 'L = [e_1, ..., e_n]' como funções em
     'x'; essa funçào é a inversa de 'polydecomp':

          compose (L, x) :=
            block ([r : x], for e in L do r : subst (e, x, r), r) $

     Re-exprimindo o exemplo acima usando 'compose':

          (%i3) polydecomp (compose ([x^2 - a, x^3 - x - 1], x), x);
                                  2       3
          (%o3)                 [x  - a, x  - x - 1]

     Note que apesar de 'compose (polydecomp (<p>, <x>), <x>)' sempre
     retornar <p> (não expandido), 'polydecomp (compose ([<p_1>, ...,
     <p_n>], <x>), <x>)' não necessáriamente retorna '[<p_1>, ...,
     <p_n>]':

          (%i4) polydecomp (compose ([x^2 + 2*x + 3, x^2], x), x);
                                    2       2
          (%o4)                   [x  + 2, x  + 1]
          (%i5) polydecomp (compose ([x^2 + x + 1, x^2 + x + 1], x), x);
                                2       2
                               x  + 3  x  + 5
          (%o5)               [------, ------, 2 x + 1]
                                 4       2

 -- Função: quotient (<p_1>, <p_2>)
 -- Função: quotient (<p_1>, <p_2>, <x_1>, ..., <x_n>)
     Retorna o polinômio <p_1> dividido pelo polinômio <p_2>.  Os
     argumentos <x_1>, ..., <x_n> são interpretados como em 'ratvars'.

     'quotient' retorna o primeiro elemento de uma lista de dois
     elementos retornada por 'divide'.

 -- Função: rat (<expr>)
 -- Função: rat (<expr>, <x_1>, ..., <x_n>)
     Converte <expr> para a forma de expressão racional canônica (CRE)
     expandindo e combinando todos os termos sobre um denominador comum
     e cancelando para fora o máximo divisor comum entre o numerador e o
     denominador, também convertendo números em ponto flutuante para
     números racionais dentro da tolerância de 'ratepsilon'.  As
     variáveis são ordenadas de acordo com <x_1>, ..., <x_n>, se
     especificado, como em 'ratvars'.

     'rat' geralmente não simplifica funções outras que não sejam adição
     '+', subtração '-', multiplicação '*', divisão '/', e exponenciação
     com expoente inteiro, uma vez que 'ratsimp' não manuseia esses
     casos.  Note que átomos (números e variáveis) na forma CRE não são
     os mesmos que eles são na forma geral.  Por exemplo, 'rat(x)- x'
     retorna 'rat(0)' que tem uma representação interna diferente de 0.

     Quando 'ratfac' for 'true', 'rat' retorna uma forma parcialmente
     fatorada para CRE. Durante operações racionais a expressão é
     mantida como totalmente fatorada como possível sem uma chamada ao
     pacote de fatoração ('factor').  Isso pode sempre economizar espaço
     de memória e algum tempo em algumas computações.  O numerador e o
     denominador são ainda tidos como relativamente primos (e.g.  'rat
     ((x^2 - 1)^4/(x + 1)^2)' retorna '(x - 1)^4 (x + 1)^2)', mas os
     fatores dentro de cada parte podem não ser relativamente primos.

     'ratprint' se 'false' suprime a impressão de mensagens informando o
     usuário de conversões de números em ponto flutuante para números
     racionais.

     'keepfloat' se 'true' evita que números em ponto flutuante sejam
     convertidos para números racionais.

     Veja também 'ratexpand' e 'ratsimp'.

     Exemplos:

          (%i1) ((x - 2*y)^4/(x^2 - 4*y^2)^2 + 1)*(y + a)*(2*y + x) /(4*y^2 + x^2);
                                                     4
                                            (x - 2 y)
                        (y + a) (2 y + x) (------------ + 1)
                                             2      2 2
                                           (x  - 4 y )
          (%o1)         ------------------------------------
                                        2    2
                                     4 y  + x
          (%i2) rat (%, y, a, x);
                                      2 a + 2 y
          (%o2)/R/                    ---------
                                       x + 2 y

 -- Variável de opção: ratalgdenom
     Valor Padrão: 'true'

     Quando 'ratalgdenom' for 'true', permite racionalização de
     denominadores com respeito a radicais tenham efeito.  'ratalgdenom'
     tem efeito somente quando expressões racionais canônicas (CRE)
     forem usadas no modo algébrico.

 -- Função: ratcoef (<expr>, <x>, <n>)
 -- Função: ratcoef (<expr>, <x>)
     Retorna o coeficiente da expressão '<x>^<n>' dentro da expressão
     <expr>.  Se omitido, <n> é assumido ser 1.

     O valor de retorno está livre (exceto possivelmente em um senso não
     racional) das variáveis em <x>.  Se nenhum coeficiente desse tipo
     existe, 0 é retornado.

     'ratcoef' expande e simplifica racionalmente seu primeiro argumento
     e dessa forma pode produzir respostas diferentes das de 'coeff' que
     é puramente sintática.  Dessa forma 'ratcoef ((x + 1)/y + x, x)'
     retorna '(y + 1)/y' ao passo que 'coeff' retorna 1.

     'ratcoef (<expr>, <x>, 0)', visualiza <expr> como uma adição,
     retornando uma soma desses termos que não possuem <x>.  portanto se
     <x> ocorre para quaisquer expoentes negativos, 'ratcoef' pode não
     ser usado.

     Uma vez que <expr> é racionalmente simplificada antes de ser
     examinada, coeficientes podem não aparecer inteiramente no caminho
     que eles foram pensados.

     Exemplo:

          (%i1) s: a*x + b*x + 5$
          (%i2) ratcoef (s, a + b);
          (%o2)                           x

 -- Função: ratdenom (<expr>)
     Retorna o denominador de <expr>, após forçar a conversão de <expr>
     para expressão racional canônica (CRE). O valor de retorno é a CRE.

     <expr> é forçada para uma CRE por 'rat' se não for já uma CRE. Essa
     conversão pode mudar a forma de <expr> colocando todos os termos
     sobre um denominador comum.

     'denom' é similar, mas retorna uma expressão comum em lugar de uma
     CRE. Também, 'denom' não tenta colocar todos os termos sobre um
     denominador comum, e dessa forma algumas expressões que são
     consideradas razões por 'ratdenom' não são consideradas razões por
     'denom'.

 -- Variável de opção: ratdenomdivide
     Valor Padrão: 'true'

     Quando 'ratdenomdivide' for 'true', 'ratexpand' expande uma razão
     cujo o numerador for uma adição dentro de uma soma de razões, tendo
     todos um denominador comum.  De outra forma, 'ratexpand' colapsa
     uma adição de razões dentro de uma razão simples, cujo numerador
     seja a adição dos numeradores de cada razão.

     Exemplos:

          (%i1) expr: (x^2 + x + 1)/(y^2 + 7);
                                      2
                                     x  + x + 1
          (%o1)                      ----------
                                        2
                                       y  + 7
          (%i2) ratdenomdivide: true$
          (%i3) ratexpand (expr);
                                 2
                                x        x        1
          (%o3)               ------ + ------ + ------
                               2        2        2
                              y  + 7   y  + 7   y  + 7
          (%i4) ratdenomdivide: false$
          (%i5) ratexpand (expr);
                                      2
                                     x  + x + 1
          (%o5)                      ----------
                                        2
                                       y  + 7
          (%i6) expr2: a^2/(b^2 + 3) + b/(b^2 + 3);
                                               2
                                     b        a
          (%o6)                    ------ + ------
                                    2        2
                                   b  + 3   b  + 3
          (%i7) ratexpand (expr2);
                                            2
                                       b + a
          (%o7)                        ------
                                        2
                                       b  + 3

 -- Função: ratdiff (<expr>, <x>)
     Realiza a derivação da expressão racional <expr> com relação a <x>.
     <expr> deve ser uma razão de polinômios ou um polinômio em <x>.  O
     argumento <x> pode ser uma variável ou uma subexpressão de <expr>.

     O resultado é equivalente a 'diff', embora talvez em uma forma
     diferente.  'ratdiff' pode ser mais rápida que 'diff', para
     expressões racionais.

     'ratdiff' retorna uma expressão racional canônica (CRE) se 'expr'
     for uma CRE. De outra forma, 'ratdiff' retorna uma expressão geral.

     'ratdiff' considera somente as dependências de <expr> sobre <x>, e
     ignora quaisquer dependências estabelecidas por 'depends'.

     Exemplo:

          (%i1) expr: (4*x^3 + 10*x - 11)/(x^5 + 5);
                                     3
                                  4 x  + 10 x - 11
          (%o1)                   ----------------
                                        5
                                       x  + 5
          (%i2) ratdiff (expr, x);
                              7       5       4       2
                           8 x  + 40 x  - 55 x  - 60 x  - 50
          (%o2)          - ---------------------------------
                                    10       5
                                   x   + 10 x  + 25
          (%i3) expr: f(x)^3 - f(x)^2 + 7;
                                   3       2
          (%o3)                   f (x) - f (x) + 7
          (%i4) ratdiff (expr, f(x));
                                     2
          (%o4)                   3 f (x) - 2 f(x)
          (%i5) expr: (a + b)^3 + (a + b)^2;
                                        3          2
          (%o5)                  (b + a)  + (b + a)
          (%i6) ratdiff (expr, a + b);
                              2                    2
          (%o6)            3 b  + (6 a + 2) b + 3 a  + 2 a

 -- Função: ratdisrep (<expr>)
     Retorna seu argumento como uma expressão geral.  Se <expr> for uma
     expressão geral, é retornada inalterada.

     Tipicamente 'ratdisrep' é chamada para converter uma expressão
     racional canônica (CRE) em uma expressão geral.  Isso é algumas
     vezes conveniente se deseja-se parar o "contágio", ou caso se
     esteja usando funções racionais em contextos não racionais.

     Veja também 'totaldisrep'.

 -- Variável de opção: ratepsilon
     Valor Padrão: 2.0e-8

     'ratepsilon' é a tolerância usada em conversões de números em ponto
     flutuante para números racionais.

 -- Função: ratexpand (<expr>)
 -- Variável de opção: ratexpand
     Expande <expr> multiplicando para fora produtos de somas e somas
     exponenciadas, combinando frações sobre um denominador comum,
     cancelando o máximo divisor comum entre entre o numerador e o
     denominador, então quebrando o numerador (se for uma soma) dentro
     de suas respectivas parcelas divididas pelo denominador.

     O valor de retorno de 'ratexpand' é uma expressão geral, mesmo se
     <expr> for uma expressão racional canônica (CRE).

     O comutador 'ratexpand' se 'true' fará com que expressões CRE sejam
     completamente expandidas quando forem convertidas de volta para a
     forma geral ou mostradas, enquanto se for 'false' então elas serão
     colocadas na forma recursiva.  Veja também 'ratsimp'.

     Quando 'ratdenomdivide' for 'true', 'ratexpand' expande uma razão
     na qual o numerador é uma adição dentro de uma adição de razões,
     todas tendo um denominador comum.  De outra forma, 'ratexpand'
     contrai uma soma de razões em uma razão simples, cujo numerador é a
     soma dos numeradores de cada razão.

     Quando 'keepfloat' for 'true', evita que números em ponto flutuante
     sejam racionalizados quando expressões que contenham números em
     ponto flutuante forem convertidas para a forma de expressão
     racional canônica (CRE).

     Exemplos:

          (%i1) ratexpand ((2*x - 3*y)^3);
                               3         2       2        3
          (%o1)          - 27 y  + 54 x y  - 36 x  y + 8 x
          (%i2) expr: (x - 1)/(x + 1)^2 + 1/(x - 1);
                                   x - 1       1
          (%o2)                   -------- + -----
                                         2   x - 1
                                  (x + 1)
          (%i3) expand (expr);
                              x              1           1
          (%o3)          ------------ - ------------ + -----
                          2              2             x - 1
                         x  + 2 x + 1   x  + 2 x + 1
          (%i4) ratexpand (expr);
                                  2
                               2 x                 2
          (%o4)           --------------- + ---------------
                           3    2            3    2
                          x  + x  - x - 1   x  + x  - x - 1

 -- Variável de opção: ratfac
     Valor Padrão: 'false'

     Quando 'ratfac' for 'true', expressões racionais canônicas (CRE)
     são manipuladas na forma parcialmente fatorada.

     Durante operações racionais a expressão é mantida como
     completamente fatorada como foi possível sem chamadas a 'factor'.
     Isso pode sempre economizar espaço e pode economizar tempo em
     algumas computações.  O numerador e o denominador são feitos
     relativamente primos, por exemplo 'rat ((x^2 - 1)^4/(x + 1)^2)'
     retorna '(x - 1)^4 (x + 1)^2)', mas o fator dentro de cada parte
     pode não ser relativamente primo.

     No pacote 'ctensor' (Manipulação de componentes de tensores),
     tensores de Ricci, Einstein, Riemann, e de Weyl e a curvatura
     escalar são fatorados automaticamente quando 'ratfac' for 'true'.
     'ratfac' pode somente ser escolhido para casos onde as componentes
     tensoriais sejam sabidametne consistidas de poucos termos.

     Os esquemas de 'ratfac' e de 'ratweight' são incompatíveis e não
     podem ambos serem usados ao mesmo tempo.

 -- Função: ratnumer (<expr>)
     Retorna o numerador de <expr>, após forçar <expr> para uma
     expressão racional canônica (CRE). O valor de retorno é uma CRE.

     <expr> é forçada para uma CRE por 'rat' se isso não for já uma CRE.
     Essa conversão pode alterar a forma de <expr> pela colocação de
     todos os termos sobre um denominador comum.

     'num' é similar, mas retorna uma expressão comum em lugar de uma
     CRE. Também, 'num' não tenta colocar todos os termos sobre um
     denominador comum, e dessa forma algumas expressões que são
     consideradas razões por 'ratnumer' não são consideradas razões por
     'num'.

 -- Função: ratnump (<expr>)
     Retorna 'true' se <expr> for um inteiro literal ou razão de
     inteiros literais, de outra forma retorna 'false'.

 -- Função: ratp (<expr>)
     Retorna 'true' se <expr> for uma expressão racional canônica (CRE)
     ou CRE extendida, de outra forma retorna 'false'.

     CRE são criadas por 'rat' e funções relacionadas.  CRE extendidas
     são criadas por 'taylor' e funções relacionadas.

 -- Variável de opção: ratprint
     Valor Padrão: 'true'

     Quando 'ratprint' for 'true', uma mensagem informando ao usuário da
     conversão de números em ponto flutuante para números racionais é
     mostrada.

 -- Função: ratsimp (<expr>)
 -- Função: ratsimp (<expr>, <x_1>, ..., <x_n>)
     Simplifica a expressão <expr> e todas as suas subexpressões,
     incluindo os argumentos para funções não racionais.  O resultado é
     retornado como o quociente de dois polinômios na forma recursiva,
     isto é, os coeficientes de variável principal são polinômios em
     outras variáveis.  Variáveis podem incluir funções não racionais
     (e.g., 'sin (x^2 + 1)') e os argumentos para quaisquer tais funções
     são também simplificados racionalmente.

     'ratsimp (<expr>, <x_1>, ..., <x_n>)' habilita simplificação
     racional com a especiicação de variável ordenando como em
     'ratvars'.

     Quando 'ratsimpexpons' for 'true', 'ratsimp' é aplicado para os
     expoentes de expressões durante a simplificação.

     Veja também 'ratexpand'.  Note que 'ratsimp' é afetado por algum
     dos sinalizadores que afetam 'ratexpand'.

     Exemplos:

          (%i1) sin (x/(x^2 + x)) = exp ((log(x) + 1)^2 - log(x)^2);
                                                   2      2
                             x         (log(x) + 1)  - log (x)
          (%o1)        sin(------) = %e
                            2
                           x  + x
          (%i2) ratsimp (%);
                                       1          2
          (%o2)                  sin(-----) = %e x
                                     x + 1
          (%i3) ((x - 1)^(3/2) - (x + 1)*sqrt(x - 1))/sqrt((x - 1)*(x + 1));
                                 3/2
                          (x - 1)    - sqrt(x - 1) (x + 1)
          (%o3)           --------------------------------
                               sqrt((x - 1) (x + 1))
          (%i4) ratsimp (%);
                                     2 sqrt(x - 1)
          (%o4)                    - -------------
                                           2
                                     sqrt(x  - 1)
          (%i5) x^(a + 1/a), ratsimpexpons: true;
                                         2
                                        a  + 1
                                        ------
                                          a
          (%o5)                        x

 -- Variável de opção: ratsimpexpons
     Valor Padrão: 'false'

     Quando 'ratsimpexpons' for 'true', 'ratsimp' é aplicado para os
     expoentes de expressões durante uma simplificação.

 -- Função: ratsubst (<a>, <b>, <c>)
     Substitue <a> por <b> em <c> e retorna a expressão resultante.  <b>
     pode também ser uma adição, produto, expoente, etc.

     'ratsubst' sabe alguma coisa do significado de expressões uma vez
     que 'subst' não é uma substituição puramente sintática.  Dessa
     forma 'subst (a, x + y, x + y + z)' retorna 'x + y + z' ao passo
     que 'ratsubst' retorna 'z + a'.

     Quando 'radsubstflag' for 'true', 'ratsubst' faz substituição de
     radicais em expressões que explicitamente não possuem esses
     radicais.

     Exemplos:

          (%i1) ratsubst (a, x*y^2, x^4*y^3 + x^4*y^8);
                                        3      4
          (%o1)                      a x  y + a
          (%i2) cos(x)^4 + cos(x)^3 + cos(x)^2 + cos(x) + 1;
                         4         3         2
          (%o2)       cos (x) + cos (x) + cos (x) + cos(x) + 1
          (%i3) ratsubst (1 - sin(x)^2, cos(x)^2, %);
                      4           2                     2
          (%o3)    sin (x) - 3 sin (x) + cos(x) (2 - sin (x)) + 3
          (%i4) ratsubst (1 - cos(x)^2, sin(x)^2, sin(x)^4);
                                  4           2
          (%o4)                cos (x) - 2 cos (x) + 1
          (%i5) radsubstflag: false$
          (%i6) ratsubst (u, sqrt(x), x);
          (%o6)                           x
          (%i7) radsubstflag: true$
          (%i8) ratsubst (u, sqrt(x), x);
                                          2
          (%o8)                          u

 -- Função: ratvars (<x_1>, ..., <x_n>)
 -- Função: ratvars ()
 -- Variável de sistema: ratvars
     Declara variáveis principais <x_1>, ..., <x_n> para expressões
     racionais.  <x_n>, se presente em uma expressão racional, é
     considerada a variável principal.  De outra forma, <x_[n-1]> é
     considerada a variável principal se presente, e assim por diante
     até as variáveis precedentes para <x_1>, que é considerada a
     variável principal somente se nenhuma das variáveis que a sucedem
     estiver presente.

     Se uma variável em uma expressão racional não está presente na
     lista 'ratvars', a ela é dada uma prioridade menor que <x_1>.

     Os argumentos para 'ratvars' podem ser ou variáveis ou funções não
     racionais tais como 'sin(x)'.

     A variável 'ratvars' é uma lista de argumentos da função 'ratvars'
     quando ela foi chamada mais recentemente.  Cada chamada para a
     função 'ratvars' sobre-grava a lista apagando seu conteúdo
     anterior.  'ratvars ()' limpa a lista.

 -- Função: ratweight (<x_1>, <w_1>, ..., <x_n>, <w_n>)
 -- Função: ratweight ()
     Atribui um peso <w_i> para a variável <x_i>.  Isso faz com que um
     termo seja substituído por 0 se seu peso exceder o valor da
     variável 'ratwtlvl' (o padrão retorna sem truncação).  O peso de um
     termo é a soma dos produtos dos pesos de uma variável no termo
     vezes seu expoente.  Por exemplo, o peso de '3 x_1^2 x_2' é '2 w_1
     + w_2'.  A truncação de acordo com 'ratwtlvl' é realizada somente
     quando multiplicando ou exponencializando expressões racionais
     canônicas (CRE).

     'ratweight ()' retorna a lista cumulativa de atribuições de pesos.

     Nota: Os esquemas de 'ratfac' e 'ratweight' são incompatíveis e não
     podem ambo serem usados ao mesmo tempo.

     Exemplos:

          (%i1) ratweight (a, 1, b, 1);
          (%o1)                     [a, 1, b, 1]
          (%i2) expr1: rat(a + b + 1)$
          (%i3) expr1^2;
                            2                  2
          (%o3)/R/         b  + (2 a + 2) b + a  + 2 a + 1
          (%i4) ratwtlvl: 1$
          (%i5) expr1^2;
          (%o5)/R/                  2 b + 2 a + 1

 -- Variável de sistema: ratweights
     Valor Padrão: '[]'

     'ratweights' é a lista de pesos atribuídos por 'ratweight'.  A
     lista é cumulativa: cada chamada a 'ratweight' coloca ítens
     adicionais na lista.

     'kill (ratweights)' e 'save (ratweights)' ambos trabalham como
     esperado.

 -- Variável de opção: ratwtlvl
     Valor Padrão: 'false'

     'ratwtlvl' é usada em combinação com a função 'ratweight' para
     controlar a truncação de expressão racionais canônicas (CRE). Para
     o valor padrão 'false', nenhuma truncação ocorre.

 -- Função: remainder (<p_1>, <p_2>)
 -- Função: remainder (<p_1>, <p_2>, <x_1>, ..., <x_n>)
     Retorna o resto do polinômio <p_1> dividido pelo polinômio <p_2>.
     Os argumentos <x_1>, ..., <x_n> são interpretados como em
     'ratvars'.

     'remainder' retorna o segundo elemento de uma lista de dois
     elementos retornada por 'divide'.

 -- Função: resultant (<p_1>, <p_2>, <x>)
 -- Variável: resultant
     Calcula o resultante de dois polinômios <p_1> e <p_2>, eliminando a
     variável <x>.  O resultante é um determinante dos coeficientes de
     <x> em <p_1> e <p_2>, que é igual a zero se e somente se <p_1> e
     <p_2> tiverem um fator em comum não constante.

     Se <p_1> ou <p_2> puderem ser fatorados, pode ser desejável chamar
     'factor' antes de chamar 'resultant'.

     A variável 'resultant' controla que algorítmo será usado para
     calcular o resultante.  'subres' para o prs subresultante, 'mod'
     para o algorítmo resultante modular, e 'red' para prs reduzido.
     Para muitos problemas 'subres' pode ser melhor.  Para alguns
     problemas com valores grandes de grau de uma única variável ou de
     duas variáveis 'mod' pode ser melhor.

     A função 'bezout' pega os mesmos argumentos que 'resultant' e
     retorna uma matriz.  O determinante do valor de retorno é o
     resultante desejado.

 -- Variável de opção: savefactors
     Valor Padrão: 'false'

     Quando 'savefactors' for 'true', faz com que os fatores de uma
     expressão que é um produto de fatores sejam gravados por certas
     funções com o objetivo de aumentar a velocidade em posteriores
     fatorações de expressões contendo algum desses mesmos fatores.

 -- Função: sqfr (<expr>)
     é similar a 'factor' exceto que os fatores do polinômio são "livres
     de raízes".  Isto é, eles possuem fatores somente de grau um.  Esse
     algorítmo, que é também usado no primeiro estágio de 'factor',
     utiliza o fato que um polinômio tem em comum com sua n'ésima
     derivada todos os seus fatores de grau maior que n.  Dessa forma
     pegando o maior divisor comum com o polinômio das derivadas com
     relação a cada variável no polinômio, todos os fatores de grau
     maior que 1 podem ser achados.

     Exemplo:

          (%i1) sqfr (4*x^4 + 4*x^3 - 3*x^2 - 4*x - 1);
                                          2   2
          (%o1)                  (2 x + 1)  (x  - 1)

 -- Função: tellrat (<p_1>, ..., <p_n>)
 -- Função: tellrat ()
     Adiciona ao anel dos inteiros algébricos conhecidos do Maxima os
     elementos que são as soluções dos polinômios <p_1>, ..., <p_n>.
     Cada argumento <p_i> é um polinômio concoeficientes inteiros.

     'tellrat (<x>)' efetivamente significa substituir 0 por <x> em
     funções racionais.

     'tellrat ()' retorna uma lista das substituições correntes.

     'algebraic' deve ser escolhida para 'true' com o objetivo de que a
     simplificação de inteiros algébricos tenha efeito.

     Maxima inicialmente sabe sobre a unidade imaginária '%i' e todas as
     raízes de inteiros.

     Existe um comando 'untellrat' que pega kernels (núcleos) e remove
     propriedades 'tellrat'.

     Quando fazemos 'tellrat' em um polinômio de várias variáveis, e.g.,
     'tellrat (x^2 - y^2)', pode existir uma ambigüidade como para ou
     substituir '<y>^2' por '<x>^2' ou vice-versa.  Maxima seleciona uma
     ordenação particular, mas se o usuário desejar especificar qual
     e.g.  'tellrat (y^2 = x^2)' forneçe uma sintaxe que diga para
     substituir '<y>^2' por '<x>^2'.

     Exemplos:

          (%i1) 10*(%i + 1)/(%i + 3^(1/3));
                                     10 (%i + 1)
          (%o1)                      -----------
                                            1/3
                                      %i + 3
          (%i2) ev (ratdisrep (rat(%)), algebraic);
                       2/3      1/3              2/3      1/3
          (%o2)    (4 3    - 2 3    - 4) %i + 2 3    + 4 3    - 2
          (%i3) tellrat (1 + a + a^2);
                                      2
          (%o3)                     [a  + a + 1]
          (%i4) 1/(a*sqrt(2) - 1) + a/(sqrt(3) + sqrt(2));
                                1                 a
          (%o4)           ------------- + -----------------
                          sqrt(2) a - 1   sqrt(3) + sqrt(2)
          (%i5) ev (ratdisrep (rat(%)), algebraic);
                   (7 sqrt(3) - 10 sqrt(2) + 2) a - 2 sqrt(2) - 1
          (%o5)    ----------------------------------------------
                                         7
          (%i6) tellrat (y^2 = x^2);
                                  2    2   2
          (%o6)                 [y  - x , a  + a + 1]

 -- Função: totaldisrep (<expr>)
     Converte toda subexpressão de <expr> da forma de expressão
     racionais canônicas (CRE) para a forma geral e retorna o resultado.
     Se <expr> é em sí mesma na forma CRE então 'totaldisrep' é identica
     a 'ratdisrep'.

     'totaldisrep' pode ser usada para fazer um 'ratdisrep' em
     expressões tais como equações, listas, matrizes, etc., que tiverem
     algumas subexpressões na forma CRE.

 -- Função: untellrat (<x_1>, ..., <x_n>)
     Remove propriedades 'tellrat' de <x_1>, ..., <x_n>.


File: maxima.info,  Node: Constantes,  Next: Logarítmos,  Prev: Polinômios,  Up: Top

13 Constantes
*************

* Menu:

* Funções e Variáveis Definidas para Constantes::


File: maxima.info,  Node: Funções e Variáveis Definidas para Constantes,  Prev: Constantes,  Up: Constantes

13.1 Funções e Variáveis Definidas para Constantes
==================================================

 -- Constante: %e
     '%e' representa a base do logarítmo natural, também conhecido como
     constante de Euler.  O valor numérico de '%e' é um número em ponto
     flutuante de precisão dupla 2.718281828459045d0.

 -- Constante: %i
     '%i' representa a unidade imaginária, sqrt(- 1).

 -- Constante: false
     'false' representa a constante Booleana falso.  Maxima implementa
     'false' através do valor 'NIL' no Lisp.

 -- Constante: inf
     'inf' representa o infinito positivo real.

 -- Constante: infinity
     'infinity' representa o infinito complexo.

 -- Constante: minf
     'minf' representa o menos infinito (i.e., negativo) real.

 -- Constante: %phi

     '%phi' representa o então chamado número áureo, (1 + sqrt(5))/2.  O
     valor numérico de '%phi' é o número em ponto flutuante de de dupla
     precisão 1.618033988749895d0.

     'fibtophi' expressa números de Fibonacci 'fib(n)' em termos de
     '%phi'.

     Por padrão, Maxima não conhece as propriedade algébricas de '%phi'.
     Após avaliar 'tellrat(%phi^2 - %phi - 1)' e 'algebraic: true',
     'ratsimp' pode simplificar algumas expressãoes contendo '%phi'.

     Exemplos:

     'fibtophi' expresses Fibonacci numbers 'fib(n)' in terms of '%phi'.

          (%i1) fibtophi (fib (n));
                                     n             n
                                 %phi  - (1 - %phi)
          (%o1)                  -------------------
                                     2 %phi - 1
          (%i2) fib (n-1) + fib (n) - fib (n+1);
          (%o2)          - fib(n + 1) + fib(n) + fib(n - 1)
          (%i3) fibtophi (%);
                      n + 1             n + 1       n             n
                  %phi      - (1 - %phi)        %phi  - (1 - %phi)
          (%o3) - --------------------------- + -------------------
                          2 %phi - 1                2 %phi - 1
                                                    n - 1             n - 1
                                                %phi      - (1 - %phi)
                                              + ---------------------------
                                                        2 %phi - 1
          (%i4) ratsimp (%);
          (%o4)                           0

     Por padrão, Maxima não conhece as propriedade algébricas de '%phi'.
     Após avaliar 'tellrat(%phi^2 - %phi - 1)' e 'algebraic: true',
     'ratsimp' pode simplificar algumas expressãoes contendo '%phi'.

          (%i1) e : expand ((%phi^2 - %phi - 1) * (A + 1));
                           2                      2
          (%o1)        %phi  A - %phi A - A + %phi  - %phi - 1
          (%i2) ratsimp (e);
                            2                     2
          (%o2)        (%phi  - %phi - 1) A + %phi  - %phi - 1
          (%i3) tellrat (%phi^2 - %phi - 1);
                                      2
          (%o3)                  [%phi  - %phi - 1]
          (%i4) algebraic : true;
          (%o4)                         true
          (%i5) ratsimp (e);
          (%o5)                           0

 -- Constante: %pi
     '%pi' representa a razão do perímetro de um círculo para seu
     diâmetro.  O valor numérico de '%pi' é o n;umero em ponto flutuante
     de dupla precisão 3.141592653589793d0.

 -- Constante: true
     'true' representa a constante Booleana verdadeiro.  Maxima
     implementa 'true' através do valor 'T' no Lisp.


File: maxima.info,  Node: Logarítmos,  Next: Trigonometria,  Prev: Constantes,  Up: Top

14 Logarítmos
*************

* Menu:

* Funções e Variáveis Definidas para Logarítmos::


File: maxima.info,  Node: Funções e Variáveis Definidas para Logarítmos,  Prev: Logarítmos,  Up: Logarítmos

14.1 Funções e Variáveis Definidas para Logarítmos
==================================================

 -- Variável de opção: %e_to_numlog
     Valor padrão: 'false'

     Quando 'true', sendo 'r' algum número racional, e 'x' alguma
     expressão, '%e^(r*log(x))' será simplificado em 'x^r' .  Note-se
     que o comando 'radcan' também faz essa transformação, e
     transformações mais complicadas desse tipo também.  O comando
     'logcontract' "contrai" expressões contendo 'log'.

 -- Função: li [<s>] (<z>)
     Representa a função polilogarítmo de ordem <s> e argumento <z>,
     definida por meio de séries infinitas

                                           inf
                                           ====   k
                                           \     z
                                  Li (z) =  >    --
                                    s      /      s
                                           ====  k
                                           k = 1

     'li [1]' é '- log (1 - z)'.  'li [2]' e 'li [3]' são as funções
     dilogarítmo e trilogarítmo, respectivamente.

     Quando a ordem for 1, o polilogarítmo simplifica para '- log (1 -
     z)', o qual por sua vez simplifica para um valor numérico se <z>
     for um número em ponto flutuante real ou complexo ou o sinalizador
     de avaliação 'numer' estiver presente.

     Quando a ordem for 2 ou 3, o polilogarítmo simplifica para um valor
     numérico se <z> for um número real em ponto flutuante ou o
     sinalizador de avaliação 'numer' estiver presente.

     Exemplos:

          (%i1) assume (x > 0);
          (%o1)                        [x > 0]
          (%i2) integrate ((log (1 - t)) / t, t, 0, x);
          (%o2)                       - li (x)
                                          2
          (%i3) li [2] (7);
          (%o3)                        li (7)
                                         2
          (%i4) li [2] (7), numer;
          (%o4)        1.24827317833392 - 6.113257021832577 %i
          (%i5) li [3] (7);
          (%o5)                        li (7)
                                         3
          (%i6) li [2] (7), numer;
          (%o6)        1.24827317833392 - 6.113257021832577 %i
          (%i7) L : makelist (i / 4.0, i, 0, 8);
          (%o7)   [0.0, 0.25, 0.5, 0.75, 1.0, 1.25, 1.5, 1.75, 2.0]
          (%i8) map (lambda ([x], li [2] (x)), L);
          (%o8) [0, .2676526384986274, .5822405249432515,
          .9784693966661848, 1.64493407, 2.190177004178597
           - .7010261407036192 %i, 2.374395264042415
           - 1.273806203464065 %i, 2.448686757245154
           - 1.758084846201883 %i, 2.467401098097648
           - 2.177586087815347 %i]
          (%i9) map (lambda ([x], li [3] (x)), L);
          (%o9) [0, .2584613953442624, 0.537213192678042,
          .8444258046482203, 1.2020569, 1.642866878950322
           - .07821473130035025 %i, 2.060877505514697
           - .2582419849982037 %i, 2.433418896388322
           - .4919260182322965 %i, 2.762071904015935
           - .7546938285978846 %i]

 -- Função: log (<x>)
     Representa o logarítmo natural (base e) de <x>.

     Maxima não possui uma função interna para logarítmo de base 10 ou
     de outras bases.  'log10(x) := log(x) / log(10)' é uma definição
     útil.

     Simplificação e avaliação de logarítmos são governadas por muitos
     sinalizadores globais:

     'logexpand' - faz com que 'log(a^b)' torne-se 'b*log(a)'.  Se
     'logexpand' for escolhida para 'all', 'log(a*b)' irá também
     simplificar para 'log(a)+log(b)'.  Se 'logexpand' for escolhida
     para 'super', então 'log(a/b)' irá também simplificar para
     'log(a)-log(b)' para números racionais 'a/b', 'a#1'.  ('log(1/b)',
     para 'b' inteiro, sempre simplifica).  Se 'logexpand' for escolhida
     para 'false', todas essas simplificações irão ser desabilitadas.

     'logsimp' - se 'false' então nenhuma simplificação de '%e' para um
     expoente contendo 'log''s é concluída.

     'lognumer' - se 'true' então argumentos negativos em ponto
     flutuante para 'log' irá sempre ser convertido para seu valor
     absoluto antes que 'log' seja tomado.  Se 'numer' for também
     'true', então argumentos negativos inteiros para 'log' irão também
     ser convertidos para seu valor absoluto.

     'lognegint' - se 'true' implementa a regra 'log(-n)' ->
     'log(n)+%i*%pi' para 'n' um inteiro positivo.

     '%e_to_numlog' - quando 'true', 'r' sendo algum número racional, e
     'x' alguma expressão, '%e^(r*log(x))' será simplificado em 'x^r' .
     Note-se que o comando 'radcan' também faz essa transformação, e
     transformações mais complicadas desse tipo também.  O comando
     'logcontract' "contrai" expressões contendo 'log'.

 -- Variável de opção: logabs
     Valor padrão: 'false'

     Quando fazendo integração indefinida onde logs são gerados, e.g.
     'integrate(1/x,x)', a resposta é dada em termos de 'log(abs(...))'
     se 'logabs' for 'true', mas em termos de 'log(...)' se 'logabs' for
     'false'.  Para integração definida, a escolha 'logabs:true' é
     usada, porque aqui "avaliação" de integral indefinida nos extremos
     é muitas vezes necessária.

 -- Variável de opção: logarc
 -- Função: logarc (<expr>)

     Quando a variável global 'logarc' for 'true', funções circulares
     inversas e funções hiperbólicas serão convertidas em funções
     logarítimicas equivalentes.  O valor padrão de 'logarc' é 'false'.

     A função 'logarc(<expr>)' realiza aquela substituíção para uma
     expressão <expr> sem modificar o valor da variável global 'logarc'.

 -- Variável de opção: logconcoeffp
     Valor padrão: 'false'

     Controla quais coeficientes são contraídos quando usando
     'logcontract'.  Pode ser escolhida para o nome de uma função
     predicado de um argumento.  E.g.  se você gosta de gerar raízes
     quadradas, você pode fazer 'logconcoeffp:'logconfun$
     logconfun(m):=featurep(m,integer) ou ratnump(m)$' .  Então
     'logcontract(1/2*log(x));' irá fornecer 'log(sqrt(x))'.

 -- Função: logcontract (<expr>)
     Recursivamente examina a expressão <expr>, transformando
     subexpressões da forma 'a1*log(b1) + a2*log(b2) + c' em
     'log(ratsimp(b1^a1 * b2^a2)) + c'

          (%i1) 2*(a*log(x) + 2*a*log(y))$
          (%i2) logcontract(%);
                                           2  4
          (%o2)                     a log(x  y )


     Se você faz 'declare(n,integer);' então
     'logcontract(2*a*n*log(x));' fornece 'a*log(x^(2*n))'.  Os
     coeficientes que "contraem" dessa maneira são aqueles tais que 2 e
     'n' que satisfazem 'featurep(coeff,integer)'.  O usuário pode
     controlar quais coeficientes são contraídos escolhendo a opção
     'logconcoeffp' para o nome de uma função predicado de um argumento.
     E.g.  se você gosta de gerara raízes quadradas, você pode fazer
     'logconcoeffp:'logconfun$ logconfun(m):=featurep(m,integer) ou
     ratnump(m)$' .  Então 'logcontract(1/2*log(x));' irá fornecer
     'log(sqrt(x))'.

 -- Variável de opção: logexpand
     Valor padrão: 'true'

     Faz com que 'log(a^b)' torne-se 'b*log(a)'.  Se for escolhida para
     'all', 'log(a*b)' irá também simplificar para 'log(a)+log(b)'.  Se
     for escolhida para 'super', então 'log(a/b)' irá também simplificar
     para 'log(a)-log(b)' para números racionais 'a/b', 'a#1'.
     ('log(1/b)', para 'b' inteiro, sempre simplifica).  Se for
     escolhida para 'false', todas essas simplificações irão ser
     desabilitadas.

 -- Variável de opção: lognegint
     Valor padrão: 'false'

     Se 'true' implementa a regra 'log(-n)' -> 'log(n)+%i*%pi' para 'n'
     um inteiro positivo.

 -- Variável de opção: lognumer
     Valor padrão: 'false'

     Se 'true' então argumentos negativos em ponto flutuante para 'log'
     irão sempre ser convertidos para seus valores absolutos antes que o
     'log' seja tomado.  Se 'numer' for também 'true', então argumentos
     inteiros negativos para 'log' irão também ser convertidos para seus
     valores absolutos.

 -- Variável de opção: logsimp
     Valor padrão: 'true'

     Se 'false' então nenhuma simplificação de '%e' para um expoente
     contendo 'log''s é concluída.

 -- Função: plog (<x>)
     Representa o principal ramo logarítmos naturais avaliados para
     complexos com '-%pi' < 'carg(<x>)' <= '+%pi' .


File: maxima.info,  Node: Trigonometria,  Next: Funções Especiais,  Prev: Logarítmos,  Up: Top

15 Trigonometria
****************

* Menu:

* Introdução ao Pacote Trigonométrico::
* Funções e Variáveis Definidas para Trigonometria::


File: maxima.info,  Node: Introdução ao Pacote Trigonométrico,  Next: Funções e Variáveis Definidas para Trigonometria,  Prev: Trigonometria,  Up: Trigonometria

15.1 Introdução ao Pacote Trigonométrico
========================================

Maxima tem muitas funções trigonométricas definidas.  Não todas as
identidades trigonometricas estão programadas, mas isso é possível para
o usuário adicionar muitas delas usando a compatibilidade de
correspondência de modelos do sistema.  As funções trigonométricas
definidas no Maxima são: 'acos', 'acosh', 'acot', 'acoth', 'acsc',
'acsch', 'asec', 'asech', 'asin', 'asinh', 'atan', 'atanh', 'cos',
'cosh', 'cot', 'coth', 'csc', 'csch', 'sec', 'sech', 'sin', 'sinh',
'tan', e 'tanh'.  Existe uma coleção de comandos especialmente para
manusear funções trigonométricas, veja 'trigexpand', 'trigreduce', e o
comutador 'trigsign'.  Dois pacotes compartilhados extendem as regras de
simplificação construídas no Maxima, 'ntrig' e 'atrig1'.  Faça
'describe(<comando>)' para detalhes.


File: maxima.info,  Node: Funções e Variáveis Definidas para Trigonometria,  Prev: Introdução ao Pacote Trigonométrico,  Up: Trigonometria

15.2 Funções e Variáveis Definidas para Trigonometria
=====================================================

 -- Função: acos (<x>)
     - Arco Cosseno.

 -- Função: acosh (<x>)
     - Arco Cosseno Hiperbólico.

 -- Função: acot (<x>)
     - Arco Cotangente.

 -- Função: acoth (<x>)
     - Arco Cotangente Hiperbólico.

 -- Função: acsc (<x>)
     - Arco Cossecante.

 -- Função: acsch (<x>)
     - Arco Cossecante Hiperbólico.

 -- Função: asec (<x>)
     - Arco Secante.

 -- Função: asech (<x>)
     - Arco Secante Hiperbólico.

 -- Função: asin (<x>)
     - Arco Seno.

 -- Função: asinh (<x>)
     - Arco Seno Hiperbólico.

 -- Função: atan (<x>)
     - Arco Tangente.

 -- Função: atan2 (<y>, <x>)
     - retorna o valor de 'atan(<y>/<x>)' no intervalo de '-%pi' a
     '%pi'.

 -- Função: atanh (<x>)
     - Arco tangente Hiperbólico.

 -- Pacote: atrig1
     O pacote 'atrig1' contém muitas regras adicionais de simplificação
     para funções trigonométricas inversas.  Junto com regras já
     conhecidas para Maxima, os seguintes ângulos estão completamente
     implementados: '0', '%pi/6', '%pi/4', '%pi/3', e '%pi/2'.  Os
     ângulos correspondentes nos outros três quadrantes estão também
     disponíveis.  Faça 'load(atrig1);' para usá-lo.

 -- Função: cos (<x>)
     - Cosseno.

 -- Função: cosh (<x>)
     - Cosseno hiperbólico.

 -- Função: cot (<x>)
     - Cotangente.

 -- Função: coth (<x>)
     - Cotangente Hyperbólica.

 -- Função: csc (<x>)
     - Cossecante.

 -- Função: csch (<x>)
     - Cossecante Hyperbólica.

 -- Variável de opção: halfangles
     Default value: 'false'

     Quando 'halfangles' for 'true', meios-ângulos são simplificados
     imediatamente.

 -- Pacote: ntrig
     O pacote 'ntrig' contém um conjunto de regras de simplificação que
     são usadas para simplificar função trigonométrica cujos argumentos
     estão na forma '<f>(<n> %pi/10)' onde <f> é qualquer das funções
     'sin', 'cos', 'tan', 'csc', 'sec' e 'cot'.

 -- Função: sec (<x>)
     - Secante.

 -- Função: sech (<x>)
     - Secante Hyperbólica.

 -- Função: sin (<x>)
     - Seno.

 -- Função: sinh (<x>)
     - Seno Hyperbólico.

 -- Função: tan (<x>)
     - Tangente.

 -- Função: tanh (<x>)
     - Tangente Hyperbólica.

 -- Função: trigexpand (<expr>)
     Expande funções trigonometricas e hyperbólicas de adições de
     ângulos e de ângulos multiplos que ocorram em <expr>.  Para
     melhores resultados, <expr> deve ser expandida.  Para intensificar
     o controle do usuário na simplificação, essa função expande somente
     um nível de cada vez, expandindo adições de ângulos ou ângulos
     multiplos.  Para obter expansão completa dentro de senos e cossenos
     imediatamente, escolha o comutador 'trigexpand: true'.

     'trigexpand' é governada pelos seguintes sinalizadores globais:

     'trigexpand'
          Se 'true' causa expansão de todas as expressões contendo senos
          e cossenos ocorrendo subseqüêntemente.
     'halfangles'
          Se 'true' faz com que meios-ângulos sejam simplificados
          imediatamente.
     'trigexpandplus'
          Controla a regra "soma" para 'trigexpand', expansão de adições
          (e.g.  'sin(x + y)') terão lugar somente se 'trigexpandplus'
          for 'true'.
     'trigexpandtimes'
          Controla a regra "produto" para 'trigexpand', expansão de
          produtos (e.g.  'sin(2 x)') terão lugar somente se
          'trigexpandtimes' for 'true'.

     Exemplos:

          (%i1) x+sin(3*x)/sin(x),trigexpand=true,expand;
                                   2           2
          (%o1)               - sin (x) + 3 cos (x) + x
          (%i2) trigexpand(sin(10*x+y));
          (%o2)          cos(10 x) sin(y) + sin(10 x) cos(y)


 -- Variável de opção: trigexpandplus
     Valor padrão: 'true'

     'trigexpandplus' controla a regra da "soma" para 'trigexpand'.
     Dessa forma, quando o comando 'trigexpand' for usado ou o comutador
     'trigexpand' escolhido para 'true', expansão de adições (e.g.
     'sin(x+y))' terão lugar somente se 'trigexpandplus' for 'true'.

 -- Variável de opção: trigexpandtimes
     Valor padrão: 'true'

     'trigexpandtimes' controla a regra "produto" para 'trigexpand'.
     Dessa forma, quando o comando 'trigexpand' for usado ou o comutador
     'trigexpand' escolhido para 'true', expansão de produtos (e.g.
     'sin(2*x)') terão lugar somente se 'trigexpandtimes' for 'true'.

 -- Variável de opção: triginverses
     Valor padrão: 'all'

     'triginverses' controla a simplificação de composições de funções
     trigonométricas e hiperbólicas com suas funções inversas.

     Se 'all', ambas e.g.  'atan(tan(<x>))' e 'tan(atan(<x>))'
     simplificarão para <x>.

     Se 'true', a simplificação de '<arcfun>(<fun>(<x>))' é
     desabilitada.

     Se 'false', ambas as simplificações '<arcfun>(<fun>(<x>))' e
     '<fun>(<arcfun>(<x>))' são desabilitadas.

 -- Função: trigreduce (<expr>, <x>)
 -- Função: trigreduce (<expr>)
     Combina produtos e expoentes de senos e cossenso trigonométricos e
     hiperbólicos de <x> dentro daqueles de múltiplos de <x>.  Também
     tenta eliminar essas funções quando elas ocorrerem em
     denominadores.  Se <x> for omitido então todas as variáveis em
     <expr> são usadas.

     Veja também 'poissimp'.

          (%i1) trigreduce(-sin(x)^2+3*cos(x)^2+x);
                         cos(2 x)      cos(2 x)   1        1
          (%o1)          -------- + 3 (-------- + -) + x - -
                            2             2       2        2


     As rotinas de simplificação trigonométrica irão usar informações
     declaradas em alguns casos simples.  Declarações sobre variáveis
     são usadas como segue, e.g.

          (%i1) declare(j, integer, e, even, o, odd)$
          (%i2) sin(x + (e + 1/2)*%pi);
          (%o2)                        cos(x)
          (%i3) sin(x + (o + 1/2)*%pi);
          (%o3)                       - cos(x)


 -- Variável de opção: trigsign
     Valor padrão: 'true'

     Quando 'trigsign' for 'true', permite simplificação de argumentos
     negativos para funções trigonométricas.  E.g., 'sin(-x)'
     transformar-se-á em '-sin(x)' somente se 'trigsign' for 'true'.

 -- Função: trigsimp (<expr>)
     Utiliza as identidades sin(x)^2 + cos(x)^2 = 1 and cosh(x)^2 -
     sinh(x)^2 = 1 para simplificar expressões contendo 'tan', 'sec',
     etc., para 'sin', 'cos', 'sinh', 'cosh'.

     'trigreduce', 'ratsimp', e 'radcan' podem estar habilitadas a
     adicionar simplificações ao resultado.

     'demo ("trgsmp.dem")' mostra alguns exemplos de 'trigsimp'.

 -- Função: trigrat (<expr>)
     Fornece uma forma quase-linear simplificada canônica de uma
     expressão trigonométrica; <expr> é uma fração racional de muitos
     'sin', 'cos' ou 'tan', os argumentos delas são formas lineares em
     algumas variáveis (ou kernels-núcleos) e '%pi/<n>' (<n> inteiro)
     com coeficientes inteiros.  O resultado é uma fração simplificada
     com numerador e denominador ambos lineares em 'sin' e 'cos'.  Dessa
     forma 'trigrat' lineariza sempre quando isso for passível.

          (%i1) trigrat(sin(3*a)/sin(a+%pi/3));
          (%o1)            sqrt(3) sin(2 a) + cos(2 a) - 1


     O seguinte exemplo encontra-se em Davenport, Siret, and Tournier,
     Calcul Formel, Masson (ou em inglês, Addison-Wesley), seção 1.5.5,
     teorema de Morley.

          (%i1) c: %pi/3 - a - b;
                                              %pi
          (%o1)                     - b - a + ---
                                               3
          (%i2) bc: sin(a)*sin(3*c)/sin(a+b);
                                sin(a) sin(3 b + 3 a)
          (%o2)                 ---------------------
                                     sin(b + a)
          (%i3) ba: bc, c=a, a=c$
          (%i4) ac2: ba^2 + bc^2 - 2*bc*ba*cos(b);
                   2       2
                sin (a) sin (3 b + 3 a)
          (%o4) -----------------------
                         2
                      sin (b + a)

                                                  %pi
             2 sin(a) sin(3 a) cos(b) sin(b + a - ---) sin(3 b + 3 a)
                                                   3
           - --------------------------------------------------------
                                     %pi
                             sin(a - ---) sin(b + a)
                                      3

                2         2         %pi
             sin (3 a) sin (b + a - ---)
                                     3
           + ---------------------------
                       2     %pi
                    sin (a - ---)
                              3
          (%i5) trigrat (ac2);
          (%o5) - (sqrt(3) sin(4 b + 4 a) - cos(4 b + 4 a)

           - 2 sqrt(3) sin(4 b + 2 a) + 2 cos(4 b + 2 a)

           - 2 sqrt(3) sin(2 b + 4 a) + 2 cos(2 b + 4 a)

           + 4 sqrt(3) sin(2 b + 2 a) - 8 cos(2 b + 2 a) - 4 cos(2 b - 2 a)

           + sqrt(3) sin(4 b) - cos(4 b) - 2 sqrt(3) sin(2 b) + 10 cos(2 b)

           + sqrt(3) sin(4 a) - cos(4 a) - 2 sqrt(3) sin(2 a) + 10 cos(2 a)

           - 9)/4



File: maxima.info,  Node: Funções Especiais,  Next: Funções Elípticas,  Prev: Trigonometria,  Up: Top

16 Funções Especiais
********************

* Menu:

* Introdução a Funções Especiais::
* Funções e Variáveis Definidas para Funções Especiais::


File: maxima.info,  Node: Introdução a Funções Especiais,  Next: Funções e Variáveis Definidas para Funções Especiais,  Prev: Funções Especiais,  Up: Funções Especiais

16.1 Introdução a Funções Especiais
===================================

A notação de função especial segue adiante:

     bessel_j (index, expr)         Função de Bessel, primeiro tipo
     bessel_y (index, expr)         Função de Bessel, segundo tipo
     bessel_i (index, expr)         Função de Bessel modificada, primeiro tipo
     bessel_k (index, expr)         Função de Bessel modificada, segundo tipo
     %he[n] (z)                     Polinômio de Hermite (Note bem: he, não h. Veja A&S 22.5.18)
     %p[u,v] (z)                    Função de Legendre
     %q[u,v] (z)                    Função de Legendre, segundo tipo
     hstruve[n] (z)                 Função H de Struve H
     lstruve[n] (z)                 Função L de Struve
     %f[p,q] ([], [], expr)         Função Hipergeométrica Generalizada
     gamma()                        Função Gamma
     gamma_incomplete_lower(a,z)    Função gama incompleta inferior
     gammaincomplete(a,z)           Final da função gama incompleta
     slommel
     %m[u,k] (z)                    Função de Whittaker, primeiro tipo
     %w[u,k] (z)                    Função de Whittaker, segundo tipo
     erfc (z)                       Complemento da função erf (função de erros - integral da distribuição normal)
     ei (z)                         Integral de exponencial (?)
     kelliptic (z)                  integral eliptica completa de primeiro tipo (K)
     %d [n] (z)                     Função cilíndrica parabólica


File: maxima.info,  Node: Funções e Variáveis Definidas para Funções Especiais,  Prev: Introdução a Funções Especiais,  Up: Funções Especiais

16.2 Funções e Variáveis Definidas para Funções Especiais
=========================================================

 -- Função: airy_ai (<x>)
     A função de Airy Ai, como definida em Abramowitz e Stegun, Handbook
     of Mathematical Functions, Sessão 10.4.

     A equação de Airy 'diff (y(x), x, 2) - x y(x) = 0' tem duas
     soluções linearmente independentes, 'y = Ai(x)' e 'y = Bi(x)'.  A
     derivada de 'diff (airy_ai(x), x)' é 'airy_dai(x)'.

     Se o argumento 'x' for um número real ou um número complexo
     qualquer deles em ponto flutuante , o valor numérico de 'airy_ai' é
     retornado quando possível.

     Veja também 'airy_bi', 'airy_dai', 'airy_dbi'.

 -- Função: airy_dai (<x>)
     A derivada da função de Airy Ai 'airy_ai(x)'.

     Veja 'airy_ai'.

 -- Função: airy_bi (<x>)
     A função de Airy Bi, como definida em Abramowitz e Stegun, Handbook
     of Mathematical Functions, Sessão 10.4, é a segunda solução da
     equação de Airy 'diff (y(x), x, 2) - x y(x) = 0'.

     Se o argumento 'x' for um número real ou um número complexo
     qualquer deles em ponto flutuante, o valor numérico de 'airy_bi' é
     retornado quando possível.  Em outros casos a expressão não
     avaliada é retornada.

     A derivada de 'diff (airy_bi(x), x)' é 'airy_dbi(x)'.

     Veja 'airy_ai', 'airy_dbi'.

 -- Função: airy_dbi (<x>)
     A derivada de função de Airy Bi 'airy_bi(x)'.

     Veja 'airy_ai' e 'airy_bi'.

 -- Função: asympa
     'asympa' é um pacote para análise assintótica.  O pacote contém
     funções de simplificação para análise assintótica, incluindo as
     funções "grande O" e "pequeno o" que são largamente usadas em
     análises de complexidade e análise numérica.

     'load ("asympa")' chama esse pacote.

 -- Função: bessel (<z>, <a>)
     A função de Bessel de primeiro tipo.

     Essa função está desatualizada.  Escreva 'bessel_j (<z>, <a>)' em
     lugar dessa.

 -- Função: bessel_j (<v>, <z>)
     A função de Bessel do primeiro tipo de ordem v e argumento z.

     'bessel_j' calcula o array 'besselarray' tal que 'besselarray [i] =
     bessel_j [i + v - int(v)] (z)' para 'i' de zero a 'int(v)'.

     'bessel_j' é definida como
                          inf
                          ====       k  - v - 2 k  v + 2 k
                          \     (- 1)  2          z
                           >    --------------------------
                          /        k! gamma(v + k + 1)
                          ====
                          k = 0

     todavia séries infinitas não são usadas nos cálculos.

 -- Função: bessel_y (<v>, <z>)
     A função de Bessel do segundo tipo de ordem v e argumento z.

     'bessel_y' calcula o array 'besselarray' tal que 'besselarray [i] =
     bessel_y [i + v - int(v)] (z)' para 'i' de zero a 'int(v)'.

     'bessel_y' é definida como
                        cos(%pi v) bessel_j(v, z) - bessel_j(-v, z)
                        -------------------------------------------
                                       sin(%pi v)

     quando v não for um inteiro.  Quando v for um inteiro n, o limite
     com v aprocimando-se de n é tomado.

 -- Função: bessel_i (<v>, <z>)
     A função de Bessel modificada de primeiro tipo de ordem v e
     argumento z.

     'bessel_i' calcula o array 'besselarray' tal que 'besselarray [i] =
     bessel_i [i + v - int(v)] (z)' para 'i' de zero a 'int(v)'.

     'bessel_i' é definida como
                              inf
                              ====   - v - 2 k  v + 2 k
                              \     2          z
                               >    -------------------
                              /     k! gamma(v + k + 1)
                              ====
                              k = 0

     embora séries infinitas não são usadas nos cálculos.

 -- Função: bessel_k (<v>, <z>)
     A função de Bessel modificada de segundo tipo de ordem v e
     argumento z.

     'bessel_k' calcula o array 'besselarray' tal que 'besselarray [i] =
     bessel_k [i + v - int(v)] (z)' para 'i' de zero a 'int(v)'.

     'bessel_k' é definida como
                     %pi csc(%pi v) (bessel_i(-v, z) - bessel_i(v, z))
                     -------------------------------------------------
                                            2

     quando v não for inteiro.  Se v for um inteiro n, então o limite
     com v aproximando-se de n é tomado.

 -- Variável de opção: besselexpand
     Valor padrão: 'false'

     Expansões de controle de funções de Bessel quando a ordem for a
     metade de um inteiro ímpar.  Nesse caso, as funções de Bessel podem
     ser expandidas em termos de outras funções elementares.  Quando
     'besselexpand' for 'true', a função de Bessel é expandida.

          (%i1) besselexpand: false$
          (%i2) bessel_j (3/2, z);
                                              3
          (%o2)                      bessel_j(-, z)
                                              2
          (%i3) besselexpand: true$
          (%i4) bessel_j (3/2, z);
                                    2 z   sin(z)   cos(z)
          (%o4)                sqrt(---) (------ - ------)
                                    %pi      2       z
                                            z

 -- Função: scaled_bessel_i (<v>, <z>)

     A função homotética modificada de Bessel de primeiro tipo de ordem
     v e argumento z.  Isto é, scaled_bessel_i(v,z) =
     exp(-abs(z))*bessel_i(v, z).  Essa função é particularmente útil
     para calcular bessel_i para grandes valores de z.  Todavia, maxima
     não conhece outra forma muito mais sobre essa função.  Para
     computação simbólica, é provavelmete preferível trabalhar com a
     expressão 'exp(-abs(z))*bessel_i(v, z)'.

 -- Função: scaled_bessel_i0 (<z>)

     Idêntica a 'scaled_bessel_i(0,z)'.

 -- Função: scaled_bessel_i1 (<z>)

     Idêntica a 'scaled_bessel_i(1,z)'.

 -- Função: beta (<x>, <y>)
     A função beta, definida como 'gamma(x) gamma(y)/gamma(x + y)'.

 -- Função: gamma (<x>)
     A função gama.

     Veja também 'makegamma'.

     A variável 'gammalim' controla a simplificação da função gama.

     A constante de Euler-Mascheroni é '%gamma'.

 -- Variável de opção: gammalim
     Valor padrão: 1000000

     'gammalim' controla a simplificação da função gama para integral e
     argumentos na forma de números racionais.  Se o valor absoluto do
     argumento não for maior que 'gammalim', então a simplificação
     ocorrerá.  Note que 'factlim' comuta controle de simplificaçcão do
     resultado de 'gamma' de um argumento inteiro também.

 -- Função: intopois (<a>)
     Converte <a> em um código de Poisson.

 -- Função: makefact (<expr>)
     Transforma instâncias de funções binomiais, gama, e beta em <expr>
     para fatoriais.

     Veja também 'makegamma'.

 -- Função: makegamma (<expr>)
     Transforma instâncias de funções binomiais, fatorial, e beta em
     <expr> para funções gama.

     Veja também 'makefact'.

 -- Função: numfactor (<expr>)
     Retorna o fator numérico multiplicando a expressão <expr>, que pode
     ser um termo simples.

     'content' retorna o máximo divisor comum (mdc) de todos os termos
     em uma adição.

          (%i1) gamma (7/2);
                                    15 sqrt(%pi)
          (%o1)                     ------------
                                         8
          (%i2) numfactor (%);
                                         15
          (%o2)                          --
                                         8

 -- Função: outofpois (<a>)
     Converte <a> de um código de Poisson para uma representação geral.
     Se <a> não for uma forma de Poisson, 'outofpois' realiza a
     conversão, i.e., o valor de retorno é 'outofpois (intopois (<a>))'.
     Essa função é desse modo um simplificador canônico para adições e
     potências de termos de seno e cosseno de um tipo particular.

 -- Função: poisdiff (<a>, <b>)
     Deriva <a> em relação a <b>.  <b> deve ocorrer somente nos
     argumentos trigonométricos ou somente nos coeficientes.

 -- Função: poisexpt (<a>, <b>)
     Funcionalmente identica a 'intopois (<a>^<b>)'.  <b> deve ser um
     inteiro positico.

 -- Função: poisint (<a>, <b>)
     Integra em um senso restrito similarmente (para 'poisdiff').
     Termos não periódicos em <b> são diminuídos se <b> estiver em
     argumentos trigonométricos.

 -- Variável de opção: poislim
     Valor padrão: 5

     'poislim' determina o domínio dos coeficientes nos argumentos de
     funções trigonométricas.  O valor inicial de 5 corresponde ao
     intervalo [-2^(5-1)+1,2^(5-1)], ou [-15,16], mas isso pode ser
     alterado para [-2^(n-1)+1, 2^(n-1)].

 -- Função: poismap (<series>, <sinfn>, <cosfn>)
     mapeará as funções <sinfn> sobre os termos de seno e <cosfn> ssobre
     os termos de cosseno das séries de Poisson dadas.  <sinfn> e
     <cosfn> são funções de dois argumentos que são um coeficiente e uma
     parte trigonométrica de um termo em séries respectivamente.

 -- Função: poisplus (<a>, <b>)
     É funcionalmente identica a 'intopois (a + b)'.

 -- Função: poissimp (<a>)
     Converte <a> em séries de Poisson para <a> em representação geral.

 -- Símbolo especial: poisson
     O símbolo '/P/' segue o rótulo de linha de uma expressão contendo
     séries de Poisson.

 -- Função: poissubst (<a>, <b>, <c>)
     Substitue <a> por <b> em <c>.  <c> é uma série de Poisson.

     (1) Quando <B> é uma variável <u>, <v>, <w>, <x>, <y>, ou <z>,
     então <a> deve ser uma expressão linear nessas variáveis (e.g.,
     '6*u + 4*v').

     (2) Quando <b> for outra que não essas variáveis, então <a> deve
     também ser livre dessas variáveis, e alé disso, livre de senos ou
     cossenos.

     'poissubst (<a>, <b>, <c>, <d>, <n>)' é um tipo especial d
     substituição que opera sobre <a> e <b> como no tipo (1) acima, mas
     onde <d> é uma série de Poisson, expande 'cos(<d>)' e 'sin(<d>)'
     para a ordem <n> como provendo o resultado da substituição '<a> +
     <d>' por <b> em <c>.  A idéia é que <d> é uma expansão em termos de
     um pequeno parâmetro.  Por exemplo, 'poissubst (u, v, cos(v), %e,
     3)' retorna 'cos(u)*(1 - %e^2/2) - sin(u)*(%e - %e^3/6)'.

 -- Função: poistimes (<a>, <b>)
     É funcionalmente idêntica a 'intopois (<a>*<b>)'.

 -- Função: poistrim ()
     é um nome de função reservado que (se o usuário tiver definido uma
     função com esse nome) é aplicada durante multiplicação de Poisson.
     Isso é uma função predicada de 6 argumentos que são os coeficientes
     de <u>, <v>, ..., <z> em um termo.  Termos para os quais 'poistrim'
     for 'true' (para os coeficientes daquele termo) são eliminados
     durante a multiplicação.

 -- Função: printpois (<a>)
     Mostra uma série de Poisson em um formato legível.  Em comum com
     'outofpois', essa função converterá <a> em um código de Poisson
     primeiro, se necessário.

 -- Função: psi [<n>](<x>)

     A derivada de 'log (gamma (<x>))' de ordem '<n>+1'.  Dessa forma,
     'psi[0](<x>)' é a primeira derivada, 'psi[1](<x>)' é a segunda
     derivada, etc.

     Maxima não sabe como, em geral, calcular um valor numérico de
     'psi', mas Maxima pode calcular alguns valores exatos para
     argumentos racionais.  Muitas variáveis controlam qual intervalo de
     argumentos racionais 'psi' irá retornar um valor exato, se
     possível.  Veja 'maxpsiposint', 'maxpsinegint', 'maxpsifracnum', e
     'maxpsifracdenom'.  Isto é, <x> deve localizar-se entre
     'maxpsinegint' e 'maxpsiposint'.  Se o valor absoluto da parte
     facionária de <x> for racional e tiver um numerador menor que
     'maxpsifracnum' e tiver um denominador menor que 'maxpsifracdenom',
     'psi' irá retornar um valor exato.

     A função 'bfpsi' no pacote 'bffac' pode calcular valores numéricos.

 -- Variável de opção: maxpsiposint
     Valor padrão: 20

     'maxpsiposint' é o maior valor positivo para o qual 'psi[n](x)' irá
     tentar calcular um valor exato.

 -- Variável de opção: maxpsinegint
     Valor padrão: -10

     'maxpsinegint' é o valor mais negativo para o qual 'psi[n](x)' irá
     tentar calcular um valor exato.  Isto é, se <x> for menor que
     'maxnegint', 'psi[n](<x>)' não irá retornar resposta simplificada,
     mesmo se isso for possível.

 -- Variável de opção: maxpsifracnum
     Valor padrão: 6

     Tomemos <x> como sendo um número racional menor que a unidade e da
     forma 'p/q'.  Se 'p' for menor que 'maxpsifracnum', então
     'psi[<n>](<x>)' não irá tentar retornar um valor simplificado.

 -- Variável de opção: maxpsifracdenom
     Valor padrão: 6

     Tomemos <x> como sendo um número racional menor que a unidade e da
     forma 'p/q'.  Se 'q' for maior que 'maxpsifracdenom', então
     'psi[<n>](<x>)' não irá tentar retornar um valor simplificado.

 -- Function: specint (exp(- s*<t>) * <expr>, <t>)

     Calcula a trasformada de Laplace de <expr> com relação à variável
     <t>.  O integrando <expr> pode conter funções especiais.

     Se 'specint' não puder calcular a integral, o valor de retorno pode
     coter vários símbolos do Lisp, incluindo
     'other-defint-to-follow-negtest', 'other-lt-exponential-to-follow',
     'product-of-y-with-nofract-indices', etc.; isso é um erro.

     'demo(hypgeo)' mostra muitos exemplos de tansformadas de Laplace
     calculados por meio de 'specint'.

     Exemplos:

          (%i1) assume (p > 0, a > 0);
          (%o1)                    [p > 0, a > 0]
          (%i2) specint (t^(1/2) * exp(-a*t/4) * exp(-p*t), t);
                                     sqrt(%pi)
          (%o2)                     ------------
                                           a 3/2
                                    2 (p + -)
                                           4
          (%i3) specint (t^(1/2) * bessel_j(1, 2 * a^(1/2) * t^(1/2)) * exp(-p*t), t);
                                             - a/p
                                   sqrt(a) %e
          (%o3)                    ---------------
                                          2
                                         p


File: maxima.info,  Node: Funções Elípticas,  Next: Limites,  Prev: Funções Especiais,  Up: Top

17 Funções Elípticas
********************

* Menu:

* Introdução a Funções Elípticas e Integrais::
* Funções e Variáveis Definidas para Funções Elípticas::
* Funções e Variáveis Definidas para Integrais Elípticas::


File: maxima.info,  Node: Introdução a Funções Elípticas e Integrais,  Next: Funções e Variáveis Definidas para Funções Elípticas,  Up: Top

17.1 Introdução a Funções Elípticas e Integrais
===============================================

Maxima inclui suporte a funções elípticas Jacobianas e a integrais
elípticas completas e incompletas.  Isso inclui manipulação simbólica
dessas funções e avaliação numérica também.  Definições dessas funções e
muitas de suas propriedades podem ser encontradas em Abramowitz e
Stegun, Capítulos 16-17.  Tanto quanto possível, usamos as definições e
relações dadas aí.

   Em particular, todas as funções elípticas e integrais elípticas usam
o parâmetro m em lugar de módulo k ou o ângulo modular \alpha.  Isso é
uma área onde discordamos de Abramowitz e Stegun que usam o ângulo
modular para as funções elípticas.  As seguintes relações são
verdadeiras: m = k^2 e k = \sin(\alpha)

   As funções elípticas e integrais elípticas estão primariamente
tencionando suportar computação simbólica.  Portanto, a maiora das
derivadas de funções e integrais são conhecidas.  Todavia, se valores em
ponto flutuante forem dados, um resultado em ponto flutuante é
retornado.

   Suporte para a maioria de outras propriedades das funções elípticas e
integrais elípticas além das derivadas não foram ainda escritas.

   Alguns exemplos de funções elípticas:

     (%i1) jacobi_sn (u, m);
     (%o1)                    jacobi_sn(u, m)
     (%i2) jacobi_sn (u, 1);
     (%o2)                        tanh(u)
     (%i3) jacobi_sn (u, 0);
     (%o3)                        sin(u)
     (%i4) diff (jacobi_sn (u, m), u);
     (%o4)            jacobi_cn(u, m) jacobi_dn(u, m)
     (%i5) diff (jacobi_sn (u, m), m);
     (%o5) jacobi_cn(u, m) jacobi_dn(u, m)

           elliptic_e(asin(jacobi_sn(u, m)), m)
      (u - ------------------------------------)/(2 m)
                          1 - m

                 2
        jacobi_cn (u, m) jacobi_sn(u, m)
      + --------------------------------
                   2 (1 - m)

   Alguns exemplos de integrais elípticas:

     (%i1) elliptic_f (phi, m);
     (%o1)                  elliptic_f(phi, m)
     (%i2) elliptic_f (phi, 0);
     (%o2)                          phi
     (%i3) elliptic_f (phi, 1);
                                    phi   %pi
     (%o3)                  log(tan(--- + ---))
                                     2     4
     (%i4) elliptic_e (phi, 1);
     (%o4)                       sin(phi)
     (%i5) elliptic_e (phi, 0);
     (%o5)                          phi
     (%i6) elliptic_kc (1/2);
                                          1
     (%o6)                    elliptic_kc(-)
                                          2
     (%i7) makegamma (%);
                                      2 1
                                 gamma (-)
                                        4
     (%o7)                      -----------
                                4 sqrt(%pi)
     (%i8) diff (elliptic_f (phi, m), phi);
                                     1
     (%o8)                 ---------------------
                                         2
                           sqrt(1 - m sin (phi))
     (%i9) diff (elliptic_f (phi, m), m);
            elliptic_e(phi, m) - (1 - m) elliptic_f(phi, m)
     (%o9) (-----------------------------------------------
                                   m

                                      cos(phi) sin(phi)
                                  - ---------------------)/(2 (1 - m))
                                                  2
                                    sqrt(1 - m sin (phi))

   Suporte a funções elípticas e integrais elípticas foi escrito por
Raymond Toy.  Foi colocado sob os termos da Licençã Pública Geral (GPL)
que governa a distribuição do Maxima.


File: maxima.info,  Node: Funções e Variáveis Definidas para Funções Elípticas,  Next: Funções e Variáveis Definidas para Integrais Elípticas,  Prev: Introdução a Funções Elípticas e Integrais,  Up: Top

17.2 Funções e Variáveis Definidas para Funções Elípticas
=========================================================

 -- Função: jacobi_sn (<u>, <m>)
     A Função elíptica Jacobiana sn(u,m).

 -- Função: jacobi_cn (<u>, <m>)
     A função elíptica Jacobiana cn(u,m).

 -- Função: jacobi_dn (<u>, <m>)
     A função elíptica Jacobiana dn(u,m).

 -- Função: jacobi_ns (<u>, <m>)
     A função elíptica Jacobiana ns(u,m) = 1/sn(u,m).

 -- Função: jacobi_sc (<u>, <m>)
     A função elíptica Jacobiana sc(u,m) = sn(u,m)/cn(u,m).

 -- Função: jacobi_sd (<u>, <m>)
     A função elíptica Jacobiana sd(u,m) = sn(u,m)/dn(u,m).

 -- Função: jacobi_nc (<u>, <m>)
     A função elíptica Jacobiana nc(u,m) = 1/cn(u,m).

 -- Função: jacobi_cs (<u>, <m>)
     A função elíptica Jacobiana cs(u,m) = cn(u,m)/sn(u,m).

 -- Função: jacobi_cd (<u>, <m>)
     A função elíptica Jacobiana cd(u,m) = cn(u,m)/dn(u,m).

 -- Função: jacobi_nd (<u>, <m>)
     A função elíptica Jacobiana nc(u,m) = 1/cn(u,m).

 -- Função: jacobi_ds (<u>, <m>)
     A função elíptica Jacobiana ds(u,m) = dn(u,m)/sn(u,m).

 -- Função: jacobi_dc (<u>, <m>)
     A função elíptica Jacobiana dc(u,m) = dn(u,m)/cn(u,m).

 -- Função: inverse_jacobi_sn (<u>, <m>)
     A inversa da função elíptica Jacobiana sn(u,m).

 -- Função: inverse_jacobi_cn (<u>, <m>)
     A inversa da função elíptica Jacobiana cn(u,m).

 -- Função: inverse_jacobi_dn (<u>, <m>)
     A inversa da função elíptica Jacobiana dn(u,m).

 -- Função: inverse_jacobi_ns (<u>, <m>)
     A inversa da função elíptica Jacobiana ns(u,m).

 -- Função: inverse_jacobi_sc (<u>, <m>)
     A inversa da função elíptica Jacobiana sc(u,m).

 -- Função: inverse_jacobi_sd (<u>, <m>)
     A inversa da função elíptica Jacobiana sd(u,m).

 -- Função: inverse_jacobi_nc (<u>, <m>)
     A inversa da função elíptica Jacobiana nc(u,m).

 -- Função: inverse_jacobi_cs (<u>, <m>)
     A inversa da função elíptica Jacobiana cs(u,m).

 -- Função: inverse_jacobi_cd (<u>, <m>)
     A inversa da função elíptica Jacobiana cd(u,m).

 -- Função: inverse_jacobi_nd (<u>, <m>)
     A inversa da função elíptica Jacobiana nc(u,m).

 -- Função: inverse_jacobi_ds (<u>, <m>)
     A inversa da função elíptica Jacobiana ds(u,m).

 -- Função: inverse_jacobi_dc (<u>, <m>)
     A inversa da função elíptica Jacobiana dc(u,m).


File: maxima.info,  Node: Funções e Variáveis Definidas para Integrais Elípticas,  Prev: Funções e Variáveis Definidas para Funções Elípticas,  Up: Top

17.3 Funções e Variáveis Definidas para Integrais Elípticas
===========================================================

 -- Função: elliptic_f (<phi>, <m>)
     A integral elíptica incompleta de primeiro tipo, definida como

     integrate(1/sqrt(1 - m*sin(x)^2), x, 0, phi)

     Veja também *note elliptic_e:: e *note elliptic_kc::.

 -- Função: elliptic_e (<phi>, <m>)
     A integral elíptica incompleta de segundo tipo, definida como

     elliptic_e(u, m) = integrate(sqrt(1 - m*sin(x)^2), x, 0, phi) Veja
     também *note elliptic_e:: e *note elliptic_ec::.

 -- Função: elliptic_eu (<u>, <m>)
     A integral elíptica incompleta de segundo tipo, definida como
     integrate(dn(v,m)^2,v,0,u) = integrate(sqrt(1-m*t^2)/sqrt(1-t^2),
     t, 0, tau)

     onde tau = sn(u,m)

     Isso é relacionado a elliptic_e através de elliptic_eu(u, m) =
     elliptic_e(asin(sn(u,m)),m) Veja também *note elliptic_e::.

 -- Função: elliptic_pi (<n>, <phi>, <m>)
     A integral elíptica incompleta de terceiro tipo, definida como

     integrate(1/(1-n*sin(x)^2)/sqrt(1 - m*sin(x)^2), x, 0, phi)

     Somente a derivada em relação a phi é conhecida pelo Maxima.

 -- Função: elliptic_kc (<m>)
     A integral elíptica completa de primeiro tipo, definida como

     integrate(1/sqrt(1 - m*sin(x)^2), x, 0, %pi/2)

     Para certos valores de m, o valor da integral é conhecido em termos
     de funções Gamma.  Use 'makegamma' para avaliar esse valor.

 -- Função: elliptic_ec (<m>)
     A integral elíptica completa de sgundo tipo, definida como

     integrate(sqrt(1 - m*sin(x)^2), x, 0, %pi/2)

     Para certos valores de m, o valor da integral é conhecido em termos
     de funçõesvGamma.  Use 'makegamma' para avaliar esse valor.


File: maxima.info,  Node: Limites,  Next: Diferenciação,  Prev: Funções Elípticas,  Up: Top

18 Limites
**********

* Menu:

* Funções e Variáveis Definidas para Limites::


File: maxima.info,  Node: Funções e Variáveis Definidas para Limites,  Prev: Limites,  Up: Limites

18.1 Funções e Variáveis Definidas para Limites
===============================================

 -- Variável de Opção: lhospitallim
     Valor padrão: 4

     'lhospitallim' é o máximo número de vezes que a regra L'Hospital é
     usada em 'limit'.  Isso evita ciclos infinitos em casos como 'limit
     (cot(x)/csc(x), x, 0)'.

 -- Função: limit (<expr>, <x>, <val>, <dir>)
 -- Função: limit (<expr>, <x>, <val>)
 -- Função: limit (<expr>)
     Calcula o limite de <expr> com a variável real <x> aproximando-se
     do valor <val> pela direção <dir>.  <dir> pode ter o valor 'plus'
     para um limite pela direita, 'minus' para um limite pela esquerda,
     ou pode ser omitido (implicando em um limite em ambos os lados é
     para ser computado).

     'limit' usa os seguintes símbolos especiais: 'inf' (infinito
     positivo) e 'minf' (infinito negativo).  Em saídas essa função pode
     também usar 'und' (undefined - não definido), 'ind' (indefinido mas
     associado) e 'infinity' (infinito complexo).

     'lhospitallim' é o máximo número de vezes que a regra L'Hospital é
     usada em 'limit'.  Isso evita ciclos infinitos em casos como 'limit
     (cot(x)/csc(x), x, 0)'.

     'tlimswitch' quando 'true' fará o pacote 'limit' usar série de
     Taylor quando possível.

     'limsubst' evita que 'limit' tente substituições sobre formas
     desconhecidas.  Isso é para evitar erros como 'limit (f(n)/f(n+1),
     n, inf)' dando igual a 1.  Escolhendo 'limsubst' para 'true'
     permitirá tais substituições.

     'limit' com um argumento é muitas vezes chamado em ocasiões para
     simplificar expressões de constantes, por exemplo, 'limit (inf-1)'.

     'example (limit)' mostra alguns exemplos.

     Para saber sobre o método utilizado veja Wang, P., "Evaluation of
     Definite Integrals by Symbolic Manipulation", tese de Ph.D., MAC
     TR-92, Outubro de 1971.

 -- Variável de Opção: limsubst
     valor padrão: 'false' - evita que 'limit' tente substituições sobre
     formas desconhecidas.  Isso é para evitar erros como 'limit
     (f(n)/f(n+1), n, inf)' dando igual a 1.  Escolhendo 'limsubst' para
     'true' permitirá tais substituições.

 -- Função: tlimit (<expr>, <x>, <val>, <dir>)
 -- Função: tlimit (<expr>, <x>, <val>)
 -- Função: tlimit (<expr>)
     Retorna 'limit' com 'tlimswitch' escolhido para 'true'.

 -- Variável de Opção: tlimswitch
     Valor padrão: 'false'

     Quando 'tlimswitch' for 'true', fará o pacote 'limit' usar série de
     Taylor quando possível.


File: maxima.info,  Node: Diferenciação,  Next: Integração,  Prev: Limites,  Up: Top

19 Diferenciação
****************

/Differentiation.texi/1.20/Sat Jun 2 00:12:38 2007/-ko/
* Menu:

* Funções e Variáveis Definidas para Diferenciação::


File: maxima.info,  Node: Funções e Variáveis Definidas para Diferenciação,  Prev: Diferenciação,  Up: Diferenciação

19.1 Funções e Variáveis Definidas para Diferenciação
=====================================================

 -- Função: antid (<expr>, <x>, <u(x)>)
     Retorna uma lista de dois elementos, tais que uma antiderivada de
     <expr> com relação a <x> pode ser constuída a partir da lista.  A
     expressão <expr> pode conter uma função desconhecida <u> e suas
     derivadas.

     Tome <L>, uma lista de dois elementos, como sendo o valor de
     retorno de 'antid'.  Então '<L>[1] + 'integrate (<L>[2], <x>)' é
     uma antiderivada de <expr> com relação a <x>.

     Quando 'antid' obtém sucesso inteiramente, o segundo elemento do
     valor de retorno é zero.  De outra forma, o segundo elemento é não
     zero, e o primeiro elemento não zero ou zero.  Se 'antid' não pode
     fazer nenhum progresso, o primeiro elemento é zero e o segundo não
     zero.

     'load ("antid")' chama essa função.  O pacote 'antid' também define
     as funções 'nonzeroandfreeof' e 'linear'.

     'antid' está relacionada a 'antidiff' como segue.  Tome <L>, uma
     lista de dois elementos, que é o valor de retorno de 'antid'.
     Então o valor de retorno de 'antidiff' é igual a '<L>[1] +
     'integrate (<L>[2], <x>)' onde <x> é a variável de integração.

     Exemplos:

          (%i1) load ("antid")$
          (%i2) expr: exp (z(x)) * diff (z(x), x) * y(x);
                                      z(x)  d
          (%o2)                y(x) %e     (-- (z(x)))
                                            dx
          (%i3) a1: antid (expr, x, z(x));
                                 z(x)      z(x)  d
          (%o3)          [y(x) %e    , - %e     (-- (y(x)))]
                                                 dx
          (%i4) a2: antidiff (expr, x, z(x));
                                      /
                               z(x)   [   z(x)  d
          (%o4)         y(x) %e     - I %e     (-- (y(x))) dx
                                      ]         dx
                                      /
          (%i5) a2 - (first (a1) + 'integrate (second (a1), x));
          (%o5)                           0
          (%i6) antid (expr, x, y(x));
                                       z(x)  d
          (%o6)             [0, y(x) %e     (-- (z(x)))]
                                             dx
          (%i7) antidiff (expr, x, y(x));
                            /
                            [        z(x)  d
          (%o7)             I y(x) %e     (-- (z(x))) dx
                            ]              dx
                            /

 -- Função: antidiff (<expr>, <x>, <u>(<x>))
     Retorna uma antiderivada de <expr> com relação a <x>.  A expressão
     <expr> pode conter uma função desconhecida <u> e suas derivadas.

     Quando 'antidiff' obtém sucesso inteiramente, a expressão
     resultante é livre do sinal de integral (isto é, livre do
     substantivo 'integrate').  De outra forma, 'antidiff' retorna uma
     expressão que é parcialmente ou inteiramente dentro de um sinal de
     um sinal de integral.  Se 'antidiff' não pode fazer qualquer
     progresso, o valor de retorno é inteiramente dentro de um sinal de
     integral.

     'load ("antid")' chama essa função.  O pacote 'antid' também define
     as funções 'nonzeroandfreeof' e 'linear'.

     'antidiff' é relacionada a 'antid' como segue.  Tome <L>, uma lista
     de dois elementos, como sendo o valor de retorno de 'antid'.  Então
     o valor de retorno de 'antidiff' é igual a '<L>[1] + 'integrate
     (<L>[2], <x>)' onde <x> é a variável de integração.

     Exemplos:

          (%i1) load ("antid")$
          (%i2) expr: exp (z(x)) * diff (z(x), x) * y(x);
                                      z(x)  d
          (%o2)                y(x) %e     (-- (z(x)))
                                            dx
          (%i3) a1: antid (expr, x, z(x));
                                 z(x)      z(x)  d
          (%o3)          [y(x) %e    , - %e     (-- (y(x)))]
                                                 dx
          (%i4) a2: antidiff (expr, x, z(x));
                                      /
                               z(x)   [   z(x)  d
          (%o4)         y(x) %e     - I %e     (-- (y(x))) dx
                                      ]         dx
                                      /
          (%i5) a2 - (first (a1) + 'integrate (second (a1), x));
          (%o5)                           0
          (%i6) antid (expr, x, y(x));
                                       z(x)  d
          (%o6)             [0, y(x) %e     (-- (z(x)))]
                                             dx
          (%i7) antidiff (expr, x, y(x));
                            /
                            [        z(x)  d
          (%o7)             I y(x) %e     (-- (z(x))) dx
                            ]              dx
                            /

 -- propriedade: atomgrad

     'atomgrad' é a propriedade do gradiente atômico de uma expressão.
     Essa propriedade é atribuída por 'gradef'.

 -- Função: atvalue (<expr>, [<x_1> = <a_1>, ..., <x_m> = <a_m>], <c>)
 -- Função: atvalue (<expr>, <x_1> = <a_1>, <c>)
     Atribui o valor <c> a <expr> no ponto '<x> = <a>'.  Tipicamente
     valores de extremidade são estabelecidos por esse mecanismo.

     <expr> é a função de avaliação, '<f>(<x_1>, ..., <x_m>)', ou uma
     derivada, 'diff (<f>(<x_1>, ..., <x_m>), <x_1>, <n_1>, ..., <x_n>,
     <n_m>)' na qual os argumentos da função explicitamente aparecem.
     <n_i> é a ordem de diferenciação com relação a <x_i>.

     O ponto no qual o 'atvalue' é estabelecido é dado pela lista de
     equações '[<x_1> = <a_1>, ..., <x_m> = <a_m>]'.  Se existe uma
     variável simples <x_1>, uma única equação pode ser dada sem ser
     contida em uma lista.

     'printprops ([<f_1>, <f_2>, ...], atvalue)' mostra os 'atvalues'
     das funções '<f_1>, <f_2>, ...' como especificado por chamadas a
     'atvalue'.  'printprops (<f>, atvalue)' mostra os 'atvalues' de uma
     função <f>.  'printprops (all, atvalue)' mostra os 'atvalue's de
     todas as funções para as quais 'atvalue's são definidos.

     Os simbolos '@1', '@2', ...  representam as variáveis <x_1>, <x_2>,
     ...  quando 'atvalue's são mostrados.

     'atvalue' avalia seus argumentos.  'atvalue' retorna <c>, o
     'atvalue'.

     Exemplos:

          (%i1) atvalue (f(x,y), [x = 0, y = 1], a^2);
                                          2
          (%o1)                          a
          (%i2) atvalue ('diff (f(x,y), x), x = 0, 1 + y);
          (%o2)                        @2 + 1
          (%i3) printprops (all, atvalue);
                                          !
                            d             !
                           --- (f(@1, @2))!       = @2 + 1
                           d@1            !
                                          !@1 = 0

                                               2
                                    f(0, 1) = a

          (%o3)                         done
          (%i4) diff (4*f(x,y)^2 - u(x,y)^2, x);
                            d                          d
          (%o4)  8 f(x, y) (-- (f(x, y))) - 2 u(x, y) (-- (u(x, y)))
                            dx                         dx
          (%i5) at (%, [x = 0, y = 1]);
                                                   !
                        2              d           !
          (%o5)     16 a  - 2 u(0, 1) (-- (u(x, y))!            )
                                       dx          !
                                                   !x = 0, y = 1

 -- Função: cartan -
     O cálculo exterior de formas diferenciais é uma ferramenta básica
     de geometria diferencial desenvolvida por Elie Cartan e tem
     importantes aplicações na teoria das equações diferenciais
     parciais.  O pacote 'cartan' implementa as funções 'ext_diff' e
     'lie_diff', juntamente com os operadores '~' (produto da cunha) e
     '|' (contração de uma forma com um vetor.)  Digite 'demo (tensor)'
     para ver uma breve descrição desses comandos juntamente com
     exemplos.

     'cartan' foi implementado por F.B. Estabrook e H.D. Wahlquist.

 -- Função: del (<x>)
     'del (<x>)' representa a diferencial da variável x.

     'diff' retorna uma expressão contendo 'del' se uma variável
     independente não for especificada.  Nesse caso, o valor de retorno
     é a então chamada "diferencial total".

     Exemplos:

          (%i1) diff (log (x));
                                       del(x)
          (%o1)                        ------
                                         x
          (%i2) diff (exp (x*y));
                               x y              x y
          (%o2)            x %e    del(y) + y %e    del(x)
          (%i3) diff (x*y*z);
          (%o3)         x y del(z) + x z del(y) + y z del(x)

 -- Função: delta (<t>)
     A função Delta de Dirac.

     Correntemente somente 'laplace' sabe sobre a função 'delta'.

     Exemplo:

          (%i1) laplace (delta (t - a) * sin(b*t), t, s);
          Is  a  positive, negative, or zero?

          p;
                                             - a s
          (%o1)                   sin(a b) %e

 -- Variável: dependencies
     Valor padrão: '[]'

     'dependencies' é a lista de átomos que possuem dependências
     funcionais, atribuídas por 'depends' ou 'gradef'.  A lista
     'dependencies' é cumulativa: cada chamada a 'depends' ou a 'gradef'
     anexa ítens adicionais.

     Veja 'depends' e 'gradef'.

 -- Função: depends (<f_1>, <x_1>, ..., <f_n>, <x_n>)
     Declara dependêcias funcionais entre variáveis para o propósito de
     calcular derivadas.  Na ausência de dependêcias declaradas, 'diff
     (f, x)' retorna zero.  Se 'depends (f, x)' for declarada, 'diff (f,
     x)' retorna uma derivada simbólica (isto é, um substantivo 'diff').

     Cada argumento <f_1>, <x_1>, etc., pode ser o nome de uma variável
     ou array, ou uma lista de nomes.  Todo elemento de <f_i> (talvez
     apenas um elemento simples) é declarado para depender de todo
     elemento de <x_i> (talvez apenas um elemento simples).  Se algum
     <f_i> for o nome de um array ou contém o nome de um array, todos os
     elementos do array dependem de <x_i>.

     'diff' reconhece dependências indiretas estabelecidas por 'depends'
     e aplica a regra da cadeia nesses casos.

     'remove (<f>, dependency)' remove todas as dependências declaradas
     para <f>.

     'depends' retorna uma lista de dependências estabelecidas.  As
     dependências são anexadas à variável global 'dependencies'.
     'depends' avalia seus argumentos.

     'diff' é o único comando Maxima que reconhece dependências
     estabelecidas por 'depends'.  Outras funções ('integrate',
     'laplace', etc.)  somente reconhecem dependências explicitamente
     representadas por seus argumentos.  Por exemplo, 'integrate' não
     reconhece a dependência de 'f' sobre 'x' a menos que explicitamente
     representada como 'integrate (f(x), x)'.

          (%i1) depends ([f, g], x);
          (%o1)                     [f(x), g(x)]
          (%i2) depends ([r, s], [u, v, w]);
          (%o2)               [r(u, v, w), s(u, v, w)]
          (%i3) depends (u, t);
          (%o3)                        [u(t)]
          (%i4) dependencies;
          (%o4)      [f(x), g(x), r(u, v, w), s(u, v, w), u(t)]
          (%i5) diff (r.s, u);
                                   dr           ds
          (%o5)                    -- . s + r . --
                                   du           du

          (%i6) diff (r.s, t);
                                dr du           ds du
          (%o6)                 -- -- . s + r . -- --
                                du dt           du dt

          (%i7) remove (r, dependency);
          (%o7)                         done
          (%i8) diff (r.s, t);
                                          ds du
          (%o8)                       r . -- --
                                          du dt

 -- Variável de opção: derivabbrev
     Valor padrão: 'false'

     Quando 'derivabbrev' for 'true', derivadas simbólicas (isto é,
     substantivos 'diff') são mostradas como subscritos.  De outra
     forma, derivadas são mostradas na notação de Leibniz 'dy/dx'.

 -- Função: derivdegree (<expr>, <y>, <x>)
     Retorna o maior grau de uma derivada da variável dependente <y> com
     relação à variável independente <x> ocorrendo em <expr>.

     Exemplo:
          (%i1) 'diff (y, x, 2) + 'diff (y, z, 3) + 'diff (y, x) * x^2;
                                   3     2
                                  d y   d y    2 dy
          (%o1)                   --- + --- + x  --
                                    3     2      dx
                                  dz    dx
          (%i2) derivdegree (%, y, x);
          (%o2)                           2

 -- Função: derivlist (<var_1>, ..., <var_k>)
     Causa somente diferenciações com relação às variáveis indicadas,
     dentro do comando 'ev'.

 -- Variável de opção: derivsubst
     Valor padrão: 'false'

     Quando 'derivsubst' for 'true', uma substiruíção não sintática tais
     como 'subst (x, 'diff (y, t), 'diff (y, t, 2))' retorna ''diff (x,
     t)'.

 -- Função: diff (<expr>, <x_1>, <n_1>, ..., <x_m>, <n_m>)
 -- Função: diff (<expr>, <x>, <n>)
 -- Função: diff (<expr>, <x>)
 -- Função: diff (<expr>)
     Retorna uma derivada ou diferencial de <expr> com relação a alguma
     ou todas as variáveis em <expr>.

     'diff (<expr>, <x>, <n>)' retorna a <n>'ésima derivada de <expr>
     com relação a <x>.

     'diff (<expr>, <x_1>, <n_1>, ..., <x_m>, <n_m>)' retorna a derivada
     parcial mista de <expr> com relação a <x_1>, ..., <x_m>.  Isso é
     equivalente a 'diff (... (diff (<expr>, <x_m>, <n_m>) ...), <x_1>,
     <n_1>)'.

     'diff (<expr>, <x>)' retorna a primeira derivada de <expr> com
     relação a uma variável <x>.

     'diff (<expr>)' retorna a diferencial total de <expr>, isto é, a
     soma das derivadas de <expr> com relação a cada uma de suas
     variáveis vezes a diferencial 'del' de cada variável.  Nenhuma
     simplificação adicional de 'del' é oferecida.

     A forma substantiva de 'diff' é requerida em alguns contextos, tal
     como declarando uma equação diferencial.  Nesses casos, 'diff' pode
     ser colocado apóstrofo (com ''diff') para retornar a forma
     substantiva em lugar da realização da diferenciação.

     Quando 'derivabbrev' for 'true', derivadas são mostradas como
     subscritos.  De outra forma, derivadas são mostradas na notação de
     Leibniz, 'dy/dx'.

     Exemplos:

          (%i1) diff (exp (f(x)), x, 2);
                               2
                        f(x)  d               f(x)  d         2
          (%o1)       %e     (--- (f(x))) + %e     (-- (f(x)))
                                2                   dx
                              dx
          (%i2) derivabbrev: true$
          (%i3) 'integrate (f(x, y), y, g(x), h(x));
                                   h(x)
                                  /
                                  [
          (%o3)                   I     f(x, y) dy
                                  ]
                                  /
                                   g(x)
          (%i4) diff (%, x);
                 h(x)
                /
                [
          (%o4) I     f(x, y)  dy + f(x, h(x)) h(x)  - f(x, g(x)) g(x)
                ]            x                     x                  x
                /
                 g(x)

     Para o pacote tensor, as seguintes modificações foram incorporadas:

     (1) As derivadas de quaisquer objetos indexados em <expr> terão as
     variáveis <x_i> anexadas como argumentos adicionais.  Então todos
     os índices de derivada serão ordenados.

     (2) As variáveis <x_i> podem ser inteiros de 1 até o valor de uma
     variável 'dimension' [valor padrão: 4].  Isso fará com que a
     diferenciação seja concluída com relação aos <x_i>'ésimos membros
     da lista 'coordinates' que pode ser escolhida para uma lista de
     nomes de coordenadas, e.g., '[x, y, z, t]'.  Se 'coordinates' for
     associada a uma variável atômica, então aquela variável subscrita
     por <x_i> será usada para uma variável de diferenciação.  Isso
     permite um array de nomes de coordenadas ou nomes subscritos como
     'X[1]', 'X[2]', ...  sejam usados.  Se 'coordinates' não foram
     atribuídas um valor, então as variáveis seram tratadas como em (1)
     acima.

 -- Símbolo especial: diff

     Quando 'diff' está presente como um 'evflag' em chamadas para 'ev',
     Todas as diferenciações indicadas em 'expr' são realizdas.

 -- Função: dscalar (<f>)
     Aplica o d'Alembertiano escalar para a função escalar <f>.

     'load ("ctensor")' chama essa função.

 -- Função: express (<expr>)

     Expande o substantivo do operador diferencial em expressões em
     termos de derivadas parciais.  'express' reconhece os operadores
     'grad', 'div', 'curl', 'laplacian'.  'express' também expande o
     produto do X '~'.

     Derivadas simbólicas (isto é, substantivos 'diff') no valor de
     retorno de 'express' podem ser avaliadas incluíndo 'diff' na
     chamada à função 'ev' ou na linha de comando.  Nesse contexto,
     'diff' age como uma 'evfun'.

     'load ("vect")' chama essa função.

     Exemplos:

          (%i1) load ("vect")$
          (%i2) grad (x^2 + y^2 + z^2);
                                        2    2    2
          (%o2)                  grad (z  + y  + x )
          (%i3) express (%);
                 d    2    2    2   d    2    2    2   d    2    2    2
          (%o3) [-- (z  + y  + x ), -- (z  + y  + x ), -- (z  + y  + x )]
                 dx                 dy                 dz
          (%i4) ev (%, diff);
          (%o4)                    [2 x, 2 y, 2 z]
          (%i5) div ([x^2, y^2, z^2]);
                                        2   2   2
          (%o5)                   div [x , y , z ]
          (%i6) express (%);
                             d    2    d    2    d    2
          (%o6)              -- (z ) + -- (y ) + -- (x )
                             dz        dy        dx
          (%i7) ev (%, diff);
          (%o7)                    2 z + 2 y + 2 x
          (%i8) curl ([x^2, y^2, z^2]);
                                         2   2   2
          (%o8)                   curl [x , y , z ]
          (%i9) express (%);
                 d    2    d    2   d    2    d    2   d    2    d    2
          (%o9) [-- (z ) - -- (y ), -- (x ) - -- (z ), -- (y ) - -- (x )]
                 dy        dz       dz        dx       dx        dy
          (%i10) ev (%, diff);
          (%o10)                      [0, 0, 0]
          (%i11) laplacian (x^2 * y^2 * z^2);
                                            2  2  2
          (%o11)                laplacian (x  y  z )
          (%i12) express (%);
                   2                2                2
                  d     2  2  2    d     2  2  2    d     2  2  2
          (%o12)  --- (x  y  z ) + --- (x  y  z ) + --- (x  y  z )
                    2                2                2
                  dz               dy               dx
          (%i13) ev (%, diff);
                                2  2      2  2      2  2
          (%o13)             2 y  z  + 2 x  z  + 2 x  y
          (%i14) [a, b, c] ~ [x, y, z];
          (%o14)                [a, b, c] ~ [x, y, z]
          (%i15) express (%);
          (%o15)          [b z - c y, c x - a z, a y - b x]

 -- Função: gradef (<f>(<x_1>, ..., <x_n>), <g_1>, ..., <g_m>)
 -- Função: gradef (<a>, <x>, <expr>)
     Define as derivadas parciais (i.e., os componentes do gradiente) da
     função <f> ou variável <a>.

     'gradef (<f>(<x_1>, ..., <x_n>), <g_1>, ..., <g_m>)' define
     'd<f>/d<x_i>' como <g_i>, onde <g_i> é uma expressão; <g_i> pode
     ser uma chamada de função, mas não o nome de uma função.  O número
     de derivadas parciais <m> pode ser menor que o número de argumentos
     <n>, nesses casos derivadas são definidas com relação a <x_1> até
     <x_m> somente.

     'gradef (<a>, <x>, <expr>)' define uma derivada de variável <a> com
     relação a <x> como <expr>.  Isso também estabelece a dependência de
     <a> sobre <x> (via 'depends (<a>, <x>)').

     O primeiro argumento '<f>(<x_1>, ..., <x_n>)' ou <a> é acompanhado
     de apóstrofo, mas os argumentos restantes <g_1>, ..., <g_m> são
     avaliados.  'gradef' retorna a função ou variável para as quais as
     derivadas parciais são definidas.

     'gradef' pode redefinir as derivadas de funções internas do Maxima.
     Por exemplo, 'gradef (sin(x), sqrt (1 - sin(x)^2))' redefine uma
     derivada de 'sin'.

     'gradef' não pode definir derivadas parciais para um função
     subscrita.

     'printprops ([<f_1>, ..., <f_n>], gradef)' mostra as derivadas
     parciais das funções <f_1>, ..., <f_n>, como definidas por
     'gradef'.

     'printprops ([<a_n>, ..., <a_n>], atomgrad)' mostra as derivadas
     parciais das variáveis <a_n>, ..., <a_n>, como definidas por
     'gradef'.

     'gradefs' é a lista de funções para as quais derivadas parciais
     foram definidas por 'gradef'.  'gradefs' não inclui quaisquer
     variáveis para quais derivadas parciais foram definidas por
     'gradef'.

     Gradientes são necessários quando, por exemplo, uma função não é
     conhecida explicitamente mas suas derivadas primeiras são e isso é
     desejado para obter derivadas de ordem superior.

 -- Variável de sistema: gradefs
     Valor padrão: '[]'

     'gradefs' é a lista de funções para as quais derivadas parciais
     foram definidas por 'gradef'.  'gradefs' não inclui quaisquer
     variáveis para as quais derivadas parciais foram deinidas por
     'gradef'.

 -- Função: laplace (<expr>, <t>, <s>)
     Tenta calcular a transformada de Laplace de <expr> com relação a
     uma variável <t> e parâmetro de transformação <s>.  Se 'laplace'
     não pode achar uma solução, um substantivo ''laplace' é retornado.

     'laplace' reconhece em <expr> as funções 'delta', 'exp', 'log',
     'sin', 'cos', 'sinh', 'cosh', e 'erf', também 'derivative',
     'integrate', 'sum', e 'ilt'.  Se algumas outras funções estiverem
     presente, 'laplace' pode não ser habilitada a calcular a
     tranformada.

     <expr> pode também ser uma equação linear, diferencial de
     coeficiente contante no qual caso o 'atvalue' da variável
     dependente é usado.  O requerido 'atvalue' pode ser fornecido ou
     antes ou depois da transformada ser calculada.  Uma vez que as
     condições iniciais devem ser especificadas em zero, se um teve
     condições de limite impostas em qualquer outro lugar ele pode impor
     essas sobre a solução geral e eliminar as constantes resolvendo a
     solução geral para essas e substituindo seus valores de volta.

     'laplace' reconhece integrais de convolução da forma 'integrate
     (f(x) * g(t - x), x, 0, t)'; outros tipos de convoluções não são
     reconhecidos.

     Relações funcionais devem ser explicitamente representadas em
     <expr>; relações implícitas, estabelecidas por 'depends', não são
     reconhecidas.  Isto é, se <f> depende de <x> e <y>, 'f (x, y)' deve
     aparecer em <expr>.

     Veja também 'ilt', a transformada inversa de Laplace.

     Exemplos:

          (%i1) laplace (exp (2*t + a) * sin(t) * t, t, s);
                                      a
                                    %e  (2 s - 4)
          (%o1)                    ---------------
                                     2           2
                                   (s  - 4 s + 5)
          (%i2) laplace ('diff (f (x), x), x, s);
          (%o2)             s laplace(f(x), x, s) - f(0)
          (%i3) diff (diff (delta (t), t), t);
                                    2
                                   d
          (%o3)                    --- (delta(t))
                                     2
                                   dt
          (%i4) laplace (%, t, s);
                                      !
                         d            !         2
          (%o4)        - -- (delta(t))!      + s  - delta(0) s
                         dt           !
                                      !t = 0


File: maxima.info,  Node: Integração,  Next: Equações,  Prev: Diferenciação,  Up: Top

20 Integração
*************

* Menu:

* Introdução a Integração::
* Funções e Variáveis Definidas para Integração::
* Introdução a QUADPACK::
* Funções e Variáveis Definidas para QUADPACK::


File: maxima.info,  Node: Introdução a Integração,  Next: Funções e Variáveis Definidas para Integração,  Prev: Integração,  Up: Integração

20.1 Introdução a Integração
============================

Maxima tem muitas rotinas para manusear integração.  A função
'integrate' faz uso de muitas dessas.  Exite também o pacote 'antid',
que manuseia uma função não especificada (e suas derivadas, certamente).
Para usos numericos, existe um conjunto de integradores adaptativos de
QUADPACK, a saber 'quad_qag', 'quad_qags', etc., os quais são descritos
sob o tópico 'QUADPACK'.  Funções hipergeométricas estão sendo
trabalhadas, veja 'specint' para detalhes.  Geralmente falando, Maxima
somente manuseia integrais que são integráveis em termos de "funções
elementares" (funções racionais, trigonometricas, logarítmicas,
exponenciais, radicais, etc.)  e umas poucas extensões (função de erro,
dilogarithm).  Isso não manuseia integrais em termos de funções
desconhecidas tais como 'g(x)' e 'h(x)'.


File: maxima.info,  Node: Funções e Variáveis Definidas para Integração,  Next: Introdução a QUADPACK,  Prev: Introdução a Integração,  Up: Integração

20.2 Funções e Variáveis Definidas para Integração
==================================================

 -- Função: changevar (<expr>, <f(x,y)>, <y>, <x>)
     Faz a mudança de variável dada por '<f(x,y)> = 0' em todas as
     integrais que ocorrem em <expr> com integração em relação a <x>.  A
     nova variável é <y>.

          (%i1) assume(a > 0)$
          (%i2) 'integrate (%e**sqrt(a*y), y, 0, 4);
                                4
                               /
                               [    sqrt(a) sqrt(y)
          (%o2)                I  %e                dy
                               ]
                               /
                                0
          (%i3) changevar (%, y-z^2/a, z, y);
                                0
                               /
                               [                abs(z)
                             2 I            z %e       dz
                               ]
                               /
                                - 2 sqrt(a)
          (%o3)            - ----------------------------
                                          a

     Uma expressão contendo uma forma substantiva, tais como as
     instâncias de ''integrate' acima, pode ser avaliada por 'ev' com o
     sinalizador 'nouns'.  Por exemplo, a expressão retornada por
     'changevar' acima pode ser avaliada por 'ev (%o3, nouns)'.

     'changevar' pode também ser usada para alterações nos índices de
     uma soma ou de um produto.  Todavia, isso deve obrigatóriamente ser
     realizado de forma que quando uma alteração é feita em uma soma ou
     produto, essa mudança deve ser um artifício, i.e., 'i = j+ ...',
     não uma função de grau mais alto.  E.g.,

          (%i4) sum (a[i]*x^(i-2), i, 0, inf);
                                   inf
                                   ====
                                   \         i - 2
          (%o4)                     >    a  x
                                   /      i
                                   ====
                                   i = 0
          (%i5) changevar (%, i-2-n, n, i);
                                  inf
                                  ====
                                  \               n
          (%o5)                    >      a      x
                                  /        n + 2
                                  ====
                                  n = - 2

 -- Função: dblint (<f>, <r>, <s>, <a>, <b>)
     Uma rotina de integral dupla que foi escrita no alto-nível do
     Maxima e então traduzida e compilada para linguagem de máquina.
     Use 'load (dblint)' para acessar esse pacote.  Isso usa o método da
     regra de Simpson em ambas as direções x e y para calcular

          /b /s(x)
          |  |
          |  |    f(x,y) dy dx
          |  |
          /a /r(x)

     A função <f> deve ser uma função traduzida ou compilada de duas
     variáveis, e <r> e <s> devem cada uma ser uma função traduzida ou
     compilada de uma variável, enquanto <a> e <b> devem ser números em
     ponto flutuante.  A rotina tem duas variáveis globais que
     determinam o número de divisões dos intervalos x e y: 'dblint_x' e
     'dblint_y', ambas as quais são inicialmente 10, e podem ser
     alteradas independentemente para outros valores inteiros (existem
     '2*dblint_x+1' pontos calculados na direção x , e '2*dblint_y+1' na
     direção y).  A rotina subdivide o eixo X e então para cada valor de
     X isso primeiro calcula '<r>(x)' e '<s>(x)'; então o eixo Y entre
     '<r>(x)' e '<s>(x)' é subdividido e a integral ao longo do eixo Y é
     executada usando a regra de Simpson; então a integral ao longo do
     eixo X é concluída usando a regra de Simpson com os valores da
     função sendo as integrais-Y. Esse procedimento pode ser
     numericamente instável por uma grande variedade razões, mas
     razoávelmente rápido: evite usar isso sobre funções altamente
     oscilatórias e funções com singularidades (postes ou pontos de
     ramificação na região).  As integrais Y dependem de quanto
     fragmentados '<r>(x)' e '<s>(x)' são, então se a ditância '<s>(x) -
     <r>(x)' varia rapidamente com X, nesse ponto pode ter erros
     substanciais provenientes de truncação com diferentes
     saltos-tamanhos nas várias integrais Y. Um pode incrementar
     'dblint_x' e 'dblint_y' em uma tentativa para melhorar a
     convergência da reião, com sacrifício do tempo de computação.  Os
     valores da função não são salvos, então se a função é muito
     desperdiçadora de tempo,você terá de esperar por re-computação se
     você mudar qualquer coisa (desculpe).  Isso é requerido que as
     funções <f>, <r>, e <s> sejam ainda traduzidas ou compiladas
     previamente chamando 'dblint'.  Isso resultará em ordens de
     magnitude de melhoramentos de velocidade sobre o código
     interpretado em muitos casos!

     'demo (dblint)' executa uma demonstração de 'dblint' aplicado a um
     problema exemplo.

 -- Função: defint (<expr>, <x>, <a>, <b>)
     Tenta calcular uma integral definida.  'defint' é chamada por
     'integrate' quando limites de integração são especificados, i.e.,
     quando 'integrate' é chamado como 'integrate (<expr>, <x>, <a>,
     <b>)'.  Dessa forma do ponto de vista do usuário, isso é suficiente
     para chamar 'integrate'.

     'defint' retorna uma expressão simbólica, e executa um dos dois: ou
     calcula a integral ou a forma substantiva da integral.  Veja
     'quad_qag' e funções rellacionadas para aproximação numérica de
     integrais definidas.

 -- Função: erf (<x>)
     Representa a função de erro, cuja derivada é:
     '2*exp(-x^2)/sqrt(%pi)'.

 -- Variável de opção: erfflag
     Valor padrão: 'true'

     Quando 'erfflag' é 'false', previne 'risch' da introdução da função
     'erf' na resposta se não houver nenhum no integrando para começar.

 -- Função: ilt (<expr>, <t>, <s>)
     Calcula a transformação inversa de Laplace de <expr> em relação a
     <t> e parâmetro <s>.  <expr> deve ser uma razão de polinômios cujo
     denominador tem somente fatores lineares e quadráticos.  Usando a
     funções 'laplace' e 'ilt' juntas com as funções 'solve' ou
     'linsolve' o usuário pode resolver uma diferencial simples ou uma
     equação integral de convolução ou um conjunto delas.

          (%i1) 'integrate (sinh(a*x)*f(t-x), x, 0, t) + b*f(t) = t**2;
                        t
                       /
                       [                                    2
          (%o1)        I  f(t - x) sinh(a x) dx + b f(t) = t
                       ]
                       /
                        0
          (%i2) laplace (%, t, s);
                                         a laplace(f(t), t, s)   2
          (%o2)  b laplace(f(t), t, s) + --------------------- = --
                                                 2    2           3
                                                s  - a           s
          (%i3) linsolve ([%], ['laplace(f(t), t, s)]);
                                                  2      2
                                               2 s  - 2 a
          (%o3)     [laplace(f(t), t, s) = --------------------]
                                              5         2     3
                                           b s  + (a - a  b) s
          (%i4) ilt (rhs (first (%)), s, t);
          Is  a b (a b - 1)  positive, negative, or zero?

          pos;
                         sqrt(a b (a b - 1)) t
                  2 cosh(---------------------)       2
                                   b               a t
          (%o4) - ----------------------------- + -------
                        3  2      2               a b - 1
                       a  b  - 2 a  b + a

                                                                 2
                                                       + ------------------
                                                          3  2      2
                                                         a  b  - 2 a  b + a

 -- Função: integrate (<expr>, <x>)
 -- Função: integrate (<expr>, <x>, <a>, <b>)
     Tenta símbolicamente calcular a integral de <expr> em relação a
     <x>.  'integrate (<expr>, <x>)' é uma integral indefinida, enquanto
     'integrate (<expr>, <x>, <a>, <b>)' é uma integral definida, com
     limites de integração <a> e <b>.  Os limites não poderam conter
     <x>, embora 'integrate' não imponha essa restrição.  <a> não
     precisa ser menor que <b>.  Se <b> é igual a <a>, 'integrate'
     retorna zero.

     Veja 'quad_qag' e funções relacionadas para aproximação numérica de
     integrais definidas.  Veja 'residue' para computação de resíduos
     (integração complexa).  Veja 'antid' para uma forma alternativa de
     calcular integrais indefinidas.

     A integral (uma expressão livre de 'integrate') é retornada se
     'integrate' obtém sucesso.  De outra forma o valor de retorno é a
     forma substantiva da integral (o operador com apóstrofo
     ''integrate') ou uma expressão contendo uma ou mais formas
     substantivas.  A forma substantiva de 'integrate' é mostrada com um
     sinal de integral.

     Em algumas circunstâncias isso é útil para construir uma forma
     substantiva manualmente, colocando em 'integrate' um apóstrofo,
     e.g., ''integrate (<expr>, <x>)'.  Por exemplo, a integral pode
     depender de alguns parâmetos que não estão ainda calculados.  A
     forma substantiva pode ser aplicada a seus argumentos por 'ev (<i>,
     nouns)' onde <i> é a forma substantiva de interesse.

     'integrate' manuseia integrais definidas separadamente das
     indefinidas, e utiliza uma gama de heurísticas para manusear cada
     caso.  Casos especiais de integrais definidas incluem limites de
     integração iguais a zero ou infinito ('inf' ou 'minf'), funções
     trigonométricas com limites de integração iguais a zero e '%pi' ou
     '2 %pi', funções racionais, integrais relacionadas para as
     definições de funções 'beta' e 'psi', e algumas integrais
     logarítmicas e trigonométricas.  Processando funções racionais pode
     incluir computação de resíduo.  Se um caso especial aplicável não é
     encontrado, tentativa será feita para calcular a integra indefinida
     e avaliar isso nos limites de integração.  Isso pode incluir pegar
     um limite como um limite de integração tendendo ao infinito ou a
     menos infinito; veja também 'ldefint'.

     Casos especiais de integrais indefinidas incluem funções
     trigonométricas, exponenciais e funções logarítmicas, e funções
     racionais.  'integrate' pode também fazer uso de uma curta tabela
     de integais elementares.

     'integrate' pode realizar uma mudança de variável se o integrando
     tem a forma 'f(g(x)) * diff(g(x), x)'.  'integrate' tenta achar uma
     subexpressão 'g(x)' de forma que a derivada de 'g(x)' divida o
     integrando.  Essa busca pode fazer uso de derivadas definidas pela
     função 'gradef'.  Veja também 'changevar' e 'antid'.

     Se nenhum dos procedimentos heurísticos acha uma integral
     indefinida, o algorítmo de Risch é executado.  O sinalizador
     'risch' pode ser escolhido como um 'evflag', na chamada para 'ev'
     ou na linha de comando, e.g., 'ev (integrate (<expr>, <x>), risch)'
     ou 'integrate (<expr>, <x>), risch'.  Se 'risch' está presente,
     'integrate' chama a função 'risch' sem tentar heurísticas primeiro.
     Veja também 'risch'.

     'integrate' trabalha somente com relações funcionais representadas
     explicitamente com a notação 'f(x)'.  'integrate' não respeita
     dependências implicitas estabelecidas pela função 'depends'.
     'integrate' pode necessitar conhecer alguma propriedade de um
     parâmetro no integrando.  'integrate' irá primeiro consultar a base
     de dados do 'assume', e , se a variável de interesse não está lá,
     'integrate' perguntará ao usuário.  Dependendo da pergunta,
     respostas adequadas são 'yes;' ou 'no;', ou 'pos;', 'zero;', ou
     'neg;'.

     'integrate' não é, por padrão, declarada ser linear.  Veja
     'declare' e 'linear'.

     'integrate' tenta integração por partes somente em uns poucos casos
     especiais.

     Exemplos:

        * Integrais definidas e indefinidas elementares.

               (%i1) integrate (sin(x)^3, x);
                                          3
                                       cos (x)
               (%o1)                   ------- - cos(x)
                                          3
               (%i2) integrate (x/ sqrt (b^2 - x^2), x);
                                                2    2
               (%o2)                    - sqrt(b  - x )
               (%i3) integrate (cos(x)^2 * exp(x), x, 0, %pi);
                                              %pi
                                          3 %e      3
               (%o3)                      ------- - -
                                             5      5
               (%i4) integrate (x^2 * exp(-x^2), x, minf, inf);
                                           sqrt(%pi)
               (%o4)                       ---------
                                               2

        * Uso de 'assume' e dúvida interativa.

               (%i1) assume (a > 1)$
               (%i2) integrate (x**a/(x+1)**(5/2), x, 0, inf);
                   2 a + 2
               Is  -------  an integer?
                      5

               no;
               Is  2 a - 3  positive, negative, or zero?

               neg;
                                                  3
               (%o2)                  beta(a + 1, - - a)
                                                  2

        * Mudança de variável.  Existem duas mudanças de variável nesse
          exemplo: uma usando a derivada estabelecida por 'gradef', e
          uma usando a derivação 'diff(r(x))' de uma função não
          especificada 'r(x)'.

               (%i3) gradef (q(x), sin(x**2));
               (%o3)                         q(x)
               (%i4) diff (log (q (r (x))), x);
                                     d               2
                                    (-- (r(x))) sin(r (x))
                                     dx
               (%o4)                ----------------------
                                           q(r(x))
               (%i5) integrate (%, x);
               (%o5)                     log(q(r(x)))

        * O valor de retorno contém a forma substantiva ''integrate'.
          Nesse exemplo, Maxima pode extrair um fator do denominador de
          uma função racional, mas não pode fatorar o restante ou de
          outra forma achar sua integral.  'grind' mostra a forma
          substantiva ''integrate' no resultado.  Veja também
          'integrate_use_rootsof' para mais sobre integrais de funções
          racionais.

               (%i1) expand ((x-4) * (x^3+2*x+1));
                                   4      3      2
               (%o1)              x  - 4 x  + 2 x  - 7 x - 4
               (%i2) integrate (1/%, x);
                                             /  2
                                             [ x  + 4 x + 18
                                             I ------------- dx
                                             ]  3
                                log(x - 4)   / x  + 2 x + 1
               (%o2)            ---------- - ------------------
                                    73               73
               (%i3) grind (%);
               log(x-4)/73-('integrate((x^2+4*x+18)/(x^3+2*x+1),x))/73$

        * Definindo uma função em termos de uma integral.  O corpo de
          uma função não é avaliado quando a função é definida.  Dessa
          forma o corpo de 'f_1' nesse exemplo contém a forma
          substantiva de 'integrate'.  O operador apóstrofo-apóstrofo
          '''' faz com que a integral seja avaliada, e o resultado
          transforme-se no corpo de 'f_2'.

               (%i1) f_1 (a) := integrate (x^3, x, 1, a);
                                                    3
               (%o1)           f_1(a) := integrate(x , x, 1, a)
               (%i2) ev (f_1 (7), nouns);
               (%o2)                          600
               (%i3) /* Note parentheses around integrate(...) here */
                     f_2 (a) := ''(integrate (x^3, x, 1, a));
                                                  4
                                                 a    1
               (%o3)                   f_2(a) := -- - -
                                                 4    4
               (%i4) f_2 (7);
               (%o4)                          600

 -- Variável de sistema: integration_constant_counter
     Valor padrão: 0

     'integração_constant_counter' é um contador que é atualizado a cada
     vez que uma constante de integração (nomeada pelo Maxima, e.g.,
     'integrationconstant1') é introduzida em uma expressão pela
     integração indefinida de uma equação.

 -- Variável de opção: integrate_use_rootsof
     Valor padrão: 'false'

     Quando 'integrate_use_rootsof' é 'true' e o denominador de uma
     função racional não pode ser fatorado, 'integrate' retorna a
     integral em uma forma que é uma soma sobre as raízes (não
     conhecidas ainda) do denominador.

     Por exemplo, com 'integrate_use_rootsof' escolhido para 'false',
     'integrate' retorna uma integral não resolvida de uma função
     racional na forma substantiva:

          (%i1) integrate_use_rootsof: false$
          (%i2) integrate (1/(1+x+x^5), x);
                  /  2
                  [ x  - 4 x + 5
                  I ------------ dx                            2 x + 1
                  ]  3    2                2            5 atan(-------)
                  / x  - x  + 1       log(x  + x + 1)          sqrt(3)
          (%o2)   ----------------- - --------------- + ---------------
                          7                 14             7 sqrt(3)

     Agora vamos escolher o sinalizador para ser true e a parte não
     resolvida da integral será expressa como um somatório sobre as
     raízes do denominador da função racional:

          (%i3) integrate_use_rootsof: true$
          (%i4) integrate (1/(1+x+x^5), x);
                ====        2
                \       (%r4  - 4 %r4 + 5) log(x - %r4)
                 >      -------------------------------
                /                    2
                ====            3 %r4  - 2 %r4
                                  3      2
                %r4 in rootsof(%r4  - %r4  + 1, %r4)
          (%o4) ----------------------------------------------------------
                         7

                                                                       2 x + 1
                                                   2            5 atan(-------)
                                              log(x  + x + 1)          sqrt(3)
                                            - --------------- + ---------------
                                                    14             7 sqrt(3)

     Alternativamente o usuário pode calcular as raízes do denominador
     separadamente, e então expressar o integrando em termos dessas
     raízes, e.g., '1/((x - a)*(x - b)*(x - c))' ou '1/((x^2 - (a+b)*x +
     a*b)*(x - c))' se o denominador for um polinômio cúbico.  Algumas
     vezes isso ajudará Maxima a obter resultados mais úteis.

 -- Função: ldefint (<expr>, <x>, <a>, <b>)
     Tenta calcular a integral definida de <expr> pelo uso de 'limit'
     para avaliar a integral indefinida <expr> em relação a <x> no
     limite superior <b> e no limite inferior <a>.  Se isso falha para
     calcular a integral definida, 'ldefint' retorna uma expressão
     contendo limites como formas substantivas.

     'ldefint' não é chamada por 'integrate', então executando 'ldefint
     (<expr>, <x>, <a>, <b>)' pode retornar um resultado diferente de
     'integrate (<expr>, <x>, <a>, <b>)'.  'ldefint' sempre usa o mesmo
     método para avaliar a integral definida, enquanto 'integrate' pode
     utilizar várias heurísticas e pode reconhecer alguns casos
     especiais.

 -- Função: potential (<givengradient>)
     O cálculo faz uso da variável global 'potentialzeroloc[0]' que deve
     ser 'nonlist' ou da forma

          [indeterminatej=expressãoj, indeterminatek=expressãok, ...]

     O formador sendo equivalente para a expressão nonlist para todos os
     lados direitos-manuseados mais tarde.  Os lados direitos indicados
     são usados como o limite inferior de integração.  O sucesso das
     integrações pode depender de seus valores e de sua ordem.
     'potentialzeroloc' é inicialmente escolhido para 0.

 -- Função: residue (<expr>, <z>, <z_0>)
     Calcula o resíduo no plano complexo da expressão <expr> quando a
     variável <z> assumes o valor <z_0>.  O resíduo é o coeficiente de
     '(<z> - <z_0>)^(-1)' nas séries de Laurent para <expr>.

          (%i1) residue (s/(s**2+a**2), s, a*%i);
                                          1
          (%o1)                           -
                                          2
          (%i2) residue (sin(a*x)/x**4, x, 0);
                                           3
                                          a
          (%o2)                         - --
                                          6

 -- Função: risch (<expr>, <x>)
     Integra <expr> em relação a <x> usando um caso transcendental do
     algorítmo de Risch.  (O caso algébrico do algorítmo de Risch foi
     implementado.)  Isso atualmente manuseia os casos de exponenciais
     aninhadas e logarítmos que a parte principal de 'integrate' não
     pode fazer.  'integrate' irá aplicar automaticamente 'risch' se
     dados esses casos.

     'erfflag', se 'false', previne 'risch' da introdução da função
     'erf' na resposta se não for achado nenhum no integrando para
     começar.

          (%i1) risch (x^2*erf(x), x);
                                                                  2
                       3                      2                - x
                  %pi x  erf(x) + (sqrt(%pi) x  + sqrt(%pi)) %e
          (%o1)   -------------------------------------------------
                                        3 %pi
          (%i2) diff(%, x), ratsimp;
                                       2
          (%o2)                       x  erf(x)

 -- Função: tldefint (<expr>, <x>, <a>, <b>)
     Equivalente a 'ldefint' com 'tlimswitch' escolhido para 'true'.


File: maxima.info,  Node: Introdução a QUADPACK,  Next: Funções e Variáveis Definidas para QUADPACK,  Prev: Funções e Variáveis Definidas para Integração,  Up: Integração

20.3 Introdução a QUADPACK
==========================

QUADPACK é uma coleção de funções para aálculo numérico de integrais
definidas unidimensionais.  O pacote QUADPACK resultou da junção de um
projeto de R. Piessens (1), E. de Doncker (2), C. Ueberhuber (3), e D.
Kahaner (4).

   A biblioteca QUADPACK inclída no Maxima é uma tradução automática
(feita através do programa 'f2cl') do código fonte em de QUADPACK como
aparece na SLATEC Common Mathematical Library, Versão 4.1 (5).  A
biblioteca Fortran SLATEC é datada de Julho de 1993, mas as funções
QUADPACK foram escritas alguns anos antes.  Existe outra versão de
QUADPACK em Netlib (6); não está claro no que aquela versão difere da
versão existente em SLATEC.

   As funções QUADPACK incluídas no Maxima são toda automáticas, no
sentido de que essas funções tentam calcular um resultado para uma
precisão específica, requerendo um número não especificado de avaliações
de função.  A tradução do Lisp do Maxima da iblioteca QUADPACK também
inclui algumas funçe~s não automáticas, mas elas não são expostas a
nível de Maxima.

   Informação adicionalsobre a bilioteca QUADPACK pode ser encontrada no
livro do QUADPACK (7).

20.3.1 Overview
---------------

'quad_qag'
     Integração de uma função genérica sobre um intervalo finito.
     'quad_qag' implementa um integrador adaptativo globalmente simples
     usando a estratégia de Aind (Piessens, 1973).  O chamador pode
     escolher entre 6 pares de formulas da quadratura de Gauss-Kronrod
     para a componente de avaliação da regra.  As regras de alto grau
     são adequadas para integrandos fortemente oscilantes.

'quad_qags'
     Integração de uma função genérica sob um intervalo finito.
     'quad_qags' implementa subdivisão de intervalos globalmente
     adaptativos com extrapolação (de Doncker, 1978) por meio do
     algorítmo de Epsilon (Wynn, 1956).

'quad_qagi'
     Integração de uma função genérica sobre um intervalo finito ou
     semi-finito.  O intervalo é mapeado sobre um intervalo finito e
     então a mesma estratégia de 'quad_qags' é aplicada.

'quad_qawo'
     Integração de cos(omega x) f(x) ou sin(omega x) f(x) sobre um
     intervalo finito, onde omega é uma constante.  A componente de
     avaliação da regra é baseada na técnica modificada de
     Clenshaw-Curtis.  'quad_qawo' aplica subdivisão adaptativa com
     extrapolação, similar a 'quad_qags'.

'quad_qawf'
     Calcula uma transformação de cosseno de Fourier ou de um seno de
     Fourier sobre um intervalo semi-finito.  O mesmo aproxima como
     'quad_qawo' aplicado sobre intervalos finitos sucessivos, e
     aceleração de convergência por meio d algorítimo de Epsilon (Wynn,
     1956) aplicado a séries de contribuições de integrais.

'quad_qaws'
     Integraçào de w(x) f(x) sobre um intervalo finito [a, b], onde w é
     uma função da forma (x - a)^alpha (b - x)^beta v(x) e v(x) é 1 ou
     log(x - a) ou log(b - x) ou log(x - a) log(b - x), e alpha > -1 e
     beta > -1.  Auma estratégia de subdivisão adaptativa é aplicada,
     com integração modificada de Clenshaw-Curtis sobre os subintervalos
     que possuem a ou b.

'quad_qawc'
     Calcula o valor principal de Cauchy de f(x)/(x - c) sobre um
     intervalo finito (a, b) e um c especificado.  A estratégia é
     globalmente adaptativa, e a integração modificada de
     Clenshaw-Curtis é usada sobre subamplitudes que possuírem o ponto x
     = c.

   ---------- Footnotes ----------

   (1) Applied Mathematics and Programming Division, K.U. Leuven

   (2) Applied Mathematics and Programming Division, K.U. Leuven

   (3) Institut für Mathematik, T.U. Wien

   (4) National Bureau of Standards, Washington, D.C., U.S.A

   (5) http://www.netlib.org/slatec

   (6) http://www.netlib.org/quadpack

   (7) R. Piessens, E. de Doncker-Kapenga, C.W. Uberhuber, e D.K.
Kahaner.  QUADPACK: A Subroutine Package for Automatic Integration.
Berlin: Springer-Verlag, 1983, ISBN 0387125531.


File: maxima.info,  Node: Funções e Variáveis Definidas para QUADPACK,  Prev: Introdução a QUADPACK,  Up: Integração

20.4 Funções e Variáveis Definidas para QUADPACK
================================================

 -- Função: quad_qag (<f(x)>, <x>, <a>, <b>, <chave>, <epsrel>,
          <limite>)
 -- Função: quad_qag (<f>, <x>, <a>, <b>, <chave>, <epsrel>, <limite>)

     Integração de uma função genérica sobre um intervalo finito.
     'quad_qag' implementa um integrador adaptativo globalmente simples
     usando a estratégia de Aind (Piessens, 1973).  O chamador pode
     escolher entre 6 pares de fórmulas da quadratura de Gauss-Kronrod
     para a componente de avaliação da regra.  As regras de alto nível
     são adequadas para integrandos fortemente oscilatórios.

     'quad_qag' calcula a integral

     integrate (f(x), x, a, b)

     A função a ser integrada é <f(x)>, com variável dependente <x>, e a
     função é para ser integrada entre os limites <a> e <b>.  <chave> é
     o integrador a ser usado e pode ser um inteiro entre 1 e 6,
     inclusive.  O valor de <chave> seleciona a ordem da regra de
     integração de Gauss-Kronrod.  Regra de alta ordem são adequadas
     para integrandos fortemente oscilatórios.

     O integrando pode ser especidficado como o nome de uma função
     Maxima ou uma função Lisp ou um operador, uma expressão lambda do
     Maxima, ou uma expressão geral do Maxima.

     A integração numérica é concluída adaptativamente pela subdivisão a
     região de integração até que a precisão desejada for completada.

     Os argumentos opcionais <epsrel> e <limite> são o erro relativo
     desejado e o número máximo de subintervalos respectivamente.
     <epsrel> padrão em 1e-8 e <limite> é 200.

     'quad_qag' retorna uma lista de quatro elementos:

        * uma aproximação para a integral,
        * o erro absoluto estimado da aproximação,
        * o número de avaliações do integrando,
        * um código de erro.

     O código de erro (quarto elemento do valor de retorno) pode ter os
     valores:

     '0'
          se nenhum problema for encontrado;
     '1'
          se muitos subintervalos foram concluídos;
     '2'
          se erro excessivo é detectado;
     '3'
          se ocorre comportamento extremamente ruim do integrando;
     '6'
          se a entrada é inválida.

     Exemplos:

          (%i1) quad_qag (x^(1/2)*log(1/x), x, 0, 1, 3);
          (%o1)    [.4444444444492108, 3.1700968502883E-9, 961, 0]
          (%i2) integrate (x^(1/2)*log(1/x), x, 0, 1);
                                          4
          (%o2)                           -
                                          9

 -- Função: quad_qags (<f(x)>, <x>, <a>, <b>, <epsrel>, <limite>)
 -- Função: quad_qags (<f>, <x>, <a>, <b>, <epsrel>, <limite>)

     Integração de uma função geral sobre um intervalo finito.
     'quad_qags' implementa subdivisão de intervalo globalmente
     adaptativa com extrapolação (de Doncker, 1978) através do algorítmo
     de (Wynn, 1956).

     'quad_qags' computes the integral

     integrate (f(x), x, a, b)

     A função a ser integrada é <f(x)>, com variável dependente <x>, e a
     função é para ser integrada entre os limites <a> e <b>.

     O integrando pode ser especidficado como o nome de uma função
     Maxima ou uma função Lisp ou um operador, uma expressão lambda do
     Maxima, ou uma expressão geral do Maxima.

     Os argumentos opcionais <epsrel> e <limite> são o erro relativo
     desejado e o número máximo de subintervalos, respectivamente.
     <epsrel> padrão em 1e-8 e <limite> é 200.

     'quad_qags' retorna uma lista de quatro elementos:

        * uma aproximação para a integral,
        * o erro absoluto estimado da aproximação,
        * o número de avaliações do integrando,
        * um código de erro.

     O código de erro (quarto elemento do valor de retorno) pode ter os
     valores:

     '0'
          nenhum problema foi encontrado;
     '1'
          muitos subintervalos foram concluídos;
     '2'
          erro excessivo é detectado;
     '3'
          ocorreu comportamento excessivamente ruim do integrando;
     '4'
          falhou para convergência
     '5'
          integral é provavelmente divergente ou lentamente convergente
     '6'
          se a entrada é inválida.

     Exemplos:

          (%i1) quad_qags (x^(1/2)*log(1/x), x, 0 ,1);
          (%o1)   [.4444444444444448, 1.11022302462516E-15, 315, 0]

     Note que 'quad_qags' é mais preciso e eficiente que 'quad_qag' para
     esse integrando.

 -- Função: quad_qagi (<f(x)>, <x>, <a>, <inftype>, <epsrel>, <limite>)
 -- Função: quad_qagi (<f>, <x>, <a>, <inftype>, <epsrel>, <limite>)

     Integração de uma função genérica sobre um intervalo finito ou
     semi-finito.  O intervalo é mapeado sobre um intervalo finito e
     então a mesma estratégia que em 'quad_qags' é aplicada.

     'quad_qagi' avalia uma das seguintes integrais

     integrate (f(x), x, minf, inf)

     integrate (f(x), x, minf, a)

     integrate (f(x), x, a, minf, inf)

     usando a rotina Quadpack QAGI. A função a ser integrada é <f(x)>,
     com variável dependente <x>, e a função é para ser integrada sobre
     um intervalo infinito.

     O integrando pode ser especidficado como o nome de uma função
     Maxima ou uma função Lisp ou um operador, uma expressão lambda do
     Maxima, ou uma expressão geral do Maxima.

     O parâmetro <inftype> determina o intervalo de integração como
     segue:

     'inf'
          O intervalo vai de <a> ao infinito positivo.
     'minf'
          O intervalo vai do infinito negativo até <a>.
     'both'
          O intervalo corresponde a toda reta real.

     Os argumentos opcionais <epsrel> e <limite> são o erro relativo
     desejado e o número maximo de subintervalos, respectivamente.
     <epsrel> padrão para 1e-8 e <limite> é 200.

     'quad_qagi' retorna uma lista de quatro elementos:

        * uma aproximação para a integral,
        * o erro absoluto estimado da aproximação,
        * o número de avaliações do integrando,
        * um código de erro.

     O código de erro (quarto elemento do valor de retorno) pode ter os
     valores:

     '0'
          nenhum problema foi encontrado;
     '1'
          muitos subintervalos foram concluídos;
     '2'
          erro excessivo é detectado;
     '3'
          ocorreu comportamento excessivamente ruim do integrando;
     '4'
          falhou para convergência;
     '5'
          integral é provavelmente divergente ou lentamente convergente;
     '6'
          se a entrada for inválida.

     Exemplos:

          (%i1) quad_qagi (x^2*exp(-4*x), x, 0, inf);
          (%o1)        [0.03125, 2.95916102995002E-11, 105, 0]
          (%i2) integrate (x^2*exp(-4*x), x, 0, inf);
                                         1
          (%o2)                          --
                                         32

 -- Função: quad_qawc (<f(x)>, <x>, <c>, <a>, <b>, <epsrel>, <limite>)
 -- Função: quad_qawc (<f>, <x>, <c>, <a>, <b>, <epsrel>, <limite>)

     Calcula o valor principal de Cauchy de f(x)/(x - c) over a finite
     interval.  A estratégia é globalmente adaptativa, e a integração de
     Clenshaw-Curtis modificada é usada sobre as subamplitudes que
     possuírem o ponto x = c.

     'quad_qawc' calcula o valor principal de Cauchy de

     integrate (f(x)/(x - c), x, a, b)

     usando a rotina Quadpack QAWC. A função a ser integrada é
     '<f(x)>/(<x> - <c>)', com variável dependente <x>, e a função é
     para ser integrada sobre o intervalo que vai de <a> até <b>.

     O integrando pode ser especidficado como o nome de uma função
     Maxima ou uma função Lisp ou um operador, uma expressão lambda do
     Maxima, ou uma expressão geral do Maxima.

     Os argumentos opcionais <epsrel> e <limite> são o erro relativo
     desejado e o máximo número de subintervalos, respectivamente.
     <epsrel> padrão para 1e-8 e <limite> é 200.

     'quad_qawc' retorna uma lista de quatro elementos:

        * uma aproximação para a integral,
        * o erro absoluto estimado da aproximação,
        * o número de avaliações do integrando,
        * um código de erro.

     O código de erro (quarto elemento do valoor de retorno) pode ter os
     valores:

     '0'
          nenhum problema foi encontrado;
     '1'
          muitos subintervalos foram concluídos;
     '2'
          erro excessivo é detectado;
     '3'
          ocorreu comportamento excessivamente ruim do integrando;
     '6'
          se a entrada é inválida.

     Exemplos:

          (%i1) quad_qawc (2^(-5)*((x-1)^2+4^(-5))^(-1), x, 2, 0, 5);
          (%o1)    [- 3.130120337415925, 1.306830140249558E-8, 495, 0]
          (%i2) integrate (2^(-alpha)*(((x-1)^2 + 4^(-alpha))*(x-2))^(-1), x, 0, 5);
          Principal Value
                                 alpha
                  alpha       9 4                 9
                 4      log(------------- + -------------)
                                alpha           alpha
                            64 4      + 4   64 4      + 4
          (%o2) (-----------------------------------------
                                  alpha
                               2 4      + 2

                   3 alpha                       3 alpha
                   -------                       -------
                      2            alpha/2          2          alpha/2
                2 4        atan(4 4       )   2 4        atan(4       )   alpha
              - --------------------------- - -------------------------)/2
                          alpha                        alpha
                       2 4      + 2                 2 4      + 2
          (%i3) ev (%, alpha=5, numer);
          (%o3)                    - 3.130120337415917

 -- Função: quad_qawf (<f(x)>, <x>, <a>, <omega>, <trig>, <epsabs>,
          <limit>, <maxp1>, <limlst>)
 -- Função: quad_qawf (<f>, <x>, <a>, <omega>, <trig>, <epsabs>,
          <limit>, <maxp1>, <limlst>)

     Calcula uma transformação de cosseno de Fourier ou de um seno de
     Fourier sobre um intervalo semi-finito.  usando a função QAWF do
     pacote Quadpack.  A mesma aproxima como em 'quad_qawo' quando
     aplicada sobre intervalos finitos sucessivos, e aceleração de
     convergência por meio d algorítimo de Epsilon (Wynn, 1956) aplicado
     a séries de contribuições de integrais.

     'quad_qawf' calcula a integral

     integrate (f(x)*w(x), x, a, inf)

     A função peso w é selecionada por <trig>:

     'cos'
          w(x) = cos (omega x)
     'sin'
          w(x) = sin (omega x)

     O integrando pode ser especidficado como o nome de uma função
     Maxima ou uma função Lisp ou um operador, uma expressão lambda do
     Maxima, ou uma expressão geral do Maxima.

     Os argumentos opcionais são:

     'epsabs'
          Erro absoluto de aproximação desejado.  Padrão é 1d-10.
     'limit'
          Tamanho de array interno de trabalho.  (<limit> - <limlst>)/2
          é o maximo número de subintervalos para usar.  O Padrão é 200.
     'maxp1'
          O número máximo dos momentos de Chebyshev.  Deve ser maior que
          0.  O padrão é 100.
     'limlst'
          Limite superior sobre número de ciclos.  Deve ser maior ou
          igual a 3.  O padrão é 10.

     <epsabs> e <limit> são o erro relativo desejado e o número maximo
     de subintervalos, respectivamente.  <epsrel> padrão para 1e-8 e
     <limit> é 200.

     'quad_qawf' retorna uma lista de quatro elementos:

        * uma aproximação para a integral,
        * o erro absoluto estimado da aproximação,
        * o número de avaliações do integrando,
        * um código de erro.

     O código de erro (quarto elemento do valor de retorno) pode ter os
     valores:

     '0'
          nenhum problema foi encontrado;
     '1'
          muitos subintervalos foram concluídos;
     '2'
          erro excessivo é detectado;
     '3'
          ocorreu um comportamento excessivamente ruim do integrando;
     '6'
          se a entrada é invalida.

     Exemplos:

          (%i1) quad_qawf (exp(-x^2), x, 0, 1, 'cos);
          (%o1)   [.6901942235215714, 2.84846300257552E-11, 215, 0]
          (%i2) integrate (exp(-x^2)*cos(x), x, 0, inf);
                                    - 1/4
                                  %e      sqrt(%pi)
          (%o2)                   -----------------
                                          2
          (%i3) ev (%, numer);
          (%o3)                   .6901942235215714

 -- Função: quad_qawo (<f(x)>, <x>, <a>, <b>, <omega>, <trig>, <epsabs>,
          <limite>, <maxp1>, <limlst>)
 -- Função: quad_qawo (<f>, <x>, <a>, <b>, <omega>, <trig>, <epsabs>,
          <limite>, <maxp1>, <limlst>)

     Integração de cos(omega x) f(x) ou sin(omega x) f(x) sobre um
     intervalo finito, onde omega é uma constante.  A componente de
     avaliação da regra é baseada na técnica modificada de
     Clenshaw-Curtis.  'quad_qawo' aplica subdivisão adaptativa com
     extrapolação, similar a 'quad_qags'.

     'quad_qawo' calcula a integral usando a rotina Quadpack QAWO:

     integrate (f(x)*w(x), x, a, b)

     A função peso w é selecionada por <trig>:

     'cos'
          w(x) = cos (omega x)
     'sin'
          w(x) = sin (omega x)

     O integrando pode ser especidficado como o nome de uma função
     Maxima ou uma função Lisp ou um operador, uma expressão lambda do
     Maxima, ou uma expressão geral do Maxima.

     Os argumentos opcionais são:

     'epsabs'
          Erro absoluto desejado de aproximação.  O Padrão é 1d-10.
     'limite'
          Tamanho do array interno de trabalho.  (<limite> - <limlst>)/2
          é o número máximo de subintervalos a serem usados.  Default é
          200.
     'maxp1'
          Número máximo dos momentos de Chebyshev.  Deve ser maior que
          0.  O padrão é 100.
     'limlst'
          Limite superior sobre o número de ciclos.  Deve ser maior que
          ou igual a 3.  O padrão é 10.

     <epsabs> e <limite> são o erro relativo desejado e o número máximo
     de subintervalos, respectivamente.  <epsrel> o padrão é 1e-8 e
     <limite> é 200.

     'quad_qawo' retorna uma lista de quatro elementos:

        * uma aproximação para a integral,
        * o erro absoluto estimado da aproximação,
        * o número de avaliações do integrando,
        * um código de erro.

     O código de erro (quarto elemento do valor de retorno) pode ter os
     valores:

     '0'
          nenhum problema foi encontrado;
     '1'
          muitos subintervalos foram concluídos;
     '2'
          erro excessivo é detectado;
     '3'
          comportamento extremamente ruim do integrando;
     '6'
          se a entrada é inválida.

     Exemplos:

          (%i1) quad_qawo (x^(-1/2)*exp(-2^(-2)*x), x, 1d-8, 20*2^2, 1, cos);
          (%o1)     [1.376043389877692, 4.72710759424899E-11, 765, 0]
          (%i2) rectform (integrate (x^(-1/2)*exp(-2^(-alpha)*x) * cos(x), x, 0, inf));
                             alpha/2 - 1/2            2 alpha
                  sqrt(%pi) 2              sqrt(sqrt(2        + 1) + 1)
          (%o2)   -----------------------------------------------------
                                         2 alpha
                                   sqrt(2        + 1)
          (%i3) ev (%, alpha=2, numer);
          (%o3)                     1.376043390090716

 -- Função: quad_qaws (<f(x)>, <x>, <a>, <b>, <alpha>, <beta>, <wfun>,
          <epsabs>, <limite>)
 -- Função: quad_qaws (<f>, <x>, <a>, <b>, <alpha>, <beta>, <wfun>,
          <epsabs>, <limite>)

     Integração de w(x) f(x) sobre um intervalo finito, onde w(x) é uma
     certa função algébrica ou logarítmica.  Uma estratégia de
     subdivisão globalmente adaptativa é aplicada, com integração
     modificada de Clenshaw-Curtis sobre os subintervalos que possuírem
     os pontos finais dos intervalos de integração.

     'quad_qaws' calcula a integral usando a rotina Quadpack QAWS:

     integrate (f(x)*w(x), x, a, b)

     A função peso w é selecionada por <wfun>:

     '1'
          w(x) = (x - a)^alpha (b - x)^beta
     '2'
          w(x) = (x - a)^alpha (b - x)^beta log(x - a)
     '3'
          w(x) = (x - a)^alpha (b - x)^beta log(b - x)
     '4'
          w(x) = (x - a)^alpha (b - x)^beta log(x - a) log(b - x)

     O integrando pode ser especidficado como o nome de uma função
     Maxima ou uma função Lisp ou um operador, uma expressão lambda do
     Maxima, ou uma expressão geral do Maxima.

     O argumentos opcionais são:

     'epsabs'
          Erro absoluto desejado de aproximação.  O padrão é 1d-10.
     'limite'
          Tamanho do array interno de trabalho.  (<limite> - <limlst>)/2
          é o número máximo de subintervalos para usar.  O padrão é 200.

     <epsabs> e <limit> são o erro relativo desejado e o número máximo
     de subintervalos, respectivamente.  <epsrel> o padrão é 1e-8 e
     <limite> é 200.

     'quad_qaws' retorna uma lista de quatro elementos:

        * uma aproximação para a integral,
        * o erro absoluto estimado da aproximação,
        * o número de avaliações do integrando,
        * um código de erro.

     O código de erro (quarto elemento do valor de retorno) pode ter os
     valores:

     '0'
          nenhum problema foi encontrado;
     '1'
          muitos subintervalos foram concluídos;
     '2'
          erro excessivo é detectado;
     '3'
          ocorreu um comportamento excessivamente ruim do integrando;
     '6'
          se a entrada é invalida.

     Exemplos:

          (%i1) quad_qaws (1/(x+1+2^(-4)), x, -1, 1, -0.5, -0.5, 1);
          (%o1)     [8.750097361672832, 1.24321522715422E-10, 170, 0]
          (%i2) integrate ((1-x*x)^(-1/2)/(x+1+2^(-alpha)), x, -1, 1);
                 alpha
          Is  4 2      - 1  positive, negative, or zero?

          pos;
                                    alpha         alpha
                             2 %pi 2      sqrt(2 2      + 1)
          (%o2)              -------------------------------
                                         alpha
                                      4 2      + 2
          (%i3) ev (%, alpha=4, numer);
          (%o3)                     8.750097361672829


File: maxima.info,  Node: Equações,  Next: Equações Diferenciais,  Prev: Integração,  Up: Top

21 Equações
***********

* Menu:

* Funções e Variáveis Definidas para Equações::


File: maxima.info,  Node: Funções e Variáveis Definidas para Equações,  Prev: Equações,  Up: Equações

21.1 Funções e Variáveis Definidas para Equações
================================================

 -- Variável: %rnum_list
     Valor padrão: '[]'

     '%rnum_list' é a lista de variáveis introduzidas em soluções por
     'algsys'.  '%r' variáveis São adicionadas a '%rnum_list' na ordem
     em que forem criadas.  Isso é conveniente para fazer substituições
     dentro da solução mais tarde.  É recomendado usar essa lista em
     lugar de fazer 'concat ('%r, j)'.

 -- Variável: algexact
     Valor padrão: 'false'

     'algexact' afeta o comportamento de 'algsys' como segue:

     Se 'algexact' é 'true', 'algsys' sempre chama 'solve' e então usa
     'realroots' sobre falhas de 'solve'.

     Se 'algexact' é 'false', 'solve' é chamada somente se o eliminante
     não for de uma variável, ou se for uma quadrática ou uma
     biquadrada.

     Dessa forma 'algexact: true' não garante somente soluções exatas,
     apenas que 'algsys' tentará primeiro pegar soluções exatas, e
     somente retorna aproximações quando tudo mais falha.

 -- Função: algsys ([<expr_1>, ..., <expr_m>], [<x_1>, ..., <x_n>])
 -- Função: algsys ([<eqn_1>, ..., <eqn_m>], [<x_1>, ..., <x_n>])
     Resolve polinômios simultâneos <expr_1>, ..., <expr_m> ou equações
     polinômiais <eqn_1>, ..., <eqn_m> para as variáveis <x_1>, ...,
     <x_n>.  Uma expressão <expr> é equivalente a uma equação '<expr> =
     0'.  Pode existir mais equações que variáveis ou vice-versa.

     'algsys' retorna uma lista de soluções, com cada solução dada com
     uma lista de valores de estado das equações das variáveis <x_1>,
     ..., <x_n> que satisfazem o sistema de equações.  Se 'algsys' não
     pode achar uma solução, uma lista vazia '[]' é retornada.

     Os símbolos '%r1', '%r2', ..., são introduzidos tantos quantos
     forem necessários para representar parâmetros arbitrários na
     solução; essas variáveis são também anexadas à lista '%rnum_list'.

     O método usado é o seguinte:

     (1) Primeiro as equações são fatoradas e quebradas em subsistemas.

     (2) Para cada subsistema <S_i>, uma equação <E> e uma variável <x>
     são selecionados.  A variável é escolhida para ter o menor grau não
     zero.  Então a resultante de <E> e <E_j> em relação a <x> é
     calculada para cada um das equações restantes <E_j> nos subsistemas
     <S_i>.  Isso retorna um novo subsistema <S_i'> em umas poucas
     variáveis, como <x> tenha sido eliminada.  O processo agora retorna
     ao passo (1).

     (3) Eventualmente, um subsistema consistindo de uma equação simples
     é obtido.  Se a equação é de várias variáveis e aproximações na
     forma de números em ponto flutuante nã tenham sido introduzidas,
     então 'solve' é chamada para achar uma solução exata.

     Em alguns casos, 'solve' não está habilitada a achar uma solução,
     ou se isso é feito a solução pode ser uma expressão expressão muito
     larga.

     Se a equação é de uma única variável e é ou linear, ou quadrática,
     ou biquadrada, então novamente 'solve' é chamada se aproximações
     não tiverem sido introduzidas.  Se aproximações tiverem sido
     introduzidas ou a equação não é de uma única variável e nem tão
     pouco linear, quadratica, ou biquadrada, então o comutador
     'realonly' é 'true', A função 'realroots' é chamada para achar o
     valor real das soluções.  Se 'realonly' é 'false', então 'allroots'
     é chamada a qual procura por soluções reais e complexas.

     Se 'algsys' produz uma solução que tem poucos digitos
     significativos que o requerido, o usuário pode escolher o valor de
     'algepsilon' para um valor maior.

     Se 'algexact' é escolhido para 'true', 'solve' será sempre chamada.

     (4) Finalmente, as soluções obtidas no passo (3) são substituídas
     dentro dos níveis prévios e o processo de solução retorna para (1).

     Quando 'algsys' encontrar uma equação de várias variáveis que
     contém aproximações em ponto flutuante (usualmente devido a suas
     falhas em achar soluções exatas por um estágio mais fácil), então
     não tentará aplicar métodos exatos para tais equações e em lugar
     disso imprime a mensagem: "'algsys' cannot solve - system too
     complicated."

     Interações com 'radcan' podem produzir expressões largas ou
     complicadas.  Naquele caso, pode ser possível isolar partes do
     resultado com 'pickapart' ou 'reveal'.

     Ocasionalmente, 'radcan' pode introduzir uma unidade imaginária
     '%i' dentro de uma solução que é atualmente avaliada como real.

     Exemplos:

     ++
          (%i1) e1: 2*x*(1 - a1) - 2*(x - 1)*a2;
          (%o1)              2 (1 - a1) x - 2 a2 (x - 1)
          (%i2) e2: a2 - a1;
          (%o2)                        a2 - a1
          (%i3) e3: a1*(-y - x^2 + 1);
                                             2
          (%o3)                   a1 (- y - x  + 1)
          (%i4) e4: a2*(y - (x - 1)^2);
                                                 2
          (%o4)                   a2 (y - (x - 1) )
          (%i5) algsys ([e1, e2, e3, e4], [x, y, a1, a2]);
          (%o5) [[x = 0, y = %r1, a1 = 0, a2 = 0],

                                            [x = 1, y = 0, a1 = 1, a2 = 1]]
          (%i6) e1: x^2 - y^2;
                                        2    2
          (%o6)                        x  - y
          (%i7) e2: -1 - y + 2*y^2 - x + x^2;
                                   2        2
          (%o7)                 2 y  - y + x  - x - 1
          (%i8) algsys ([e1, e2], [x, y]);
                           1            1
          (%o8) [[x = - -------, y = -------],
                        sqrt(3)      sqrt(3)

                  1              1             1        1
          [x = -------, y = - -------], [x = - -, y = - -], [x = 1, y = 1]]
               sqrt(3)        sqrt(3)          3        3

 -- Função: allroots (<expr>)
 -- Função: allroots (<eqn>)
     Calcula aproximações numéricas de raízes reais e complexas do
     polinômio <expr> ou equação polinômial <eqn> de uma variável.

     O sinalizador 'polyfactor' quando 'true' faz com que 'allroots'
     fatore o polinômio sobre os números reais se o polinômio for real,
     ou sobre os números complexos, se o polinômio for complexo.

     'allroots' pode retornar resultados imprecisos no caso de multiplas
     raízes.  Se o polinômio for real, 'allroots (%i*<p>)') pode
     retornar aproximações mais precisas que 'allroots (<p>)', como
     'allroots' invoca um algorítmo diferente naquele caso.

     'allroots' rejeita não-polinômios.  Isso requer que o numerador
     após a classificação ('rat''ing) poderá ser um polinômio, e isso
     requer que o denominador seja quando muito um número complexo.  Com
     um resultado disso 'allroots' irá sempre retornar uma expressão
     equivalente (mas fatorada), se 'polyfactor' for 'true'.

     Para polinômios complexos um algorítmo por Jenkins e Traub é usado
     (Algorithm 419, Comm.  ACM, vol.  15, (1972), p.  97).  Para
     polinômios reais o algorítmo usado é devido a Jenkins (Algorithm
     493, ACM TOMS, vol.  1, (1975), p.178).

     Exemplos:

          (%i1) eqn: (1 + 2*x)^3 = 13.5*(1 + x^5);
                                      3          5
          (%o1)              (2 x + 1)  = 13.5 (x  + 1)
          (%i2) soln: allroots (eqn);
          (%o2) [x = .8296749902129361, x = - 1.015755543828121,

          x = .9659625152196369 %i - .4069597231924075,

          x = - .9659625152196369 %i - .4069597231924075, x = 1.0]
          (%i3) for e in soln
                  do (e2: subst (e, eqn), disp (expand (lhs(e2) - rhs(e2))));
                                - 3.5527136788005E-15

                               - 5.32907051820075E-15

                   4.44089209850063E-15 %i - 4.88498130835069E-15

                  - 4.44089209850063E-15 %i - 4.88498130835069E-15

                                 3.5527136788005E-15

          (%o3)                         done
          (%i4) polyfactor: true$
          (%i5) allroots (eqn);
          (%o5) - 13.5 (x - 1.0) (x - .8296749902129361)

                                     2
           (x + 1.015755543828121) (x  + .8139194463848151 x

           + 1.098699797110288)

 -- Variável: backsubst
     Valor padrão: 'true'

     Quando 'backsubst' é 'false', evita substituições em expressões
     anteriores após as equações terem sido triangularizadas.  Isso pode
     ser de grande ajuda em problemas muito grandes onde substituição em
     expressões anteriores pode vir a causar a geração de expressões
     extremamente largas.

 -- Variável: breakup
     Valor padrão: 'true'

     Quando 'breakup' é 'true', 'solve' expressa soluções de equações
     cúbicas e quárticas em termos de subexpressões comuns, que são
     atribuídas a rótulos de expressões intermediárias ('%t1', '%t2',
     etc.).  De outra forma, subexpressões comuns não são identificadas.

     'breakup: true' tem efeito somente quando 'programmode' é 'false'.

     Exemplos:

          (%i1) programmode: false$
          (%i2) breakup: true$
          (%i3) solve (x^3 + x^2 - 1);

                                  sqrt(23)    25 1/3
          (%t3)                  (--------- + --)
                                  6 sqrt(3)   54
          Solution:

                                                sqrt(3) %i   1
                                                ---------- - -
                          sqrt(3) %i   1            2        2   1
          (%t4)    x = (- ---------- - -) %t3 + -------------- - -
                              2        2            9 %t3        3

                                                sqrt(3) %i   1
                                              - ---------- - -
                        sqrt(3) %i   1              2        2   1
          (%t5)    x = (---------- - -) %t3 + ---------------- - -
                            2        2             9 %t3         3

                                             1     1
          (%t6)                  x = %t3 + ----- - -
                                           9 %t3   3
          (%o6)                    [%t4, %t5, %t6]
          (%i6) breakup: false$
          (%i7) solve (x^3 + x^2 - 1);
          Solution:

                       sqrt(3) %i   1
                       ---------- - -
                           2        2        sqrt(23)    25 1/3
          (%t7) x = --------------------- + (--------- + --)
                       sqrt(23)    25 1/3    6 sqrt(3)   54
                    9 (--------- + --)
                       6 sqrt(3)   54

                                                        sqrt(3) %i   1    1
                                                     (- ---------- - -) - -
                                                            2        2    3

                     sqrt(23)    25 1/3  sqrt(3) %i   1
          (%t8) x = (--------- + --)    (---------- - -)
                     6 sqrt(3)   54          2        2

                                                      sqrt(3) %i   1
                                                    - ---------- - -
                                                          2        2      1
                                                + --------------------- - -
                                                     sqrt(23)    25 1/3   3
                                                  9 (--------- + --)
                                                     6 sqrt(3)   54

                      sqrt(23)    25 1/3             1             1
          (%t9)  x = (--------- + --)    + --------------------- - -
                      6 sqrt(3)   54          sqrt(23)    25 1/3   3
                                           9 (--------- + --)
                                              6 sqrt(3)   54
          (%o9)                    [%t7, %t8, %t9]

 -- Função: dimension (<eqn>)
 -- Função: dimension (<eqn_1>, ..., <eqn_n>)
     'dimen' é um pacote de análise dimensional.  'load ("dimen")' chama
     esse pacote.  'demo ("dimen")' mostra uma cura demostração.

 -- Variável: dispflag
     Valor padrão: 'true'

     Se escolhida para 'false' dentro de um 'block' inibirá a
     visualização da saída gerada pelas funções solve chamadas de dentro
     de 'block'.  Terminando 'block' com um sinal de dolar, $, escolhe
     'dispflag' para 'false'.

 -- Função: funcsolve (<eqn>, <g>(<t>))
     Retorna '[<g>(<t>) = ...]' ou '[]', dependendo de existir ou não
     uma função racional '<g>(<t>)' satisfazendo <eqn>, que deve ser de
     primeira ordem, polinômio linear em (para esse caso) '<g>(<t>)' e
     '<g>(<t>+1)'

          (%i1) eqn: (n + 1)*f(n) - (n + 3)*f(n + 1)/(n + 1) = (n - 1)/(n + 2);
                                      (n + 3) f(n + 1)   n - 1
          (%o1)        (n + 1) f(n) - ---------------- = -----
                                           n + 1         n + 2
          (%i2) funcsolve (eqn, f(n));

          Equações dependentes eliminadas:  (4 3)
                                             n
          (%o2)                f(n) = ---------------
                                      (n + 1) (n + 2)

     Atenção: essa é uma implementação muito rudimentar - muitas
     verificações de segurança e obviamente generalizações estão
     ausêntes.

 -- Variável: globalsolve
     Valor padrão: 'false'

     When 'globalsolve' for 'true', variáveis para as quais as equações
     são resolvidas são atribuidas aos valores da solução encontrados
     por 'linsolve', e por 'solve' quando resolvendo duas ou mais
     equações lineares.

     Quando 'globalsolve' for 'false', soluções encontradas por
     'linsolve' e por 'solve' quando resolvendo duas ou mais equações
     lineares são espressas como equações, e as variáveis para as quais
     a equação foi resolvida não são atribuidas.

     Quando resolvendo qualquer coisa outra que não duas equações
     lineares ou mais, 'solve' ignora 'globalsolve'.  Outras funções que
     resolvem equações (e.g., 'algsys') sempre ignoram 'globalsolve'.

     Exemplos:

          (%i1) globalsolve: true$
          (%i2) solve ([x + 3*y = 2, 2*x - y = 5], [x, y]);
          Solution

                                           17
          (%t2)                        x : --
                                           7

                                             1
          (%t3)                        y : - -
                                             7
          (%o3)                     [[%t2, %t3]]
          (%i3) x;
                                         17
          (%o3)                          --
                                         7
          (%i4) y;
                                           1
          (%o4)                          - -
                                           7
          (%i5) globalsolve: false$
          (%i6) kill (x, y)$
          (%i7) solve ([x + 3*y = 2, 2*x - y = 5], [x, y]);
          Solution

                                           17
          (%t7)                        x = --
                                           7

                                             1
          (%t8)                        y = - -
                                             7
          (%o8)                     [[%t7, %t8]]
          (%i8) x;
          (%o8)                           x
          (%i9) y;
          (%o9)                           y

 -- Função: ieqn (<ie>, <unk>, <tech>, <n>, <guess>)
     'inteqn' é um pacote para resolver equações com integrais.  'load
     ("inteqn")' carrega esse pacote.

     <ie> é a equação integral; <unk> é a função desconhecida; <tech> é
     a técnica a ser tentada nesses dados acima (<tech> = 'first'
     significa: tente a primeira técnica que achar uma solução; <tech> =
     'all' significa: tente todas a técnicas aplicáveis); <n> é o número
     máximo de termos a serem usados de 'taylor', 'neumann',
     'firstkindseries', ou 'fredseries' (isso é também o número máximo
     de ciclos de recurssão para o método de diferenciação); <guess> é o
     inicial suposto para 'neumann' ou 'firstkindseries'.

     Valores padrão do segundo até o quinto parâmetro são:

     <unk>: '<p>(<x>)', onde <p> é a primeira função encontrada em um
     integrando que é desconhecida para Maxima e <x> é a variável que
     ocorre como um argumento para a primeira ocorrência de <p> achada
     fora de uma integral no caso de equações 'secondkind' , ou é
     somente outra variável ao lado da variável de integração em
     equações 'firstkind'.  Se uma tentativa de procurar por <x> falha,
     o usuário será perguntado para suprir a variável independente.

     tech: 'first'

     n: 1

     guess: 'none' o que fará com que 'neumann' e 'firstkindseries' use
     '<f>(<x>)' como uma suposição inicial.

 -- Variável de opção: ieqnprint
     Valor padrão: 'true'

     'ieqnprint' governa o comportamento do resultado retornado pelo
     comando 'ieqn'.  Quando 'ieqnprint' é 'false', as listas retornadas
     pela função 'ieqn' são da forma

     [<solução>, <tecnica usada>, <nterms>, <sinalizador>]

     onde <sinalizador> é retirado se a solução for exata.

     De outra forma, isso é a palavra 'approximate' ou 'incomplete'
     correspondendo à forma inexata ou forma aberta de solução,
     respectivamente.  Se um método de série foi usado, <nterms> fornece
     o número de termos usados (que poderá ser menor que os n dados para
     'ieqn' se ocorrer um erro evita a geração de termos adicionais).

 -- Função: lhs (<expr>)
     Retorna o lado esquerdo (isto é, o primeiro argumento) da expressão
     <expr>, quando o operador de <expr> for um dos operadores
     relacionais '< <= = # equal notequal >= >', um dos operadores de
     atribuição ':= ::= : ::', ou um operadro infixo definido pelo
     usuário, como declarado por meio de 'infix'.

     Quando <expr> for um átomo ou seu operador for alguma coisa que não
     esses listados acima, 'lhs' retorna <expr>.

     Veja também 'rhs'.

     Exemplos:

          (%i1) e: aa + bb = cc;
          (%o1)                     bb + aa = cc
          (%i2) lhs (e);
          (%o2)                        bb + aa
          (%i3) rhs (e);
          (%o3)                          cc
          (%i4) [lhs (aa < bb), lhs (aa <= bb), lhs (aa >= bb), lhs (aa > bb)];
          (%o4)                   [aa, aa, aa, aa]
          (%i5) [lhs (aa = bb), lhs (aa # bb), lhs (equal (aa, bb)), lhs (notequal (aa, bb))];
          (%o5)                   [aa, aa, aa, aa]
          (%i6) e1: '(foo(x) := 2*x);
          (%o6)                     foo(x) := 2 x
          (%i7) e2: '(bar(y) ::= 3*y);
          (%o7)                    bar(y) ::= 3 y
          (%i8) e3: '(x : y);
          (%o8)                         x : y
          (%i9) e4: '(x :: y);
          (%o9)                        x :: y
          (%i10) [lhs (e1), lhs (e2), lhs (e3), lhs (e4)];
          (%o10)               [foo(x), bar(y), x, x]
          (%i11) infix ("][");
          (%o11)                         ][
          (%i12) lhs (aa ][ bb);
          (%o12)                         aa

 -- Função: linsolve ([<expr_1>, ..., <expr_m>], [<x_1>, ..., <x_n>])
     Resolve a lista de equações lineares simultâneas para a lista de
     variáveis.  As expressões devem ser cada uma polinômios nas
     variáveis e podem ser equações.

     Quando 'globalsolve' é 'true' então variáveis que foram resolvidas
     serão escolhidas para a solução do conjunto de equações
     simultâneas.

     Quando 'backsubst' é 'false', 'linsolve' não realiza substituição
     em equações anteriores após as equações terem sido
     triangularizadas.  Isso pode ser necessário em problemas muito
     grandes onde substituição em equações anteriores poderá causar a
     geração de expressões extremamente largas.

     Quando 'linsolve_params' for 'true', 'linsolve' também gera
     símbolos '%r' usados para representar parâmetros arbitrários
     descritos no manual sob 'algsys'.  De outra forma, 'linsolve'
     resolve um menor-determinado sistema de equações com algumas
     variáveis expressas em termos de outras.

     Quando 'programmode' for 'false', 'linsolve' mostra a solução com
     expressões intermediárias com rótulos ('%t'), e retorna a lista de
     rótulos.

          (%i1) e1: x + z = y;
          (%o1)                       z + x = y
          (%i2) e2: 2*a*x - y = 2*a^2;
                                                 2
          (%o2)                   2 a x - y = 2 a
          (%i3) e3: y - 2*z = 2;
          (%o3)                      y - 2 z = 2
          (%i4) [globalsolve: false, programmode: true];
          (%o4)                     [false, true]
          (%i5) linsolve ([e1, e2, e3], [x, y, z]);
          (%o5)            [x = a + 1, y = 2 a, z = a - 1]
          (%i6) [globalsolve: false, programmode: false];
          (%o6)                    [false, false]
          (%i7) linsolve ([e1, e2, e3], [x, y, z]);
          Solution

          (%t7)                       z = a - 1

          (%t8)                        y = 2 a

          (%t9)                       x = a + 1
          (%o9)                    [%t7, %t8, %t9]
          (%i9) ''%;
          (%o9)            [z = a - 1, y = 2 a, x = a + 1]
          (%i10) [globalsolve: true, programmode: false];
          (%o10)                    [true, false]
          (%i11) linsolve ([e1, e2, e3], [x, y, z]);
          Solution

          (%t11)                      z : a - 1

          (%t12)                       y : 2 a

          (%t13)                      x : a + 1
          (%o13)                 [%t11, %t12, %t13]
          (%i13) ''%;
          (%o13)           [z : a - 1, y : 2 a, x : a + 1]
          (%i14) [x, y, z];
          (%o14)                 [a + 1, 2 a, a - 1]
          (%i15) [globalsolve: true, programmode: true];
          (%o15)                    [true, true]
          (%i16) linsolve ([e1, e2, e3], '[x, y, z]);
          (%o16)           [x : a + 1, y : 2 a, z : a - 1]
          (%i17) [x, y, z];
          (%o17)                 [a + 1, 2 a, a - 1]

 -- Variável: linsolvewarn
     Valor padrão: 'true'

     Quando 'linsolvewarn' é 'true', 'linsolve' imprime uma mensagem
     "Dependent equações eliminated".

 -- Variável: linsolve_params
     Valor padrão: 'true'

     Quando 'linsolve_params' é 'true', 'linsolve' também gera os
     símbolos '%r' usados para representar parâmetros arbitrários
     descritos no manual sob 'algsys'.  De outra forma, 'linsolve'
     resolve um menor-determinado sistema de equações com algumas
     variáveis expressas em termos e outras.

 -- Variável: multiplicities
     Valor padrão: 'not_set_yet'

     'multiplicities' é escolhida para uma lista de multiplicidades das
     soluções individuais retornadas por 'solve' ou 'realroots'.

 -- Função: nroots (<p>, <low>, <high>)
     Retorna o número de raízes reais do polinômio real de uma única
     variável <p> no intervalo semi-aberto '(<low>, <high>]'.  Uma
     extremidade do intervalo podem ser 'minf' ou 'inf'.  infinito e
     mais infinito.

     'nroots' usa o método das sequüências de Sturm.

          (%i1) p: x^10 - 2*x^4 + 1/2$
          (%i2) nroots (p, -6, 9.1);
          (%o2)                           4

 -- Função: nthroot (<p>, <n>)
     Onde p é um polinômio com coeficientes inteiros e n é um inteiro
     positivo retorna q, um polinômio sobre os inteiros, tal que q^n=p
     ou imprime uma mensagem de erro indicando que p não é uma potência
     n-ésima perfeita.  Essa rotina é mais rápida que 'factor' ou mesmo
     'sqfr'.

 -- Variável: programmode
     Valor padrão: 'true'

     Quando 'programmode' é 'true', 'solve', 'realroots', 'allroots', e
     'linsolve' retornam soluções como elementos em uma lista.  (Exceto
     quando 'backsubst' é escolhido para 'false', nesse caso
     'programmode: false' é assumido.)

     Quando 'programmode' é 'false', 'solve', etc.  cria rótulos de
     expressões intermediárias '%t1', 't2', etc., e atribui as soluções
     para eles.

 -- Variável: realonly
     Valor padrão: 'false'

     Quando 'realonly' é 'true', 'algsys' retorna somente aquelas
     soluções que estão livres de '%i'.

 -- Função: realroots (<expr>, <bound>)
 -- Função: realroots (<eqn>, <bound>)
 -- Função: realroots (<expr>)
 -- Função: realroots (<eqn>)
     Calcula aproximações racionais das raízes reais da expressão
     polinomial <expr> ou da equação polinomial <eqn> de uma variável,
     dentro de uma tolerância de <bound>.  coeficientes de <expr> ou de
     <eqn> devem ser números literais; constantes símbolo tais como
     '%pi' são rejeitadas.

     'realroots' atribui as multiplicidades das raízes que encontrar
     para a variável global 'multiplicities'.

     'realroots' constrói uma seqüência de Sturm para delimitar cada
     raíz, e então palica a bisecção para redefinir as aproximações.
     Todos os coeficientes são convertidos para os equivalentes
     racionais antes da busca por raízes, e cálculos são realizados por
     meio de aritmética racional exata.  Mesmo se alguns coeficientes
     forem números em ponto flutuante, os resultados são racionais (a
     menos que forçados a números em ponto flutuante por 'float' ou por
     'numer' flags).

     Quando <bound> for menor que 1, todas as raízes inteiras são
     encontradas exatamente.  Quando <bound> não for especificado, será
     assumido como sendo igual à variável globa 'rootsepsilon'.

     Quando a varável global 'programmode' for 'true', 'realroots'
     retorna uma lista da forma '[x = <x_1>, x = <x_2>, ...]'.  Quando
     'programmode' for 'false', 'realroots' cria rótulos de expressões
     intermediárias '%t1', '%t2', ..., atribui os resultados a eles, e
     retorna a lista de rótulos.

     Exemplos:

          (%i1) realroots (-1 - x + x^5, 5e-6);
                                         612003
          (%o1)                     [x = ------]
                                         524288
          (%i2) ev (%[1], float);
          (%o2)                 x = 1.167303085327148
          (%i3) ev (-1 - x + x^5, %);
          (%o3)                - 7.396496210176905E-6

          (%i1) realroots (expand ((1 - x)^5 * (2 - x)^3 * (3 - x)), 1e-20);
          (%o1)                 [x = 1, x = 2, x = 3]
          (%i2) multiplicities;
          (%o2)                       [5, 3, 1]

 -- Função: rhs (<expr>)
     Retorna o lado direito (isto é, o segundo argumento) da expressão
     <expr>, quando o operador de <expr> for um dos operadores
     relacionais '< <= = # equal notequal >= >', um dos operadores de
     atribuição ':= ::= : ::', ou um operador binário infixo definido
     pelo usuário, como declarado por meio de 'infix'.

     Quando <expr> for um étomo ou seu operadro for alguma coisa que não
     esses listados acima, 'rhs' retorna 0.

     Veja também 'lhs'.

     Exemplos:

          (%i1) e: aa + bb = cc;
          (%o1)                     bb + aa = cc
          (%i2) lhs (e);
          (%o2)                        bb + aa
          (%i3) rhs (e);
          (%o3)                          cc
          (%i4) [rhs (aa < bb), rhs (aa <= bb), rhs (aa >= bb), rhs (aa > bb)];
          (%o4)                   [bb, bb, bb, bb]
          (%i5) [rhs (aa = bb), rhs (aa # bb), rhs (equal (aa, bb)), rhs (notequal (aa, bb))];
          (%o5)                   [bb, bb, bb, bb]
          (%i6) e1: '(foo(x) := 2*x);
          (%o6)                     foo(x) := 2 x
          (%i7) e2: '(bar(y) ::= 3*y);
          (%o7)                    bar(y) ::= 3 y
          (%i8) e3: '(x : y);
          (%o8)                         x : y
          (%i9) e4: '(x :: y);
          (%o9)                        x :: y
          (%i10) [rhs (e1), rhs (e2), rhs (e3), rhs (e4)];
          (%o10)                  [2 x, 3 y, y, y]
          (%i11) infix ("][");
          (%o11)                         ][
          (%i12) rhs (aa ][ bb);
          (%o12)                         bb

 -- Variável de opção: rootsconmode
     Valor padrão: 'true'

     'rootsconmode' governa o comportamento do comando 'rootscontract'.
     Veja 'rootscontract' para detalhes.

 -- Função: rootscontract (<expr>)
     Converte produtos de raízes em raízes de produtos.  Por exemplo,
     'rootscontract (sqrt(x)*y^(3/2))' retorna 'sqrt(x*y^3)'.

     Quando 'radexpand' é 'true' e 'domain' é 'real', 'rootscontract'
     converte 'abs' em 'sqrt', e.g., 'rootscontract (abs(x)*sqrt(y))'
     retorna 'sqrt(x^2*y)'.

     Existe uma opção 'rootsconmode' afetando 'rootscontract' como
     segue:

          Problem            Value of        Result of applying
                            rootsconmode        rootscontract

          x^(1/2)*y^(3/2)      false          (x*y^3)^(1/2)
          x^(1/2)*y^(1/4)      false          x^(1/2)*y^(1/4)
          x^(1/2)*y^(1/4)      true           (x*y^(1/2))^(1/2)
          x^(1/2)*y^(1/3)      true           x^(1/2)*y^(1/3)
          x^(1/2)*y^(1/4)      all            (x^2*y)^(1/4)
          x^(1/2)*y^(1/3)      all            (x^3*y^2)^(1/6)

     Quando 'rootsconmode' é 'false', 'rootscontract' contrai somente
     como relação a expoentes de número racional cujos denominadores são
     os mesmos.  A chave para os exemplos 'rootsconmode: true' é
     simplesmente que 2 divides 4 mas não divide 3.  'rootsconmode: all'
     envolve pegar o menor multiplo comum dos denominadores dos
     expoentes.

     'rootscontract' usa 'ratsimp' em uma maneira similar a
     'logcontract'.

     Exemplos:

          (%i1) rootsconmode: false$
          (%i2) rootscontract (x^(1/2)*y^(3/2));
                                             3
          (%o2)                      sqrt(x y )
          (%i3) rootscontract (x^(1/2)*y^(1/4));
                                             1/4
          (%o3)                     sqrt(x) y
          (%i4) rootsconmode: true$
          (%i5) rootscontract (x^(1/2)*y^(1/4));
          (%o5)                    sqrt(x sqrt(y))
          (%i6) rootscontract (x^(1/2)*y^(1/3));
                                             1/3
          (%o6)                     sqrt(x) y
          (%i7) rootsconmode: all$
          (%i8) rootscontract (x^(1/2)*y^(1/4));
                                        2   1/4
          (%o8)                       (x  y)
          (%i9) rootscontract (x^(1/2)*y^(1/3));
                                       3  2 1/6
          (%o9)                      (x  y )
          (%i10) rootsconmode: false$
          (%i11) rootscontract (sqrt(sqrt(x) + sqrt(1 + x))
                              *sqrt(sqrt(1 + x) - sqrt(x)));
          (%o11)                          1
          (%i12) rootsconmode: true$
          (%i13) rootscontract (sqrt(5 + sqrt(5)) - 5^(1/4)*sqrt(1 + sqrt(5)));
          (%o13)                          0

 -- Variável de opção: rootsepsilon
     Valor padrão: 1.0e-7

     'rootsepsilon' é a tolerância que estabelece o intervalo de
     conficência para as raízes achadas pela função 'realroots'.

 -- Função: solve (<expr>, <x>)
 -- Função: solve (<expr>)
 -- Função: solve ([<eqn_1>, ..., <eqn_n>], [<x_1>, ..., <x_n>])
     Resolve a equação algébrica <expr> para a variável <x> e retorna
     uma lista de equações solução em <x>.  Se <expr> não é uma equação,
     a equação '<expr> = 0' é assumida em seu lugar.  <x> pode ser uma
     função (e.g.  'f(x)'), ou outra expressão não atômica exceto uma
     adição ou um produto.  <x> pode ser omitido se <expr> contém
     somente uma variável.  <expr> pode ser uma expressão racional, e
     pode conter funções trigonométricas, exponenciais, etc.

     O seguinte método é usado:

     Tome <E> sendo a expressão e <X> sendo a variável.  Se <E> é linear
     em <X> então isso é trivialmente resolvido para <X>.  De outra
     forma se <E> é da forma 'A*X^N + B' então o resultado é
     '(-B/A)^1/N)' vezes as 'N''ésimas raízes da unidade.

     Se <E> não é linear em <X> então o máximo divisor comum (mdc) dos
     expoentes de <X> em <E> (digamos <N>) é dividido dentro dos
     expoentes e a multiplicidade das raízes é multiplicada por <N>.
     Então 'solve' é chamada novamente sobre o resultado.  Se <E> for
     dada em fatores então 'solve' é chamada sobre cada um dos fatores.
     Finalmente 'solve' usará as fórmulas quadráticas, cúbicas, ou
     quárticas onde necessário.

     No caso onde <E> for um polinômio em alguma função de variável a
     ser resolvida, digamos 'F(X)', então isso é primeiro resolvida para
     'F(X)' (chama o resultado <C>), então a equação 'F(X)=C' pode ser
     resolvida para <X> fornecendo o inverso da função <F> que é
     conhecida.

     'breakup' se 'false' fará com que 'solve' expresse as soluções de
     equações cúbicas ou quárticas como expressões simples ao invés de
     como feito em cima de várias subexpressões comuns que é o padrão.

     'multiplicities' - será escolhido para uma lista de multiplicidades
     de soluções individuais retornadas por 'solve', 'realroots', ou
     'allroots'.  Tente 'apropos (solve)' para os comutadores que afetam
     'solve'.  'describe' pode então ser usada sobre o nome do comutador
     individual se seu proprósito não é claro.

     'solve ([<eqn_1>, ..., <eqn_n>], [<x_1>, ..., <x_n>])' resolve um
     sistema de equações polinomiais (lineares ou não-lineares)
     simultâneas por chamada a 'linsolve' ou 'algsys' e retorna uma
     lista de listas solução nas variáveis.  No caso de 'linsolve' essa
     lista conterá uma lista simples de soluções.  Isso pega duas listas
     como argumentos.  A primeira lista representa as equações a serem
     resolvidas; a segunda lista é a lista de desconhecidos a ser
     determinada.  Se o número total de variáveis nas equações é igual
     ao número de equações, a segunda lista-argumento pode ser omitida.
     Para sistemas lineares se as dadas equações não são compatíveis, a
     mensagem 'inconsistent' será mostrada (veja o comutador
     'solve_inconsistent_error' ); se não existe solução única, então
     'singular' será mostrado.

     Quando 'programmode' for 'false', 'solve' mostra soluções com
     rótulos de expressões intermediárias ('%t'), e retorna a lista de
     rótulos.

     Quando 'globalsolve' for 'true' e o problema for resolver duas ou
     mais equações lineares, cada variável para a qual a equação for
     resolvida é associada a seu valor na solução das equações.

     Exemplos:
          (%i1) solve (asin (cos (3*x))*(f(x) - 1), x);

          SOLVE is using arc-trig functions to get a solution.
          Some solutions will be lost.
                                      %pi
          (%o1)                  [x = ---, f(x) = 1]
                                       6
          (%i2) ev (solve (5^f(x) = 125, f(x)), solveradcan);
                                          log(125)
          (%o2)                   [f(x) = --------]
                                           log(5)
          (%i3) [4*x^2 - y^2 = 12, x*y - x = 2];
                                2    2
          (%o3)             [4 x  - y  = 12, x y - x = 2]
          (%i4) solve (%, [x, y]);
          (%o4) [[x = 2, y = 2], [x = .5202594388652008 %i

           - .1331240357358706, y = .0767837852378778

           - 3.608003221870287 %i], [x = - .5202594388652008 %i

           - .1331240357358706, y = 3.608003221870287 %i

           + .0767837852378778], [x = - 1.733751846381093,

          y = - .1535675710019696]]
          (%i5) solve (1 + a*x + x^3, x);
                                                 3
                        sqrt(3) %i   1   sqrt(4 a  + 27)   1 1/3
          (%o5) [x = (- ---------- - -) (--------------- - -)
                            2        2      6 sqrt(3)      2

                  sqrt(3) %i   1
                 (---------- - -) a
                      2        2
           - --------------------------, x =
                        3
                sqrt(4 a  + 27)   1 1/3
             3 (--------------- - -)
                   6 sqrt(3)      2

                                    3
           sqrt(3) %i   1   sqrt(4 a  + 27)   1 1/3
          (---------- - -) (--------------- - -)
               2        2      6 sqrt(3)      2

                   sqrt(3) %i   1
                (- ---------- - -) a
                       2        2
           - --------------------------, x =
                        3
                sqrt(4 a  + 27)   1 1/3
             3 (--------------- - -)
                   6 sqrt(3)      2

                   3
           sqrt(4 a  + 27)   1 1/3               a
          (--------------- - -)    - --------------------------]
              6 sqrt(3)      2                  3
                                        sqrt(4 a  + 27)   1 1/3
                                     3 (--------------- - -)
                                           6 sqrt(3)      2
          (%i6) solve (x^3 - 1);
                       sqrt(3) %i - 1        sqrt(3) %i + 1
          (%o6)   [x = --------------, x = - --------------, x = 1]
                             2                     2
          (%i7) solve (x^6 - 1);
                     sqrt(3) %i + 1      sqrt(3) %i - 1
          (%o7) [x = --------------, x = --------------, x = - 1,
                           2                   2

                               sqrt(3) %i + 1        sqrt(3) %i - 1
                         x = - --------------, x = - --------------, x = 1]
                                     2                     2
          (%i8) ev (x^6 - 1, %[1]);
                                                6
                                (sqrt(3) %i + 1)
          (%o8)                 ----------------- - 1
                                       64
          (%i9) expand (%);
          (%o9)                           0
          (%i10) x^2 - 1;
                                        2
          (%o10)                       x  - 1
          (%i11) solve (%, x);
          (%o11)                  [x = - 1, x = 1]
          (%i12) ev (%th(2), %[1]);
          (%o12)                          0

 -- Variável de opção: solvedecomposes
     Valor padrão: 'true'

     Quando 'solvedecomposes' é 'true', 'solve' chama 'polydecomp' se
     perguntado para resolver polinômios.

 -- Variável de opção: solveexplicit
     Valor padrão: 'false'

     Quando 'solveexplicit' é 'true', inibe 'solve' de retornar soluções
     implícitas, isto é, soluções da forma 'F(x) = 0' onde 'F' é alguma
     função.

 -- Variável de opção: solvefactors
     Valor padrão: 'true'

     Quando 'solvefactors' é 'false', 'solve' não tenta fatorar a
     expressão.  O 'false' escolhido pode ser desejado em alguns casos
     onde a fatoração não é necessária.

 -- Variável de opção: solvenullwarn
     Valor padrão: 'true'

     Quando 'solvenullwarn' é 'true', 'solve' imprime uma mensagem de
     alerta se chamada com ou uma lista equação ou uma variável lista
     nula.  Por exemplo, 'solve ([], [])' imprimirá duas mensagens de
     alerta e retorna '[]'.

 -- Variável de opção: solveradcan
     Valor padrão: 'false'

     Quando 'solveradcan' é 'true', 'solve' chama 'radcan' que faz
     'solve' lento mas permitirá certamente que problemas contendo
     exponeniais e logarítmos sejam resolvidos.

 -- Variável de opção: solvetrigwarn
     Valor padrão: 'true'

     Quando 'solvetrigwarn' é 'true', 'solve' pode imprimir uma mensagem
     dizendo que está usando funções trigonométricas inversas para
     resolver a equação, e desse modo perdendo soluções.

 -- Variável de opção: solve_inconsistent_error
     Valor padrão: 'true'

     Quando 'solve_inconsistent_error' for 'true', 'solve' e 'linsolve'
     resultam em erro se as equações a serem resolvidas forem
     inconsistentes.

     Se 'false', 'solve' e 'linsolve' retornam uma lista vazia '[]' se
     as equações forem inconsistentes.

     Exemplo:

          (%i1) solve_inconsistent_error: true$
          (%i2) solve ([a + b = 1, a + b = 2], [a, b]);
          Inconsistent equações:  (2)
           -- an error.  Quitting.  To debug this try debugmode(true);
          (%i3) solve_inconsistent_error: false$
          (%i4) solve ([a + b = 1, a + b = 2], [a, b]);
          (%o4)                          []


File: maxima.info,  Node: Equações Diferenciais,  Next: Numérico,  Prev: Equações,  Up: Top

22 Equações Diferenciais
************************

* Menu:

* Introdução a Equações Diferenciais::
* Funções e Variáveis Definidas para Equações Diferenciais::
Definições para Equações Diferenciais


File: maxima.info,  Node: Introdução a Equações Diferenciais,  Next: Funções e Variáveis Definidas para Equações Diferenciais,  Prev: Equações Diferenciais,  Up: Equações Diferenciais

22.1 Introdução a Equações Diferenciais
=======================================

Essa seção descreve as funções disponíves no Maxima para obter soluções
analíticas para alguns tipos específicos de equações diferencias de
primeira ordem e de equações diferencias de segunda ordem.  Para obter
uma solução numérica para um sistema de equações diferenciais, veja o
pacote adicional 'dynamics'.  Para representações gráficas em espaço de
fase, veja o pacote adicional 'plotdf'.


File: maxima.info,  Node: Funções e Variáveis Definidas para Equações Diferenciais,  Prev: Introdução a Equações Diferenciais,  Up: Equações Diferenciais

22.2 Funções e Variáveis Definidas para Equações Diferenciais
=============================================================

 -- Função: bc2 (<solução>, <xval1>, <yval1>, <xval2>, <yval2>)
     Resolve o problema do valor limite para equações diferenciais de
     segunda ordem.  Aqui: <solução> é uma solução geral para a equação,
     como encontrado por 'ode2', <xval1> especifica o valor da variável
     independente em um primeiro ponto, na forma '<x> = <x1>', e <yval1>
     fornece o valor da variável dependente naquele ponto, na forma '<y>
     = <y1>'.  As expressões <xval2> e <yval2> fornecem os valores para
     essas variáveis em um segundo ponto, usando a mesma forma.

     Veja 'ode2' para um exemplo de sua utilização.

 -- Função: desolve (<eqn>, <x>)
 -- Função: desolve ([<eqn_1>, ..., <eqn_n>], [<x_1>, ..., <x_n>])
     A Função 'dsolve' resolve sistema de equações diferenciais lineares
     ordinárias usando a transformada de Laplace.  Aqui as <eqn>'s são
     equações diferenciais nas variáveis dependentes <x_1>, ..., <x_n>.
     A dependência funcional de <x_1>, ..., <x_n> com relação à variável
     independente, por exemplo <x>, deve ser explicitamente indicada nas
     variáveis e em suas derivadas.  Por exemplo, isso pode não ser
     caminho correto para definir duas equações:

          eqn_1: 'diff(f,x,2) = sin(x) + 'diff(g,x);
          eqn_2: 'diff(f,x) + x^2 - f = 2*'diff(g,x,2);

     O caminho correto pode ser:

          eqn_1: 'diff(f(x),x,2) = sin(x) + 'diff(g(x),x);
          eqn_2: 'diff(f(x),x) + x^2 - f(x) = 2*'diff(g(x),x,2);

     A chamada à função 'desolve' pode então ser
          desolve([eqn_1, eqn_2], [f(x),g(x)]);

     Se condições iniciais em 'x=0' forem conhecidas, elas podem ser
     fornecidas antes chamando 'desolve' através de 'atvalue'.

          (%i1) 'diff(f(x),x)='diff(g(x),x)+sin(x);
                           d           d
          (%o1)            -- (f(x)) = -- (g(x)) + sin(x)
                           dx          dx
          (%i2) 'diff(g(x),x,2)='diff(f(x),x)-cos(x);
                            2
                           d            d
          (%o2)            --- (g(x)) = -- (f(x)) - cos(x)
                             2          dx
                           dx
          (%i3) atvalue('diff(g(x),x),x=0,a);
          (%o3)                           a
          (%i4) atvalue(f(x),x=0,1);
          (%o4)                           1
          (%i5) desolve([%o1,%o2],[f(x),g(x)]);
                            x
          (%o5) [f(x) = a %e  - a + 1, g(x) =

                                                          x
                                             cos(x) + a %e  - a + g(0) - 1]
          (%i6) [%o1,%o2],%o5,diff;
                       x       x      x                x
          (%o6)   [a %e  = a %e , a %e  - cos(x) = a %e  - cos(x)]


     Se 'desolve' não pode obter uma solução, retorna 'false'.

 -- Função: ic1 (<solução>, <xval>, <yval>)
     Resolve problemas de valor inicial para equações diferenciais de
     primeira ordem.  Aqui <solução> é uma solução geral para a equação,
     como encontrado por 'ode2', <xval> fornece um valor inicial para a
     variável independente na forma '<x> = <x0>', e <yval> fornece o
     valor inicial para a variável dependente na forma '<y> = <y0>'.

     Veja 'ode2' para um exemplo de sua utilização.

 -- Função: ic2 (<solução>, <xval>, <yval>, <dval>)
     Resolve problemas de valor inicial para equações diferenciais de
     segunda ordem.  Aqui <solução> é uma solução geral para a equação,
     como encontrada por 'ode2', <xval> fornece o valor inicial para a
     variável independente na forma '<x> = <x0>', <yval> fornece o valor
     inicial da veriável dependente na forma '<y> = <y0>', e <dval>
     fornece o valor inicial para a primeira derivada da variável
     dependente com relação à variável independente, na forma
     'diff(<y>,<x>) = <dy0>' ('diff' não precisa receber apóstrofo para
     evitar avaliação).

     Veja 'ode2' para um exemplo de seu uso.

 -- Função: ode2 (<eqn>, <dvar>, <ivar>)
     A função 'ode2' resolve uma equação diferencial ordinária (EDO) de
     primeira ou de segunda ordem.  'ode2' usa três argumentos: uma EDO
     fornecida por <eqn>, a variável dependente <dvar>, e a variável
     independente <ivar>.  Quando 'ode2' encontra uma solução, 'ode2'
     retorna ou uma solução explícita ou uma sulução implícita para a
     variável dependente.  '%c' é usado para representar a constante de
     integração no caso de equações de primeira ordem, e '%k1' e '%k2'
     as constantes para equações de segunda ordem.  A dependência da
     variável dependente com relação à variável independente não tem que
     ser escrita explicitamente, como no caso de 'desolve', mas a
     variável independente deve sempre ser fornecida como o terceiro
     argumento.

     Se 'ode2' não conseguir obter uma solução por qualquer razaão,
     'ode2' retorna 'false', após talvez imprimir uma mensagem de erro.
     Os métodos implementados para equações de primeira ordem na
     seqüência em que eles foram testados são: linear, separável, exato
     - talvez requerendo um fator de integração, homogêneo, equação de
     Bernoulli, e um método homogêneo generalizado.  Os tipos de equaçõe
     de segunda ordem que podem ser resolvidos são: coeficientes
     constantes, exato, linear homogêneo com coeficientes não constantes
     que podem ser transformados em coeficientes constantes, o tipo de
     equação de Euler também chamado de equação equi-dimensional,
     equações resolvíveis pelo método de variação de parâmetros, e
     equações as quais são livres ou da variável independente ou da
     dependente de modo que elas possam ser reduzidas a duas equações
     lineares de primeira ordem para serem resolvidas seqüêncialmente.

     Na resolução de EDO's pelo Maxima, muitas variáveis são escolhidas
     puramente para propósitos informativos: 'método' denota o método de
     solução usado (e.g., 'linear'), 'intfactor' denota qualquer fator
     de integração usado, 'odeindex' denota o índice para o método de
     Bernoulli ou para o método homogêneo generalizado, e 'yp' denota a
     solução particular para a técnica de variação de parâmetros.

     Com o objetivo de resolver poblemas de valor inicial (PVI) as
     funções 'ic1' e 'ic2' estão disponíveis para equações de primeira e
     de segunda ordem, e para resolver problemas do valor de segunda
     ordem associado (BVP em inglês) a função 'bc2' pode ser usada.

     Exemplo:

          (%i1) x^2*'diff(y,x) + 3*y*x = sin(x)/x;
                                2 dy           sin(x)
          (%o1)                x  -- + 3 x y = ------
                                  dx             x
          (%i2) ode2(%,y,x);
                                       %c - cos(x)
          (%o2)                    y = -----------
                                            3
                                           x
          (%i3) ic1(%o2,x=%pi,y=0);
                                        cos(x) + 1
          (%o3)                   y = - ----------
                                             3
                                            x
          (%i4) 'diff(y,x,2) + y*'diff(y,x)^3 = 0;
                                   2
                                  d y      dy 3
          (%o4)                   --- + y (--)  = 0
                                    2      dx
                                  dx
          (%i5) ode2(%,y,x);
                                3
                               y  + 6 %k1 y
          (%o5)                ------------ = x + %k2
                                    6
          (%i6) ratsimp(ic2(%o5,x=0,y=0,'diff(y,x)=2));
                                       3
                                    2 y  - 3 y
          (%o6)                   - ---------- = x
                                        6
          (%i7) bc2(%o5,x=0,y=1,x=1,y=3);
                                   3
                                  y  - 10 y       3
          (%o7)                   --------- = x - -
                                      6           2



File: maxima.info,  Node: Numérico,  Next: Arrays,  Prev: Equações Diferenciais,  Up: Top

23 Numérico
***********

* Menu:

* Introdução a Numérico::
* Pacotes de Fourier::
* Funções e Variáveis Definidas para Numérico::
* Funções e Variáveis Definidas para Séries de Fourier::


File: maxima.info,  Node: Introdução a Numérico,  Next: Pacotes de Fourier,  Prev: Numérico,  Up: Numérico

23.1 Introdução a Numérico
==========================


File: maxima.info,  Node: Pacotes de Fourier,  Next: Funções e Variáveis Definidas para Numérico,  Prev: Introdução a Numérico,  Up: Numérico

23.2 Pacotes de Fourier
=======================

O pacote 'fft' compreende funções para computação numérica (não
simbólica) das transformações rápidas de Fourier.  'load ("fft")' chama
esse pacote.  Veja 'fft'.

   O pacote 'fourie' compreende funções para computação simbólica de
séries de Fourier.  'load ("fourie")' chama esse pacote.  Existem
funções no pacote 'fourie' para calcular coeficientes da integral de
Fourier e algumas funções para manipulação de expressões.  Veja 'Funções
e Variáveis Definidas para Séries'.


File: maxima.info,  Node: Funções e Variáveis Definidas para Numérico,  Next: Funções e Variáveis Definidas para Séries de Fourier,  Prev: Pacotes de Fourier,  Up: Numérico

23.3 Funções e Variáveis Definidas para Numérico
================================================

 -- Função: polartorect (<magnitude_array>, <phase_array>)

     Traduz valores complexos da forma 'r %e^(%i t)' para a forma 'a + b
     %i'.  'load ("fft")' chama essa função dentro do Maxima.  Veja
     também 'fft'.

     O módulo e a fase, 'r' e 't', São tomados de <magnitude_array> e
     <phase_array>, respectivamente.  Os valores originais de arrays de
     entrada são substituídos pelas partes real e emaginária, 'a' e 'b',
     no retorno.  As saídas são calculadas como

          a: r cos (t)
          b: r sin (t)

     Os arrays de entrada devem ter o mesmo tamanho e ser
     unidimensionais.  O tamanho do array não deve ser uma potência de
     2.

     'polartorect' é a função inversa de 'recttopolar'.

 -- Função: recttopolar (<real_array>, <imaginary_array>)

     Traduz valores complexos da forma 'a + b %i' para a forma 'r %e^(%i
     t)'.  'load ("fft")' chama essa função dentro do Maxima.  Veja
     também 'fft'.

     As partes real e imaginária, 'a' e 'b', são tomadas de <real_array>
     e <imaginary_array>, respectivamente.  Os valores originais dos
     arrays de entrada são substituídos pelo módulo e pelo ângulo, 'r' e
     't', no retorno.  As saídas são calculadas como

          r: sqrt (a^2 + b^2)
          t: atan2 (b, a)

     O ângulo calculado encontra-se no intervalo de '-%pi' a '%pi'.

     Os arrays de entrada devem ter o mesmo tamanho e ser
     unidimensionais.  O tamanho do array não deve ser uma potência de
     2.

     'recttopolar' é a função inversa de 'polartorect'.

 -- Função: ift (<real_array>, <imaginary_array>)

     Transformação rápida inversa discreta de Fourier .  'load ("fft")'
     chama essa função dentro do Maxima.

     'ift' realiza a transformação rápida complexa de Fourier sobre
     arrays em ponto flutuante unidimensionais.  A transformação inversa
     é definida como

          x[j]: sum (y[j] exp (+2 %i %pi j k / n), k, 0, n-1)

     Veja 'fft' para maiores detalhes.

 -- Função: fft (<real_array>, <imaginary_array>)
 -- Função: ift (<real_array>, <imaginary_array>)
 -- Função: recttopolar (<real_array>, <imaginary_array>)
 -- Função: polartorect (<magnitude_array>, <phase_array>)

     Transformação rápidada de Fourier e funções relacionadas.  'load
     ("fft")' chama essas funções dentro do Maxima.

     'fft' e 'ift' realiza transformação rápida complexa de Fourier e a
     transformação inversa, respectivamente, sobre arrays em ponto
     flutuante unidimensionais.  O tamanho de <imaginary_array> deve ser
     igual ao tamanho de <real_array>.

     'fft' e 'ift' operam in-loco.  Isto é, sobre o retorno de 'fft' ou
     de 'ift', O conteúdo original dos arrays de entrada é substituído
     pela saída.  A função 'fillarray' pode fazer uma cópia de um array,
     isso pode ser necessário.

     A transformação discreta de Fourier e sua transformação inversa são
     definidas como segue.  Tome 'x' sendo os dados originais, com

          x[i]: real_array[i] + %i imaginary_array[i]

     Tome 'y' sendo os dados transformados.  A transformação normal e
     sua transformação inversa são

          y[k]: (1/n) sum (x[j] exp (-2 %i %pi j k / n), j, 0, n-1)

          x[j]:       sum (y[j] exp (+2 %i %pi j k / n), k, 0, n-1)

     Arrays adequadas podem ser alocadas pela função 'array'.  Por
     exemplo:

          array (my_array, float, n-1)$

     declara um array unidimensional com n elementos, indexado de 0 a
     n-1 inclusive.  O número de elementos n deve ser igual a 2^m para
     algum m.

     'fft' pode ser aplicada a dados reais (todos os arrays imaginários
     são iguais a zero) para obter coeficientes seno e cosseno.  Após
     chamar 'fft', os coeficientes seno e cosseno, digamos 'a' e 'b',
     podem ser calculados como

          a[0]: real_array[0]
          b[0]: 0

     e

          a[j]: real_array[j] + real_array[n-j]
          b[j]: imaginary_array[j] - imaginary_array[n-j]

     para j variando de 1 a n/2-1, e

          a[n/2]: real_array[n/2]
          b[n/2]: 0

     'recttopolar' traduz valores complexos da forma 'a + b %i' para a
     forma 'r %e^(%i t)'.  Veja 'recttopolar'.

     'polartorect' traduz valores complexos da forma 'r %e^(%i t)' para
     a forma 'a + b %i'.  Veja 'polartorect'.

     'demo ("fft")' exibe uma demonstração do pacote 'fft'.

 -- Variável de opção: fortindent
     Valor padrão: 0

     'fortindent' controla a margem esquerda de indentação de expressões
     mostradas pelo comando 'fortran'.  0 fornece indentação normal
     (i.e., 6 espaços), e valores positivos farão com que expressões
     sejam mostrados mais além para a direita.

 -- Função: fortran (<expr>)
     Mostra <expr> como uma declaração Fortran.  A linha de saída é
     indentada com espaços.  Se a linha for muito longa, 'fortran'
     imprime linhas de continuação.  'fortran' mostra o operador de
     exponenciação '^' como '**', e mostra um número complexo 'a + b %i'
     na forma '(a,b)'.

     <expr> pode ser uma equação.  Nesse caso, 'fortran' mostra uma
     declaração de atribuição, atribuindo o primeiro membro (esquerda)
     da equação ao segundo membro (direita).  Em particular, se o
     primeiro membro <expr> é um nome de uma matriz, então 'fortran'
     mostra uma declaração de atribuição para cada elemento da matriz.

     Se <expr> não for alguma coisa reconhecida por 'fortran', a
     expressão é mostrada no formato 'grind' sem reclamação.  'fortran'
     não conhece listas, arrays ou funções.

     'fortindent' controla o margem esquerda das linhas mostradas.  0 é
     a margem normal (i.e., indentada 6 espaços).  Incrementando
     'fortindent' faz com que expressões sejam mostradas adiante para a
     direita.

     quando 'fortspaces' for 'true', 'fortran' preenche cada linha
     mostrada com espaços em branco até completar 80 columas.

     'fortran' avalia seus argumentos; colocando um apóstrofo em um
     argumento evita avaliação.  'fortran' sempre retorna 'done'.

     Exemplos:

          (%i1) expr: (a + b)^12$
          (%i2) fortran (expr);
                (b+a)**12
          (%o2)                         done
          (%i3) fortran ('x=expr);
                x = (b+a)**12
          (%o3)                         done
          (%i4) fortran ('x=expand (expr));
                x = b**12+12*a*b**11+66*a**2*b**10+220*a**3*b**9+495*a**4*b**8+792
               1   *a**5*b**7+924*a**6*b**6+792*a**7*b**5+495*a**8*b**4+220*a**9*b
               2   **3+66*a**10*b**2+12*a**11*b+a**12
          (%o4)                         done
          (%i5) fortran ('x=7+5*%i);
                x = (7,5)
          (%o5)                         done
          (%i6) fortran ('x=[1,2,3,4]);
                x = [1,2,3,4]
          (%o6)                         done
          (%i7) f(x) := x^2$
          (%i8) fortran (f);
                f
          (%o8)                         done

 -- Variável de opção: fortspaces
     Valor padrão: 'false'

     Quando 'fortspaces' for 'true', 'fortran' preenche cada linha
     mostrada com espaços em branco até completar 80 columas.

 -- Função: horner (<expr>, <x>)
 -- Função: horner (<expr>)
     Retorna uma representação rearranjada de <expr> como na regra de
     Horner, usando <x> como variável principal se isso for
     especificado.  'x' pode ser omitido e nesse caso a variável
     principal da forma de expressão racional canônica de <expr> é
     usada.

     'horner' algumas vezes melhora a estabilidade se 'expr' for ser
     numericamente avaliada.  Isso também é útil se Maxima é usado para
     gerar programas para rodar em Fortran.  Veja também 'stringout'.

          (%i1) expr: 1e-155*x^2 - 5.5*x + 5.2e155;
                                     2
          (%o1)            1.0E-155 x  - 5.5 x + 5.2E+155
          (%i2) expr2: horner (%, x), keepfloat: true;
          (%o2)            (1.0E-155 x - 5.5) x + 5.2E+155
          (%i3) ev (expr, x=1e155);
          Maxima encountered a Lisp error:

           floating point overflow

          Automatically continuing.
          To reenable the Lisp debugger set *debugger-hook* to nil.
          (%i4) ev (expr2, x=1e155);
          (%o4)                       7.0E+154

 -- Função: find_root (<f>(<x>), <x>, <a>, <b>)
 -- Função: find_root (<f>, <a>, <b>)
     Encontra a raíz da função <f> com a variável <x> percorrendo o
     intervalo '[<a>, <b>]'.  A função deve ter um sinal diferente em
     cada ponto final.  Se essa condição não for alcançada, a action of
     the function is governed by 'find_root_error'.  If
     'find_root_error' is 'true' then an error occurs, otherwise the
     value of 'find_root_error' is returned (thus for plotting
     'find_root_error' might be set to 0.0).  De outra forma (dado que
     Maxima pode avaliar o primeiro argumento no intervalo especificado,
     e que o intervalo é contínuo) 'find_root' é garantido vir para cima
     com a raíz (ou um deles se existir mais que uma raíz).  A precisão
     de 'find_root' é governada por 'intpolabs' e 'intpolrel' os quais
     devem ser números em ponto flutuante não negativos.  'find_root'
     encerrará quando o primeiro argumento avaliar para alguma coisa
     menor que ou igual a 'intpolabs' ou se sucessivas aproximações da
     raíz diferirem por não mais que 'intpolrel * <um dos
     aproximandos>'.  O valor padrão de 'intpolabs' e 'intpolrel' são
     0.0 de forma que 'find_root' pega como boa uma resposta como for
     possível com a precisão aritmética simples que tivermos.  O
     primeiro argumento pode ser uma equação.  A ordem dos dois últimos
     argumentos é irrelevante.  Dessa forma

          find_root (sin(x) = x/2, x, %pi, 0.1);

     é equivalente a

          find_root (sin(x) = x/2, x, 0.1, %pi);

     O método usado é uma busca binária no intervalo especificado pelos
     últimos dois argumentos.  Quando o resultado da busca for
     encontrado a função é fechada o suficiente para ser linear, isso
     inicia usando interpolação linear.

     Examples:
          (%i1) f(x) := sin(x) - x/2;
                                                  x
          (%o1)                  f(x) := sin(x) - -
                                                  2
          (%i2) find_root (sin(x) - x/2, x, 0.1, %pi);
          (%o2)                   1.895494267033981
          (%i3) find_root (sin(x) = x/2, x, 0.1, %pi);
          (%o3)                   1.895494267033981
          (%i4) find_root (f(x), x, 0.1, %pi);
          (%o4)                   1.895494267033981
          (%i5) find_root (f, 0.1, %pi);
          (%o5)                   1.895494267033981

 -- Variável de opção: find_root_abs
     Valor padrão: 0.0

     'find_root_abs' é a precisão do comando 'find_root'.  A precisão é
     governada por 'find_root_abs' e 'find_root_rel' que devem ser
     números não negativos em ponto flutuante.  'find_root' terminará
     quando o primeiro argumento avaliar para alguma coisa menor que ou
     igual a 'find_root_abs' ou se sucessivos aproximandos para a raíz
     diferirem por não mais que 'find_root_rel * <um dos aproximandos>'.
     Os valores padrão de 'find_root_abs' e 'find_root_rel' são 0.0 de
     forma que 'find_root' tome como boa uma resposta que for possível
     com a precisão aritmética simples que tivermos.

 -- Variável de opção: find_root_error
     Valor padrão: 'true'

     'find_root_error' governa o comportamento de 'find_root'.  Quando
     'find_root' for chamada, ela determina se a função a ser resolvida
     satisfaz ou não a condição que os valores da função nos pontos
     finais do intervalo de interpolação são opostos em sinal.  Se eles
     forem de sinais opostos, a interpolação prossegue.  Se eles forem
     de mesmo sinal, e 'find_root_error' for 'true', então um erro é
     sinalizado.  Se eles forem de mesmo sinal e 'find_root_error' não
     for 'true', o valor de 'find_root_error' é retornado.  Dessa forma
     para montagem de gráfico, 'find_root_error' pode ser escolhida para
     0.0.

 -- Variável de opção: find_root_rel
     Valor padrão: 0.0

     'find_root_rel' é a precisão do comando 'find_root' e é governada
     por 'find_root_abs' e 'find_root_rel' que devem ser números não
     negativos em ponto flutuante.  'find_root' terminará quando o
     primeiro argumento avaliar para alguma coisa menor que ou igual a
     'find_root_abs' ou se sucessivos aproximandos para a raíz diferirem
     de não mais que 'find_root_rel * <um dos aproximandos>'.  Os
     valores padrão de 'find_root_labs' e 'find_root_rel' é 0.0 de forma
     que 'find_root' toma como boa uma resposta que for possível com a
     precisão aritmética simples que tivermos.

 -- Função: newton (<expr>, <x>, <x_0>, <eps>)
     Retorna uma solução aproximada de '<expr> = 0' através do método de
     Newton, considerando <expr> como sendo uma função de uma variável,
     <x>.  A busca pela solução começa com '<x> = <x_0>' e prossegue até
     'abs(<expr>) < <eps>' (com <expr> avaliada para o valor corrente de
     <x>).

     'newton' permite que variáveis indefinidas apareçam em <expr>,
     contanto que o teste de terminação 'abs(<expr>) < <eps>' avalie
     para 'true' ou 'false'.  Dessa forma não é necessário que <expr>
     avalie para um número.

     'load(newton1)' chama essa função.

     Veja também 'realroots', 'allroots', 'find_root', e 'mnewton'.

     Exemplos:

          (%i1) load (newton1);
          (%o1) /usr/share/maxima/5.10.0cvs/share/numeric/newton1.mac
          (%i2) newton (cos (u), u, 1, 1/100);
          (%o2)                   1.570675277161251
          (%i3) ev (cos (u), u = %);
          (%o3)                 1.2104963335033528E-4
          (%i4) assume (a > 0);
          (%o4)                        [a > 0]
          (%i5) newton (x^2 - a^2, x, a/2, a^2/100);
          (%o5)                  1.00030487804878 a
          (%i6) ev (x^2 - a^2, x = %);
                                                     2
          (%o6)                6.098490481853958E-4 a


File: maxima.info,  Node: Funções e Variáveis Definidas para Séries de Fourier,  Prev: Funções e Variáveis Definidas para Numérico,  Up: Numérico

23.4 Funções e Variáveis Definidas para Séries de Fourier
=========================================================

 -- Função: equalp (<x>, <y>)
     Retorna 'true' se 'equal (<x>, <y>)' de outra forma 'false' (não
     fornece uma mensagem de erro como 'equal (x, y)' poderia fazer
     nesse caso).

 -- Função: remfun (<f>, <expr>)
 -- Função: remfun (<f>, <expr>, <x>)
     'remfun (<f>, <expr>)' substitue todas as ocorrências de '<f>
     (<arg>)' por <arg> em <expr>.

     'remfun (<f>, <expr>, <x>)' substitue todas as ocorrências de '<f>
     (<arg>)' por <arg> em <expr> somente se <arg> contiver a variável
     <x>.

 -- Função: funp (<f>, <expr>)
 -- Função: funp (<f>, <expr>, <x>)
     'funp (<f>, <expr>)' retorna 'true' se <expr> contém a função <f>.

     'funp (<f>, <expr>, <x>)' retorna 'true' se <expr> contém a função
     <f> e a variável <x> em algum lugar no argumento de uma das
     instâncias de <f>.

 -- Função: absint (<f>, <x>, <halfplane>)
 -- Função: absint (<f>, <x>)
 -- Função: absint (<f>, <x>, <a>, <b>)
     'absint (<f>, <x>, <halfplane>)' retorna a integral indefinida de
     <f> com relação a <x> no dado semi-plano ('pos', 'neg', ou 'both').
     <f> pode conter expressões da forma 'abs (x)', 'abs (sin (x))',
     'abs (a) * exp (-abs (b) * abs (x))'.

     'absint (<f>, <x>)' é equivalente a 'absint (<f>, <x>, pos)'.

     'absint (<f>, <x>, <a>, <b>)' retorna a integral definida de <f>
     com relação a <x> de <a> até <b>.  <f> pode incluir valores
     absolutos.

 -- Função: fourier (<f>, <x>, <p>)
     Retorna uma lista de coeficientes de Fourier de '<f>(<x>)'
     definidos sobre o intervalo '[-p, p]'.

 -- Função: foursimp (<l>)
     Simplifica 'sin (n %pi)' para 0 se 'sinnpiflag' for 'true' e 'cos
     (n %pi)' para '(-1)^n' se 'cosnpiflag' for 'true'.

 -- Variável de opção: sinnpiflag
     Valor padrão: 'true'

     Veja 'foursimp'.

 -- Variável de opção: cosnpiflag
     Valor padrão: 'true'

     Veja 'foursimp'.

 -- Função: fourexpand (<l>, <x>, <p>, <limit>)
     Constrói e retorna a série de Fourier partindo da lista de
     coeficientes de Fourier <l> até (up through) <limit> termos
     (<limit> pode ser 'inf').  <x> e <p> possuem o mesmo significado
     que em 'fourier'.

 -- Função: fourcos (<f>, <x>, <p>)
     Retorna os coeficientes do cosseno de Fourier para '<f>(<x>)'
     definida sobre '[0, %pi]'.

 -- Função: foursin (<f>, <x>, <p>)
     Retorna os coeficientes do seno de Fourier para '<f>(<x>)' definida
     sobre '[0, <p>]'.

 -- Função: totalfourier (<f>, <x>, <p>)
     Retorna 'fourexpand (foursimp (fourier (<f>, <x>, <p>)), <x>, <p>,
     'inf)'.

 -- Função: fourint (<f>, <x>)
     Constrói e retorna uma lista de coeficientes de integral de Fourier
     de '<f>(<x>)' definida sobre '[minf, inf]'.

 -- Função: fourintcos (<f>, <x>)
     Retorna os coeficientes da integral do cosseno de Fourier para
     '<f>(<x>)' on '[0, inf]'.

 -- Função: fourintsin (<f>, <x>)
     Retorna os coeficientes da integral do seno de Fourier para
     '<f>(<x>)' on '[0, inf]'.


File: maxima.info,  Node: Arrays,  Next: Matrizes e Álgebra Linear,  Prev: Numérico,  Up: Top

24 Arrays
*********

* Menu:

* Funções e Variáveis Definidas para Arrays::


File: maxima.info,  Node: Funções e Variáveis Definidas para Arrays,  Prev: Arrays,  Up: Arrays

24.1 Funções e Variáveis Definidas para Arrays
==============================================

 -- Função: array (<name>, <dim_1>, ..., <dim_n>)
 -- Função: array (<name>, <type>, <dim_1>, ..., <dim_n>)
 -- Função: array ([<nome_1>, ..., <nome_m>], <dim_1>, ..., <dim_n>)

     Cria um array n-dimensional.  n pode ser menor ou igual a 5.  Os
     subscritos para a i'ésima dimensão são inteiros no intervalo de 0 a
     <dim_i>.

     'array (<name>, <dim_1>, ..., <dim_n>)' cria um array genérico.

     'array (<name>, <type>, <dim_1>, ..., <dim_n>)' cria um array, com
     elementos de um tipo especificado.  <type> pode ser 'fixnum' para
     inteiros de tamanho limitado ou 'flonum' para números em ponto
     flutuante.

     'array ([<nome_1>, ..., <nome_m>], <dim_1>, ..., <dim_n>)' cria m
     arrays, todos da mesma dimensão.

     Se o usuário atribui a uma variável subscrita antes de declarar o
     array correspondente, um array não declarado é criado.  Arrays não
     declarados, também conhecidos como array desordenado (porque o
     codigo desordenado termina nos subscritos), são mais gerais que
     arrays declarados.  O usuário não declara seu tamanho máximo, e ele
     cresce dinamicamente e desordenadamente à medida que são atribuídos
     valores a mais elementos.  Os subscritos de um array não declarado
     não precisam sempre ser números.  Todavia, exceto para um array um
     tanto quanto esparso, é provavelmente mais eficiente declarar isso
     quando possível que deixar não declarado.  A função 'array' pode
     ser usada para transformar um array não declarado em um array
     declarado.

 -- Função: arrayapply (<A>, [<i_1>, ..., <i_n>])
     Avalia '<A> [<i_1>, ..., <i_n>]', quando <A> for um array e <i_1>,
     ..., <i_n> são inteiros.

     Ela é remanescente de 'apply', exceto o primeiro argumento que é um
     array ao invés de uma função.

 -- Função: arrayinfo (<A>)
     Retorna informações sobre o array <A>.  O argumento <A> pode ser um
     array declarado, uma array não declarado ( que sofreu um hash), uma
     função de array, ou uma função que possui subscrito.

     Para arrays declarados, 'arrayinfo' retorna uma lista compreendendo
     o átomo 'declared', o n;umero de dimensões, e o tamanho de cada
     dimensão.  Os elementos do array, ambos associados e não
     associados, são retornados por 'listarray'.

     Para arrays não declarados (arrays que sofreram um hash),
     'arrayinfo' retorna uma lista compreendendo o átomo 'hashed', o
     número de subscritos, e os subscritos de de todo elemento que tiver
     um valor.  Os valores são retornados por meio de 'listarray'.

     Para funções de array, 'arrayinfo' retretorna uma lista
     compreendendo o átomo 'hashed', o número de subscritos, e quaisquer
     valores de subscritos para os quais exista valores funcionais
     armazenados.  Os valores funcionais armazenados são retornados
     através de 'listarray'.

     Para funções que possuem subscritos, 'arrayinfo' retorna uma lista
     compreendendo o átomo 'hashed', o número de subscritos, e qualquer
     valores subscritos para os quais existe uma expressões lambda.  As
     expressões lambda são retornadas por 'listarray'.

     Examples:

     'arrayinfo' e 'listarray' aplicado a um array declarado.

          (%i1) array (aa, 2, 3);
          (%o1)                          aa
          (%i2) aa [2, 3] : %pi;
          (%o2)                          %pi
          (%i3) aa [1, 2] : %e;
          (%o3)                          %e
          (%i4) arrayinfo (aa);
          (%o4)                 [declared, 2, [2, 3]]
          (%i5) listarray (aa);
          (%o5) [#####, #####, #####, #####, #####, #####, %e, #####,
                                                  #####, #####, #####, %pi]

     'arrayinfo' e 'listarray' aplicado a um array não declarado (no
     qual foi aplicado um hash).

          (%i1) bb [FOO] : (a + b)^2;
                                             2
          (%o1)                       (b + a)
          (%i2) bb [BAR] : (c - d)^3;
                                             3
          (%o2)                       (c - d)
          (%i3) arrayinfo (bb);
          (%o3)               [hashed, 1, [BAR], [FOO]]
          (%i4) listarray (bb);
                                        3         2
          (%o4)                 [(c - d) , (b + a) ]

     'arrayinfo' e 'listarray' aplicado a uma função de array.

          (%i1) cc [x, y] := y / x;
                                               y
          (%o1)                      cc     := -
                                       x, y    x
          (%i2) cc [u, v];
                                          v
          (%o2)                           -
                                          u
          (%i3) cc [4, z];
                                          z
          (%o3)                           -
                                          4
          (%i4) arrayinfo (cc);
          (%o4)              [hashed, 2, [4, z], [u, v]]
          (%i5) listarray (cc);
                                        z  v
          (%o5)                        [-, -]
                                        4  u

     'arrayinfo' e 'listarray' aplicadas a funções com subscritos.

          (%i1) dd [x] (y) := y ^ x;
                                               x
          (%o1)                     dd (y) := y
                                      x
          (%i2) dd [a + b];
                                              b + a
          (%o2)                  lambda([y], y     )
          (%i3) dd [v - u];
                                              v - u
          (%o3)                  lambda([y], y     )
          (%i4) arrayinfo (dd);
          (%o4)             [hashed, 1, [b + a], [v - u]]
          (%i5) listarray (dd);
                                   b + a                v - u
          (%o5)      [lambda([y], y     ), lambda([y], y     )]

 -- Função: arraymake (<A>, [<i_1>, ..., <i_n>])
     Retorna a expressão '<A>[<i_1>, ..., <i_n>]'.  O resultado é uma
     referência a um array não avaliado.

     'arraymake' é remanicência de 'funmake', exceto o valor retornado é
     um array de referência não avaliado ao invés de uma chamada de
     função não avaliada.

     Exemplos:

          (%i1) arraymake (A, [1]);
          (%o1)                          A
                                          1
          (%i2) arraymake (A, [k]);
          (%o2)                          A
                                          k
          (%i3) arraymake (A, [i, j, 3]);
          (%o3)                       A
                                       i, j, 3
          (%i4) array (A, fixnum, 10);
          (%o4)                           A
          (%i5) fillarray (A, makelist (i^2, i, 1, 11));
          (%o5)                           A
          (%i6) arraymake (A, [5]);
          (%o6)                          A
                                          5
          (%i7) ''%;
          (%o7)                          36
          (%i8) L : [a, b, c, d, e];
          (%o8)                    [a, b, c, d, e]
          (%i9) arraymake ('L, [n]);
          (%o9)                          L
                                          n
          (%i10) ''%, n = 3;
          (%o10)                          c
          (%i11) A2 : make_array (fixnum, 10);
          (%o11)          {Array:  #(0 0 0 0 0 0 0 0 0 0)}
          (%i12) fillarray (A2, [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]);
          (%o12)          {Array:  #(1 2 3 4 5 6 7 8 9 10)}
          (%i13) arraymake ('A2, [8]);
          (%o13)                         A2
                                           8
          (%i14) ''%;
          (%o14)                          9

 -- Variável de sistema: arrays
     Valor padrão: '[]'

     'arrays' é uma lista dos arrays que tiverem sido alocados.  Essa
     lista compreende arrays declarados através de 'array', arrays
     desordenados (hashed) construídos através de definição implícita
     (atribuindo alguma coisa a um elemento de array), e funções de
     array definidas por meio de ':=' e 'define'.  Arrays definidos por
     meio de 'make_array' não estão incluídos.

     Veja também 'array', 'arrayapply', 'arrayinfo', 'arraymake',
     'fillarray', 'listarray', e 'rearray'.

     Exemplos:

          (%i1) array (aa, 5, 7);
          (%o1)                          aa
          (%i2) bb [FOO] : (a + b)^2;
                                             2
          (%o2)                       (b + a)
          (%i3) cc [x] := x/100;
                                             x
          (%o3)                      cc  := ---
                                       x    100
          (%i4) dd : make_array ('any, 7);
          (%o4)       {Array:  #(NIL NIL NIL NIL NIL NIL NIL)}
          (%i5) arrays;
          (%o5)                     [aa, bb, cc]

 -- Função: bashindices (<expr>)
     Transforma a expressão <expr> dando a cada somatório e a cada
     produto um único índice.  Isso dá a 'changevar' grande precisão
     quando se está trabalhando com somatórios e produtos.  A forma do
     único índice é 'j<number>'.  A quantidade <number> é determindad
     por referência a 'gensumnum', que pode ser alterada pelo usuário.
     Por exemplo, 'gensumnum:0$' reseta isso.

 -- Função: fillarray (<A>, <B>)
     Preenche o array <A> com <B>, que é uma lista ou um array.

     Se um tipo específico for declarado para <A> no momento de sua
     criação, <A> somente porde ser preenchido com elementos do tipo
     especificado; Constitui um erro alguma tentativa feita para copiar
     um um elemento de um tipo diferente.

     Se as dimensões dos arrays <A> e <B> forem diferents, <A> é
     preenchido no ordem de maior fileira.  Se não existirem elementos
     livres em <B> o último elemento é usado para preencher todo o resto
     de <A>.  Se existirem muitos , esses restantes seram ignorados.

     'fillarray' retorna esse primeiro argumento.

     Exemplos:

     Create an array of 9 elements and fill it from a list.

          (%i1) array (a1, fixnum, 8);
          (%o1)                          a1
          (%i2) listarray (a1);
          (%o2)              [0, 0, 0, 0, 0, 0, 0, 0, 0]
          (%i3) fillarray (a1, [1, 2, 3, 4, 5, 6, 7, 8, 9]);
          (%o3)                          a1
          (%i4) listarray (a1);
          (%o4)              [1, 2, 3, 4, 5, 6, 7, 8, 9]

     Quando existirem poucos elementos para preencher o array, o último
     elemento é repetido.  Quando houverem muitos elementos, os
     elementos extras são ignorados.

          (%i1) a2 : make_array (fixnum, 8);
          (%o1)             {Array:  #(0 0 0 0 0 0 0 0)}
          (%i2) fillarray (a2, [1, 2, 3, 4, 5]);
          (%o2)             {Array:  #(1 2 3 4 5 5 5 5)}
          (%i3) fillarray (a2, [4]);
          (%o3)             {Array:  #(4 4 4 4 4 4 4 4)}
          (%i4) fillarray (a2, makelist (i, i, 1, 100));
          (%o4)             {Array:  #(1 2 3 4 5 6 7 8)}

     Arrays multi-dimensionais são preenchidos em ordem de maior
     fileira.

          (%i1) a3 : make_array (fixnum, 2, 5);
          (%o1)        {Array:  #2A((0 0 0 0 0) (0 0 0 0 0))}
          (%i2) fillarray (a3, [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]);
          (%o2)        {Array:  #2A((1 2 3 4 5) (6 7 8 9 10))}
          (%i3) a4 : make_array (fixnum, 5, 2);
          (%o3)     {Array:  #2A((0 0) (0 0) (0 0) (0 0) (0 0))}
          (%i4) fillarray (a4, a3);
          (%o4)     {Array:  #2A((1 2) (3 4) (5 6) (7 8) (9 10))}

 -- Função: listarray (<A>)
     Retorna uma lista dos elementos do array <A>.  O argumento <A> pode
     ser um array declarado, um array não declarado (desordenado -
     hashed), uma função de array, ou uma função com subscritos.

     Elementos são listados em ordem de linha maior.  Isto é, elementos
     são ordenados conforme o primeiro índice, en seguida conforme o
     segundo índice, e assim sucessivamente.  A sequüência de ordenação
     por meio dos valores dos índices é a mesma ordem estabelecida por
     meio de 'orderless'.

     Para arrays não declarados , funções de arrays, e funções com
     subscritos, os elementos correspondem aos valores de índice
     retornados através de 'arrayinfo'.

     Elemetos não associados de arrays genéricos declarados (isto é, não
     'fixnum' e não 'flonum') são retornados como '#####'.  Elementos
     não associados de arrays declarados 'fixnum' ou 'flonum' são
     retornados como 0 ou 0.0, respectivamente.  Elementos não
     associados de arrays não declarados, funções de array, e funções
     subscritas não são retornados.

     Exemplos:

     'listarray' e 'arrayinfo' aplicados a um array declarado.

          (%i1) array (aa, 2, 3);
          (%o1)                          aa
          (%i2) aa [2, 3] : %pi;
          (%o2)                          %pi
          (%i3) aa [1, 2] : %e;
          (%o3)                          %e
          (%i4) listarray (aa);
          (%o4) [#####, #####, #####, #####, #####, #####, %e, #####,
                                                  #####, #####, #####, %pi]
          (%i5) arrayinfo (aa);
          (%o5)                 [declared, 2, [2, 3]]

     'listarray' e 'arrayinfo' aplicadas a arrays não declarados (hashed
     - desordenados).

          (%i1) bb [FOO] : (a + b)^2;
                                             2
          (%o1)                       (b + a)
          (%i2) bb [BAR] : (c - d)^3;
                                             3
          (%o2)                       (c - d)
          (%i3) listarray (bb);
                                        3         2
          (%o3)                 [(c - d) , (b + a) ]
          (%i4) arrayinfo (bb);
          (%o4)               [hashed, 1, [BAR], [FOO]]

     'listarray' e 'arrayinfo' aplicada a uma função de array.

          (%i1) cc [x, y] := y / x;
                                               y
          (%o1)                      cc     := -
                                       x, y    x
          (%i2) cc [u, v];
                                          v
          (%o2)                           -
                                          u
          (%i3) cc [4, z];
                                          z
          (%o3)                           -
                                          4
          (%i4) listarray (cc);
                                        z  v
          (%o4)                        [-, -]
                                        4  u
          (%i5) arrayinfo (cc);
          (%o5)              [hashed, 2, [4, z], [u, v]]

     'listarray' e 'arrayinfo' aplicadas a funções com subscritos.

          (%i1) dd [x] (y) := y ^ x;
                                               x
          (%o1)                     dd (y) := y
                                      x
          (%i2) dd [a + b];
                                              b + a
          (%o2)                  lambda([y], y     )
          (%i3) dd [v - u];
                                              v - u
          (%o3)                  lambda([y], y     )
          (%i4) listarray (dd);
                                   b + a                v - u
          (%o4)      [lambda([y], y     ), lambda([y], y     )]
          (%i5) arrayinfo (dd);
          (%o5)             [hashed, 1, [b + a], [v - u]]

 -- Função: make_array (<type>, <dim_1>, ..., <dim_n>)
     Cria e retorna um array de Lisp.  <type> pode ser 'any', 'flonum',
     'fixnum', 'hashed' ou 'functional'.  Existem n indices, e o
     i'enésimo indice está no intervalo de 0 a <dim_i> - 1.

     A vantagem de 'make_array' sobre 'array' é que o valor de retorno
     não tem um nome, e uma vez que um ponteiro a ele vai, ele irá
     também.  Por exemplo, se 'y: make_array (...)' então 'y' aponta
     para um objeto que ocupa espaço, mas depois de 'y: false', 'y' não
     mais aponta para aquele objeto, então o objeto pode ser descartado.

     Exemplos:

          (%i1) A1 : make_array (fixnum, 10);
          (%o1)           {Array:  #(0 0 0 0 0 0 0 0 0 0)}
          (%i2) A1 [8] : 1729;
          (%o2)                         1729
          (%i3) A1;
          (%o3)          {Array:  #(0 0 0 0 0 0 0 0 1729 0)}
          (%i4) A2 : make_array (flonum, 10);
          (%o4) {Array:  #(0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0)}
          (%i5) A2 [2] : 2.718281828;
          (%o5)                      2.718281828
          (%i6) A2;
          (%o6)
               {Array:  #(0.0 0.0 2.718281828 0.0 0.0 0.0 0.0 0.0 0.0 0.0)}
          (%i7) A3 : make_array (any, 10);
          (%o7) {Array:  #(NIL NIL NIL NIL NIL NIL NIL NIL NIL NIL)}
          (%i8) A3 [4] : x - y - z;
          (%o8)                      - z - y + x
          (%i9) A3;
          (%o9) {Array:  #(NIL NIL NIL NIL ((MPLUS SIMP) $X ((MTIMES SIMP)\
           -1 $Y) ((MTIMES SIMP) -1 $Z))
            NIL NIL NIL NIL NIL)}
          (%i10) A4 : make_array (fixnum, 2, 3, 5);
          (%o10) {Array:  #3A(((0 0 0 0 0) (0 0 0 0 0) (0 0 0 0 0)) ((0 0 \
          0 0 0) (0 0 0 0 0) (0 0 0 0 0)))}
          (%i11) fillarray (A4, makelist (i, i, 1, 2*3*5));
          (%o11) {Array:  #3A(((1 2 3 4 5) (6 7 8 9 10) (11 12 13 14 15))
              ((16 17 18 19 20) (21 22 23 24 25) (26 27 28 29 30)))}
          (%i12) A4 [0, 2, 1];
          (%o12)                         12

 -- Função: rearray (<A>, <dim_1>, ..., <dim_n>)
     Altera as dimenções de um array.  O novo array será preenchido com
     os elementos do antigo em ordem da maior linha.  Se o array antigo
     era muito pequeno, os elementos restantes serão preenchidos com
     'false', '0.0' ou '0', dependendo do tipo do array.  O tipo do
     array não pode ser alterado.

 -- Função: remarray (<A_1>, ..., <A_n>)
 -- Função: remarray (all)
     Remove arrays e funções associadas a arrays e libera o espaço
     ocupado.  Os argumentos podem ser arrays declarados, arrays não
     declarados (dsordenados - hashed), funções de array functions, e
     funções com subscritos.

     'remarray (all)' remove todos os ítens na lista global 'arrays'.

     Isso pode ser necessário para usar essa função se isso é desejado
     para redefinir os valores em um array desordenado.

     'remarray' retorna a lista dos arrays removidos.

 -- Função: subvar (<x>, <i>)
     Avalia a expressão subscrita '<x>[<i>]'.

     'subvar' avalia seus argumentos.

     'arraymake (<x>, [<i>]' constrói a expressão '<x>[<i>]', mas não a
     avalia.

     Exemplos:

          (%i1) x : foo $
          (%i2) i : 3 $
          (%i3) subvar (x, i);
          (%o3)                         foo
                                           3
          (%i4) foo : [aa, bb, cc, dd, ee]$
          (%i5) subvar (x, i);
          (%o5)                          cc
          (%i6) arraymake (x, [i]);
          (%o6)                         foo
                                           3
          (%i7) ''%;
          (%o7)                          cc

 -- Variável de pção: use_fast_arrays
     - Se 'true' somente dois tipos de arrays são reconhecidos.

     1) O array art-q (t no Lisp Comum) que pode ter muitas dimensões
     indexadas por inteiros, e pode aceitar qualquer objeto do Lisp ou
     do Maxima como uma entrada.  Para construir assim um array, insira
     'a:make_array(any,3,4);' então 'a' terá como valor, um array com
     doze posições, e o índice é baseado em zero.

     2) O array Hash_table que é o tipo padrão de array criado se um faz
     'b[x+1]:y^2' (e 'b' não é ainda um array, uma lista, ou uma matriz
     - se isso ou um desses ocorrer um erro pode ser causado desde 'x+1'
     não poderá ser um subscrito válido para um array art-q, uma lista
     ou uma matriz).  Esses índices (também conhecidos como chaves)
     podem ser quaisquer objetos.  Isso somente pega uma chave por vez a
     cada vez ('b[x+1,u]:y' ignorará o 'u').  A referência termina em
     'b[x+1] ==> y^2'.  Certamente a chave poe ser uma lista , e.g.
     'b[[x+1,u]]:y' poderá ser válido.  Isso é incompatível com os
     arrays antigos do Maxima, mas poupa recursos.

     Uma vantagem de armazenar os arrays como valores de símbolos é que
     as convenções usuais sobre variáveis locais de uma função
     aplicam-se a arrays também.  O tipo Hash_table também usa menos
     recursos e é mais eficiente que o velho tipo hashar do Maxima.
     Para obter comportamento consistente em códigos traduzidos e
     compilados posicione 'translate_fast_arrays' para ser 'true'.


File: maxima.info,  Node: Matrizes e Álgebra Linear,  Next: Funções Afins,  Prev: Arrays,  Up: Top

25 Matrizes e Álgebra Linear
****************************

/Matrices.texi/1.29/Sat Jun 2 00:12:57 2007/-ko/
* Menu:

* Introdução a Matrizes e Álgebra Linear::
* Funções e Variáveis Definidas para Matrizes e Álgebra Linear::


File: maxima.info,  Node: Introdução a Matrizes e Álgebra Linear,  Next: Funções e Variáveis Definidas para Matrizes e Álgebra Linear,  Prev: Matrizes e Álgebra Linear,  Up: Matrizes e Álgebra Linear

25.1 Introdução a Matrizes e Álgebra Linear
===========================================

* Menu:

* Ponto::
* Vetores::
* auto::


File: maxima.info,  Node: Ponto,  Next: Vetores,  Prev: Introdução a Matrizes e Álgebra Linear,  Up: Introdução a Matrizes e Álgebra Linear

25.1.1 Ponto
------------

O operador '.' representa multiplicação não comutativa e produto
escalar.  Quando os operandos são matrizes 1-coluna ou 1-linha 'a' e
'b', a expresão 'a.b' é equivalente a 'sum (a[i]*b[i], i, 1,
length(a))'.  Se 'a' e 'b' não são complexos, isso é o produto escalar,
também chamado produto interno ou produto do ponto, de 'a' e 'b'.  O
produto escalar é definido como 'conjugate(a).b' quando 'a' e 'b' são
complexos; 'innerproduct' no pacote 'eigen' fornece o produto escalar
complexo.

   Quando os operandos são matrizes mais gerais, o produto é a matriz
produto 'a' e 'b'.  O número de linhas de 'b' deve ser igual ao número
de colunas de 'a', e o resultado tem número de linhas igual ao número de
linhas de 'a' e número de colunas igual ao número de colunas de 'b'.

   Para distingüir '.' como um operador aritmético do ponto decimal em
um número em ponto flutuante, pode ser necessário deixar espaços em cada
lado.  Por exemplo, '5.e3' é '5000.0' mas '5 . e3' é '5' vezes 'e3'.

   Existem muitos sinalizadores que governam a simplificação de
expresões envolvendo '.', a saber 'dot', 'dot0nscsimp', 'dot0simp',
'dot1simp', 'dotassoc', 'dotconstrules', 'dotdistrib', 'dotexptsimp',
'dotident', e 'dotscrules'.


File: maxima.info,  Node: Vetores,  Next: auto,  Prev: Ponto,  Up: Introdução a Matrizes e Álgebra Linear

25.1.2 Vetores
--------------

'vect' é um pacote de funções para análise vetorial.  'load ("vect")'
chama esse pacote, e 'demo ("vect")' permite visualizar uma
demonstração.

   O pacote de análise vetorial pode combinar e simplificar expresões
simbólicas incluindo produtos dos pontos e productos dos x, juntamente
com o gradiente, divergencia, torção, e operadores Laplacianos.  A
distribuição desses operadores sobre adições ou produtos é governada por
muitos sinalizadores, como são várias outras expansões, incluindo
expansão dentro de componentes em qualquer sistema de coordenadas
ortogonais.  Existem também funções para derivar o escalar ou vetor
potencial de um campo.

   O pacote 'vect' contém essas funções: 'vectorsimp', 'scalefactors',
'express', 'potential', e 'vectorpotential'.

   Atenção: o pacote 'vect' declara o operador ponto '.' como sendo um
operador comutativo.


File: maxima.info,  Node: auto,  Prev: Vetores,  Up: Introdução a Matrizes e Álgebra Linear

25.1.3 auto
-----------

O pacote 'eigen' contém muitas funções devotadas para a computação
simbólica de autovalores e autovetores.  Maxima chama o pacote
automaticamente se uma das funções 'eigenvalues' ou 'eigenvectors' é
invocada.  O pacote pode ser chamado explicitamente com 'load
("eigen")'.

   'demo ("eigen")' mostra uma demonstração das compatibilidades desse
pacote.  'batch ("eigen")' executa a mesma demonstração, mas sem
lembretes de usuário entre sucessivas computações.

   As funções no pacote 'eigen' são 'innerproduct', 'unitvector',
'columnvector', 'gramschmidt', 'eigenvalues', 'eigenvectors',
'uniteigenvectors', e 'similaritytransform'.


File: maxima.info,  Node: Funções e Variáveis Definidas para Matrizes e Álgebra Linear,  Prev: Introdução a Matrizes e Álgebra Linear,  Up: Matrizes e Álgebra Linear

25.2 Funções e Variáveis Definidas para Matrizes e Álgebra Linear
=================================================================

 -- Função: addcol (<M>, <list_1>, ..., <list_n>)
     Anexa a(s) coluna(s) dadas por uma ou mais listas (ou matrizes)
     sobre a matriz <M>.

 -- Função: addrow (<M>, <list_1>, ..., <list_n>)
     Anexa a(s) linha(s) dadas por uma ou mais listas (ou matrizes)
     sobre a matriz <M>.

 -- Função: adjoint (<M>)
     Retorna a matriz adjunta da matriz <M>.  A matriz adjunta é a
     transposta da matriz dos cofatores de <M>.

 -- Função: augcoefmatrix ([<eqn_1>, ..., <eqn_m>], [<x_1>, ..., <x_n>])
     Retorna a matriz dos coeficientes aumentada para as variáveis
     <x_1>, ..., <x_n> do sistema de equações lineares <eqn_1>, ...,
     <eqn_m>.  Essa é a matriz dos coeficientes com uma coluna anexada
     para os termos independentes em cada equação (i.e., esses termos
     não dependem de <x_1>, ..., <x_n>).

          (%i1) m: [2*x - (a - 1)*y = 5*b, c + b*y + a*x = 0]$
          (%i2) augcoefmatrix (m, [x, y]);
                                 [ 2  1 - a  - 5 b ]
          (%o2)                  [                 ]
                                 [ a    b      c   ]

 -- Função: charpoly (<M>, <x>)
     Retorna um polinômio característico para a matriz <M> em relação à
     variável <x>.  Que é, 'determinant (<M> - diagmatrix (length (<M>),
     <x>))'.

          (%i1) a: matrix ([3, 1], [2, 4]);
                                      [ 3  1 ]
          (%o1)                       [      ]
                                      [ 2  4 ]
          (%i2) expand (charpoly (a, lambda));
                                     2
          (%o2)                lambda  - 7 lambda + 10
          (%i3) (programmode: true, solve (%));
          (%o3)               [lambda = 5, lambda = 2]
          (%i4) matrix ([x1], [x2]);
                                       [ x1 ]
          (%o4)                        [    ]
                                       [ x2 ]
          (%i5) ev (a . % - lambda*%, %th(2)[1]);
                                    [ x2 - 2 x1 ]
          (%o5)                     [           ]
                                    [ 2 x1 - x2 ]
          (%i6) %[1, 1] = 0;
          (%o6)                     x2 - 2 x1 = 0
          (%i7) x2^2 + x1^2 = 1;
                                      2     2
          (%o7)                     x2  + x1  = 1
          (%i8) solve ([%th(2), %], [x1, x2]);
                            1               2
          (%o8) [[x1 = - -------, x2 = - -------],
                         sqrt(5)         sqrt(5)

                                                       1             2
                                              [x1 = -------, x2 = -------]]
                                                    sqrt(5)       sqrt(5)

 -- Função: coefmatrix ([<eqn_1>, ..., <eqn_m>], [<x_1>, ..., <x_n>])
     Retorna a matriz dos coeficientes para as variáveis <x_1>, ...,
     <x_n> do sistema de equações lineares <eqn_1>, ..., <eqn_m>.

          (%i1) coefmatrix([2*x-(a-1)*y+5*b = 0, b*y+a*x = 3], [x,y]);
                                           [ 2  1 - a ]
          (%o1)                            [          ]
                                           [ a    b   ]

 -- Função: col (<M>, <i>)
     Reorna a <i>'ésima coluna da matriz <M>.  O valor de retorno é uma
     matriz.

 -- Função: columnvector (<L>)
 -- Função: covect (<L>)
     Retorna uma matriz de uma coluna e 'length (<L>)' linhas, contendo
     os elementos da lista <L>.

     'covect' é um sinônimo para 'columnvector'.

     'load ("eigen")' chama essa função.

     Isso é útil se você quer usar partes das saídas das funções nesse
     pacote em cálculos matriciais.

     Exemplo:

          (%i1) load ("eigen")$
          Warning - you are redefining the Macsyma function autovalores
          Warning - you are redefining the Macsyma function autovetores
          (%i2) columnvector ([aa, bb, cc, dd]);
                                       [ aa ]
                                       [    ]
                                       [ bb ]
          (%o2)                        [    ]
                                       [ cc ]
                                       [    ]
                                       [ dd ]

 -- Função: conjugate (<x>)
     Retorna o conjugado complexo de <x>.

          (%i1) declare ([aa, bb], real, cc, complex, ii, imaginary);

          (%o1)                         done
          (%i2) conjugate (aa + bb*%i);

          (%o2)                      aa - %i bb
          (%i3) conjugate (cc);

          (%o3)                     conjugate(cc)
          (%i4) conjugate (ii);

          (%o4)                         - ii
          (%i5) conjugate (xx + yy);

          (%o5)             conjugate(yy) + conjugate(xx)

 -- Função: copymatrix (<M>)
     Retorna uma cópia da matriz <M>.  Esse é o único para fazer uma
     copia separada copiando <M> elemento a elemento.

     Note que uma atribuição de uma matriz para outra, como em 'm2: m1',
     não copia 'm1'.  Uma atribuição 'm2 [i,j]: x' ou 'setelmx (x, i, j,
     m2' também modifica 'm1 [i,j]'.  criando uma cópia com 'copymatrix'
     e então usando atribução cria uma separada e modificada cópia.

 -- Função: determinant (<M>)
     Calcula o determinante de <M> por um método similar à eliminação de
     Gauss.

     A forma do resultado depende da escolha do comutador 'ratmx'.

     Existe uma rotina especial para calcular determinantes esparsos que
     é chamada quando os comutadores 'ratmx' e 'sparse' são ambos
     'true'.

 -- Variável: detout
     Valor padrão: 'false'

     Quando 'detout' é 'true', o determinante de uma matriz cuja inversa
     é calculada é fatorado fora da inversa.

     Para esse comutador ter efeito 'doallmxops' e 'doscmxops' deveram
     ambos serem 'false' (veja suas transcrições).  Alternativamente
     esses comutadores podem ser dados para 'ev' o que faz com que os
     outros dois sejam escolhidos corretamente.

     Exemplo:

          (%i1) m: matrix ([a, b], [c, d]);
                                      [ a  b ]
          (%o1)                       [      ]
                                      [ c  d ]
          (%i2) detout: true$
          (%i3) doallmxops: false$
          (%i4) doscmxops: false$
          (%i5) invert (m);
                                    [  d   - b ]
                                    [          ]
                                    [ - c   a  ]
          (%o5)                     ------------
                                     a d - b c

 -- Função: diagmatrix (<n>, <x>)
     Retorna uma matriz diagonal de tamanho <n> por <n> com os elementos
     da diagonal todos iguais a <x>.  'diagmatrix (<n>, 1)' retorna uma
     matriz identidade (o mesmo que 'ident (<n>)').

     <n> deve avaliar para um inteiro, de outra forma 'diagmatrix'
     reclama com uma mensagem de erro.

     <x> pode ser qualquer tipo de expresão, incluindo outra matriz.  Se
     <x> é uma matriz, isso não é copiado; todos os elementos da
     diagonal referem-se à mesma instância, <x>.

 -- Variável: doallmxops
     Valor padrão: 'true'

     Quando 'doallmxops' é 'true', todas as operações relacionadas a
     matrizes são realizadas.  Quando isso é 'false' então a escolha de
     comutadores individuais 'dot' governam quais operações são
     executadas.

 -- Variável: domxexpt
     Valor padrão: 'true'

     Quando 'domxexpt' é 'true', uma matriz exponencial, 'exp (<M>)'
     onde <M> é a matriz, é interpretada como uma matriz com elementos
     '[i,j' iguais a 'exp (m[i,j])'.  de outra forma 'exp (<M>)' avalia
     para 'exp (<ev(M)>'.

     'domxexpt' afeta todas as expresões da forma '<base>^<expoente>'
     onde <base> é uma expresão assumida escalar ou constante, e
     <expoente> é uma lista ou matriz.

     Exemplo:

          (%i1) m: matrix ([1, %i], [a+b, %pi]);
                                   [   1    %i  ]
          (%o1)                    [            ]
                                   [ b + a  %pi ]
          (%i2) domxexpt: false$
          (%i3) (1 - c)^m;
                                       [   1    %i  ]
                                       [            ]
                                       [ b + a  %pi ]
          (%o3)                 (1 - c)
          (%i4) domxexpt: true$
          (%i5) (1 - c)^m;
                            [                      %i  ]
                            [    1 - c      (1 - c)    ]
          (%o5)             [                          ]
                            [        b + a         %pi ]
                            [ (1 - c)       (1 - c)    ]

 -- Variável de opção: domxmxops
     Valor padrão: 'true'

     Quando 'domxmxops' é 'true', todas as operações matriz-matriz ou
     matriz-lista são realizadas (mas não operações escalar-matriz); se
     esse comutador é 'false' tais operações não são.

 -- Variável de opção: domxnctimes
     Valor padrão: 'false'

     Quando 'domxnctimes' é 'true', produtos não comutativos de matrizes
     são realizados.

 -- Variável de opção: dontfactor
     Valor padrão: '[]'

     'dontfactor' pode ser escolhido para uma lista de variáveis em
     relação a qual fatoração não é para ocorrer.  (A lista é
     inicialmente vazia.)  Fatoração também não pegará lugares com
     relação a quaisquer variáveis que são menos importantes, conforme a
     hierarquía de variável assumida para a forma expresão racional
     canônica (CRE), que essas na lista 'dontfactor'.

 -- Variável de opção: doscmxops
     Valor padrão: 'false'

     Quando 'doscmxops' é 'true', operações escalar-matriz são
     realizadas.

 -- Variável de opção: doscmxplus
     Valor padrão: 'false'

     Quando 'doscmxplus' é 'true', operações escalar-matriz retornam uma
     matriz resultado.  Esse comutador não é subsomado sob 'doallmxops'.

 -- Variável de opção: dot0nscsimp
     Valor padrão: 'true'

     Quando 'dot0nscsimp' é 'true', um produto não comutativo de zero e
     um termo não escalar é simplificado para um produto comutativo.

 -- Variável de opção: dot0simp
     Valor padrão: 'true'

     Quando 'dot0simp' é 'true', um produto não comutativo de zero e um
     termo escalar é simplificado para um produto não comutativo.

 -- Variável de opção: dot1simp
     Valor padrão: 'true'

     Quando 'dot1simp' é 'true', um produto não comutativo de um e outro
     termo é simplificado para um produto comutativo.

 -- Variável de opção: dotassoc
     Valor padrão: 'true'

     Quando 'dotassoc' é 'true', uma expresão '(A.B).C' simplifica para
     'A.(B.C)'.

 -- Variável de opção: dotconstrules
     Valor padrão: 'true'

     Quando 'dotconstrules' é 'true', um produto não comutativo de uma
     constante e outro termo é simplificado para um produto comutativo.
     Ativando esse sinalizador efetivamente ativamos 'dot0simp',
     'dot0nscsimp', e 'dot1simp' também.

 -- Variável de opção: dotdistrib
     Valor padrão: 'false'

     Quando 'dotdistrib' é 'true', uma expresão 'A.(B + C)' simplifica
     para 'A.B + A.C'.

 -- Variável de opção: dotexptsimp
     Valor padrão: 'true'

     Quando 'dotexptsimp' é 'true', uma expresão 'A.A' simplifica para
     'A^^2'.

 -- Variável de opção: dotident
     Valor padrão: 1

     'dotident' é o valor retornado por 'X^^0'.

 -- Variável de opção: dotscrules
     Valor padrão: 'false'

     Quando 'dotscrules' é 'true', uma expresão 'A.SC' ou 'SC.A'
     simplifica para 'SC*A' e 'A.(SC*B)' simplifica para 'SC*(A.B)'.

 -- Função: echelon (<M>)
     Retorna a forma escalonada da matriz <M>, como produzido através da
     eliminação de Gauss.  A forma escalonada é calculada de <M> por
     operações elementares de linha tais que o primeiro elemento não
     zero em cada linha na matriz resultante seja o número um e os
     elementos da coluna abaixo do primeiro número um em cada linha
     sejam todos zero.

     'triangularize' também realiza eliminação de Gaussian, mas não
     normaliza o elemento líder não nulo em cada linha.

     'lu_factor' e 'cholesky' são outras funções que retornam matrizes
     triangularizadas.

          (%i1) M: matrix ([3, 7, aa, bb], [-1, 8, 5, 2], [9, 2, 11, 4]);
                                 [  3   7  aa  bb ]
                                 [                ]
          (%o1)                  [ - 1  8  5   2  ]
                                 [                ]
                                 [  9   2  11  4  ]
          (%i2) echelon (M);
                            [ 1  - 8  - 5      - 2     ]
                            [                          ]
                            [         28       11      ]
                            [ 0   1   --       --      ]
          (%o2)             [         37       37      ]
                            [                          ]
                            [              37 bb - 119 ]
                            [ 0   0    1   ----------- ]
                            [              37 aa - 313 ]

 -- Função: eigenvalues (<M>)
 -- Função: eivals (<M>)
     Retorna uma lista de duas listas contendo os autovalores da matriz
     <M>.  A primeira sublista do valor de retorno é a lista de
     autovalores da matriz, e a segunda sublista é a lista de
     multiplicidade dos autovalores na ordem correspondente.

     'eivals' é um sinônimo de 'eigenvalues'.

     'eigenvalues' chama a função 'solve' para achar as raízes do
     polinômio característico da matriz.  Algumas vezes 'solve' pode não
     estar habilitado a achar as raízes do polinômio; nesse caso algumas
     outras funções nesse pacote (except 'innerproduct', 'unitvector',
     'columnvector' e 'gramschmidt') não irão trabalhar.

     Em alguns casos os autovalores achados por 'solve' podem ser
     expresões complicadas.  (Isso pode acontecer quando 'solve' retorna
     uma expresão real não trivial para um autovalor que é sabidamente
     real.)  Isso pode ser possível para simplificar os autovalores
     usando algumas outras funções.

     O pacote 'eigen.mac' é chamado automaticamente quando 'eigenvalues'
     ou 'eigenvectors' é referenciado.  Se 'eigen.mac' não tiver sido
     ainda chamado, 'load ("eigen")' chama-o.  Após ser chamado, todas
     as funções e variáveis no pacote estarão disponíveis.

 -- Função: eigenvectors (<M>)
 -- Função: eivects (<M>)
     pegam uma matriz <M> como seu argumento e retorna uma lista de
     listas cuja primeira sublista é a saída de 'eigenvalues' e as
     outras sublistas são os autovetores da matriz correspondente para
     esses autovalores respectivamente.

     'eivects' é um sinônimo para 'eigenvectors'.

     O pacote 'eigen.mac' é chamado automaticamente quando 'eigenvalues'
     ou 'eigenvectors' é referenciado.  Se 'eigen.mac' não tiver sido
     ainda chamado, 'load ("eigen")' chama-o.  Após ser chamado, todas
     as funções e variáveis no pacote estarão disponíveis.

     Os sinalizadores que afetam essa função são:

     'nondiagonalizable' é escolhido para 'true' ou 'false' dependendo
     de se a matriz é não diagonalizável ou diagonalizável após o
     retorno de 'eigenvectors'.

     'hermitianmatrix' quando 'true', faz com que os autovetores
     degenerados da matriz Hermitiana sejam ortogonalizados usando o
     algorítmo de Gram-Schmidt.

     'knowneigvals' quando 'true' faz com que o pacote 'eigen' assumir
     que os autovalores da matriz são conhecidos para o usuário e
     armazenados sob o nome global 'listeigvals'.  'listeigvals' poderá
     ser escolhido para uma lista similar à saída de 'eigenvalues'.

     A função 'algsys' é usada aqui para resolver em relação aos
     autovetores.  Algumas vezes se os autovalores estão ausêntes,
     'algsys' pode não estar habilitado a achar uma solução.  Em alguns
     casos, isso pode ser possível para simplificar os autovalores por
     primeiro achando e então usando o comando 'eigenvalues' e então
     usando outras funções para reduzir os autovalores a alguma coisa
     mais simples.  Continuando a simplificação, 'eigenvectors' pode ser
     chamada novamente com o sinalizador 'knowneigvals' escolhido para
     'true'.

 -- Função: ematrix (<m>, <n>, <x>, <i>, <j>)
     Retorna uma matriz <m> por <n>, todos os elementos da qual são zero
     exceto para o elemento '[<i>, <j>]' que é <x>.

 -- Função: entermatrix (<m>, <n>)
     Retorna uma matriz <m> por <n>, lendo os elementos interativamente.

     Se <n> é igual a <m>, Maxima pergunta pelo tipo de matriz
     (diagonal, simétrica, antisimétrica, ou genérica) e por cada
     elemento.  Cada resposta é terminada por um ponto e vírgula ';' ou
     sinal de dólar '$'.

     Se <n> não é igual a <m>, Maxima pergunta por cada elemento.

     Os elementos podem ser quaisquer expressões, que são avaliadas.
     'entermatrix' avalia seus argumentos.

          (%i1) n: 3$
          (%i2) m: entermatrix (n, n)$

          Is the matriz  1.  Diagonal  2.  Symmetric  3.  Antisymmetric  4.  General
          Answer 1, 2, 3 or 4 :
          1$
          Row 1 Column 1:
          (a+b)^n$
          Row 2 Column 2:
          (a+b)^(n+1)$
          Row 3 Column 3:
          (a+b)^(n+2)$

          Matriz entered.
          (%i3) m;
                          [        3                     ]
                          [ (b + a)      0         0     ]
                          [                              ]
          (%o3)           [                  4           ]
                          [    0      (b + a)      0     ]
                          [                              ]
                          [                            5 ]
                          [    0         0      (b + a)  ]

 -- Função: genmatrix (<a>, <i_2>, <j_2>, <i_1>, <j_1>)
 -- Função: genmatrix (<a>, <i_2>, <j_2>, <i_1>)
 -- Função: genmatrix (<a>, <i_2>, <j_2>)
     Retorna uma matriz gerada de <a>, pegando o elemento
     '<a>[<i_1>,<j_1>]' como o elemento do canto superior esquerdo e
     '<a>[<i_2>,<j_2>]' como o elemento do canto inferior direto da
     matriz.  Aqui <a> é um array declarado (criado através de 'array'
     mas não por meio de 'make_array') ou um array não declarado, ou uma
     função array, ou uma expressão lambda de dois argumentos.  (Uma
     funçãO array é criado como outras funções com ':=' ou 'define', mas
     os argumentos são colocados entre colchêtes em lugar de
     parêntesis.)

     Se <j_1> é omitido, isso é assumido ser igual a <i_1>.  Se ambos
     <j_1> e <i_1> são omitidos, ambos são assumidos iguais a 1.

     Se um elemento selecionado 'i,j' de um array for indefinido, a
     matriz conterá um elemento simbólico '<a>[i,j]'.

     Exemplos:

          (%i1) h [i, j] := 1 / (i + j - 1);
                                              1
          (%o1)                  h     := ---------
                                  i, j    i + j - 1
          (%i2) genmatrix (h, 3, 3);
                                     [    1  1 ]
                                     [ 1  -  - ]
                                     [    2  3 ]
                                     [         ]
                                     [ 1  1  1 ]
          (%o2)                      [ -  -  - ]
                                     [ 2  3  4 ]
                                     [         ]
                                     [ 1  1  1 ]
                                     [ -  -  - ]
                                     [ 3  4  5 ]
          (%i3) array (a, fixnum, 2, 2);
          (%o3)                           a
          (%i4) a [1, 1] : %e;
          (%o4)                          %e
          (%i5) a [2, 2] : %pi;
          (%o5)                          %pi
          (%i6) genmatrix (a, 2, 2);
                                     [ %e   0  ]
          (%o6)                      [         ]
                                     [ 0   %pi ]
          (%i7) genmatrix (lambda ([i, j], j - i), 3, 3);
                                   [  0    1   2 ]
                                   [             ]
          (%o7)                    [ - 1   0   1 ]
                                   [             ]
                                   [ - 2  - 1  0 ]
          (%i8) genmatrix (B, 2, 2);
                                  [ B      B     ]
                                  [  1, 1   1, 2 ]
          (%o8)                   [              ]
                                  [ B      B     ]
                                  [  2, 1   2, 2 ]

 -- Função: gramschmidt (<x>)
 -- Função: gschmit (<x>)
     Realiza o algorítmo de ortonalização de Gram-Schmidt sobre <x>,
     seja ela uma matriz ou uma lista de listas.  <x> não é modificado
     por 'gramschmidt'.

     Se <x> é uma matriz, o algorítmo é aplicado para as linhas de <x>.
     Se <x> é uma lista de listas, o algorítmo é aplicado às sublistas,
     que devem ter igual números de elementos.  Nos dois casos, o valor
     de retorno é uma lista de listas, as sublistas das listas são
     ortogonais e gera o mesmo spaço que <x>.  Se a dimensão do conjunto
     gerador de <x> é menor que o número de linhas ou sublistas, algumas
     sublistas do valor de retorno são zero.

     'factor' é chamada a cada estágio do algorítmo para simplificar
     resultados intermediários.  Como uma conseqüência, o valor de
     retorno pode conter inteiros fatorados.

     'gschmit' (nota ortográfica) é um sinônimo para 'gramschmidt'.

     'load ("eigen")' chama essa função.

     Exemplo:

          (%i1) load ("eigen")$
          Warning - you are redefining the Macsyma function autovalores
          Warning - you are redefining the Macsyma function autovetores
          (%i2) x: matrix ([1, 2, 3], [9, 18, 30], [12, 48, 60]);
                                   [ 1   2   3  ]
                                   [            ]
          (%o2)                    [ 9   18  30 ]
                                   [            ]
                                   [ 12  48  60 ]
          (%i3) y: gramschmidt (x);
                                 2      2            4     3
                                3      3   3 5      2  3  2  3
          (%o3)  [[1, 2, 3], [- ---, - --, ---], [- ----, ----, 0]]
                                2 7    7   2 7       5     5
          (%i4) i: innerproduct$
          (%i5) [i (y[1], y[2]), i (y[2], y[3]), i (y[3], y[1])];
          (%o5)                       [0, 0, 0]

 -- Função: ident (<n>)
     Retorna uma matriz identidade <n> por <n>.

 -- Função: innerproduct (<x>, <y>)
 -- Função: inprod (<x>, <y>)
     Retorna o produto interno (também chamado produto escalar ou
     produto do ponto) de <x> e <y>, que são listas de igual
     comprimento, ou ambas matrizes 1-coluna ou 1-linha de igual
     comprimento.  O valor de retorno é 'conjugate (x) . y', onde '.' é
     o operador de multiplicação não comutativa.

     'load ("eigen")' chama essa função.

     'inprod' é um sinônimo para 'innerproduct'.

 -- Função: invert (<M>)
     Retorna a inversa da matriz <M>.  A inversa é calculada pelo método
     adjunto.

     Isso permite a um usuário calcular a inversa de uma matriz com
     entradas bfloat ou polinômios com coeficientes em ponto flutuante
     sem converter para a forma CRE.

     Cofatores são calculados pela função 'determinant', então se
     'ratmx' é 'false' a inversa é calculada sem mudar a representação
     dos elementos.

     A implementação corrente é ineficiente para matrizes de alta ordem.

     Quando 'detout' é 'true', o determinante é fatorado fora da
     inversa.

     Os elementos da inversa não são automaticamente expandidos.  Se <M>
     tem elementos polinomiais, melhor aparência de saída pode ser
     gerada por 'expand (invert (m)), detout'.  Se isso é desejável para
     ela divisão até pelo determinante pode ser excelente por 'xthru
     (%)' ou alternativamente na unha por

          expe (adjoint (m)) / expand (determinant (m))
          invert (m) := adjoint (m) / determinant (m)

     Veja '^^' (expoente não comutativo) para outro método de inverter
     uma matriz.

 -- Variável de opção: lmxchar
     Valor padrão: '['

     'lmxchar' é o caractere mostrado como o delimitador esquerdo de uma
     matriz.  Veja também 'rmxchar'.

     Exemplo:

          (%i1) lmxchar: "|"$
          (%i2) matrix ([a, b, c], [d, e, f], [g, h, i]);
                                     | a  b  c ]
                                     |         ]
          (%o2)                      | d  e  f ]
                                     |         ]
                                     | g  h  i ]

 -- Função: matrix (<row_1>, ..., <row_n>)
     Retorna uma matriz retangular que tem as linhas <row_1>, ...,
     <row_n>.  Cada linha é uma lista de expressões.  Todas as linhas
     devem ter o mesmo comprimento.

     As operações '+' (adição), '-' (subtração), '*' (multiplicação), e
     '/' (divisão), são realizadas elemento por elemento quando os
     operandos são duas matrizes, um escalar e uma matriz, ou uma matriz
     e um escalar.  A operação '^' (exponenciação, equivalentemente
     '**') é realizada elemento por elemento se os operandos são um
     escalar e uma matriz ou uma matriz e um escalar, mas não se os
     operandos forem duas matrizes.  Todos as operações são normalmente
     realizadas de forma completa, incluindo '.' (multiplicação não
     comutativa).

     Multiplicação de matrizes é representada pelo operador de
     multiplicação não comutativa '.'.  O correspondente operador de
     exponenciação não comutativa é '^^'.  Para uma matriz '<A>',
     '<A>.<A> = <A>^^2' e '<A>^^-1' é a inversa de <A>, se existir.

     Existem comutadores para controlar a simplificação de expresões
     envolvendo operações escalar e matriz-lista.  São eles
     'doallmxops', 'domxexpt' 'domxmxops', 'doscmxops', e 'doscmxplus'.

     Existem opções adicionais que são relacionadas a matrizes.  São
     elas: 'lmxchar', 'rmxchar', 'ratmx', 'listarith', 'detout',
     'scalarmatrix', e 'sparse'.

     Existe um número de funções que pegam matrizes como argumentos ou
     devolvem matrizes como valor de retorno.  Veja 'eigenvalues',
     'eigenvectors', 'determinant', 'charpoly', 'genmatrix', 'addcol',
     'addrow', 'copymatrix', 'transpose', 'echelon', e 'rank'.

     Exemplos:

        * Construção de matrizes de listas.
          (%i1) x: matrix ([17, 3], [-8, 11]);
                                     [ 17   3  ]
          (%o1)                      [         ]
                                     [ - 8  11 ]
          (%i2) y: matrix ([%pi, %e], [a, b]);
                                     [ %pi  %e ]
          (%o2)                      [         ]
                                     [  a   b  ]
        * Adição, elemento por elemento.
          (%i3) x + y;
                                [ %pi + 17  %e + 3 ]
          (%o3)                 [                  ]
                                [  a - 8    b + 11 ]
        * Subtração, elemento por elemento.
          (%i4) x - y;
                                [ 17 - %pi  3 - %e ]
          (%o4)                 [                  ]
                                [ - a - 8   11 - b ]
        * Multiplicação, elemento por elemento.
          (%i5) x * y;
                                  [ 17 %pi  3 %e ]
          (%o5)                   [              ]
                                  [ - 8 a   11 b ]
        * Divisão, elemento por elemento.
          (%i6) x / y;
                                  [ 17       - 1 ]
                                  [ ---  3 %e    ]
                                  [ %pi          ]
          (%o6)                   [              ]
                                  [   8    11    ]
                                  [ - -    --    ]
                                  [   a    b     ]
        * Matriz para um expoente escalar, elemento por elemento.
          (%i7) x ^ 3;
                                   [ 4913    27  ]
          (%o7)                    [             ]
                                   [ - 512  1331 ]
        * Base escalar para um expoente matriz, elemento por elemento.
          (%i8) exp(y);
                                   [   %pi    %e ]
                                   [ %e     %e   ]
          (%o8)                    [             ]
                                   [    a     b  ]
                                   [  %e    %e   ]
        * Base matriz para um expoente matriz.  Essa não é realizada
          elemento por elemento.
          (%i9) x ^ y;
                                          [ %pi  %e ]
                                          [         ]
                                          [  a   b  ]
                               [ 17   3  ]
          (%o9)                [         ]
                               [ - 8  11 ]
        * Multiplicação não comutativa de matrizes.
          (%i10) x . y;
                            [ 3 a + 17 %pi  3 b + 17 %e ]
          (%o10)            [                           ]
                            [ 11 a - 8 %pi  11 b - 8 %e ]
          (%i11) y . x;
                          [ 17 %pi - 8 %e  3 %pi + 11 %e ]
          (%o11)          [                              ]
                          [  17 a - 8 b     11 b + 3 a   ]
        * Exponenciação não comutativa de matrizes.  Uma base escalar
          <b> para uma potência matriz <M> é realizada elemento por
          elemento e então 'b^^m' é o mesmo que 'b^m'.
          (%i12) x ^^ 3;
                                  [  3833   1719 ]
          (%o12)                  [              ]
                                  [ - 4584  395  ]
          (%i13) %e ^^ y;
                                   [   %pi    %e ]
                                   [ %e     %e   ]
          (%o13)                   [             ]
                                   [    a     b  ]
                                   [  %e    %e   ]
        * A matriz elevada a um expoente -1 com exponenciação não
          comutativa é a matriz inversa, se existir.
          (%i14) x ^^ -1;
                                   [ 11      3  ]
                                   [ ---  - --- ]
                                   [ 211    211 ]
          (%o14)                   [            ]
                                   [  8    17   ]
                                   [ ---   ---  ]
                                   [ 211   211  ]
          (%i15) x . (x ^^ -1);
                                      [ 1  0 ]
          (%o15)                      [      ]
                                      [ 0  1 ]

 -- Função: matrixmap (<f>, <M>)
     Retorna uma matriz com elemento 'i,j' igual a '<f>(<M>[i,j])'.

     Veja também 'map', 'fullmap', 'fullmapl', e 'apply'.

 -- Função: matrixp (<expr>)
     Retorna 'true' se <expr> é uma matriz, de outra forma retorna
     'false'.

 -- Variável de opção: matrix_element_add
     Valor padrão: '+'

     'matrix_element_add' é a operação invocada em lugar da adição em
     uma multiplicação de matrizes.  A 'matrix_element_add' pode ser
     atribuído qualquer operador n-ário (que é, uma função que manuseia
     qualquer número de argumentos).  Os valores atribuídos podem ser o
     nome de um operador entre aspas duplas, o nome da função, ou uma
     expressão lambda.

     Veja também 'matrix_element_mult' e 'matrix_element_transpose'.

     Exemplo:

          (%i1) matrix_element_add: "*"$
          (%i2) matrix_element_mult: "^"$
          (%i3) aa: matrix ([a, b, c], [d, e, f]);
                                     [ a  b  c ]
          (%o3)                      [         ]
                                     [ d  e  f ]
          (%i4) bb: matrix ([u, v, w], [x, y, z]);
                                     [ u  v  w ]
          (%o4)                      [         ]
                                     [ x  y  z ]
          (%i5) aa . transpose (bb);
                               [  u  v  w   x  y  z ]
                               [ a  b  c   a  b  c  ]
          (%o5)                [                    ]
                               [  u  v  w   x  y  z ]
                               [ d  e  f   d  e  f  ]

 -- Variável de opção: matrix_element_mult
     Valor padrão: '*'

     'matrix_element_mult' é a operação invocada em lugar da
     multiplicação em uma multiplicação de matrizes.  A
     'matrix_element_mult' pode ser atribuído qualquer operador binário.
     O valor atribuído pode ser o nome de um operador entre aspas
     duplas, o nome de uma função, ou uma expressão lambda.

     O operador do ponto '.' é uma escolha útil em alguns contextos.

     Veja também 'matrix_element_add' e 'matrix_element_transpose'.

     Exemplo:

          (%i1) matrix_element_add: lambda ([[x]], sqrt (apply ("+", x)))$
          (%i2) matrix_element_mult: lambda ([x, y], (x - y)^2)$
          (%i3) [a, b, c] . [x, y, z];
                                    2          2          2
          (%o3)         sqrt((c - z)  + (b - y)  + (a - x) )
          (%i4) aa: matrix ([a, b, c], [d, e, f]);
                                     [ a  b  c ]
          (%o4)                      [         ]
                                     [ d  e  f ]
          (%i5) bb: matrix ([u, v, w], [x, y, z]);
                                     [ u  v  w ]
          (%o5)                      [         ]
                                     [ x  y  z ]
          (%i6) aa . transpose (bb);
                         [             2          2          2  ]
                         [ sqrt((c - w)  + (b - v)  + (a - u) ) ]
          (%o6)  Col 1 = [                                      ]
                         [             2          2          2  ]
                         [ sqrt((f - w)  + (e - v)  + (d - u) ) ]

                                   [             2          2          2  ]
                                   [ sqrt((c - z)  + (b - y)  + (a - x) ) ]
                           Col 2 = [                                      ]
                                   [             2          2          2  ]
                                   [ sqrt((f - z)  + (e - y)  + (d - x) ) ]

 -- Variável de opção: matrix_element_transpose
     Valor padrão: 'false'

     'matrix_element_transpose' é a operação aplicada a cada elemento de
     uma matriz quando for uma transposta.  A 'matrix_element_mult' pode
     ser atribuído qualquer operador unário.  O valor atribuído pode ser
     nome de um operador entre aspas duplas, o nome de uma função, ou
     uma expressão lambda.

     Quando 'matrix_element_transpose' for igual a 'transpose', a função
     'transpose' é aplicada a todo elemento.  Quando
     'matrix_element_transpose' for igual a 'nonscalars', a função
     'transpose' é aplicada a todo elemento não escalar.  Se algum
     elemento é um átomo, a opção 'nonscalars' aplica 'transpose'
     somente se o átomo for declarado não escalar, enquanto a opção
     'transpose' sempre aplica 'transpose'.

     O valor padrão, 'false', significa nenhuma operação é aplicada.

     Veja também 'matrix_element_add' e 'matrix_element_mult'.

     Exemplos:

          (%i1) declare (a, nonscalar)$
          (%i2) transpose ([a, b]);
                                  [ transpose(a) ]
          (%o2)                   [              ]
                                  [      b       ]
          (%i3) matrix_element_transpose: nonscalars$
          (%i4) transpose ([a, b]);
                                  [ transpose(a) ]
          (%o4)                   [              ]
                                  [      b       ]
          (%i5) matrix_element_transpose: transpose$
          (%i6) transpose ([a, b]);
                                  [ transpose(a) ]
          (%o6)                   [              ]
                                  [ transpose(b) ]
          (%i7) matrix_element_transpose: lambda ([x], realpart(x) - %i*imagpart(x))$
          (%i8) m: matrix ([1 + 5*%i, 3 - 2*%i], [7*%i, 11]);
                               [ 5 %i + 1  3 - 2 %i ]
          (%o8)                [                    ]
                               [   7 %i       11    ]
          (%i9) transpose (m);
                                [ 1 - 5 %i  - 7 %i ]
          (%o9)                 [                  ]
                                [ 2 %i + 3    11   ]

 -- Função: mattrace (<M>)
     Retorna o traço (que é, a soma dos elementos sobre a diagonal
     principal) da matriz quadrada <M>.

     'mattrace' é chamada por 'ncharpoly', uma alternativa para
     'charpoly' do Maxima.

     'load ("nchrpl")' chama essa função.

 -- Função: minor (<M>, <i>, <j>)
     Retorna o <i>, <j> menor do elemento localizado na linha <i> coluna
     <j> da matriz <M>.  Que é <M> com linha <i> e coluna <j> ambas
     removidas.

 -- Função: ncexpt (<a>, <b>)
     Se uma expressão exponencial não comutativa é muito alta para ser
     mostrada como '<a>^^<b>' aparecerá como 'ncexpt (<a>,<b>)'.

     'ncexpt' não é o nome de uma função ou operador; o nome somente
     aparece em saídas, e não é reconhecido em entradas.

 -- Função: ncharpoly (<M>, <x>)
     Retorna o polinômio característico da matriz <M> com relação a <x>.
     Essa é uma alternativa para 'charpoly' do Maxima.

     'ncharpoly' trabalha pelo cálculo dos traços das potências na dada
     matriz, que são sabidos serem iguais a somas de potências das
     raízes do polinômio característico.  Para essas quantidade a função
     simétrica das raízes pode ser calculada, que nada mais são que os
     coeficientes do polinômio característico.  'charpoly' trabalha
     formatando o determinante de '<x> * ident [n] - a'.  Dessa forma
     'ncharpoly' é vencedor, por exemplo, no caso de largas e densas
     matrizes preencidas com inteiros, desde que isso evite inteiramente
     a aritmética polinomial.

     'load ("nchrpl")' loads this file.

 -- Função: newdet (<M>, <n>)
     Calcula o determinante de uma matriz ou array <M> pelo algorítmo da
     árvore menor de Johnson-Gentleman.  O argumento <n> é a ordem; isso
     é opcional se <M> for uma matriz.

 -- Declaração: nonscalar
     Faz átomos ser comportarem da mesma forma que uma lista ou matriz
     em relação ao operador do ponto.

 -- Função: nonscalarp (<expr>)
     Retorna 'true' se <expr> é um não escalar, i.e., isso contém átomos
     declarados como não escalares, listas, ou matrizes.

 -- Função: permanent (<M>, <n>)
     Calcula o permanente da matriz <M>.  Um permanente é como um
     determinante mas sem mudança de sinal.

 -- Função: rank (<M>)
     Calcula o posto da matriz <M>.  Que é, a ordem do mais largo
     determinante não singular de <M>.

     <rank> pode retornar uma resposta ruim se não puder determinar que
     um elemento da matriz que é equivalente a zero é realmente isso.

 -- Variável de opção: ratmx
     Valor padrão: 'false'

     Quando 'ratmx' é 'false', adição, subtração, e multiplicação para
     determinantes e matrizes são executados na representação dos
     elementos da matriz e fazem com que o resultado da inversão de
     matrizes seja esquerdo na representação geral.

     Quando 'ratmx' é 'true', as 4 operações mencionadas acima são
     executadas na forma CRE e o resultado da matriz inversa é dado na
     forma CRE. Note isso pode fazer com que os elementos sejam
     expandidos (dependendo da escolha de 'ratfac') o que pode não ser
     desejado sempre.

 -- Função: row (<M>, <i>)
     retorna a <i>'ésima linha da matriz <M>.  O valor de retorno é uma
     matriz.

 -- Variável de opção: scalarmatrixp
     Valor padrão: 'true'

     Quando 'scalarmatrixp' é 'true', então sempre que uma matriz 1 x 1
     é produzida como um resultado de cálculos o produto do ponto de
     matrizes é simplificado para um escalar, a saber o elemento
     solitário da matriz.

     Quando 'scalarmatrixp' é 'all', então todas as matrizes 1 x 1 serão
     simplificadas para escalares.

     Quando 'scalarmatrixp' é 'false', matrizes 1 x 1 não são
     simplificadas para escalares.

 -- Função: scalefactors (<coordinatetransform>)
     Aqui coordinatetransform avalia para a forma [[expresão1,
     expresão2, ...], indeterminação1, indeterminação2, ...], onde
     indeterminação1, indeterminação2, etc.  são as variáveis de
     coordenadas curvilíneas e onde a escolha de componentes cartesianas
     retangulares é dada em termos das coordenadas curvilíneas por
     [expresão1, expresão2, ...].  'coordinates' é escolhida para o
     vetor [indeterminação1, indeterminação2,...], e 'dimension' é
     escolhida para o comprimento desse vetor.  SF[1], SF[2], ...,
     SF[DIMENSION] são escohidos para fatores de escala de coordenada, e
     'sfprod' é escohido para o produto desse fatores de escala.
     Inicialmente, 'coordinates' é [X, Y, Z], 'dimension' é 3, e
     SF[1]=SF[2]=SF[3]=SFPROD=1, correspondendo a coordenadas
     Cartesianas retangulares 3-dimensional.  Para expandir uma expresão
     dentro de componentes físicos no sistema de coordenadas corrente ,
     existe uma função com uso da forma

 -- Função: setelmx (<x>, <i>, <j>, <M>)
     Atribue <x> para o (<i>, <j>)'ésimo elemento da matriz <M>, e
     retorna a matriz alterada.

     '<M> [<i>, <j>]: <x>' tem o mesmo efeito, mas retorna <x> em lugar
     de <M>.

 -- Função: similaritytransform (<M>)
 -- Função: simtran (<M>)
     'similaritytransform' calcula uma transformação homotética da
     matriz 'M'.  Isso retorna uma lista que é a saída do comando
     'uniteigenvectors'.  Em adição se o sinalizador 'nondiagonalizable'
     é 'false' duas matrizes globais 'leftmatrix' e 'rightmatrix' são
     calculadas.  Essas matrizes possuem a propriedade de 'leftmatrix .
     <M> . rightmatrix' é uma matriz diagonal com os autovalores de <M>
     sobre a diagonal.  Se 'nondiagonalizable' é 'true' as matrizes
     esquerda e direita não são computadas.

     Se o sinalizador 'hermitianmatrix' é 'true' então 'leftmatrix' é o
     conjugado complexo da transposta de 'rightmatrix'.  De outra forma
     'leftmatrix' é a inversa de 'rightmatrix'.

     'rightmatrix' é a matriz cujas colunas são os autovetores unitários
     de <M>.  Os outros sinalizadores (veja 'eigenvalues' e
     'eigenvectors') possuem o mesmo efeito desde que
     'similaritytransform' chama as outras funções no pacote com o
     objetivo de estar habilitado para a forma 'rightmatrix'.

     'load ("eigen")' chama essa função.

     'simtran' é um sinônimo para 'similaritytransform'.

 -- Variável de opção: sparse
     Valor padrão: 'false'

     Quando 'sparse' é 'true', e se 'ratmx' é 'true', então
     'determinant' usará rotinas especiais para calcular determinantes
     esparsos.

 -- Função: submatrix (<i_1>, ..., <i_m>, <M>, <j_1>, ..., <j_n>)
 -- Função: submatrix (<i_1>, ..., <i_m>, <M>)
 -- Função: submatrix (<M>, <j_1>, ..., <j_n>)
     Retorna uma nova matriz formada pela matrix <M> com linhas <i_1>,
     ..., <i_m> excluídas, e colunas <j_1>, ..., <j_n> excluídas.

 -- Função: transpose (<M>)
     Retorna a transposta de <M>.

     Se <M> é uma matriz, o valor de retorno é outra matriz <N> tal que
     'N[i,j] = M[j,i]'.

     Se <M> for uma lista, o valor de retorno é uma matrix <N> de
     'length (m)' linhas e 1 coluna, tal que 'N[i,1] = M[i]'.

     De outra forma <M> é um símbolo, e o valor de retorno é uma
     expressão substantiva ''transpose (<M>)'.

 -- Função: triangularize (<M>)
     Retorna a maior forma triangular da matriz 'M', como produzido
     através da eliminação de Gauss.  O valor de retorno é o mesmo que
     'echelon', exceto que o o coeficiente lider não nulo em cada linha
     não é normalizado para 1.

     'lu_factor' e 'cholesky' são outras funções que retornam matrizes
     triangularizadas.

          (%i1) M: matrix ([3, 7, aa, bb], [-1, 8, 5, 2], [9, 2, 11, 4]);
                                 [  3   7  aa  bb ]
                                 [                ]
          (%o1)                  [ - 1  8  5   2  ]
                                 [                ]
                                 [  9   2  11  4  ]
          (%i2) triangularize (M);
                       [ - 1   8         5            2      ]
                       [                                     ]
          (%o2)        [  0   - 74     - 56         - 22     ]
                       [                                     ]
                       [  0    0    626 - 74 aa  238 - 74 bb ]

 -- Função: uniteigenvectors (<M>)
 -- Função: ueivects (<M>)
     Calcula autovetores unitários da matriz <M>.  O valor de retorno é
     uma lista de listas, a primeiro sublista é a saída do comando
     'eigenvalues', e as outras sublistas são os autovetores unitários
     da matriz correspondente a esses autovalores respectivamente.

     Os sinalizadores mencionados na descrição do comando 'eigenvectors'
     possuem o mesmo efeito aqui também.

     Quando 'knowneigvects' é 'true', o pacote 'eigen' assume que os
     autovetores da matriz são conhecidos para o usuário são armazenados
     sob o nome global 'listeigvects'.  'listeigvects' pode ser ecolhido
     para uma lista similar à saída do comando 'eigenvectors'.

     Se 'knowneigvects' é escolhido para 'true' e a lista de autovetores
     é dada a escolha do sinalizador 'nondiagonalizable' pode não estar
     correta.  Se esse é o caso por favor ecolha isso para o valor
     correto.  O autor assume que o usuário sabe o que está fazendo e
     que não tentará diagonalizar uma matriz cujos autovetores não geram
     o mesmo espaço vetorial de dimensão apropriada.

     'load ("eigen")' chama essa função.

     'ueivects' é um sinônimo para 'uniteigenvectors'.

 -- Função: unitvector (<x>)
 -- Função: uvect (<x>)
     Retorna <x>/norm(<x>); isso é um vetor unitário na mesma direção
     que <x>.

     'load ("eigen")' chama essa função.

     'uvect' é um sinônimo para 'unitvector'.

 -- Função: vectorsimp (<expr>)
     Aplica simplificações e expansões conforme os seguintes
     sinalizadores globais:

     'expandall', 'expanddot', 'expanddotplus', 'expandcross',
     'expandcrossplus', 'expandcrosscross', 'expandgrad',
     'expandgradplus', 'expandgradprod', 'expanddiv', 'expanddivplus',
     'expanddivprod', 'expandcurl', 'expandcurlplus', 'expandcurlcurl',
     'expandlaplacian', 'expandlaplacianplus', e 'expandlaplacianprod'.

     Todos esses sinalizadores possuem valor padrão 'false'.  O sufixo
     'plus' refere-se a utilização aditivamente ou distribuitivamente.
     O sufixo 'prod' refere-se a expansão para um operando que é
     qualquer tipo de produto.

     'expandcrosscross'
          Simplifica p ~ (q ~ r) para (p . r)*q - (p . q)*r.
     'expandcurlcurl'
          Simplifica curl curl p para grad div p + div grad p.
     'expandlaplaciantodivgrad'
          Simplifica laplacian p para div grad p.
     'expandcross'
          Habilita 'expandcrossplus' e 'expandcrosscross'.
     'expandplus'
          Habilita 'expanddotplus', 'expandcrossplus', 'expandgradplus',
          'expanddivplus', 'expandcurlplus', e 'expandlaplacianplus'.
     'expandprod'
          Habilita 'expandgradprod', 'expanddivprod', e
          'expandlaplacianprod'.

     Esses sinalizadores foram todos declarados 'evflag'.

 -- Variável de opção: vect_cross
     Valor padrão: 'false'

     Quando 'vect_cross' é 'true', isso permite DIFF(X~Y,T) trabalhar
     onde ~ é definido em SHARE;VECT (onde VECT_CROSS é escolhido para
     'true', de qualqeur modo.)

 -- Função: zeromatrix (<m>, <n>)
     Retorna um matriz <m> por <n>, com todos os elementos sendo zero.

 -- Símbolo especial: [
 -- Símbolo especial: ]
     '[' e ']' marcam o omeço e o fim, respectivamente, de uma lista.

     '[' e ']' também envolvem os subscritos de uma lista, array, array
     desordenado, ou função array.

     Exemplos:

          (%i1) x: [a, b, c];
          (%o1)                       [a, b, c]
          (%i2) x[3];
          (%o2)                           c
          (%i3) array (y, fixnum, 3);
          (%o3)                           y
          (%i4) y[2]: %pi;
          (%o4)                          %pi
          (%i5) y[2];
          (%o5)                          %pi
          (%i6) z['foo]: 'bar;
          (%o6)                          bar
          (%i7) z['foo];
          (%o7)                          bar
          (%i8) g[k] := 1/(k^2+1);
                                            1
          (%o8)                     g  := ------
                                     k     2
                                          k  + 1
          (%i9) g[10];
                                          1
          (%o9)                          ---
                                         101


File: maxima.info,  Node: Funções Afins,  Next: itensor,  Prev: Matrizes e Álgebra Linear,  Up: Top

26 Funções Afins
****************

* Menu:

* Funções e Variáveis Definidas para Funções Afins::


File: maxima.info,  Node: Funções e Variáveis Definidas para Funções Afins,  Prev: Funções Afins,  Up: Funções Afins

26.1 Funções e Variáveis Definidas para Funções Afins
=====================================================

 -- Função: fast_linsolve ([<expr_1>, ..., <expr_m>], [<x_1>, ...,
          <x_n>])
     Resolve equações lineares simultâneas <expr_1>, ..., <expr_m> para
     as variáveis <x_1>, ..., <x_n>.  Cada <expr_i> pode ser uma equação
     ou uma expressão geral; se dada como uma expressão geral, ela
     tratada como uma equação na forma '<expr_i> = 0'.

     O valor de retorno é uma lista de equações da forma '[<x_1> =
     <a_1>, ..., <x_n> = <a_n>]' onde <a_1>, ..., <a_n> são todas livres
     de <x_1>, ..., <x_n>.

     'fast_linsolve' é mais rápido que 'linsolve' para sistemas de
     equações que são esparsas.

     Para usar essa função escreva primeiramente 'load(affine)'.

 -- Função: grobner_basis ([<expr_1>, ..., <expr_m>])
     Retorna uma base de Groebner para as equações <expr_1>, ...,
     <expr_m>.  A funçã 'polysimp' pode então ser usada para simplificar
     outras funções relativas às equações.

          grobner_basis ([3*x^2+1, y*x])$

          polysimp (y^2*x + x^3*9 + 2) ==> -3*x + 2

     'polysimp(f)' produz 0 se e somente se <f> está no ideal gerado por
     <expr_1>, ..., <expr_m>, isto é, se e somente se <f> for uma
     combinação polinomial dos elementos de <expr_1>, ..., <expr_m>.

     Para usar essa função escreva primeiramente 'load(affine)'.

 -- Função: set_up_dot_simplifications (<eqns>, <check_through_degree>)
 -- Função: set_up_dot_simplifications (<eqns>)
     As <eqns> são equações polinomiais em variáveis não comutativas.  O
     valor de 'current_variables' é uma lista de variáveis usadas para
     calcular graus.  As equações devem ser homogêneas, com o objetivo
     de que o procedimento termine.

     Se você checou simplificações de envoltório em
     'dot_simplifications' acima do grau de <f>, então o seguinte é
     verdadeiro: 'dotsimp (<f>)' retorna 0 se e somente se <f> está no
     ideal gerado pelas equações, i.e., se e somente se <f> for uma
     combinação polinomial dos elementos das equações.

     O grau é aquele retornado por 'nc_degree'.  Isso por sua vez é
     nfluenciado pelos pesos das variáveis individuais.

     Para usar essa função escreva primeiramente 'load(affine)'.

 -- Função: declare_weights (<x_1>, <w_1>, ..., <x_n>, <w_n>)
     Atribui pesos <w_1>, ..., <w_n> to <x_1>, ..., <x_n>,
     respectivamente.  Esses são pesos usados em cálculos 'nc_degree'.

     Para usar essa função escreva primeiramente 'load(affine)'.

 -- Função: nc_degree (<p>)
     Retorna o grau de um polinômio não comutativo <p>.  Veja
     'declare_weights'.

     Para usar essa função escreva primeiramente 'load(affine)'.

 -- Função: dotsimp (<f>)
     Retorna 0 se e somente se <f> for um ideal gerado pelas equações,
     i.e., se e somente se <f> for uma combinação polinomial dos
     elementos das equações.

     Para usar essa função escreva primeiramente 'load(affine)'.

 -- Função: fast_central_elements ([<x_1>, ..., <x_n>], <n>)
     Se 'set_up_dot_simplifications' tiver sido feito previamente, ache
     o polinômio central nas variáveis <x_1>, ..., <x_n> no grau dado,
     <n>.

     Por exemplo:
          set_up_dot_simplifications ([y.x + x.y], 3);
          fast_central_elements ([x, y], 2);
          [y.y, x.x];

     Para usar essa função escreva primeiramente 'load(affine)'.

 -- Função: check_overlaps (<n>, <add_to_simps>)
     Verifica as sobreposies através do grau <n>, tendo certeza que você
     tem regras de simplificaçõ suficiente em cada grau, para 'dotsimp'
     trabalhar corretamente.  Esse processo pode ter sua velocidade
     aumentada se você souber antes de começar souber de qual dimensão
     do espaço de monômios é.  Se ele for de dimensão global finita,
     então 'hilbert' pode ser usada.  Se você não conhece as dimensões
     monomiais, não especifique um 'rank_function'.  Um opcional
     terceiro argumento 'reset', 'false' diz para não se incomodar em
     perguntar sobre resetar coisas.

     Para usar essa função escreva primeiramente 'load(affine)'.

 -- Função: mono ([<x_1>, ..., <x_n>], <n>)
     Retorna a lista de monômios independentes relativamente à
     simplificação atual do grau <n> nas variáveis <x_1>, ..., <x_n>.

     Para usar essa função escreva primeiramente 'load(affine)'.

 -- Função: monomial_dimensions (<n>)
     Calcula a série de Hilbert através do grau <n> para a algebra
     corrente.

     Para usar essa função escreva primeiramente 'load(affine)'.

 -- Função: extract_linear_equations ([<p_1>, ..., <p_n>], [<m_1>, ...,
          <m_n>])

     Faz uma lista dos coeficientes dos polinômios não comutativos
     <p_1>, ..., <p_n> dos monomios não comutatvos <m_1>, ..., <m_n>.
     Os coeficientes podem ser escalares.  Use 'list_nc_monomials' para
     construir a lista dos monômios.

     Para usar essa função escreva primeiramente 'load(affine)'.

 -- Função: list_nc_monomials ([<p_1>, ..., <p_n>])
 -- Função: list_nc_monomials (<p>)

     Retorna uma lista de monômios não comutativos que ocorrem em um
     polinômio <p> ou em uma lista de polinômios <p_1>, ..., <p_n>.

     Para usar essa função escreva primeiramente 'load(affine)'.

 -- Variável de opção: all_dotsimp_denoms
     Valor padrão: 'false'

     Quando 'all_dotsimp_denoms' é uma lista, os denominadores
     encontrados por 'dotsimp' são adicionados ao final da lista.
     'all_dotsimp_denoms' pode ser iniciado como uma lista vazia '[]'
     antes chamando 'dotsimp'.

     Por padrão, denominadores não são coletados por 'dotsimp'.


File: maxima.info,  Node: itensor,  Next: ctensor,  Prev: Funções Afins,  Up: Top

27 itensor
**********

* Menu:

* Introdução a itensor::
* Funções e Variáveis Definidas para itensor::


File: maxima.info,  Node: Introdução a itensor,  Next: Funções e Variáveis Definidas para itensor,  Prev: itensor,  Up: itensor

27.1 Introdução a itensor
=========================

Maxima implementa a manipulação de tensores simbólicos d dois tipos
distintos: manipulação de componentes de tensores (pacote 'ctensor') e
manipulação de tensores indiciais (pacote 'itensor').

   Note bem: Por favor veja a nota sobre 'nova notação de tensor'
abaixo.

   Manipulação de componentes de tensores significa que objetos do tipo
tensor geométrico são representados como arrays ou matrizes.  Operações
com tensores tais com contração ou diferenciação covariante são
realizadas sobre índices (que ocorrem exatamente duas vezes) repetidos
com declarações 'do'.  Isto é, se executa explicitamente operações sobre
as componentes apropriadas do tensor armazenadas em um array ou uma
matriz.

   Manipulação tensorial de índice é implementada através da
representação de tensores como funções e suas covariantes,
contravariantes e índices de derivação.  Operações com tensores como
contração ou diferenciação covariante são executadas através de
manipulação dos índices em si mesmos em lugar das componentes para as
quais eles correspondem.

   Esses dois métodos aproximam-se do tratamento de processos
diferenciais, algébricos e analíticos no contexto da geometria de
Riemannian possuem várias vantagens e desvantagens as quais se revelam
por si mesmas somente apesar da natureza particular e dificuldade dos
problemas de usuário.  Todavia, se pode ter em mente as seguintes
características das duas implementações:

   As representações de tensores e de operações com tensores
explicitamente em termos de seus componntes tornam o pacote 'ctensor'
fácil de usar.  Especificação da métrica e o cálculo de tensores
induzidos e invariantes é direto.  Embora todas a capacidade de
simplificação poderosa do Maxima está em manusear, uma métrica complexa
com intrincada dependência funcional e de coordenadas pode facilmente
conduzir a expressões cujo tamanho é excessivo e cuja estrutura está
escondida.  Adicionalmente, muitos cálculos envolvem expressões
intermediárias cujo crescimento fazem com que os programas terminem
antes de serem completados.  Através da experiência, um usuário pode
evitar muitas dessas dificuldade.

   O motivo de caminhos especiais através dos quais tensores e operações
de tensores são representados em termos de operações simbólicas sobre
seus índices, expressões cujas representação de componentes podem ser
não gerenciaveis da forma comum podem algumas vezes serem grandemente
simplificadas através do uso das rotinas especiais para objetos
simétricos em 'itensor'.  Nesse caminho a estrutura de uma expressão
grande pode ser mais transparente.  Por outro lado, o motivo da
representação indicial especial em 'itensor', faz com que em alguns
casos o usuário possa encontrar dificuldade com a especificação da
métrica, definição de função, e a avaliação de objetos "indexados"
diferenciados.

27.1.1 Nova notação d tensores
------------------------------

Até agora, o pacote 'itensor' no Maxima tinha usado uma notação que
algumas vezes conduzia a ordenação incorreta de índices.  Considere o
seguinte, por exemplo:

     (%i2) imetric(g);
     (%o2)                                done
     (%i3) ishow(g([],[j,k])*g([],[i,l])*a([i,j],[]))$
                                      i l  j k
     (%t3)                           g    g    a
                                                i j
     (%i4) ishow(contract(%))$
                                           k l
     (%t4)                                a

   O resultado está incorreto a menos que ocorra ser 'a' um tensor
simétrico.  A razão para isso é que embora 'itensor' mantenha
corretamente a ordem dentro do conjunto de índices covariantes e
contravariantes, assim que um índice é incrementado ou decrementado, sua
posição relativa para o outro conjunto de índices é perdida.

   Para evitar esse problema, uma nova notação tem sido desenvolvida que
mantém total compatibilidade com a notação existente e pode ser usada
intercambiavelmente.  Nessa notação, índices contravariantes são
inseridos na posição apropriada na lista de índices covariantes, mas com
um sinal de menos colocado antes.  Funções como 'contract' e 'ishow'
estão agora consciente dessa nova notação de índice e podem processar
tensores apropriadamente.

   Nessa nova notação, o exemplo anterior retorna um resultado correto:

     (%i5) ishow(g([-j,-k],[])*g([-i,-l],[])*a([i,j],[]))$
                                      i l       j k
     (%t5)                           g    a    g
                                           i j
     (%i6) ishow(contract(%))$
                                           l k
     (%t6)                                a

   Presentemente, o único código que faz uso dessa notação é a função
'lc2kdt'.  Através dessa notação, a função 'lc2kdt' encontra com êxito
resultados consistentes como a aplicação do tensor métrico para resolver
os símbolos de Levi-Civita sem reordenar para índices numéricos.

   Uma vez que esse código é um tipo novo, provavelmente contém erros.
Enquanto esse tipo novo não tiver sido testado para garantir que ele não
interrompe nada usando a "antiga" notação de tensor, existe uma
considerável chance que "novos" tensores irão falhar em interoperar com
certas funções ou recursos.  Essas falhas serão corrigidas à medida que
forem encontradas...  até então, seja cuidadoso!

27.1.2 Manipulação de tensores indiciais
----------------------------------------

o pacote de manipulação de tensores indiciais pode ser chamado através
de 'load(itensor)'.  Demonstações estão também disponíveis: tente
'demo(tensor)'.  Em 'itensor' um tensor é representado como um "objeto
indexado" .  Um "objeto indexado" é uma função de 3 grupos de índices os
quais representam o covariante, o contravariante e o índice de
derivação.  Os índices covariantes são especificados através de uma
lista com o primeiro argumento para o objeto indexado, e os índices
contravariantes através de uma lista como segundo argumento.  Se o
objeto indexado carece de algum desses grupos de índices então a lista
vazia '[]' é fornecida como o argumento correspondente.  Dessa forma,
'g([a,b],[c])' representa um objeto indexado chamado 'g' o qual tem dois
índices covariantes '(a,b)', um índice contravariante ('c') e não possui
índices de derivação.

   Os índices de derivação, se estiverem presente, são anexados ao final
como argumentos adicionais para a função numérica representando o
tensor.  Eles podem ser explicitamente especificado pelo usuário ou
serem criados no processo de diferenciação com relação a alguma variável
coordenada.  Uma vez que diferenciação ordinária é comutativa, os
índices de derivação são ordenados alfanumericamente, a menos que
'iframe_flag' seja escolhida para 'true', indicando que uma moldura
métrica está sendo usada.  Essa ordenação canônica torna possível para
Maxima reconhecer que, por exemplo, 't([a],[b],i,j)' é o mesmo que
't([a],[b],j,i)'.  Diferenciação de um objeto indexado com relação a
alguma coordenada cujos índices não aparecem como um argumento para o
objeto indexado podem normalmente retornar zero.  Isso é porque Maxima
pode não saber que o tensor representado através do objeto indexado
possívelmente depende implicitamente da respectiva coordenada.  Pela
modificação da função existente no Maxima, 'diff', em 'itensor', Maxima
sabe assumir que todos os objetos indexados dependem de qualquer
variável de diferenciação a menos que seja declarado de outra forma.
Isso torna possível para a convençào de somatório ser extendida para
índices derivativos.  Pode ser verificado que 'itensor' não possui a
compatibilidade de incrementar índices derivativos, e então eles são
sempre tratados como covariantes.

   As seguintes funções estão disponíveis no pacote tensor para
manipulação de objetos.  Atualmente, com relação às rotinas de
simplificação, é assumido que objetos indexados não possuem por padrão
propriedades simétricas.  Isso pode ser modificado através da escolha da
variável 'allsym[false]' para 'true', o que irá resultar no tratamento
de todos os objetos indexados completamente simétricos em suas listas de
índices covariantes e simétricos em suas listas de índices
contravariantes.

   O pacote 'itensor' geralmente trata tensores como objetos opacos.
Equações tensoriais são manipuladas baseadas em regras algébricas,
especificamente simetria e regras de contração.  Adicionalmente, o
pacote 'itensor' não entende diferenciação covariante, curvatura, e
torsão.  Cálculos podem ser executados relativamente a um métrica de
molduras de movimento, dependendo da escolha para a variável
'iframe_flag'.

   Uma sessão demonstrativa abaixo mostra como chamar o pacote
'itensor', especificando o nome da métrica, e executando alguns cálculos
simples.

     (%i1) load(itensor);
     (%o1)      /share/tensor/itensor.lisp
     (%i2) imetric(g);
     (%o2)                                done
     (%i3) components(g([i,j],[]),p([i,j],[])*e([],[]))$
     (%i4) ishow(g([k,l],[]))$
     (%t4)                               e p
                                            k l
     (%i5) ishow(diff(v([i],[]),t))$
     (%t5)                                  0
     (%i6) depends(v,t);
     (%o6)                               [v(t)]
     (%i7) ishow(diff(v([i],[]),t))$
                                         d
     (%t7)                               -- (v )
                                         dt   i
     (%i8) ishow(idiff(v([i],[]),j))$
     (%t8)                                v
                                           i,j
     (%i9) ishow(extdiff(v([i],[]),j))$
     (%t9)                             v    - v
                                        j,i    i,j
                                       -----------
                                            2
     (%i10) ishow(liediff(v,w([i],[])))$
                                    %3          %3
     (%t10)                        v   w     + v   w
                                        i,%3    ,i  %3
     (%i11) ishow(covdiff(v([i],[]),j))$
                                                   %4
     (%t11)                        v    - v   ichr2
                                    i,j    %4      i j
     (%i12) ishow(ev(%,ichr2))$
                    %4 %5
     (%t12) v    - g      v   (e p       + e   p     - e p       - e    p
             i,j           %4     j %5,i    ,i  j %5      i j,%5    ,%5  i j

                                                     + e p       + e   p    )/2
                                                          i %5,j    ,j  i %5
     (%i13) iframe_flag:true;
     (%o13)                               true
     (%i14) ishow(covdiff(v([i],[]),j))$
                                                  %6
     (%t14)                        v    - v   icc2
                                    i,j    %6     i j
     (%i15) ishow(ev(%,icc2))$
                                                  %6
     (%t15)                        v    - v   ifc2
                                    i,j    %6     i j
     (%i16) ishow(radcan(ev(%,ifc2,ifc1)))$
                  %6 %8                    %6 %8
     (%t16) - (ifg      v   ifb       + ifg      v   ifb       - 2 v
                         %6    j %8 i             %6    i j %8      i,j

                                                         %6 %8
                                                    - ifg      v   ifb      )/2
                                                                %6    %8 i j
     (%i17) ishow(canform(s([i,j],[])-s([j,i])))$
     (%t17)                            s    - s
                                        i j    j i
     (%i18) decsym(s,2,0,[sym(all)],[]);
     (%o18)                               done
     (%i19) ishow(canform(s([i,j],[])-s([j,i])))$
     (%t19)                                 0
     (%i20) ishow(canform(a([i,j],[])+a([j,i])))$
     (%t20)                            a    + a
                                        j i    i j
     (%i21) decsym(a,2,0,[anti(all)],[]);
     (%o21)                               done
     (%i22) ishow(canform(a([i,j],[])+a([j,i])))$
     (%t22)                                 0


File: maxima.info,  Node: Funções e Variáveis Definidas para itensor,  Prev: Introdução a itensor,  Up: itensor

27.2 Funções e Variáveis Definidas para itensor
===============================================

27.2.1 Gerenciando objetos indexados
------------------------------------

 -- Função: entertensor (<nome>)

     É uma função que, através da linha de comando, permite criar um
     objeto indexado chamado <nome> com qualquer número de índices de
     tensores e derivativos.  Ou um índice simples ou uma lista de
     índices (às quais podem ser nulas) são entradas aceitáveis (veja o
     exemplo sob 'covdiff').

 -- Função: changename (<antigo>, <novo>, <expr>)

     Irá mudar o nome de todos os objetos indexados chamados <antigo>
     para <novo> em <expr>.  <antigo> pode ser ou um símbolo ou uma
     lista da forma '[<nome>, <m>, <n>]' nesse caso somente esses
     objetos indexados chamados <nome> com índice covariante <m> e
     índice contravariante <n> serão renomeados para <novo>.

 -- Função: listoftens

     Lista todos os tensores em uma expressão tensorial, incluindo seus
     índices.  E.g.,


          (%i6) ishow(a([i,j],[k])*b([u],[],v)+c([x,y],[])*d([],[])*e)$
                                                   k
          (%t6)                        d e c    + a    b
                                            x y    i j  u,v
          (%i7) ishow(listoftens(%))$
                                         k
          (%t7)                        [a   , b   , c   , d]
                                         i j   u,v   x y


 -- Função: ishow (<expr>)

     Mostra <expr> com os objetos indexados tendo seus índices
     covariantes como subscritos e índices contravariantes como
     sobrescritos.  Os índices derivativos são mostrados como
     subscritos, separados dos índices covariantes por uma vírgula (veja
     os exemplos através desse documento).

 -- Função: indices (<expr>)

     Retorna uma lista de dois elementos.  O primeiro é uma lista de
     índices livres em <expr> (aqueles que ocorrem somente uma vez).  O
     segundo é uma lista de indices que ocorrem exatamente duas vezes em
     <expr> (dummy) como demonstra o seguinte exemplo.


          (%i1) load(itensor);
          (%o1)      /share/tensor/itensor.lisp
          (%i2) ishow(a([i,j],[k,l],m,n)*b([k,o],[j,m,p],q,r))$
                                          k l      j m p
          (%t2)                          a        b
                                          i j,m n  k o,q r
          (%i3) indices(%);
          (%o3)                 [[l, p, i, n, o, q, r], [k, j, m]]


     Um produto de tensores contendo o mesmo índice mais que duas vezes
     é sintaticamente ilegal.  'indices' tenta lidar com essas
     expressões de uma forma razoável; todavia, quando 'indices' é
     chamada para operar sobre tal uma expressão ilegal, seu
     comportamento pode ser considerado indefinido.

 -- Função: rename (<expr>)
 -- Função: rename (<expr>, <contador>)

     Retorna uma expressão equivalente para <expr> mas com índices que
     ocorrem exatamente duas vezes em cada termo alterado do conjunto
     '[%1, %2,...]', se o segundo argumento opcional for omitido.  De
     outra forma, os índices que ocorrem exatamente duas vezes são
     indexados começando no valor de <contador>.  Cada índice que ocorre
     exatamente duas vezes em um produto será diferente.  Para uma
     adição, 'rename' irá operar sobre cada termo na a adição zerando o
     contador com cada termo.  Nesse caminho 'rename' pode servir como
     um simplificador tensorial.  Adicionalmente, os índices serão
     ordenados alfanumericamente (se 'allsym' for 'true') com relação a
     índices covariantes ou contravariantes dependendo do valor de
     'flipflag'.  Se 'flipflag' for 'false' então os índices serão
     renomeados conforme a ordem dos índices contravariantes.  Se
     'flipflag' for 'true' a renomeação ocorrerá conforme a ordem dos
     índices covariantes.  Isso muitas vezes ajuda que o efeito
     combinado dos dois restantes sejam reduzidos a uma expressão de
     valor um ou mais que um por si mesma.


          (%i1) load(itensor);
          (%o1)      /share/tensor/itensor.lisp
          (%i2) allsym:true;
          (%o2)                                true
          (%i3) g([],[%4,%5])*g([],[%6,%7])*ichr2([%1,%4],[%3])*
          ichr2([%2,%3],[u])*ichr2([%5,%6],[%1])*ichr2([%7,r],[%2])-
          g([],[%4,%5])*g([],[%6,%7])*ichr2([%1,%2],[u])*
          ichr2([%3,%5],[%1])*ichr2([%4,%6],[%3])*ichr2([%7,r],[%2]),noeval$
          (%i4) expr:ishow(%)$

                 %4 %5  %6 %7      %3         u          %1         %2
          (%t4) g      g      ichr2      ichr2      ichr2      ichr2
                                   %1 %4      %2 %3      %5 %6      %7 r

                        %4 %5  %6 %7      u          %1         %3         %2
                     - g      g      ichr2      ichr2      ichr2      ichr2
                                          %1 %2      %3 %5      %4 %6      %7 r
          (%i5) flipflag:true;
          (%o5)                                true
          (%i6) ishow(rename(expr))$
                 %2 %5  %6 %7      %4         u          %1         %3
          (%t6) g      g      ichr2      ichr2      ichr2      ichr2
                                   %1 %2      %3 %4      %5 %6      %7 r

                        %4 %5  %6 %7      u          %1         %3         %2
                     - g      g      ichr2      ichr2      ichr2      ichr2
                                          %1 %2      %3 %4      %5 %6      %7 r
          (%i7) flipflag:false;
          (%o7)                                false
          (%i8) rename(%th(2));
          (%o8)                                  0
          (%i9) ishow(rename(expr))$
                 %1 %2  %3 %4      %5         %6         %7        u
          (%t9) g      g      ichr2      ichr2      ichr2     ichr2
                                   %1 %6      %2 %3      %4 r      %5 %7

                        %1 %2  %3 %4      %6         %5         %7        u
                     - g      g      ichr2      ichr2      ichr2     ichr2
                                          %1 %3      %2 %6      %4 r      %5 %7

 -- Variável de Opção: flipflag

     Valor padrão: 'false'.  Se 'false' então os índices irão ser
     renomeados conforme a ordem dos índices contravariantes, de outra
     forma serão ordenados conforme a ordem dos índices covariantes.

     Se 'flipflag' for 'false' então 'rename' forma uma lista de índices
     contravariantes na ordem em que forem encontrados da esquerda para
     a direita (se 'true' então de índices contravariantes).  O primeiro
     índice que ocorre exatamente duas vezes na lista é renomeado para
     '%1', o seguinte para '%2', etc.  Então a ordenação ocorre após a
     ocorrência do 'rename' (veja o exemplo sob 'rename').

 -- Função: defcon (<tensor_1>)
 -- Função: defcon (<tensor_1>, <tensor_2>, <tensor_3>)
     Dado <tensor_1> a propriedade que a contração de um produto do
     <tensor_1> e do <tensor_2> resulta em <tensor_3> com os índices
     apropriados.  Se somente um argumento, <tensor_1>, for dado, então
     a contração do produto de <tensor_1> com qualquer objeto indexado
     tendo os índices apropriados (digamos 'my_tensor') irá retornar
     como resultado um objeto indexado com aquele nome, i.e.
     'my_tensor', e com uma nova escolha de índices refletindo as
     contrações executadas.  Por exemplo, se 'imetric:g', então
     'defcon(g)' irá implementar o incremento e decremento de índices
     através da contração com o tensor métrico.  Mais de uma 'defcon'
     pode ser dada para o mesmo objeto indexado; o último fornecido que
     for aplicado a uma contração particular será usado.  'contractions'
     é uma lista de objetos indexados que tenham fornecido propriedades
     de contrações com 'defcon'.

 -- Função: remcon (<tensor_1>, ..., <tensor_n>)
 -- Função: remcon (all)
     Remove todas as propriedades de contração de <tensor_1>, ...,
     <tensor_n>).  'remcon(all)' remove todas as propriedades de
     contração de todos os objetos indexados.

 -- Função: contract (<expr>)

     Realiza contrações tensoriais em <expr> a qual pode ser qualquer
     combinação de adições e produtos.  Essa função usa a informação
     dada para a função 'defcon'.  Para melhores resultados, 'expr' pode
     ser completamente expandida.  'ratexpand' é o meio mais rápido para
     expandir produtos e expoentes de adições se não existirem variáveis
     nos denominadores dos termos.  O comutador 'gcd' pode ser 'false'
     se cancelamentos de máximo divisor comum forem desnecessários.

 -- Função: indexed_tensor (<tensor>)

     Deve ser executada antes de atribuir componentes para um <tensor>
     para o qual um valor interno já existe como com 'ichr1', 'ichr2',
     'icurvature'.  Veja o exemplo sob 'icurvature'.

 -- Função: components (<tensor>, <expr>)

     Permite que se atribua um valor indicial a uma expressão <expr>
     dando os valores das componentes do <tensor>.  Esses são
     automaticamente substituídos para o tensor mesmo que isso ocorra
     com todos os seus índices.  O tensor deve ser da forma
     't([...],[...])' onde qualquer lista pode ser vazia.  <expr> pode
     ser qualquer expressão indexada envolvendo outros objetos com os
     mesmos índices livres que <tensor>.  Quando usada para atribuir
     valores a um tensor métrico no qual as componentes possuem índices
     que ocorrem exatamente duas vezes se deve ser cuidadoso para
     definir esses índices de forma a evitar a geração de índices que
     ocorrem exatamente duas vezes e que são multiplos.  a remoção
     dessas atribuições é dada para a função 'remcomps'.

     É importante ter em mente que 'components' cuida somente da
     valência de um tensor, e que ignora completamente qualquer
     ordenação particular de índices.  Dessa forma atribuindo
     componentes a, digamos, 'x([i,-j],[])', 'x([-j,i],[])', ou
     'x([i],[j])' todas essas atribuições produzem o mesmo resultado, a
     saber componentes sendo atribuidas a um tensor chamado 'x' com
     valência '(1,1)'.

     Componentes podem ser atribuidas a uma expressão indexada por
     quatro caminhos, dois dos quais envolvem o uso do comando
     'components':

     1) Como uma expressão indexada.  Por exemplo:


          (%i2) components(g([],[i,j]),e([],[i])*p([],[j]))$
          (%i3) ishow(g([],[i,j]))$
                                                i  j
          (%t3)                                e  p


     2) Como uma matriz:


          (%i6) components(g([i,j],[]),lg);
          (%o6)                                done
          (%i7) ishow(g([i,j],[]))$
          (%t7)                                g
                                                i j
          (%i8) g([3,3],[]);
          (%o8)                                  1
          (%i9) g([4,4],[]);
          (%o9)                                 - 1


     3) Como uma função.  Você pode usar uma função Maxima para
     especificar as componentes de um tensor baseado nesses índices.
     Por exemplo, os seguintes códigos atribuem 'kdelta' a 'h' se 'h'
     tiver o mesmo número de índices covariantes e índices
     contravariantes e nenhum índice derivativo, e atribui 'kdelta' a
     'g' caso as condições anteriores não sejam atendidas:


          (%i4) h(l1,l2,[l3]):=if length(l1)=length(l2) and length(l3)=0
            then kdelta(l1,l2) else apply(g,append([l1,l2], l3))$
          (%i5) ishow(h([i],[j]))$
                                                    j
          (%t5)                               kdelta
                                                    i
          (%i6) ishow(h([i,j],[k],l))$
                                               k
          (%t6)                               g
                                               i j,l


     4) Usando a compatibilidade dos modelos de coincidência do Maxima,
     especificamente os comandos 'defrule' e 'applyb1':


          (%i1) load(itensor);
          (%o1)      /share/tensor/itensor.lisp
          (%i2) matchdeclare(l1,listp);
          (%o2)                                done
          (%i3) defrule(r1,m(l1,[]),(i1:idummy(),
                g([l1[1],l1[2]],[])*q([i1],[])*e([],[i1])))$

          (%i4) defrule(r2,m([],l1),(i1:idummy(),
                w([],[l1[1],l1[2]])*e([i1],[])*q([],[i1])))$

          (%i5) ishow(m([i,n],[])*m([],[i,m]))$
                                              i m
          (%t5)                              m    m
                                                   i n
          (%i6) ishow(rename(applyb1(%,r1,r2)))$
                                     %1  %2  %3 m
          (%t6)                     e   q   w     q   e   g
                                                   %1  %2  %3 n



 -- Função: remcomps (<tensor>)

     Desassocia todos os valores de <tensor> que foram atribuídos com a
     função 'components'.

 -- Função: showcomps (<tensor>)

     Mostra atribuições de componentes de um tensor, feitas usando o
     comando 'components'.  Essa função pode ser particularmente útil
     quando uma matriz é atribuída a um tensor indicial usando
     'components', como demonstrado através do seguinte exemplo:


          (%i1) load(ctensor);
          (%o1)       /share/tensor/ctensor.mac
          (%i2) load(itensor);
          (%o2)      /share/tensor/itensor.lisp
          (%i3) lg:matrix([sqrt(r/(r-2*m)),0,0,0],[0,r,0,0],
                          [0,0,sin(theta)*r,0],[0,0,0,sqrt((r-2*m)/r)]);
                         [         r                                     ]
                         [ sqrt(-------)  0       0              0       ]
                         [      r - 2 m                                  ]
                         [                                               ]
                         [       0        r       0              0       ]
          (%o3)          [                                               ]
                         [       0        0  r sin(theta)        0       ]
                         [                                               ]
                         [                                      r - 2 m  ]
                         [       0        0       0        sqrt(-------) ]
                         [                                         r     ]
          (%i4) components(g([i,j],[]),lg);
          (%o4)                                done
          (%i5) showcomps(g([i,j],[]));
                            [         r                                     ]
                            [ sqrt(-------)  0       0              0       ]
                            [      r - 2 m                                  ]
                            [                                               ]
                            [       0        r       0              0       ]
          (%t5)      g    = [                                               ]
                      i j   [       0        0  r sin(theta)        0       ]
                            [                                               ]
                            [                                      r - 2 m  ]
                            [       0        0       0        sqrt(-------) ]
                            [                                         r     ]
          (%o5)                                false


     O comando 'showcomps' pode também mostrar componentes de um tensor
     de categoria maior que 2.

 -- Função: idummy ()

     Incrementos 'icounter' e retorno como seu valor um índice da forma
     '%n' onde n é um inteiro positivo.  Isso garante que índices que
     ocorrem exatamente duas vezes e que são necessários na formação de
     expressões não irão conflitar com índices que já estiverem sendo
     usados (veja o exemplo sob 'indices').

 -- Variável de opção: idummyx
     Valor padrão: '%'

     É o prefixo para índices que ocorrem exatamente duas vezes (veja o
     exemplo sob índices 'indices').

 -- Variável de Opção: icounter
     Valor padrão: '1'

     Determina o sufixo numérico a ser usado na geração do próximo
     índice que ocorre exatamente duas vezes no pacote tensor.  O
     prefixo é determinado através da opção 'idummy' (padrão: '%').

 -- Função: kdelta (<L1>, <L2>)
     é a função delta generalizada de Kronecker definida no pacote
     'itensor' com <L1> a lista de índices covariantes e <L2> a lista de
     índices contravariantes.  'kdelta([i],[j])' retorna o delta de
     Kronecker comum.  O comando 'ev(<expr>,kdelta)' faz com que a
     avaliação de uma expressão contendo 'kdelta([],[])' se dê para a
     dimensão de multiplicação.

     No que conduzir a um abuso dessa notação, 'itensor' também permite
     'kdelta' ter 2 covariantes e nenhum contravariante, ou 2
     contravariantes e nenhum índice covariante, com efeito fornecendo
     uma compatibilidade para "matriz unitária" covariante ou
     contravariante.  Isso é estritamente considerado um recurso de
     programação e não significa implicar que 'kdelta([i,j],[])' seja um
     objeto tensorial válido.

 -- Função: kdels (<L1>, <L2>)

     Delta de Kronecker simetrizado, usado em alguns cálculos.  Por
     exemplo:


          (%i1) load(itensor);
          (%o1)      /share/tensor/itensor.lisp
          (%i2) kdelta([1,2],[2,1]);
          (%o2)                                 - 1
          (%i3) kdels([1,2],[2,1]);
          (%o3)                                  1
          (%i4) ishow(kdelta([a,b],[c,d]))$
                                       c       d         d       c
          (%t4)                  kdelta  kdelta  - kdelta  kdelta
                                       a       b         a       b
          (%i4) ishow(kdels([a,b],[c,d]))$
                                       c       d         d       c
          (%t4)                  kdelta  kdelta  + kdelta  kdelta
                                       a       b         a       b


 -- Função: levi_civita (<L>)
     é o tensor de permutação (ou de Levi-Civita) que retorna 1 se a
     lista <L> consistir de uma permutação par de inteiros, -1 se isso
     consistir de uma permutação ímpar, e 0 se alguns índices em <L>
     forem repetidos.

 -- Função: lc2kdt (<expr>)
     Simplifica expressões contendo os símbolos de Levi-Civita,
     convertendo esses para expressões delta de Kronecker quando
     possível.  A principal diferença entre essa função e simplesmente
     avaliar os simbolos de Levi-Civita é que a avaliação direta muitas
     vezes resulta em expressões Kronecker contendo índices numéricos.
     Isso é muitas vezes indesejável como na prevenção de simplificação
     adicional.  A função 'lc2kdt' evita esse problema, retornando
     expressões que são mais facilmente simplificadas com 'rename' ou
     'contract'.


          (%i1) load(itensor);
          (%o1)      /share/tensor/itensor.lisp
          (%i2) expr:ishow('levi_civita([],[i,j])*'levi_civita([k,l],[])*a([j],[k]))$
                                            i j  k
          (%t2)                  levi_civita    a  levi_civita
                                                 j            k l
          (%i3) ishow(ev(expr,levi_civita))$
                                            i j  k       1 2
          (%t3)                       kdelta    a  kdelta
                                            1 2  j       k l
          (%i4) ishow(ev(%,kdelta))$
                       i       j         j       i   k
          (%t4) (kdelta  kdelta  - kdelta  kdelta ) a
                       1       2         1       2   j

                                         1       2         2       1
                                  (kdelta  kdelta  - kdelta  kdelta )
                                         k       l         k       l
          (%i5) ishow(lc2kdt(expr))$
                               k       i       j    k       j       i
          (%t5)               a  kdelta  kdelta  - a  kdelta  kdelta
                               j       k       l    j       k       l
          (%i6) ishow(contract(expand(%)))$
                                           i           i
          (%t6)                           a  - a kdelta
                                           l           l


     A função 'lc2kdt' algumas vezes faz uso de tensores métricos.  Se o
     tensor métrico não tiver sido definido previamente com 'imetric',
     isso resulta em um erro.


          (%i7) expr:ishow('levi_civita([],[i,j])*'levi_civita([],[k,l])*a([j,k],[]))$
                                           i j            k l
          (%t7)                 levi_civita    levi_civita    a
                                                               j k
          (%i8) ishow(lc2kdt(expr))$
          Maxima encountered a Lisp error:

           Error in $IMETRIC [or a callee]:
           $IMETRIC [or a callee] requires less than two arguments.

          Automatically continuing.
          To reenable the Lisp debugger set *debugger-hook* to nil.
          (%i9) imetric(g);
          (%o9)                                done
          (%i10) ishow(lc2kdt(expr))$
                   %3 i       k   %4 j       l     %3 i       l   %4 j       k
          (%t10) (g     kdelta   g     kdelta   - g     kdelta   g     kdelta  ) a
                              %3             %4               %3             %4   j k
          (%i11) ishow(contract(expand(%)))$
                                            l i      l i
          (%t11)                           a    - a g


 -- Função: lc_l

     Regra de simplificação usada para expressões contendo símbolos não
     avaliados de Levi-Civita ('levi_civita').  Juntamente com 'lc_u',
     pode ser usada para simplificar muitas expressões mais
     eficientemente que a avaliação de 'levi_civita'.  Por exemplo:


          (%i1) load(itensor);
          (%o1)      /share/tensor/itensor.lisp
          (%i2)  el1:ishow('levi_civita([i,j,k],[])*a([],[i])*a([],[j]))$
                                       i  j
          (%t2)                       a  a  levi_civita
                                                       i j k
          (%i3) el2:ishow('levi_civita([],[i,j,k])*a([i])*a([j]))$
                                                 i j k
          (%t3)                       levi_civita      a  a
                                                        i  j
          (%i4) ishow(canform(contract(expand(applyb1(el1,lc_l,lc_u)))))$
          (%t4)                                  0
          (%i5) ishow(canform(contract(expand(applyb1(el2,lc_l,lc_u)))))$
          (%t5)                                  0


 -- Função: lc_u

     Regra de simplificação usada para expressões contendo símbolos não
     avaliados de Levi-Civita ('levi_civita').  Juntamente com 'lc_u',
     pode ser usada para simplificar muitas expressões mais
     eficientemente que a avaliação de 'levi_civita'.  Para detalhes,
     veja 'lc_l'.

 -- Função: canten (<expr>)
     Simplifica <expr> por renomeação (veja 'rename') e permutando
     índices que ocorrem exatamente duas vezes.  'rename' é restrito a
     adições de produto de tensores nos quais nenhum índice derivativo
     estiver presente.  Como tal isso é limitado e pode somente ser
     usado se 'canform' não for capaz de realizar a simplificação
     requerida.

     A função 'canten' retorna um resultado matematicamente correto
     somente se seu argumento for uma expressão que é completamente
     simétrica em seus índices.  Por essa razão, 'canten' retorna um
     erro se 'allsym' não for posicionada em 'true'.

 -- Função: concan (<expr>)
     Similar a 'canten' mas também executa contração de índices.

27.2.2 Simetrias de tensores
----------------------------

 -- Variável de Opção: allsym

     Valor padrão: 'false'.  Se 'true' então todos os objetos indexados
     são assumidos simétricos em todos os seus índices covariantes e
     contravariantes.  Se 'false' então nenhum simétrico de qualquer
     tipo é assumidos nesses índices.  Índices derivativos são sempre
     tomados para serem simétricos a menos que 'iframe_flag' seja
     escolhida para 'true'.

 -- Função: decsym (<tensor>, <m>, <n>, [<cov_1>, <cov_2>, ...],
          [<contr_1>, <contr_2>, ...])

     Declara propriedades de simetria para <tensor> de covariante <m> e
     <n> índices contravariantes.  As <cov_i> e <contr_i> são
     pseudofunções expressando relações de simetrias em meio a índices
     covariante e índices contravariantes respectivamente.  Esses são da
     forma 'symoper(<index_1>, <index_2>,...)' onde 'symoper' é um entre
     'sym', 'anti' ou 'cyc' e os <index_i> são inteiros indicando a
     posição do índice no <tensor>.  Isso irá declarar <tensor> para ser
     simétrico, antisimétrico ou cíclico respectivamente nos <index_i>.
     'symoper(all)' é também forma permitida que indica todos os índices
     obedecem à condição de simetria.  Por exemplo, dado um objeto 'b'
     com 5 índices covariantes,
     'decsym(b,5,3,[sym(1,2),anti(3,4)],[cyc(all)])' declara 'b'
     simétrico no seu primeiro e no seu segundo índices e antisimétrico
     no seu terceiro e quarto índices covariantes, e cíclico em todos de
     seus índices contravariantes.  Qualquer lista de declarações de
     simetria pode ser nula.  A função que executa as simplificações é
     'canform' como o exemplo abaixo ilustra.


          (%i1) load(itensor);
          (%o1)      /share/tensor/itensor.lisp
          (%i2) expr:contract(expand(a([i1,j1,k1],[])*kdels([i,j,k],[i1,j1,k1])))$
          (%i3) ishow(expr)$
          (%t3)         a      + a      + a      + a      + a      + a
                         k j i    k i j    j k i    j i k    i k j    i j k
          (%i4) decsym(a,3,0,[sym(all)],[]);
          (%o4)                                done
          (%i5) ishow(canform(expr))$
          (%t5)                              6 a
                                                i j k
          (%i6) remsym(a,3,0);
          (%o6)                                done
          (%i7) decsym(a,3,0,[anti(all)],[]);
          (%o7)                                done
          (%i8) ishow(canform(expr))$
          (%t8)                                  0
          (%i9) remsym(a,3,0);
          (%o9)                                done
          (%i10) decsym(a,3,0,[cyc(all)],[]);
          (%o10)                               done
          (%i11) ishow(canform(expr))$
          (%t11)                        3 a      + 3 a
                                           i k j      i j k
          (%i12) dispsym(a,3,0);
          (%o12)                     [[cyc, [[1, 2, 3]], []]]


 -- Função: remsym (<tensor>, <m>, <n>)
     Remove todas as propriedades de simetria de <tensor> que tem <m>
     índices covariantes e <n> índices contravariantes.

 -- Função: canform (<expr>)
     Simplifica <expr> através de mudança de nome de índices que ocorrem
     exatamente duas vezes e reordenação de todos os índices como
     ditados pelas condições de simetria impostas sobre eles.  Se
     'allsym' for 'true' então todos os índices são assumidos
     simétricos, de outra forma a informação de simetria fornecida pelas
     declarações 'decsym' irão ser usadas.  Os índices que ocorrem
     exatamente duas vezes são renomeados da mesma maneira que na função
     'rename'.  Quando 'canform' é aplicada a uma expressão larga o
     cálculo pode tomar um considerável montante de tempo.  Esse tempo
     pode ser diminuído através do uso de 'rename' sobre a expressão em
     primeiro lugar.  Também veja o exemplo sob 'decsym'.  Nota:
     'canform' pode não estar apta a reduzir um expressão completamente
     para sua forma mais simples embora retorne sempre um resultado
     matemáticamente correto.

27.2.3 Cálculo de tensores indiciais
------------------------------------

 -- Função: diff (<expr>, <v_1>, [<n_1>, [<v_2>, <n_2>] ...])

     É a função usual de diferenciação do Maxima que tem sido expandida
     nessas habilidades para 'itensor'.  'diff' toma a derivada de
     <expr> <n_1> vezes com relação a <v_1>, <n_2> vezes com relação a
     <v_2> , etc.  Para o pacote 'tensor', a função tem sido modificada
     de forma que os <v_i> possam ser inteiros de 1 até o valor da
     variável 'dim'.  Isso causará a conclusão da diferenciação com
     relação ao <v_i>ésimo membro da lista 'vect_coords'.  Se
     'vect_coords' for associado a uma variável atômica, então aquela
     variável subscrita através de <v_i> será usada para a variável de
     diferenciação.  Isso permite que um array de nomes de coordenadas
     ou nomes subscritos como 'x[1]', 'x[2]', ...  sejam usados.

 -- Função: idiff (<expr>, <v_1>, [<n_1>, [<v_2>, <n_2>] ...])
     Diferenciação indicial.  A menos que 'diff', que diferencia com
     relação a uma variável independente, 'idiff' possa ser usada para
     diferenciar com relação a uma coordenada.  Para um objeto indexado,
     isso equivale a anexar ao final os <v_i> como índices derivativos.
     Subseqüêntemente, índices derivativos irão ser ordenados, a menos
     que 'iframe_flag' seja escolhida para 'true'.

     'idiff' pode também ser o determinante de um tensor métrico.  Dessa
     forma, se 'imetric' tiver sido associada a 'G' então
     'idiff(determinant(g),k)' irá retornar
     '2*determinant(g)*ichr2([%i,k],[%i])' onde o índice que ocorre
     exatamente duas vezes '%i' é escolhido apropriadamente.

 -- Função: liediff (<v>, <ten>)

     Calcula a derivada de Lie da expressão tensorial <ten> com relação
     ao campo vetorial <v>.  <ten> pode ser qualquer expressão tensorial
     indexada; <v> pode ser o nome (sem índices) de um campo vetorial.
     Por exemplo:


          (%i1) load(itensor);
          (%o1)      /share/tensor/itensor.lisp
          (%i2) ishow(liediff(v,a([i,j],[])*b([],[k],l)))$
                 k    %2            %2          %2
          (%t2) b   (v   a       + v   a     + v   a    )
                 ,l       i j,%2    ,j  i %2    ,i  %2 j

                                          %1  k        %1  k      %1  k
                                      + (v   b      - b   v    + v   b   ) a
                                              ,%1 l    ,l  ,%1    ,l  ,%1   i j


 -- Função: rediff (<ten>)

     Avalia todas as ocorrências do comando 'idiff' na expressão
     tensorial <ten>.

 -- Função: undiff (<expr>)

     Retorna uma expressão equivalente a <expr> mas com todas as
     derivadas de objetos indexados substituídas pela forma substantiva
     da função 'idiff'.  Seu argumento pode retornar aquele objeto
     indexado se a diferenciação for concluída.  Isso é útil quando for
     desejado substituir um objeto indexado que sofreu diferenciação com
     alguma definição de função resultando em <expr> e então concluir a
     diferenciação através de digamos 'ev(<expr>, idiff)'.

 -- Função: evundiff (<expr>)

     Equivalente à execução de 'undiff', seguida por 'ev' e 'rediff'.

     O ponto dessa operação é facilmente avaliar expressões que não
     possam ser diretamente avaliadas na forma derivada.  Por exemplo, o
     seguinte causa um erro:

          (%i1) load(itensor);
          (%o1)      /share/tensor/itensor.lisp
          (%i2) icurvature([i,j,k],[l],m);
          Maxima encountered a Lisp error:

           Error in $ICURVATURE [or a callee]:
           $ICURVATURE [or a callee] requires less than three arguments.

          Automatically continuing.
          To reenable the Lisp debugger set *debugger-hook* to nil.

     Todavia, se 'icurvature' é informado em sua forma substantiva, pode
     ser avaliado usando 'evundiff':

          (%i3) ishow('icurvature([i,j,k],[l],m))$
                                                   l
          (%t3)                          icurvature
                                                   i j k,m
          (%i4) ishow(evundiff(%))$
                       l              l         %1           l           %1
          (%t4) - ichr2        - ichr2     ichr2      - ichr2       ichr2
                       i k,j m        %1 j      i k,m        %1 j,m      i k

                          l              l         %1           l           %1
                   + ichr2        + ichr2     ichr2      + ichr2       ichr2
                          i j,k m        %1 k      i j,m        %1 k,m      i j

     Nota: Em versões anteriores do Maxima, formas derivadas dos
     símbolos de Christoffel também não podiam ser avaliadas.  Isso foi
     corrigido atualmente, de forma que 'evundiff' não mais é necessária
     para expressões como essa:

          (%i5) imetric(g);
          (%o5)                                done
          (%i6) ishow(ichr2([i,j],[k],l))$
                 k %3
                g     (g         - g         + g        )
                        j %3,i l    i j,%3 l    i %3,j l
          (%t6) -----------------------------------------
                                    2

                                   k %3
                                  g     (g       - g       + g      )
                                   ,l     j %3,i    i j,%3    i %3,j
                                + -----------------------------------
                                                   2

 -- Função: flush (<expr>, <tensor_1>, <tensor_2>, ...)
     Escolhe para zero, em <expr>, todas as ocorrências de <tensor_i>
     que não tiverem índices derivativos.

 -- Função: flushd (<expr>, <tensor_1>, <tensor_2>, ...)
     Escolhe para zero, em <expr>, todas as ocorrências de <tensor_i>
     que tiverem índices derivativos.

 -- Função: flushnd (<expr>, <tensor>, <n>)
     Escolhe para zero, em <expr>, todas as ocorrências do objeto
     diferenciado <tensor> que tem <n> ou mais índices derivativos como
     demonstra o seguinte exemplo.

          (%i1) load(itensor);
          (%o1)      /share/tensor/itensor.lisp
          (%i2) ishow(a([i],[J,r],k,r)+a([i],[j,r,s],k,r,s))$
                                          J r      j r s
          (%t2)                          a      + a
                                          i,k r    i,k r s
          (%i3) ishow(flushnd(%,a,3))$
                                               J r
          (%t3)                               a
                                               i,k r

 -- Função: coord (<tensor_1>, <tensor_2>, ...)

     Dados os <tensor_i> a propriedade de diferenciação da coordenada
     que a derivada do vetor contravariante cujo nome é um dos
     <tensor_i> retorna um delta de Kronecker.  Por exemplo, se
     'coord(x)' tiver sido concluída então 'idiff(x([],[i]),j)' fornece
     'kdelta([i],[j])'.  'coord' que é uma lista de todos os objetos
     indexados tendo essa propriedade.

 -- Função: remcoord (<tensor_1>, <tensor_2>, ...)
 -- Função: remcoord (all)

     Remove a propriedade de coordenada de diferenciação dos 'tensor_i'
     que foram estabelecidos através da função 'coord'.  'remcoord(all)'
     remove essa propriedade de todos os objetos indexados.

 -- Função: makebox (<expr>)
     Mostra <expr> da mesma maneira que 'show'; todavia, qualquer tensor
     d'Alembertiano ocorrendo em <expr> será indicado usando o símbolo
     '[]'.  Por exemplo, '[]p([m],[n])' representa
     'g([],[i,j])*p([m],[n],i,j)'.

 -- Função: conmetderiv (<expr>, <tensor>)

     Simplifica expressões contendo derivadas comuns de ambas as formas
     covariantes e contravariantes do tensor métrico (a restrição
     corrente).  Por exemplo, 'conmetderiv' pode relatar a derivada do
     tensor contravariante métrico com símbolos de Christoffel como
     visto adiante:


          (%i1) load(itensor);
          (%o1)      /share/tensor/itensor.lisp
          (%i2) ishow(g([],[a,b],c))$
                                                a b
          (%t2)                                g
                                                ,c
          (%i3) ishow(conmetderiv(%,g))$
                                   %1 b      a       %1 a      b
          (%t3)                 - g     ichr2     - g     ichr2
                                             %1 c              %1 c

 -- Função: simpmetderiv (<expr>)
 -- Função: simpmetderiv (<expr>[, <stop>])

     Simplifica expressões contendo produtos de derivadas de tensores
     métricos.  Especificamente, 'simpmetderiv' reconhece duas
     identidades:


             ab        ab           ab                 a
            g   g   + g   g     = (g   g  )   = (kdelta )   = 0
             ,d  bc        bc,d         bc ,d          c ,d


     conseqüêntemente


             ab          ab
            g   g   = - g   g
             ,d  bc          bc,d

     e


            ab          ab
           g   g     = g   g
            ,j  ab,i    ,i  ab,j


     que seguem de simetrias de símbolos de Christoffel.

     A função 'simpmetderiv' toma um parâmetro opcional que, quando
     presente, faz com que a função pare após a primeira substituição
     feita com sucesso em uma expressão produto.  A função
     'simpmetderiv' também faz uso da variável global <flipflag> que
     determina como aplicar uma ordenação "canonica" para os índices de
     produto.

     Colocados juntos, essas compatibilidades podem ser usadas
     poderosamente para encontrar simplificações que são difíceis ou
     impossíveis de realizar de outra forma.  Isso é demonstrado através
     do seguinte exemplo que explicitamente usa o recurso de
     simplificação parcial de 'simpmetderiv' para obter uma expressão
     contractível:


          (%i1) load(itensor);
          (%o1)      /share/tensor/itensor.lisp
          (%i2) imetric(g);
          (%o2)                                done
          (%i3) ishow(g([],[a,b])*g([],[b,c])*g([a,b],[],d)*g([b,c],[],e))$
                                       a b  b c
          (%t3)                       g    g    g      g
                                                 a b,d  b c,e
          (%i4) ishow(canform(%))$

          errexp1 has improper indices
           -- an error.  Quitting.  To debug this try debugmode(true);
          (%i5) ishow(simpmetderiv(%))$
                                       a b  b c
          (%t5)                       g    g    g      g
                                                 a b,d  b c,e
          (%i6) flipflag:not flipflag;
          (%o6)                                true
          (%i7) ishow(simpmetderiv(%th(2)))$
                                         a b  b c
          (%t7)                         g    g    g    g
                                         ,d   ,e   a b  b c
          (%i8) flipflag:not flipflag;
          (%o8)                                false
          (%i9) ishow(simpmetderiv(%th(2),stop))$
                                         a b  b c
          (%t9)                       - g    g    g      g
                                              ,e   a b,d  b c
          (%i10) ishow(contract(%))$
                                              b c
          (%t10)                           - g    g
                                              ,e   c b,d


     Veja também 'weyl.dem' para um exemplo que usa 'simpmetderiv' e
     'conmetderiv' juntos para simplificar contrações do tensor de Weyl.

 -- Função: flush1deriv (<expr>, <tensor>)

     Escolhe para zero, em 'expr', todas as ocorrências de 'tensor' que
     possuem exatamente um índice derivativo.

27.2.4 Tensores em espaços curvos
---------------------------------

 -- Função: imetric (<g>)
 -- Variável de sistema: imetric

     Especifica a métrica através de atribuição à variável 'imetric:<g>'
     adicionalmente, as propriedades de contração da métrica <g> são
     escolhidas através da execução dos comandos
     'defcon(<g>),defcon(<g>,<g>,kdelta)'.  A variável 'imetric'
     (desassociada por padrão), é associada à métrica, atribuida pelo
     comando 'imetric(<g>)'.

 -- Função: idim (<n>)
     Escolhe as dimensões da métrica.  Também inicializa as propriedades
     de antisimetria dos símbolos de Levi-Civita para as dimensões
     dadas.

 -- Função: ichr1 ([<i>, <j>, <k>])
     Retorna o símbolo de Christoffel de primeiro tipo via definição
                 (g      + g      - g     )/2 .
                   ik,j     jk,i     ij,k
     Para avaliar os símbolos de Christoffel para uma métrica
     particular, à variável 'imetric' deve ser atribuída um nome como no
     exemplo sob 'chr2'.

 -- Função: ichr2 ([<i>, <j>], [<k>])
     Retorna o símbolo de Christoffel de segundo tipo definido pela
     relação
                                 ks
             ichr2([i,j],[k]) = g    (g      + g      - g     )/2
                                       is,j     js,i     ij,s

 -- Função: icurvature ([<i>, <j>, <k>], [<h>])
     Retorna o tensor da curvatura de Riemann em termos de símbolos de
     Christoffel de segundo tipo ('ichr2').  A seguinte notação é usada:
                         h             h            h         %1         h
               icurvature     = - ichr2      - ichr2     ichr2    + ichr2
                         i j k         i k,j        %1 j      i k        i j,k
                                         h          %1
                                  + ichr2      ichr2
                                         %1 k       i j

 -- Função: covdiff (<expr>, <v_1>, <v_2>, ...)
     Retorna a derivada da covariante de <expr> com relação às variáveis
     <v_i> em termos de símbolos de Christoffel de segundo tipo
     ('ichr2').  Com o objetivo de avaliar esses, se pode usar
     'ev(<expr>,ichr2)'.


          (%i1) load(itensor);
          (%o1)      /share/tensor/itensor.lisp
          (%i2) entertensor()$
          Enter tensor name: a;
          Enter a list of the índices covariantes: [i,j];
          Enter a list of the índices contravariantes: [k];
          Enter a list of the derivative indices: [];
                                                k
          (%t2)                                a
                                                i j
          (%i3) ishow(covdiff(%,s))$
                       k         %1     k         %1     k            k     %1
          (%t3)     - a     ichr2    - a     ichr2    + a      + ichr2     a
                       i %1      j s    %1 j      i s    i j,s        %1 s  i j
          (%i4) imetric:g;
          (%o4)            g
          (%i5) ishow(ev(%th(2),ichr2))$
            %1 %4  k
           g      a     (g       - g       + g  )
            i %1   s %4,j  j s,%4    j %4,s
          (%t5) - ------------------------------------------
                 2
              %1 %3  k
             g   a     (g       - g    + g     )
              %1 j   s %3,i    i s,%3    i %3,s
           - ------------------------------------------
                   2
              k %2  %1
             g     a    (g        - g    + g      )
             i j   s %2,%1    %1 s,%2    %1 %2,s   k
           + ------------------------------------------- + a
             2     i j,s
          (%i6)

 -- Função: lorentz_gauge (<expr>)
     Impõe a condição de Lorentz através da substituição de 0 para todos
     os objetos indexados em <expr> que possui um índice de derivada
     idêntico ao índice contravariante.

 -- Função: igeodesic_coords (<expr>, <nome>)

     Faz com que símbolos de Christoffel não diferenciados e a primeira
     derivada do tensor métrico tendam para zero em <expr>.  O <nome> na
     função 'igeodesic_coords' refere-se à métrica <nome> (se isso
     aparecer em <expr>) enquando os coeficientes de conecção devem ser
     chamados com os nomes 'ichr1' e/ou 'ichr2'.  O seguinte exemplo
     demonstra a verificação da identidade cíclica satisfeita através do
     tensor da curvatura de Riemann usando a função 'igeodesic_coords'.


          (%i1) load(itensor);
          (%o1)      /share/tensor/itensor.lisp
          (%i2) ishow(icurvature([r,s,t],[u]))$
                       u            u         %1         u            u         %1
          (%t2) - ichr2      - ichr2     ichr2    + ichr2      + ichr2     ichr2
                       r t,s        %1 s      r t        r s,t        %1 t      r s
          (%i3) ishow(igeodesic_coords(%,ichr2))$
                                           u            u
          (%t3)                       ichr2      - ichr2
                                           r s,t        r t,s
          (%i4) ishow(igeodesic_coords(icurvature([r,s,t],[u]),ichr2)+
                      igeodesic_coords(icurvature([s,t,r],[u]),ichr2)+
                      igeodesic_coords(icurvature([t,r,s],[u]),ichr2))$
                       u            u            u            u            u
          (%t4) - ichr2      + ichr2      + ichr2      - ichr2      - ichr2
                       t s,r        t r,s        s t,r        s r,t        r t,s

                                                                            u
                                                                     + ichr2
                                                                            r s,t
          (%i5) canform(%);
          (%o5)                                  0


27.2.5 Molduras móveis
----------------------

Maxima atualmente tem a habilidade de executar cálculos usando molduras
móveis.  Essas podem ser molduras ortonormais (tetrads, vielbeins) ou
uma moldura arbitrária.

   Para usar molduras, você primeiro escolhe 'iframe_flag' para 'true'.
Isso faz com que os símbolos de Christoffel, 'ichr1' e 'ichr2', sejam
substituídos pelas molduras mais gerais de coeficientes de conecção
'icc1' e 'icc2' em cálculos.  Especialmente, o comportamento de
'covdiff' e 'icurvature' são alterados.

   A moldura é definida através de dois tensores: o campo de moldura
inversa ('ifri'), a base tetrad dual), e a métrica da moldura 'ifg'.  A
métrica da moldura é a matriz identidade para molduras ortonormais, ou a
métrica de Lorentz para molduras ortonormais no espaço-tempo de
Minkowski.  O campo de moldura inversa define a base da moldura (vetores
unitários).  Propriedades de contração são definidas para o campo de
moldura e para a métrica da moldura.

   Quando 'iframe_flag' for 'true', muitas expressões 'itensor' usam a
métrica da moldura 'ifg' em lugar da métrica definida através de
'imetric' para o decremento e para o incremento de índices.

   IMPORTANTE: Escolhendo a variável 'iframe_flag' para 'true' NÃO
remove a definição das propriedades de contração de uma métrica definida
através de uma chamada a 'defcon' ou 'imetric'.  Se um campo de moldura
for usado, ele é melhor para definir a métrica através de atribuição
desse nome para a variável 'imetric' e NÃO invoque a função 'imetric'.

   Maxima usa esses dois tensores para definir os coeficientes de
moldura ('ifc1' e 'ifc2') cuja forma parte dos coeficientes de conecção
('icc1' e 'icc2'), como demonstra o seguinte exemplo:


     (%i1) load(itensor);
     (%o1)      /share/tensor/itensor.lisp
     (%i2) iframe_flag:true;
     (%o2)                                true
     (%i3) ishow(covdiff(v([],[i]),j))$
                                    i        i     %1
     (%t3)                         v   + icc2     v
                                    ,j       %1 j
     (%i4) ishow(ev(%,icc2))$
                             %1      i           i        i
     (%t4)                  v   (ifc2     + ichr2    ) + v
                                     %1 j        %1 j     ,j
     (%i5) ishow(ev(%,ifc2))$
                 %1    i %2
                v   ifg     (ifb        - ifb        + ifb       )
                                j %2 %1      %2 %1 j      %1 j %2     i
     (%t5)      -------------------------------------------------- + v
                                        2                             ,j
     (%i6) ishow(ifb([a,b,c]))$
                            %5    %4
     (%t6)               ifr   ifr   (ifri        - ifri       )
                            a     b       c %4,%5       c %5,%4


   Um método alternativo é usado para calcular o suporte da moldura
('ifb') se o sinalizador 'iframe_bracket_form' é escolhido para 'false':


     (%i8) block([iframe_bracket_form:false],ishow(ifb([a,b,c])))$
                            %7    %6        %6      %7
     (%t8)              (ifr   ifr     - ifr     ifr  ) ifri
                            a     b,%7      a,%7    b       c %6


 -- Função: iframes ()

     Uma vez que nessa versão do Maxima, identidades de contração para
     'ifr' e 'ifri' são sempre definidas, como é o suporte da moldura
     ('ifb'), essa função não faz nada.

 -- Variável: ifb

     O suporte da moldura.  A contribuição da métrica da moldura para os
     coeficientes de conecção é expressa usando o suporte da moldura:


                    - ifb      + ifb      + ifb
                         c a b      b c a      a b c
          ifc1    = --------------------------------
              abc                  2


     O suporte da moldura por si mesmo é definido em termos de campo de
     moldura e métrica da moldura.  Dois métodos alternativos de cálculo
     são usados dependendo do valor de 'frame_bracket_form'.  Se 'true'
     (o padrão) ou se o sinalizador 'itorsion_flag' for 'true':


                    d      e                                      f
          ifb =  ifr    ifr   (ifri      - ifri      - ifri    itr   )
             abc    b      c       a d,e       a e,d       a f    d e



     Otherwise:


                       e      d        d      e
          ifb    = (ifr    ifr    - ifr    ifr   ) ifri
             abc       b      c,e      b,e    c        a d


 -- Variável: icc1

     Coeficientes de conecção de primeiro tipo.  Em 'itensor', definido
     como


          icc1    = ichr1    - ikt1    - inmc1
              abc        abc       abc        abc


     Nessa expressão, se 'iframe_flag' for 'true', o símbolo de
     Christoffel 'ichr1' é substituído com o coeficiente de conecção da
     moldura 'ifc1'.  Se 'itorsion_flag' for 'false', 'ikt1' será
     omitido.  'ikt1' é também omitido se uma base de moldura for usada,
     como a torsão está já calculada como parte do suporte da moldura.
     Ultimamente, como 'inonmet_flag' é 'false', 'inmc1' não estará
     presente.

 -- Variável: icc2

     Coeficientes de conecção de segundo tipo.  Em 'itensor', definido
     como


              c         c        c         c
          icc2   = ichr2   - ikt2   - inmc2
              ab        ab       ab        ab


     Nessa expressão, se 'iframe_flag' for 'true', o símbolo de
     Christoffel 'ichr2' é substituído com o coeficiente de conecção
     'ifc2'.  Se 'itorsion_flag' for 'false', 'ikt2' será omitido.
     'ikt2' também será omitido se uma base de moldura for usada, uma
     vez que a torsão já está calculada como parte do suporte da
     moldura.  Ultimamente, como 'inonmet_flag' é 'false', 'inmc2' não
     estará presente.

 -- Variável: ifc1

     Coeficiente de moldura de primeiro tipo (também conhecido como
     coeficientes de rotação de Ricci).  Esse tensor representa a
     contribuição da métrica da moldura para o coeficiente de conecção
     de primeiro tipo.  Definido como:


                    - ifb      + ifb      + ifb
                         c a b      b c a      a b c
          ifc1    = --------------------------------
              abc                   2



 -- Variável: ifc2

     Coeficiente de moldura de primeiro tipo.  Esse tensor representa a
     contribuição da métrica da moldura para o coeficiente de conecção
     de primeiro tipo.  Definido como uma permutação de suporte de
     moldura ('ifb') com os índices apropriados incrementados e
     decrementados como necessário:


              c       cd
          ifc2   = ifg   ifc1
              ab             abd


 -- Variável: ifr

     O campo da moldura.  Contrai ('ifri') para e com a forma do campo
     inverso da moldura para formar a métrica da moldura ('ifg').

 -- Variável: ifri

     O campo inverso da moldura.  Especifica a base da moldura (vetores
     base duais).  Juntamente com a métrica da moldura, forma a base de
     todos os cálculos baseados em molduras.

 -- Variável: ifg

     A métrica da moldura.  O valor padrão é 'kdelta', mas pode ser
     mudada usando 'components'.

 -- Variável: ifgi

     O inverso da métrica da moldura.  Contrai com a métrica da moldura
     ('ifg') para 'kdelta'.

 -- Variável de Opção: iframe_bracket_form
     Valor padrão: 'true'

     Especifica como o suporte da moldura ('ifb') é calculado.

27.2.6 Torsão e não metricidade
-------------------------------

Maxima pode trabalhar com torsão e não metricidade.  Quando o
sinalizador 'itorsion_flag' for escolhido para 'true', a contribuição de
torsão é adicionada aos coeficientes de conecção.  Similarmente, quando
o sinalizador 'inonmet_flag' for 'true', componentes de não metricidades
são incluídos.

 -- Variável: inm

     O vetor de não metricidade.  Conforme a não metricidade está
     definida através da derivada covariante do tensor métrico.
     Normalmente zero, o tensor da métrica derivada covariante irá
     avaliar para o seguinte quando 'inonmet_flag' for escolhido para
     'true':


          g     =- g  inm
           ij;k     ij  k


 -- Variável: inmc1

     Permutação covariante de componentes do vetor de não metricidade.
     Definida como


                     g   inm  - inm  g   - g   inm
                      ab    c      a  bc    ac    b
          inmc1    = ------------------------------
               abc                 2


     (Substitue 'ifg' em lugar de 'g' se uma moldura métrica for usada.)

 -- Variável: inmc2

     Permutação covariante de componentes do vetor de não metricidade.
     Usada nos coeficicientes de conecção se 'inonmet_flag' for 'true'.
     Definida como:


                                c         c         cd
                    -inm  kdelta  - kdelta  inm  + g   inm  g
               c        a       b         a    b          d  ab
          inmc2   = -------------------------------------------
               ab                        2


     (Substitue 'ifg' em lugar de 'g' se uma moldura métrica for usada.)

 -- Variável: ikt1

     Permutação covariante do tensor de torsão (também conhecido como
     contorsão).  Definido como:


                            d           d       d
                    -g   itr  - g    itr   - itr   g
                      ad    cb    bd    ca      ab  cd
          ikt1    = ----------------------------------
              abc                   2


     (Substitue 'ifg' em lugar de 'g' se uma moldura métrica for usada.)

 -- Variável: ikt2

     Permutação contravariante do tensor de torsão (também conhecida
     como contorsão).  Definida como:


              c     cd
          ikt2   = g   ikt1
              ab           abd


     (Substitue 'ifg' em lugar de 'g' se uma moldura métrica for usada.)

 -- Variável: itr

     O tensor de torsão.  Para uma métrica com torsão, diferenciação
     covariante repetida sobre uma funçào escalar não irá comutar,como
     demonstrado através do seguinte exemplo:


          (%i1) load(itensor);
          (%o1)      /share/tensor/itensor.lisp
          (%i2) imetric:g;
          (%o2)                                  g
          (%i3) covdiff(covdiff(f([],[]),i),j)-covdiff(covdiff(f([],[]),j),i)$
          (%i4) ishow(%)$
                                             %4              %2
          (%t4)                    f    ichr2    - f    ichr2
                                    ,%4      j i    ,%2      i j
          (%i5) canform(%);
          (%o5)                                  0
          (%i6) itorsion_flag:true;
          (%o6)                                true
          (%i7) covdiff(covdiff(f([],[]),i),j)-covdiff(covdiff(f([],[]),j),i)$
          (%i8) ishow(%)$
                                     %8             %6
          (%t8)             f    icc2    - f    icc2    - f     + f
                             ,%8     j i    ,%6     i j    ,j i    ,i j
          (%i9) ishow(canform(%))$
                                             %1             %1
          (%t9)                     f    icc2    - f    icc2
                                     ,%1     j i    ,%1     i j
          (%i10) ishow(canform(ev(%,icc2)))$
                                             %1             %1
          (%t10)                    f    ikt2    - f    ikt2
                                     ,%1     i j    ,%1     j i
          (%i11) ishow(canform(ev(%,ikt2)))$
                                %2 %1                    %2 %1
          (%t11)          f    g      ikt1       - f    g      ikt1
                           ,%2            i j %1    ,%2            j i %1
          (%i12) ishow(factor(canform(rename(expand(ev(%,ikt1))))))$
                                     %3 %2            %1       %1
                               f    g      g      (itr    - itr   )
                                ,%3         %2 %1     j i      i j
          (%t12)               ------------------------------------
                                                2
          (%i13) decsym(itr,2,1,[anti(all)],[]);
          (%o13)                               done
          (%i14) defcon(g,g,kdelta);
          (%o14)                               done
          (%i15) subst(g,nounify(g),%th(3))$
          (%i16) ishow(canform(contract(%)))$
                                                     %1
          (%t16)                           - f    itr
                                              ,%1    i j


27.2.7 Álgebra externa (como em produto externo)
------------------------------------------------

O pacote 'itensor' pode executar operações sobre campos tensores
covariantes totalmente antisimétricos.  Um campo tensor totalmente
antisimétrico de classe (0,L) corresponde a uma forma diferencial L.
Sobre esses objetos, uma operação de multiplicação funciona como um
produto externo, ou produto cunha, é definido.

   Desafortunadamente, nem todos os autores concordam sobre a definição
de produto cunha.  Alguns autores preferem uma definição que corresponde
à noção de antisimetrização: nessas palavras, o produto cunha de dois
campos vetoriais, por exemplo, pode ser definido como

                 a a  - a a
                  i j    j i
      a  /\ a  = -----------
       i     j        2

   Mais geralmente, o produto de uma forma p e uma forma q pode ser
definido como

                            1     k1..kp l1..lq
     A       /\ B       = ------ D              A       B
      i1..ip     j1..jq   (p+q)!  i1..ip j1..jq  k1..kp  l1..lq

   onde 'D' simboliza o delta de Kronecker.

   Outros autores, todavia, preferem uma definição "geométrica" que
corresponde à notação de elemento volume:

     a  /\ a  = a a  - a a
      i     j    i j    j i

   e, no caso geral

                            1    k1..kp l1..lq
     A       /\ B       = ----- D              A       B
      i1..ip     j1..jq   p! q!  i1..ip j1..jq  k1..kp  l1..lq

   Uma vez que 'itensor' é um pacote de algebra de tensores, a primeira
dessas duas definições aparenta ser a mais natural por si mesma.  Muitas
aplicações, todavia, usam a segunda definição.  Para resolver esse
dilema, um sinalizador tem sido implementado que controla o
comportamento do produto cunha: se 'igeowedge_flag' for 'false' (o
padrão), a primeira, definição "tensorial" é usada, de outra forma a
segunda, definição "geométrica" irá ser aplicada.

 -- Operador: ~
     O operador do produto cunha é definido como sendo o acento til '~'.
     O til é um operador binário.  Seus argumentos podem ser expressões
     envolvendo escalares, tensores covariantes de categoria 1, ou
     tensores covariantes de categoria 'l' que tiverem sido declarados
     antisimétricos em todos os índices covariantes.

     O comportamento do operador do produto cunha é controlado através
     do sinalizador 'igeowedge_flag', como no seguinte exemplo:

          (%i1) load(itensor);
          (%o1)      /share/tensor/itensor.lisp
          (%i2) ishow(a([i])~b([j]))$
                                           a  b  - b  a
                                            i  j    i  j
          (%t2)                            -------------
                                                 2
          (%i3) decsym(a,2,0,[anti(all)],[]);
          (%o3)                                done
          (%i4) ishow(a([i,j])~b([k]))$
                                    a    b  + b  a    - a    b
                                     i j  k    i  j k    i k  j
          (%t4)                     ---------------------------
                                                 3
          (%i5) igeowedge_flag:true;
          (%o5)                                true
          (%i6) ishow(a([i])~b([j]))$
          (%t6)                            a  b  - b  a
                                            i  j    i  j
          (%i7) ishow(a([i,j])~b([k]))$
          (%t7)                     a    b  + b  a    - a    b
                                     i j  k    i  j k    i k  j

 -- Operador: |
     A barra vertical '|' denota a operação binária "contração com um
     vetor".  Quando um tensor covariante totalmente antisimétrico é
     contraído com um vetor contravariante, o resultado é o mesmo
     independente de qual índice foi usado para a contração.  Dessa
     forma, é possível definir a operação de contração de uma forma
     livre de índices.

     No pacote 'itensor', contração com um vetor é sempre realizada com
     relação ao primeiro índice na ordem literal de ordenação.  Isso
     garante uma melhor simplificação de expressões envolvendo o
     operador '|'.  Por exemplo:

          (%i1) load(itensor);
          (%o1)      /share/tensor/itensor.lisp
          (%i2) decsym(a,2,0,[anti(all)],[]);
          (%o2)                                done
          (%i3) ishow(a([i,j],[])|v)$
                                              %1
          (%t3)                              v   a
                                                  %1 j
          (%i4) ishow(a([j,i],[])|v)$
                                               %1
          (%t4)                             - v   a
                                                   %1 j

     Note que isso é essencial que os tensores usado como o operador '|'
     seja declarado totalmente antisimétrico em seus índices
     covariantes.  De outra forma, os resultados serão incorretos.

 -- Função: extdiff (<expr>, <i>)

     Calcula a derivada externa de <expr> com relação ao índice <i>.  A
     derivada externa é formalmente definida como o produto cunha do
     operador de derivada parcial e uma forma diferencial.  Como tal,
     essa operação é também controlada através da escolha de
     'igeowedge_flag'.  Por exemplo:

          (%i1) load(itensor);
          (%o1)      /share/tensor/itensor.lisp
          (%i2) ishow(extdiff(v([i]),j))$
                                            v    - v
                                             j,i    i,j
          (%t2)                             -----------
                                                 2
          (%i3) decsym(a,2,0,[anti(all)],[]);
          (%o3)                                done
          (%i4) ishow(extdiff(a([i,j]),k))$
                                     a      - a      + a
                                      j k,i    i k,j    i j,k
          (%t4)                      ------------------------
                                                3
          (%i5) igeowedge_flag:true;
          (%o5)                                true
          (%i6) ishow(extdiff(v([i]),j))$
          (%t6)                             v    - v
                                             j,i    i,j
          (%i7) ishow(extdiff(a([i,j]),k))$
          (%t7)                      a      - a      + a
                                      j k,i    i k,j    i j,k

 -- Função: hodge (<expr>)

     Calcula o Hodge dual de <expr>.  Por exemplo:


          (%i1) load(itensor);
          (%o1)      /share/tensor/itensor.lisp
          (%i2) imetric(g);
          (%o2)                            done
          (%i3) idim(4);
          (%o3)                            done
          (%i4) icounter:100;
          (%o4)                             100
          (%i5) decsym(A,3,0,[anti(all)],[])$

          (%i6) ishow(A([i,j,k],[]))$
          (%t6)                           A
                                           i j k
          (%i7) ishow(canform(hodge(%)))$
                                    %1 %2 %3 %4
                         levi_civita            g        A
                                                 %1 %102  %2 %3 %4
          (%t7)          -----------------------------------------
                                             6
          (%i8) ishow(canform(hodge(%)))$
                           %1 %2 %3 %8            %4 %5 %6 %7
          (%t8) levi_civita            levi_civita            g        g
                                                               %1 %106  %2 %107
                                                      g        g      A        /6
                                                       %3 %108  %4 %8  %5 %6 %7
          (%i9) lc2kdt(%)$

          (%i10) %,kdelta$

          (%i11) ishow(canform(contract(expand(%))))$
          (%t11)                     - A
                                        %106 %107 %108


 -- Variável de Opção: igeowedge_flag
     Valor padrão: 'false'

     Controla o comportamento de produto cunha e derivada externa.
     Quando for esconhida para 'false' (o padrão), a noção de formas
     diferenciais irá corresponder àquela de um campo tensor covariante
     totalmente antisimétrico.  Quando escolhida para 'true', formas
     diferenciais irão concordar com a noção do elemento volume.

27.2.8 Exportando expressões TeX
--------------------------------

O pacote 'itensor' fornece suporte limitado à exportação de expressões
de tensores para o TeX. Uma vez que expressões 'itensor' aparecem como
chamada a funções, o comando regular 'tex' do Maxima não produzirá a
saída esperada.  Você pode tentar em seu lugar o comando 'tentex', o
qual tenta traduzir expressões de tensores dentro de objetos TeX
indexados apropriadamente.

 -- Função: tentex (<expr>)

     Para usar a função 'tentex', você deve primeiro chamar 'tentex',
     como no seguinte exemplo:


          (%i1) load(itensor);
          (%o1)      /share/tensor/itensor.lisp
          (%i2) load(tentex);
          (%o2)       /share/tensor/tentex.lisp
          (%i3) idummyx:m;
          (%o3)                                  m
          (%i4) ishow(icurvature([j,k,l],[i]))$
                      m1       i           m1       i           i            i
          (%t4)  ichr2    ichr2     - ichr2    ichr2     - ichr2      + ichr2
                      j k      m1 l        j l      m1 k        j l,k        j k,l
          (%i5) tentex(%)$
          $$\Gamma_{j\,k}^{m_1}\,\Gamma_{l\,m_1}^{i}-\Gamma_{j\,l}^{m_1}\,
           \Gamma_{k\,m_1}^{i}-\Gamma_{j\,l,k}^{i}+\Gamma_{j\,k,l}^{i}$$


     Note o uso da declaração 'idummyx', para evitar o aparecimento do
     sinal de porcentagem na expressão TeX, o qual pode induzir a erros
     de compilação.

     Note Bem: Essa vesão da função 'tentex' é um tanto quanto
     experimental.

27.2.9 Interagindo com o pacote 'ctensor'
-----------------------------------------

O pacote 'itensor' possui a habilidade de gerar código Maxima que pode
então ser executado no contexto do pacote 'ctensor'.  A função que
executa essa tarefa é 'ic_convert'.

 -- Função: ic_convert (<eqn>)

     Converte a equação <eqn> na sintaxe 'itensor' para uma declaração
     de atribuição 'ctensor'.  Adições implícitas sobre índices que
     ocorrem exatamente duas vezes são tornadas explícitas enquanto
     objetos indexados são transformados em arrays (os arrays subscritos
     estão na ordem de covariância seguidos de índices contravariantes
     dos objetos indexados).  A derivada de um objeto indexado será
     substituída pela forma substantiva de 'diff' tomada com relação a
     'ct_coords' subscrita pelo índice de derivação.  Os símbolos de
     Christoffel 'ichr1' e 'ichr2' irão ser traduzidos para 'lcs' e
     'mcs', respectivamente e se 'metricconvert' for 'true' então todas
     as ocorrências da métrica com dois índices covariantes (ou
     contravariantes) irão ser renomeadas para 'lg' (ou 'ug').
     Adicionalmente, ciclos 'do' irão ser introduzidos adicionando sobre
     todos os índices livres de forma que a declaração de atribuição
     transformada pode ser avaliada através de apenas fazendo 'ev'.  Os
     seguintes exemplos demonstam os recursos dessa função.

          (%i1) load(itensor);
          (%o1)      /share/tensor/itensor.lisp
          (%i2) eqn:ishow(t([i,j],[k])=f([],[])*g([l,m],[])*a([],[m],j)*b([i],[l,k]))$
                                       k        m   l k
          (%t2)                       t    = f a   b    g
                                       i j      ,j  i    l m
          (%i3) ic_convert(eqn);
          (%o3) for i thru dim do (for j thru dim

          do (for k thru dim do t        : f sum(sum(diff(a , ct_coords ) b
                                 i, j, k                   m           j   i, l, k

           g    , l, 1, dim), m, 1, dim)))
            l, m
          (%i4) imetric(g);
          (%o4)                                done
          (%i5) metricconvert:true;
          (%o5)                                true
          (%i6) ic_convert(eqn);
          (%o6) for i thru dim do (for j thru dim

          do (for k thru dim do t        : f sum(sum(diff(a , ct_coords ) b
                                 i, j, k                   m           j   i, l, k

           lg    , l, 1, dim), m, 1, dim)))
             l, m

27.2.10 Palavras reservadas
---------------------------

As palavras seguintes do Maxima são usadas internamente pelo pacote
'itensor' e não podem ser redefinidas:

       Keyword    Comments
       ------------------------------------------
       indices2() versão interna de indices()
       conti      Lista de índices contravariantes
       covi       Lista de índices covariantes de um objeto indexado
       deri       Lista de índices de derivada de um objeto indexado
       name       Retorna o nome de um objeto indexado
       concan
       irpmon
       lc0
       _lc2kdt0
       _lcprod
       _extlc


File: maxima.info,  Node: ctensor,  Next: Pacote atensor,  Prev: itensor,  Up: Top

28 ctensor
**********

* Menu:

* Introdução a ctensor::
* Funções e Variáveis Definidas para ctensor::


File: maxima.info,  Node: Introdução a ctensor,  Next: Funções e Variáveis Definidas para ctensor,  Prev: ctensor,  Up: ctensor

28.1 Introdução a ctensor
=========================

'ctensor' é um pacote de manipulação de componentes.  Para usar o pacote
'ctensor', digite 'load(ctensor)'.  Para começar uma sessão iterativa
com 'ctensor', digite 'csetup()'.  Você é primeiramente solicitado a
especificar a dimensão a ser manipulada.  Se a dimensão for 2, 3 ou 4
então a lista de coordenadas padrão é '[x,y]', '[x,y,z]' ou '[x,y,z,t]'
respectivamente.  Esses nomes podem ser mudados através da atribuição de
uma nova lista de coordenadas para a variável 'ct_coords' (descrita
abaixo) e o usuário é perguntado sobre isso.Cuidado deve ser tomado para
evitar o conflito de nomes de coordenadas com outras definições de
objetos.

   No próximo passo, o usuário informa a métrica ou diretamente ou de um
arquivo especificando sua posição ordinal.  Como um exemplo de um
arquivo de métrica comum, veja 'share/tensor/metrics.mac'.  A métrica
está armazenada na matriz LG. Finalmente, o inverso da métrica é
calculado e armazenado na matriz UG. Se tem a opção de realizar todos os
cálculos em séries de potência.

   Um protocolo amostra é iniciado abaixo para a métrica estática,
esfericamente simétrica (coordenadas padrão) que será aplicadas ao
problema de derivação das equações de vácuo de Einstein (que levam à
solução de Schwarzschild) como um exemplo.  Muitas das funções em
'ctensor' irão ser mostradas para a métrica padrão como exemplos.

     (%i1) load(ctensor);
     (%o1)      /usr/local/lib/maxima/share/tensor/ctensor.mac
     (%i2) csetup();
     Enter the dimension of the coordinate system:
     4;
     Do you wish to change the coordinate names?
     n;
     Do you want to
     1. Enter a new metric?

     2. Enter a metric from a file?

     3. Approximate a metric with a Taylor series?
     1;

     Is the matrix  1. Diagonal  2. Symmetric  3. Antisymmetric  4. General
     Answer 1, 2, 3 or 4
     1;
     Row 1 Column 1:
     a;
     Row 2 Column 2:
     x^2;
     Row 3 Column 3:
     x^2*sin(y)^2;
     Row 4 Column 4:
     -d;

     Matrix entered.
     Enter functional dependencies with the DEPENDS function or 'N' if none
     depends([a,d],x);
     Do you wish to see the metric?
     y;
                               [ a  0       0        0  ]
                               [                        ]
                               [     2                  ]
                               [ 0  x       0        0  ]
                               [                        ]
                               [         2    2         ]
                               [ 0  0   x  sin (y)   0  ]
                               [                        ]
                               [ 0  0       0       - d ]
     (%o2)                                done
     (%i3) christof(mcs);
                                                 a
                                                  x
     (%t3)                          mcs        = ---
                                       1, 1, 1   2 a

                                                  1
     (%t4)                           mcs        = -
                                        1, 2, 2   x

                                                  1
     (%t5)                           mcs        = -
                                        1, 3, 3   x

                                                 d
                                                  x
     (%t6)                          mcs        = ---
                                       1, 4, 4   2 d

                                                   x
     (%t7)                          mcs        = - -
                                       2, 2, 1     a

                                                cos(y)
     (%t8)                         mcs        = ------
                                      2, 3, 3   sin(y)

                                                    2
                                               x sin (y)
     (%t9)                      mcs        = - ---------
                                   3, 3, 1         a

     (%t10)                   mcs        = - cos(y) sin(y)
                                 3, 3, 2

                                                 d
                                                  x
     (%t11)                         mcs        = ---
                                       4, 4, 1   2 a
     (%o11)                               done



File: maxima.info,  Node: Funções e Variáveis Definidas para ctensor,  Prev: Introdução a ctensor,  Up: ctensor

28.2 Funções e Variáveis Definidas para ctensor
===============================================

28.2.1 Inicialização e configuração
-----------------------------------

 -- Função: csetup ()
     É uma função no pacote 'ctensor' (component tensor) que inicializa
     o pacote e permite ao usuário inserir uma métrica interativamente.
     Veja 'ctensor' para mais detalhes.

 -- Função: cmetric (<dis>)
 -- Função: cmetric ()
     É uma função no pacote 'ctensor' que calcula o inverso da métrica e
     prepara o pacote para cálculos adiante.

     Se 'cframe_flag' for 'false', a função calcula a métrica inversa
     'ug' a partir da matriz 'lg' (definida pelo usuário).  O
     determinante da métrica é também calculado e armazenado na variável
     'gdet'.  Mais adiante, o pacote determina se a métrica é diagonal e
     escolhe o valor de 'diagmetric' conforme a determinação.  Se o
     argumento opcional <dis> estiver presente e não for 'false', a
     saída é mostrada ao usuário pela linha de comando para que ele
     possa ver o inverso da métrica.

     Se 'cframe_flag' for 'true', a função espera que o valor de 'fri'
     (a matriz moldura inversa) e 'lfg' (a métrica da moldura) sejam
     definidas.  A partir dessas, a matriz da moldura 'fr' e a métrica
     da moldura inversa 'ufg' são calculadas.

 -- Função: ct_coordsys (<sistema_de_coordenadas>, <extra_arg>)
 -- Função: ct_coordsys (<sistema_de_coordenadas>)
     Escolhe um sistema de coordenadas predefinido e uma métrica.  O
     argumento <sistema_de_coordenadas> pode ser um dos seguintes
     símbolos:


            SYMBOL               Dim Coordenadas       Descrição/comentários
            --------------------------------------------------------------------------
            cartesian2d           2  [x,y]             Sist. de coord. cartesianas 2D
            polar                 2  [r,phi]           Sist. de coord. Polare
            elliptic              2  [u,v]
            confocalelliptic      2  [u,v]
            bipolar               2  [u,v]
            parabolic             2  [u,v]
            cartesian3d           3  [x,y,z]           Sist. de coord. cartesianas 3D
            polarcylindrical      3  [r,theta,z]
            ellipticcylindrical   3  [u,v,z]           Elíptica 2D com Z cilíndrico
            confocalellipsoidal   3  [u,v,w]
            bipolarcylindrical    3  [u,v,z]           Bipolar 2D com Z cilíndrico
            paraboliccylindrical  3  [u,v,z]           Parabólico 2D com Z cilíndrico
            paraboloidal          3  [u,v,phi]
            conical               3  [u,v,w]
            toroidal              3  [u,v,phi]
            spherical             3  [r,theta,phi]     Sist. de coord. Esféricas
            oblatespheroidal      3  [u,v,phi]
            oblatespheroidalsqrt  3  [u,v,phi]
            prolatespheroidal     3  [u,v,phi]
            prolatespheroidalsqrt 3  [u,v,phi]
            ellipsoidal           3  [r,theta,phi]
            cartesian4d           4  [x,y,z,t]         Sist. de coord. 4D
            spherical4d           4  [r,theta,eta,phi]
            exteriorschwarzschild 4  [t,r,theta,phi]   Métrica de Schwarzschild
            interiorschwarzschild 4  [t,z,u,v]        Métrica de Schwarzschild Interior
            kerr_newman           4  [t,r,theta,phi]   Métrica simétrica axialmente alterada


     'sistema_de_coordenadas' pode também ser uma lista de funções de
     transformação, seguida por uma lista contendo as varáveis
     coordenadas.  Por exemplo, você pode especificar uma métrica
     esférica como segue:


          (%i1) load(ctensor);
          (%o1)       /share/tensor/ctensor.mac
          (%i2) ct_coordsys([r*cos(theta)*cos(phi),r*cos(theta)*sin(phi),
                r*sin(theta),[r,theta,phi]]);
          (%o2)                                done
          (%i3) lg:trigsimp(lg);
                                     [ 1  0         0        ]
                                     [                       ]
                                     [     2                 ]
          (%o3)                      [ 0  r         0        ]
                                     [                       ]
                                     [         2    2        ]
                                     [ 0  0   r  cos (theta) ]
          (%i4) ct_coords;
          (%o4)                           [r, theta, phi]
          (%i5) dim;
          (%o5)                                  3


     Funções de transformação podem também serem usadas quando
     'cframe_flag' for 'true':


          (%i1) load(ctensor);
          (%o1)       /share/tensor/ctensor.mac
          (%i2) cframe_flag:true;
          (%o2)                                true
          (%i3) ct_coordsys([r*cos(theta)*cos(phi),r*cos(theta)*sin(phi),
                r*sin(theta),[r,theta,phi]]);
          (%o3)                                done
          (%i4) fri;
                [ cos(phi) cos(theta)  - cos(phi) r sin(theta)  - sin(phi) r cos(theta) ]
                [                                                                       ]
          (%o4) [ sin(phi) cos(theta)  - sin(phi) r sin(theta)   cos(phi) r cos(theta)  ]
                [                                                                       ]
                [     sin(theta)            r cos(theta)                   0            ]
          (%i5) cmetric();
          (%o5)                                false
          (%i6) lg:trigsimp(lg);
                                     [ 1  0         0        ]
                                     [                       ]
                                     [     2                 ]
          (%o6)                      [ 0  r         0        ]
                                     [                       ]
                                     [         2    2        ]
                                     [ 0  0   r  cos (theta) ]


     O argumento opcional <extra_arg> pode ser qualquer um dos
     seguintes:

     'cylindrical' diz a 'ct_coordsys' para anexar uma coordenada
     adicional cilíndrica.

     'minkowski' diz a 'ct_coordsys' para anexar uma coordenada com
     assinatura métrica negativa.

     'all' diz a 'ct_coordsys' para chamar 'cmetric' e 'christof(false)'
     após escolher a métrica.

     Se a variável global 'verbose' for escolhida para 'true',
     'ct_coordsys' mostra os valores de 'dim', 'ct_coords', e ou 'lg' ou
     'lfg' e 'fri', dependendo do valor de 'cframe_flag'.

 -- Função: init_ctensor ()
     Inicializa o pacote 'ctensor'.

     A função 'init_ctensor' reinicializa o pacote 'ctensor'.  Essa
     função remove todos os arrays e matrizes usados por 'ctensor',
     coloca todos os sinalizadores de volta a seus valores padrão,
     retorna 'dim' para 4, e retorna a métrica da moldura para a métrica
     da moldura de Lorentz.

28.2.2 Os tensores do espaço curvo
----------------------------------

O principal propósito do pacote 'ctensor' é calcular os tensores do
espaç(tempo) curvo, mais notavelmente os tensores usados na relatividade
geral.

   Quando uma base métrica é usada, 'ctensor' pode calcular os seguintes
tensores:


      lg  -- ug
        \      \
         lcs -- mcs -- ric -- uric
                   \      \       \
                    \      tracer - ein -- lein
                     \
                      riem -- lriem -- weyl
                          \
                           uriem



   'ctensor' pode também usar molduras móveis.  Quando 'cframe_flag' for
escolhida para 'true', os seguintes tensores podem ser calculados:


      lfg -- ufg
          \
      fri -- fr -- lcs -- mcs -- lriem -- ric -- uric
           \                       |  \      \       \
            lg -- ug               |   weyl   tracer - ein -- lein
                                   |\
                                   | riem
                                   |
                                   \uriem


 -- Função: christof (<dis>)
     Uma função no pacote 'ctensor'.  Essa função calcula os símbolos de
     Christoffel de ambos os tipos.  O argumento <dis> determina quais
     resultados são para serem imediatamente mostrados.  Os símbolos de
     Christoffel de primeiro e de segundo tipo são armazenados nos
     arrays 'lcs[i,j,k]' e 'mcs[i,j,k]' respectivamente e definidos para
     serem simétricos nos primeiros dois índices.  Se o argumento para
     'christof' for 'lcs' ou for 'mcs' então o único valor não nulo de
     'lcs[i,j,k]' ou de 'mcs[i,j,k]', respectivamente, será mostrado.
     Se o argumento for 'all' então o único valor não nulo de
     'lcs[i,j,k]' e o único valor não nulo de 'mcs[i,j,k]' serão
     mostrados.  Se o argumento for 'false' então a exibição dos
     elementos não acontecerá.  Os elementos do array 'mcs[i,j,k]' são
     definidos de uma tal maneira que o índice final é contravariante.

 -- Função: ricci (<dis>)
     Uma função no pacote 'ctensor'.  'ricci' calcula as componentes
     contravariantes (simétricas) 'ric[i,j]' do tensor de Ricci.  Se o
     argumento <dis> for 'true', então as componentes não nulas são
     mostradas.

 -- Função: uricci (<dis>)
     Essa função primeiro calcula as componentes contravariantes
     'ric[i,j]' do tensor de Ricci.  Então o tensor misto de Ricci é
     calculado usando o tensor métrico contravariante.  Se o valor do
     argumento <dis> for 'true', então essas componentes mistas,
     'uric[i,j]' (o índice "i" é covariante e o índice "j" é
     contravariante), serão mostradas diretamente.  De outra forma,
     'ricci(false)' irá simplesmente calcular as entradas do array
     'uric[i,j]' sem mostrar os resultados.

 -- Função: scurvature ()

     Retorna a curvatura escalar (obtida através da contração do tensor
     de Ricci) do Riemaniano multiplicado com a métrica dada.

 -- Função: einstein (<dis>)
     Uma função no pacote 'ctensor'.  'einstein' calcula o tensor misto
     de Einstein após os símbolos de Christoffel e o tensor de Ricci
     terem sido obtidos (com as funções 'christof' e 'ricci').  Se o
     argumento <dis> for 'true', então os valores não nulos do tensor
     misto de Einstein 'ein[i,j]' serão mostrados quando 'j' for o
     índice contravariante.  A variável 'rateinstein' fará com que a
     simplificação racional ocorra sobre esses componentes.  Se 'ratfac'
     for 'true' então as componentes irão também ser fatoradas.

 -- Função: leinstein (<dis>)
     Tensor covariante de Einstein.  'leinstein' armazena o valor do
     tensor covariante de Einstein no array 'lein'.  O tensor covariante
     de Einstein é calculado a partir tensor misto de Einstein 'ein'
     através da multiplicação desse pelo tensor métrico.  Se o argumento
     <dis> for 'true', então os valores não nulos do tensor covariante
     de Einstein são mostrados.

 -- Função: riemann (<dis>)
     Uma função no pacote 'ctensor'.  'riemann' calcula o tensor de
     curvatura de Riemann a partir da métrica dada e correspondendo aos
     símbolos de Christoffel.  As seguintes convenções de índice são
     usadas:

                          l      _l       _l       _l   _m    _l   _m
           R[i,j,k,l] =  R    = |      - |      + |    |   - |    |
                          ijk     ij,k     ik,j     mk   ij    mj   ik

     Essa notação é consistente com a notação usada por no pacote
     'itensor' e sua função 'icurvature'.  Se o argumento opcional <dis>
     for 'true', as componentes não nulas 'riem[i,j,k,l]' serão
     mostradas.  Como com o tensor de Einstein, vários comutadores
     escolhidos pelo usuário controlam a simplificação de componentes do
     tensor de Riemann.  Se 'ratriemann' for 'true', então simplificação
     racional será feita.  Se 'ratfac' for 'true' então cada uma das
     componentes irá também ser fatorada.

     Se a variável 'cframe_flag' for 'false', o tensor de Riemann é
     calculado diretamente dos símbolos de Christoffel.  Se
     'cframe_flag' for 'true', o tensor covariante de Riemann é
     calculado primeiro dos coeficientes de campo da moldura.

 -- Função: lriemann (<dis>)
     Tensor covariante de Riemann ('lriem[]').

     Calcula o tensor covariante de Riemann como o array 'lriem'.  Se o
     argumento <dis> for 'true', únicos valores não nulos são mostrados.

     Se a variável 'cframe_flag' for 'true', o tensor covariante de
     Riemann é calculado diretamente dos coeficientes de campo da
     moldura.  De outra forma, o tensor (3,1) de Riemann é calculado
     primeiro.

     Para informação sobre a ordenação de índice, veja 'riemann'.

 -- Função: uriemann (<dis>)
     Calcula as componentes contravariantes do tensor de curvatura de
     Riemann como elementos do array 'uriem[i,j,k,l]'.  Esses são
     mostrados se <dis> for 'true'.

 -- Função: rinvariant ()
     Compõe o invariante de Kretchmann ('kinvariant') obtido através da
     contração dos tensores

          lriem[i,j,k,l]*uriem[i,j,k,l].

     Esse objeto não é automaticamente simplificado devido ao fato de
     poder ser muito largo.

 -- Função: weyl (<dis>)
     Calcula o tensor conformal de Weyl.  Se o argumento <dis> for
     'true', as componentes não nulas 'weyl[i,j,k,l]' irão ser mostradas
     para o usuário.  De outra forma, essas componentes irão
     simplesmente serem calculadas e armazenadas.  Se o comutador
     'ratweyl' é escolhido para 'true', então as componentes irão ser
     racionalmente simplificadas; se 'ratfac' for 'true' então os
     resultados irão ser fatorados também.

28.2.3 Expansão das séries de Taylor
------------------------------------

O pacote 'ctensor' possui a habilidade para truncar resultados assumindo
que eles são aproximações das séries de Taylor.  Esse comportamenteo é
controlado através da variável 'ctayswitch'; quando escolhida para
'true', 'ctensor' faz uso internamente da função 'ctaylor' quando
simplifica resultados.

   A função 'ctaylor' é invocada pelas seguintes funções de 'ctensor':


         Function     Comments
         ---------------------------------
         christof()   só para mcs
         ricci()
         uricci()
         einstein()
         riemann()
         weyl()
         checkdiv()

 -- Função: ctaylor ()

     A função 'ctaylor' trunca seus argumentos através da conversão
     destes para uma série de Taylor usando 'taylor', e então chamando
     'ratdisrep'.  Isso tem efeito combinado de abandonar termos de
     ordem mais alta na variável de expansão 'ctayvar'.  A ordem dos
     termos que podem ser abandonados é definida através de 'ctaypov'; o
     ponto em torno do qual a expansão da série é realizada está
     especificado em 'ctaypt'.

     Como um exemplo, considere uma métrica simples que é uma
     perturbação da métrica de Minkowski.  Sem restrições adicionais,
     mesmo uma métrica diagonal produz expressões para o tensor de
     Einstein que são de longe muito complexas:


          (%i1) load(ctensor);
          (%o1)       /share/tensor/ctensor.mac
          (%i2) ratfac:true;
          (%o2)                                true
          (%i3) derivabbrev:true;
          (%o3)                                true
          (%i4) ct_coords:[t,r,theta,phi];
          (%o4)                         [t, r, theta, phi]
          (%i5) lg:matrix([-1,0,0,0],[0,1,0,0],[0,0,r^2,0],[0,0,0,r^2*sin(theta)^2]);
                                  [ - 1  0  0         0        ]
                                  [                            ]
                                  [  0   1  0         0        ]
                                  [                            ]
          (%o5)                   [          2                 ]
                                  [  0   0  r         0        ]
                                  [                            ]
                                  [              2    2        ]
                                  [  0   0  0   r  sin (theta) ]
          (%i6) h:matrix([h11,0,0,0],[0,h22,0,0],[0,0,h33,0],[0,0,0,h44]);
                                      [ h11   0    0    0  ]
                                      [                    ]
                                      [  0   h22   0    0  ]
          (%o6)                       [                    ]
                                      [  0    0   h33   0  ]
                                      [                    ]
                                      [  0    0    0   h44 ]
          (%i7) depends(l,r);
          (%o7)                               [l(r)]
          (%i8) lg:lg+l*h;
                   [ h11 l - 1      0          0                 0            ]
                   [                                                          ]
                   [     0      h22 l + 1      0                 0            ]
                   [                                                          ]
          (%o8)    [                        2                                 ]
                   [     0          0      r  + h33 l            0            ]
                   [                                                          ]
                   [                                    2    2                ]
                   [     0          0          0       r  sin (theta) + h44 l ]
          (%i9) cmetric(false);
          (%o9)                                done
          (%i10) einstein(false);
          (%o10)                               done
          (%i11) ntermst(ein);
          [[1, 1], 62]
          [[1, 2], 0]
          [[1, 3], 0]
          [[1, 4], 0]
          [[2, 1], 0]
          [[2, 2], 24]
          [[2, 3], 0]
          [[2, 4], 0]
          [[3, 1], 0]
          [[3, 2], 0]
          [[3, 3], 46]
          [[3, 4], 0]
          [[4, 1], 0]
          [[4, 2], 0]
          [[4, 3], 0]
          [[4, 4], 46]
          (%o12)                               done


     Todavia, se nós recalcularmos esse exemplo como uma aproximação que
     é linear na variável 'l', pegamos expressões muito simples:


          (%i14) ctayswitch:true;
          (%o14)                               true
          (%i15) ctayvar:l;
          (%o15)                                 l
          (%i16) ctaypov:1;
          (%o16)                                 1
          (%i17) ctaypt:0;
          (%o17)                                 0
          (%i18) christof(false);
          (%o18)                               done
          (%i19) ricci(false);
          (%o19)                               done
          (%i20) einstein(false);
          (%o20)                               done
          (%i21) ntermst(ein);
          [[1, 1], 6]
          [[1, 2], 0]
          [[1, 3], 0]
          [[1, 4], 0]
          [[2, 1], 0]
          [[2, 2], 13]
          [[2, 3], 2]
          [[2, 4], 0]
          [[3, 1], 0]
          [[3, 2], 2]
          [[3, 3], 9]
          [[3, 4], 0]
          [[4, 1], 0]
          [[4, 2], 0]
          [[4, 3], 0]
          [[4, 4], 9]
          (%o21)                               done
          (%i22) ratsimp(ein[1,1]);
                                   2      2  4               2     2
          (%o22) - (((h11 h22 - h11 ) (l )  r  - 2 h33 l    r ) sin (theta)
                                        r               r r

                                          2               2      4    2
                            - 2 h44 l    r  - h33 h44 (l ) )/(4 r  sin (theta))
                                     r r                r




     Essa compatibilidade pode ser útil, por exemplo, quando trabalhamos
     no limite do campo fraco longe de uma fonte gravitacional.

28.2.4 Campos de moldura
------------------------

Quando a variável 'cframe_flag' for escolhida para 'true', o pacote
'ctensor' executa seus cálculos usando uma moldura móvel.

 -- Função: frame_bracket (<fr>, <fri>, <diagframe>)
     O delimitador da moldura ('fb[]').

     Calcula o delimitador da moldura conforme a seguinte definição:

             c          c         c        d     e
          ifb   = ( ifri    - ifri    ) ifr   ifr
             ab         d,e       e,d      a     b

28.2.5 Classificação Algébrica
------------------------------

Um novo recurso (a partir de November de 2004) de 'ctensor' é sua
habilidade para calcular a classificação de Petrov de uma métrica espaço
tempo tetradimensional.  Para uma demonstração dessa compatibilidade,
veja o arquivo 'share/tensor/petrov.dem'.

 -- Função: nptetrad ()
     Calcula um tetrad nulo de Newman-Penrose ('np') e seus índices
     ascendentes em contrapartida ('npi').  Veja 'petrov' para um
     exemplo.

     O tetrad nulo é construído assumindo que uma moldura métrica
     ortonormal tetradimensional com assinatura métrica (-,+,+,+) está
     sendo usada.  As componentes do tetrad nulo são relacionadas para a
     matriz moldura inversa como segue:


          np  = (fri  + fri ) / sqrt(2)
            1       1      2

          np  = (fri  - fri ) / sqrt(2)
            2       1      2

          np  = (fri  + %i fri ) / sqrt(2)
            3       3         4

          np  = (fri  - %i fri ) / sqrt(2)
            4       3         4


 -- Função: psi (<dis>)
     Calcula os cinco coeficientes de Newman-Penrose
     'psi[0]'...'psi[4]'.  Se 'psi' for escolhida para 'true', os
     coeficientes são mostrados.  Veja 'petrov' para um exemplo.

     Esses coeficientes são calculados a partir do tensor de Weyl em uma
     base de coordenada.  Se uma base de moldura for usada,o tensor de
     Weyl é primeiro convertido para a base de coordenada, que pode ser
     um procedimento computacional expansível.  Por essa razão, em
     alguns casos pode ser mais vantajoso usar uma base de coordenada em
     primeiro lugar antes que o tensor de Weyl seja calculado.  Note
     todavia, que para a construção de um tetrad nulo de Newman-Penrose
     é necessário uma base de moldura.  Portanto, uma seqüência de
     cálculo expressiva pode começar com uma base de moldura, que é
     então usada para calcular 'lg' (calculada automaticamente através
     de 'cmetric') e em seguida calcula 'ug'.  Nesse ponto, você pode
     comutar de volta para uma base de coordenada escolhendo
     'cframe_flag' para 'false' antes de começar a calcular os símbolos
     de Christoffel.  Mudando para uma base de moldura em um estágio
     posterior pode retornar resultados inconsistentes, já que você pode
     terminar com um grande mistura de tensores, alguns calculados em
     uma base de moldura, alguns em uma base de coordenada, sem nenhum
     modo para distingüir entre os dois tipos.

 -- Função: petrov ()
     Calcula a classificação de petrov da métrica caracterizada através
     de 'psi[0]'...'psi[4]'.

     Por exemplo, o seguinte demonstra como obter a classificação de
     Petrov da métrica de Kerr:

          (%i1) load(ctensor);
          (%o1)       /share/tensor/ctensor.mac
          (%i2) (cframe_flag:true,gcd:spmod,ctrgsimp:true,ratfac:true);
          (%o2)                                true
          (%i3) ct_coordsys(exteriorschwarzschild,all);
          (%o3)                                done
          (%i4) ug:invert(lg)$
          (%i5) weyl(false);
          (%o5)                                done
          (%i6) nptetrad(true);
          (%t6) np =

                 [  sqrt(r - 2 m)           sqrt(r)                                     ]
                 [ ---------------   ---------------------      0             0         ]
                 [ sqrt(2) sqrt(r)   sqrt(2) sqrt(r - 2 m)                              ]
                 [                                                                      ]
                 [  sqrt(r - 2 m)            sqrt(r)                                    ]
                 [ ---------------  - ---------------------     0             0         ]
                 [ sqrt(2) sqrt(r)    sqrt(2) sqrt(r - 2 m)                             ]
                 [                                                                      ]
                 [                                              r      %i r sin(theta)  ]
                 [        0                    0             -------   ---------------  ]
                 [                                           sqrt(2)       sqrt(2)      ]
                 [                                                                      ]
                 [                                              r       %i r sin(theta) ]
                 [        0                    0             -------  - --------------- ]
                 [                                           sqrt(2)        sqrt(2)     ]

                                       sqrt(r)          sqrt(r - 2 m)
          (%t7) npi = matrix([- ---------------------, ---------------, 0, 0],
                                sqrt(2) sqrt(r - 2 m)  sqrt(2) sqrt(r)

                    sqrt(r)            sqrt(r - 2 m)
          [- ---------------------, - ---------------, 0, 0],
             sqrt(2) sqrt(r - 2 m)    sqrt(2) sqrt(r)

                     1               %i
          [0, 0, ---------, --------------------],
                 sqrt(2) r  sqrt(2) r sin(theta)

                     1                 %i
          [0, 0, ---------, - --------------------])
                 sqrt(2) r    sqrt(2) r sin(theta)

          (%o7)                                done
          (%i7) psi(true);
          (%t8)                              psi  = 0
                                                0

          (%t9)                              psi  = 0
                                                1

                                                    m
          (%t10)                             psi  = --
                                                2    3
                                                    r

          (%t11)                             psi  = 0
                                                3

          (%t12)                             psi  = 0
                                                4
          (%o12)                               done
          (%i12) petrov();
          (%o12)                                 D


     A função de classificação Petrov é baseada no algorítmo publicado
     em "Classifying geometries in general relativity: III
     Classification in practice" por Pollney, Skea, e d'Inverno, Class.
     Quant.  Grav.  17 2885-2902 (2000).  Exceto para alguns casos de
     teste simples, a implementação não está testada até 19 de Dezembro
     de 2004, e é provável que contenha erros.

28.2.6 Torsão e não metricidade
-------------------------------

'ctensor' possui a habilidade de calcular e incluir coeficientes de
torsão e não metricidade nos coeficientes de conecção.

   Os coeficientes de torsão são calculados a partir de um tensor
fornecido pelo usuário 'tr', que pode ser um tensor de categoria (2,1).
A partir disso, os coeficientes de torsão 'kt' são calculados de acordo
com a seguinte fórmula:


                   m          m      m
            - g  tr   - g   tr   - tr   g
               im  kj    jm   ki     ij  km
     kt   = -------------------------------
       ijk                 2


       k     km
     kt   = g   kt
       ij         ijm


   Note que somente o tensor de índice misto é calculao e armazenado no
array 'kt'.

   Os coeficientes de não metricidade são calculados a partir do vetor
de não metricidade fornecido pelo usuário 'nm'.  A partir disso, os
coeficientes de não metricidade 'nmc' são calculados como segue:


                  k    k        km
            -nm  D  - D  nm  + g   nm  g
        k      i  j    i   j         m  ij
     nmc  = ------------------------------
        ij                2


   onde D simboliza o delta de Kronecker.

   Quando 'ctorsion_flag' for escolhida para 'true', os valores de 'kt'
são subtraídos dos coeficientes de conecção indexados mistos calculados
através de 'christof' e armazenados em 'mcs'.  Similarmente, se
'cnonmet_flag' for escolhida para 'true', os valores de 'nmc' são
subtraídos dos coeficientes de conecção indexados mistos.

   Se necessário, 'christof' chama as funções 'contortion' e
'nonmetricity' com o objetivo de calcular 'kt' e 'nm'.

 -- Função: contortion (<tr>)

     Calcula os coeficientes de contorsão de categoria (2,1) a partir do
     tensor de torsão <tr>.

 -- Função: nonmetricity (<nm>)

     Calcula o coeficiente de não metricidade de categoria (2,1) a
     partir do vetor de não metricidade <nm>.

28.2.7 Recursos diversos
------------------------

 -- Função: ctransform (<M>)
     Uma função no pacote 'ctensor' que irá executar uma transformação
     de coordenadas sobre uma matriz simétrica quadrada arbitrária <M>.
     O usuário deve informar as funçãoes que definem a transformação.
     (Formalmente chamada 'transform'.)

 -- Função: findde (<A>, <n>)

     Retorna uma lista de equações diferenciais únicas (expressões)
     correspondendo aos elementos do array quadrado <n> dimensional <A>.
     Atualmente, <n> pode ser 2 ou 3.  'deindex' é uma lista global
     contendo os índices de <A> correspondendo a essas únicas equações
     diferenciais.  Para o tensor de Einstein ('ein'), que é um array
     dimensional, se calculado para a métrica no exemplo abaixo,
     'findde' fornece as seguintes equações diferenciais independentes:

          (%i1) load(ctensor);
          (%o1)       /share/tensor/ctensor.mac
          (%i2) derivabbrev:true;
          (%o2)                                true
          (%i3) dim:4;
          (%o3)                                  4
          (%i4) lg:matrix([a,0,0,0],[0,x^2,0,0],[0,0,x^2*sin(y)^2,0],[0,0,0,-d]);
                                    [ a  0       0        0  ]
                                    [                        ]
                                    [     2                  ]
                                    [ 0  x       0        0  ]
          (%o4)                     [                        ]
                                    [         2    2         ]
                                    [ 0  0   x  sin (y)   0  ]
                                    [                        ]
                                    [ 0  0       0       - d ]
          (%i5) depends([a,d],x);
          (%o5)                            [a(x), d(x)]
          (%i6) ct_coords:[x,y,z,t];
          (%o6)                            [x, y, z, t]
          (%i7) cmetric();
          (%o7)                                done
          (%i8) einstein(false);
          (%o8)                                done
          (%i9) findde(ein,2);
                                                      2
          (%o9) [d  x - a d + d, 2 a d d    x - a (d )  x - a  d d  x + 2 a d d
                  x                     x x         x        x    x            x

                                                                  2          2
                                                          - 2 a  d , a  x + a  - a]
                                                               x      x
          (%i10) deindex;
          (%o10)                     [[1, 1], [2, 2], [4, 4]]


 -- Função: cograd ()
     Calcula o gradiente covariante de uma função escalar permitindo ao
     usuário escolher o nome do vetor correspondente como o exemplo sob
     'contragrad' ilustra.
 -- Função: contragrad ()

     Calcula o gradiente contravariante de uma função escalar permitindo
     ao usuário escolher o nome do vetor correspondente como o exemplo
     abaixo como ilustra a métrica de Schwarzschild:


          (%i1) load(ctensor);
          (%o1)       /share/tensor/ctensor.mac
          (%i2) derivabbrev:true;
          (%o2)                                true
          (%i3) ct_coordsys(exteriorschwarzschild,all);
          (%o3)                                done
          (%i4) depends(f,r);
          (%o4)                               [f(r)]
          (%i5) cograd(f,g1);
          (%o5)                                done
          (%i6) listarray(g1);
          (%o6)                            [0, f , 0, 0]
                                                r
          (%i7) contragrad(f,g2);
          (%o7)                                done
          (%i8) listarray(g2);
                                         f  r - 2 f  m
                                          r        r
          (%o8)                      [0, -------------, 0, 0]
                                               r


 -- Função: dscalar ()
     Calcula o tensor d'Alembertiano da função escalar assim que as
     dependências tiverem sido declaradas sobre a função.  Po exemplo:

          (%i1) load(ctensor);
          (%o1)       /share/tensor/ctensor.mac
          (%i2) derivabbrev:true;
          (%o2)                                true
          (%i3) ct_coordsys(exteriorschwarzschild,all);
          (%o3)                                done
          (%i4) depends(p,r);
          (%o4)                               [p(r)]
          (%i5) factor(dscalar(p));
                                    2
                              p    r  - 2 m p    r + 2 p  r - 2 m p
                               r r           r r        r          r
          (%o5)               --------------------------------------
                                                 2
                                                r

 -- Função: checkdiv ()

     Calcula a divergência covariante do tensor de segunda categoria
     misto (cujo primeiro índice deve ser covariante) imprimindo as
     correspondentes n componentes do campo do vetor (a divergência)
     onde n = 'dim'.  Se o argumento para a função for 'g' então a
     divergência do tensor de Einstein será formada e pode ser zero.
     Adicionalmente, a divergência (vetor) é dada no array chamado
     'div'.

 -- Função: cgeodesic (<dis>)
     Uma função no pacote 'ctensor'.  'cgeodesic' calcula as equações
     geodésicas de movimento para uma dada métrica.  Elas são
     armazenadas no array 'geod[i]'.  Se o argumento <dis> for 'true'
     então essas equações são mostradas.

 -- Função: bdvac (<f>)

     Gera as componentes covariantes das equações de campo de vácuo da
     teoria de gravitação de Brans-Dicke.  O campo escalar é
     especificado através do argumento <f>, que pode ser um nome de
     função (com apóstrofo) com dependências funcionais, e.g., ''p(x)'.

     As componentes de segunda categoria do tensor campo covariante são
     as componentes de segunda categoria representadas pelo array 'bd'.

 -- Função: invariant1 ()

     Gera o tensor misto de Euler-Lagrange (equações de campo) para a
     densidade invariante de R^2.  As equações de campo são componentes
     de um array chamado 'inv1'.

 -- Função: invariant2 ()

     *** NOT YET IMPLEMENTED ***

     Gera o tensor misto de Euler-Lagrange (equações de campo) para a
     densidade invariante de 'ric[i,j]*uriem[i,j]'.  As equações de
     campo são as componentes de um array chamado 'inv2'.

 -- Função: bimetric ()

     *** NOT YET IMPLEMENTED ***

     Gera as euauações de campo da teoria bimétrica de Rosen.  As
     equações de campo são as componentes de um array chamado 'rosen'.

28.2.8 Funções utilitárias
--------------------------

 -- Função: diagmatrixp (<M>)

     Retorna 'true' se <M> for uma matriz diagonal ou um array (2D).

 -- Função: symmetricp (<M>)

     Retorna 'true' se <M> for uma matriz simétrica ou um array (2D).

 -- Função: ntermst (<f>)
     Fornece ao usuário um rápido quadro do "tamanho" do tensor
     duplamente subscrito (array) <f>.  Imprime uma lista de dois
     elementos onde o segundo elemento corresponde a N-TERMOS de
     componentes especificadas através dos primeiros elementos.  Nesse
     caminho, é possível rapidamente encontrar as expressões não nulas e
     tentar simplificação.

 -- Função: cdisplay (<ten>)
     Mostra todos os elementos do tensor <ten>, como representados por
     um array multidimensional.  Tensores de categoria 0 e 1, assim como
     outros tipos de variáveis, são mostrados com 'ldisplay'.  Tensores
     de categoria 2 são mostrados como matrizes bidimensionais, enquanto
     tensores de alta categoria são mostrados como uma lista de matrizes
     bidimensionais.  Por exemplo, o tensor de Riemann da métrica de
     Schwarzschild pode ser visto como:

          (%i1) load(ctensor);
          (%o1)       /share/tensor/ctensor.mac
          (%i2) ratfac:true;
          (%o2)                                true
          (%i3) ct_coordsys(exteriorschwarzschild,all);
          (%o3)                                done
          (%i4) riemann(false);
          (%o4)                                done
          (%i5) cdisplay(riem);
                         [ 0               0                    0            0      ]
                         [                                                          ]
                         [                              2                           ]
                         [      3 m (r - 2 m)   m    2 m                            ]
                         [ 0  - ------------- + -- - ----       0            0      ]
                         [            4          3     4                            ]
                         [           r          r     r                             ]
                         [                                                          ]
              riem     = [                                 m (r - 2 m)              ]
                  1, 1   [ 0               0               -----------       0      ]
                         [                                      4                   ]
                         [                                     r                    ]
                         [                                                          ]
                         [                                              m (r - 2 m) ]
                         [ 0               0                    0       ----------- ]
                         [                                                   4      ]
                         [                                                  r       ]

                                          [    2 m (r - 2 m)       ]
                                          [ 0  -------------  0  0 ]
                                          [          4             ]
                                          [         r              ]
                               riem     = [                        ]
                                   1, 2   [ 0        0        0  0 ]
                                          [                        ]
                                          [ 0        0        0  0 ]
                                          [                        ]
                                          [ 0        0        0  0 ]

                                          [         m (r - 2 m)    ]
                                          [ 0  0  - -----------  0 ]
                                          [              4         ]
                                          [             r          ]
                               riem     = [                        ]
                                   1, 3   [ 0  0        0        0 ]
                                          [                        ]
                                          [ 0  0        0        0 ]
                                          [                        ]
                                          [ 0  0        0        0 ]

                                          [            m (r - 2 m) ]
                                          [ 0  0  0  - ----------- ]
                                          [                 4      ]
                                          [                r       ]
                               riem     = [                        ]
                                   1, 4   [ 0  0  0        0       ]
                                          [                        ]
                                          [ 0  0  0        0       ]
                                          [                        ]
                                          [ 0  0  0        0       ]

                                         [       0         0  0  0 ]
                                         [                         ]
                                         [       2 m               ]
                                         [ - ------------  0  0  0 ]
                              riem     = [    2                    ]
                                  2, 1   [   r  (r - 2 m)          ]
                                         [                         ]
                                         [       0         0  0  0 ]
                                         [                         ]
                                         [       0         0  0  0 ]

                             [     2 m                                         ]
                             [ ------------  0        0               0        ]
                             [  2                                              ]
                             [ r  (r - 2 m)                                    ]
                             [                                                 ]
                             [      0        0        0               0        ]
                             [                                                 ]
                  riem     = [                         m                       ]
                      2, 2   [      0        0  - ------------        0        ]
                             [                     2                           ]
                             [                    r  (r - 2 m)                 ]
                             [                                                 ]
                             [                                         m       ]
                             [      0        0        0         - ------------ ]
                             [                                     2           ]
                             [                                    r  (r - 2 m) ]

                                          [ 0  0       0        0 ]
                                          [                       ]
                                          [            m          ]
                                          [ 0  0  ------------  0 ]
                               riem     = [        2              ]
                                   2, 3   [       r  (r - 2 m)    ]
                                          [                       ]
                                          [ 0  0       0        0 ]
                                          [                       ]
                                          [ 0  0       0        0 ]

                                          [ 0  0  0       0       ]
                                          [                       ]
                                          [               m       ]
                                          [ 0  0  0  ------------ ]
                               riem     = [           2           ]
                                   2, 4   [          r  (r - 2 m) ]
                                          [                       ]
                                          [ 0  0  0       0       ]
                                          [                       ]
                                          [ 0  0  0       0       ]

                                                [ 0  0  0  0 ]
                                                [            ]
                                                [ 0  0  0  0 ]
                                                [            ]
                                     riem     = [ m          ]
                                         3, 1   [ -  0  0  0 ]
                                                [ r          ]
                                                [            ]
                                                [ 0  0  0  0 ]

                                                [ 0  0  0  0 ]
                                                [            ]
                                                [ 0  0  0  0 ]
                                                [            ]
                                     riem     = [    m       ]
                                         3, 2   [ 0  -  0  0 ]
                                                [    r       ]
                                                [            ]
                                                [ 0  0  0  0 ]

                                         [   m                      ]
                                         [ - -   0   0       0      ]
                                         [   r                      ]
                                         [                          ]
                                         [        m                 ]
                                         [  0   - -  0       0      ]
                              riem     = [        r                 ]
                                  3, 3   [                          ]
                                         [  0    0   0       0      ]
                                         [                          ]
                                         [              2 m - r     ]
                                         [  0    0   0  ------- + 1 ]
                                         [                 r        ]

                                              [ 0  0  0    0   ]
                                              [                ]
                                              [ 0  0  0    0   ]
                                              [                ]
                                   riem     = [            2 m ]
                                       3, 4   [ 0  0  0  - --- ]
                                              [             r  ]
                                              [                ]
                                              [ 0  0  0    0   ]

                                          [       0        0  0  0 ]
                                          [                        ]
                                          [       0        0  0  0 ]
                                          [                        ]
                               riem     = [       0        0  0  0 ]
                                   4, 1   [                        ]
                                          [      2                 ]
                                          [ m sin (theta)          ]
                                          [ -------------  0  0  0 ]
                                          [       r                ]

                                          [ 0        0        0  0 ]
                                          [                        ]
                                          [ 0        0        0  0 ]
                                          [                        ]
                               riem     = [ 0        0        0  0 ]
                                   4, 2   [                        ]
                                          [         2              ]
                                          [    m sin (theta)       ]
                                          [ 0  -------------  0  0 ]
                                          [          r             ]

                                        [ 0  0          0          0 ]
                                        [                            ]
                                        [ 0  0          0          0 ]
                                        [                            ]
                             riem     = [ 0  0          0          0 ]
                                 4, 3   [                            ]
                                        [                2           ]
                                        [         2 m sin (theta)    ]
                                        [ 0  0  - ---------------  0 ]
                                        [                r           ]

                           [        2                                             ]
                           [   m sin (theta)                                      ]
                           [ - -------------         0                0         0 ]
                           [         r                                            ]
                           [                                                      ]
                           [                         2                            ]
                           [                    m sin (theta)                     ]
                riem     = [        0         - -------------         0         0 ]
                    4, 4   [                          r                           ]
                           [                                                      ]
                           [                                          2           ]
                           [                                   2 m sin (theta)    ]
                           [        0                0         ---------------  0 ]
                           [                                          r           ]
                           [                                                      ]
                           [        0                0                0         0 ]

          (%o5)                                done


 -- Função: deleten (<L>, <n>)
     Retorna uma nova lista consistindo de <L> com o <n>'ésimo elemento
     apagado.

28.2.9 Variáveis usadas por 'ctensor'
-------------------------------------

 -- Variável de opção: dim
     Valor padrão: 4

     Uma opção no pacote 'ctensor'.  'dim' é a dimensão de multiplicação
     com o padrão 4.  O comando 'dim: n' irá escolher a dimensão para
     qualquer outro valor 'n'.

 -- Variável de opção: diagmetric
     Valor padrão: 'false'

     Uma opção no pacote 'ctensor'.  Se 'diagmetric' for 'true' rotinas
     especiais calculam todos os objetos geométricos (que possuem o
     tensor métrico explicitamente) levando em consideração a
     diagonalidade da métrica.  Tempo de execuçào reduzido irá, com
     certeza, resultar dessa escolha.  Nota: essa opção é escolhida
     automaticamente por 'csetup' se uma métrica diagonal for
     especificada.

 -- Variável de opção: ctrgsimp

     Faz com que simplificações trigonométricas sejam usadas quando
     tensores forem calculados.  Atualmente, 'ctrgsimp' afeta somente
     cálculos envolvendo uma moldura móvel.

 -- Variável de opção: cframe_flag

     Faz com que cálculos sejam executados relativamente a uma moldura
     móvel em oposição a uma métrica holonômica.  A moldura é definida
     através do array da moldura inversa 'fri' e da métrica da moldura
     'lfg'.  Para cálculos usando uma moldura Cartesiana, 'lfg' pode ser
     a matriz unitária de dimensão apropriada; para cálculos em uma
     moldura de Lorentz, 'lfg' pode ter a assinatura apropriada.

 -- Variável de opção: ctorsion_flag

     Faz com que o tensor de contorsão seja incluído no cálculo dos
     coeficientes de conecção.  O tensor de contorsão por si mesmo é
     calculado através de 'contortion' a partir do tensor 'tr' fornecido
     pelo usuário.

 -- Variável de opção: cnonmet_flag

     Faz com que os coeficientes de não metricidade sejam incluídos no
     cálculo dos coeficientes de conecção.  Os coeficientes de não
     metricidade são calculados a partir do vetor de não metricidade
     'nm' fornecido pelo usuário através da função 'nonmetricity'.

 -- Variável de opção: ctayswitch

     Se escolhida para 'true', faz com que alguns cálculos de 'ctensor'
     sejam realizados usando expansões das séries de Taylor.
     atualmente, 'christof', 'ricci', 'uricci', 'einstein', e 'weyl'
     levam em conta essa escolha.

 -- Variável de opção: ctayvar

     Variável usada pela expansão de séries de Taylor se 'ctayswitch' é
     escolhida para 'true'.

 -- Variável de opção: ctaypov

     Maximo expoente usado em expansões de séries de Taylor quando
     'ctayswitch' for escolhida para 'true'.

 -- Variável de opção: ctaypt

     Ponto em torno do qual expansões de séries de Taylor sao realizadas
     quando 'ctayswitch' for escolhida para 'true'.

 -- Variável de sistema: gdet

     O determinante do tensor métrico 'lg'.  Calculado através de
     'cmetric' quando 'cframe_flag' for escolhido para 'false'.

 -- Variável de opção: ratchristof

     Faz com que simplificações racionais sejam aplicadas através de
     'christof'.

 -- Variável de opção: rateinstein
     Valor padrão: 'true'

     Se 'true' simplificação racional será executada sobre as
     componentes não nulas de tensores de Einstein; se 'ratfac' for
     'true' então as componentes irão também ser fatoradas.

 -- Variável de opção: ratriemann
     Valor padrão: 'true'

     Um dos comutadores que controlam simplificações dos tensores de
     Riemann; se 'true', então simplificações racionais irão ser
     concluídas; se 'ratfac' for 'true' então cada uma das componentes
     irá também ser fatorada.

 -- Variável de opção: ratweyl
     Valor padrão: 'true'

     Se 'true', esse comutador faz com que a função de 'weyl' aplique
     simplificações racionais aos valores do tensor de Weyl.  Se
     'ratfac' for 'true', então as componentes irão também ser
     fatoradas.

 -- Variável: lfg
     A moldura métrica covariante.  Por padrão, é inicializada para a
     moldura tetradimensional de Lorentz com assinatura (+,+,+,-).
     Usada quando 'cframe_flag' for 'true'.

 -- Variável: ufg
     A métrica da moldura inversa.  Calculada de 'lfg' quando 'cmetric'
     for chamada enquanto 'cframe_flag' for escolhida para 'true'.

 -- Variável: riem
     O tensor de categoria (3,1) de Riemann.  Calculado quando a função
     'riemann' é invocada.  Para informação sobre ordenação de índices,
     veja a descrição de 'riemann'.

     Se 'cframe_flag' for 'true', 'riem' é calculado a partir do tensor
     covariante de Riemann 'lriem'.

 -- Variável: lriem

     O tensor covariante de Riemann.  Calculado através de 'lriemann'.

 -- Variável: uriem

     O tensor contravariante de Riemann.  Calculado através de
     'uriemann'.

 -- Variável: ric

     O tensor misto de Ricci.  Calculado através de 'ricci'.

 -- Variável: uric

     O tensor contravariante de Ricci.  Calculado através de 'uricci'.

 -- Variável: lg

     O tensor métrico.  Esse tensor deve ser especificado (como uma
     'dim' através da matriz 'dim') antes que outro cálculo possa ser
     executado.

 -- Variável: ug

     O inverso do tensor métrico.  Calculado através de 'cmetric'.

 -- Variável: weyl

     O tensor de Weyl.  Calculado através de 'weyl'.

 -- Variável: fb

     Coeficientes delimitadores da moldura, como calculado através de
     'frame_bracket'.

 -- Variável: kinvariant

     O invariante de Kretchmann.  Calculado através de 'rinvariant'.

 -- Variável: np

     Um tetrad nulo de Newman-Penrose.  Calculado através de 'nptetrad'.

 -- Variável: npi

     O índice ascendente do tetrad nulo de Newman-Penrose.  Calculado
     através de 'nptetrad'.  Definido como 'ug.np'.  O produto
     'np.transpose(npi)' é constante:

          (%i39) trigsimp(np.transpose(npi));
                                        [  0   - 1  0  0 ]
                                        [                ]
                                        [ - 1   0   0  0 ]
          (%o39)                        [                ]
                                        [  0    0   0  1 ]
                                        [                ]
                                        [  0    0   1  0 ]

 -- Variável: tr

     Tensor de categoria 3 fornecido pelo usuário representando torsão.
     Usado por 'contortion'.

 -- Variável: kt

     O tensor de contorsão, calculado a partir de 'tr' através de
     'contortion'.

 -- Variável: nm

     Vetor de não metrcidade fornecido pelo usuário.  Usado por
     'nonmetricity'.

 -- Variável: nmc

     Os coeficientes de não metricidade, calculados a partir de 'nm' por
     'nonmetricity'.

 -- Variável de sistema: tensorkill

     Variável indicando se o pacote tensor foi inicializado.  Escolhida
     e usada por 'csetup', retornada ao seu valor original através de
     'init_ctensor'.

 -- Variável de opção: ct_coords
     Valor padrão: '[]'

     Uma opção no pacote 'ctensor'.  'ct_coords' contém uma lista de
     coordenadas.  Enquanto normalmente definida quando a função
     'csetup' for chamada, se pode redefinir as coordenadas com a
     atribuição 'ct_coords: [j1, j2, ..., jn]' onde os j's são os novos
     nomes de coordenadas.  Veja também 'csetup'.

28.2.10 Nomes reservados
------------------------

Os seguintes nomes são usados internamente pelo pacote 'ctensor' e não
devem ser redefinidos:

       Name         Description
       ---------------------------------------
       _lg()        Avalia para lfg se a moldura métrica for usada,
                         para lg de outra forma
       _ug()        Avalia para ufg se a moldura métrica for usada,
                         para ug de outra forma
       cleanup()    Remove ítens da lista deindex
       contract4()  Usado por psi()
       filemet()    Usado por csetup() quando lendo a métrica de um arquivo
       findde1()    Usado por findde()
       findde2()    Usado por findde()
       findde3()    Usado por findde()
       kdelt()      Delta de Kronecker (não generalizado)
       newmet()     Usado por csetup() para escolher uma métrica
                         interativamente
       setflags()   Usado por init_ctensor()
       readvalue()
       resimp()
       sermet()     Usado por csetup() para informar uma métricacom série
                         de Taylor
       txyzsum()
       tmetric()    Moldura métrica, usado por cmetric() quando
                         cframe_flag:true
       triemann()   Tensor de Riemann em base de moldura, usado quando
                         cframe_flag:true
       tricci()     Tensor de Ricci em base de moldura, usada quando
                         cframe_flag:true
       trrc()       Coeficientes de rotação de Ricci, usado por
                         christof()
       yesp()

28.2.11 Modificações
--------------------

Em Novembro de 2004, o pacote 'ctensor' foi extensivamente reescrito.
Muitas funções e variáveis foram renomeadas com o objetivo de tornar o
pacote com a versão comercial do Macsyma.

       Novo Nome    Nome Antigo     Descrição
       --------------------------------------------------------------------
       ctaylor()    DLGTAYLOR()     Expansão da série de Taylor de uma
       -----------------------------expressão
       lgeod[]      EM              Equações geodésicas
       ein[]        G[]             Tensor misto de Einstein
       ric[]        LR[]            Tensor misto de Ricci
       ricci()      LRICCICOM()     Calcula o tensor misto de Ricci
       ctaypov      MINP            Maximo expoente em expansões de séries de
       -----------------------------Taylor
       cgeodesic()  MOTION          Calcula as equações geodésicas
       ct_coords    OMEGA           Coordenadas métricas
       ctayvar      PARAM           Variável de expansão de séries de
       -----------------------------Taylor
       lriem[]      R[]             Tensor covariante de Riemann
       uriemann()   RAISERIEMANN()  Calcula o tensor contravariante de
       -----------------------------Riemann
       ratriemann   RATRIEMAN       Simplificação racional do tensor de
       -----------------------------Riemann
       uric[]       RICCI[]         Tensor de Ricci contravariante
       uricci()     RICCICOM()      Calcula o tensor de Ricci contravariante
       cmetric()    SETMETRIC()     Escolhe a métrica
       ctaypt       TAYPT           Ponto para expansões de séries de Taylor
       ctayswitch   TAYSWITCH       Escolhe o comutador de séries de Taylor
       csetup()     TSETUP()        Inicia sessão interativa de configuração
       ctransform() TTRANSFORM()    Transformação de coordenadas interativa
       uriem[]      UR[]            Tensor contravariante de Riemann
       weyl[]       W[]             Tensor (3,1) de Weyl



File: maxima.info,  Node: Pacote atensor,  Next: Séries,  Prev: ctensor,  Up: Top

29 Pacote atensor
*****************

* Menu:

* Introdução ao Pacote atensor::
* Funções e Variáveis Definidas para o Pacote atensor::


File: maxima.info,  Node: Introdução ao Pacote atensor,  Next: Funções e Variáveis Definidas para o Pacote atensor,  Prev: Pacote atensor,  Up: Pacote atensor

29.1 Introdução ao Pacote atensor
=================================

'atensor' é um pacote de manipulção de tensores algébricos.  Para usar
'atensor', digite 'load(atensor)', seguido por uma chamada à função
'init_atensor'.

   A essência de 'atensor' é um conjunto de regras de simplificação para
o operador de produto (ponto) não comutativo ("'.'").  'atensor'
reconhece muitos tipos de álgebra; as regras de simplificação
correspondentes são ativadas quando a função 'init_atensor' é chamada.

   A compatibilidade de 'atensor' pode ser demonstrada pela definição da
álgebra de quatérnios como uma álgera-Clifford Cl(0,2) com dois vetores
fundamentais.  As três unidades quaterniônicas imaginárias fundamentais
são então os dois vetores base e seu produto, i.e.:

         i = v     j = v     k = v  .  v
              1         2         1    2

   Embora o pacote 'atensor' tenha uma definição interna para a álgebra
dos quatérnios, isso não foi usado nesse exemplo, no qual nós nos
esforçamos para construir a tabela de multiplicação dos quatérnios como
uma matriz:


     (%i1) load(atensor);
     (%o1)       /share/tensor/atensor.mac
     (%i2) init_atensor(clifford,0,0,2);
     (%o2)                                done
     (%i3) atensimp(v[1].v[1]);
     (%o3)                                 - 1
     (%i4) atensimp((v[1].v[2]).(v[1].v[2]));
     (%o4)                                 - 1
     (%i5) q:zeromatrix(4,4);
                                     [ 0  0  0  0 ]
                                     [            ]
                                     [ 0  0  0  0 ]
     (%o5)                           [            ]
                                     [ 0  0  0  0 ]
                                     [            ]
                                     [ 0  0  0  0 ]
     (%i6) q[1,1]:1;
     (%o6)                                  1
     (%i7) for i thru adim do q[1,i+1]:q[i+1,1]:v[i];
     (%o7)                                done
     (%i8) q[1,4]:q[4,1]:v[1].v[2];
     (%o8)                               v  .  v
                                          1    2
     (%i9) for i from 2 thru 4 do for j from 2 thru 4 do
           q[i,j]:atensimp(q[i,1].q[1,j]);
     (%o9)                                done
     (%i10) q;
                        [    1        v         v      v  .  v  ]
                        [              1         2      1    2 ]
                        [                                      ]
                        [   v         - 1     v  .  v    - v    ]
                        [    1                 1    2      2   ]
     (%o10)             [                                      ]
                        [   v      - v  .  v     - 1      v     ]
                        [    2        1    2              1    ]
                        [                                      ]
                        [ v  .  v      v        - v       - 1   ]
                        [  1    2      2          1            ]

   'atensor' reconhece como bases vetoriais símbolos indexados, onde o
símbolo é aquele armazenado em 'asymbol' e o iíndice está entre 1 e
'adim'.  Para símbolos indexado, e somente para símbolos indexados, as
formas bilineares 'sf', 'af', e 'av' são avaliadas.  A avaliação
substitui os valores de 'aform[i,j]' em lugar de 'fun(v[i],v[j])' onde
'v' representa o valor de 'asymbol' e 'fun' é ainda 'af' ou 'sf'; ou,
isso substitui 'v[aform[i,j]]' em lugar de 'av(v[i],v[j])'.

   Desnecessário dizer, as funções 'sf', 'af' e 'av' podem ser
redefinidas.

   Quando o pacote 'atensor' é chamado, os seguintes sinalizadores são
configurados:

     dotscrules:true;
     dotdistrib:true;
     dotexptsimp:false;

   Se você deseja experimentar com uma álgebra não associativa, você
pode também considerar a configuração de 'dotassoc' para 'false'.  Nesse
caso, todavia, 'atensimp' não stará sempre habilitado a obter as
simplificações desejadas.


File: maxima.info,  Node: Funções e Variáveis Definidas para o Pacote atensor,  Prev: Introdução ao Pacote atensor,  Up: Pacote atensor

29.2 Funções e Variáveis Definidas para o Pacote atensor
========================================================

 -- Função: init_atensor (<alg_type>, <opt_dims>)
 -- Função: init_atensor (<alg_type>)

     Inicializa o pacote 'atensor' com o tipo especificado de álgebra.
     <alg_type> pode ser um dos seguintes:

     'universal': A álgebra universal tendo regras não comutativas.

     'grassmann': A álgebra de Grassman é definida pela relação de
     comutação 'u.v+v.u=0'.

     'clifford': A álgebra de Clifford é definida pela relação de
     comutação 'u.v+v.u=-2*sf(u,v)' onde 'sf' é a função valor-escalar
     simétrico.  Para essa álgebra, <opt_dims> pode ser acima de três
     inteiros não negativos, representando o número de dimensões
     positivas, dimensões degeneradas, e dimensões negativas da álgebra,
     respectivamente.  Se quaisquer valores <opt_dims> são fornecidos,
     'atensor' irá configurar os valores de 'adim' e 'aform'
     apropriadamente.  Caso contrário, 'adim' irá por padrão para 0 e
     'aform' não será definida.

     'symmetric': A álgebra simétrica é definida pela relação de
     comutação 'u.v-v.u=0'.

     'symplectic': A álgebra simplética é definida pela relação de
     comutação 'u.v-v.u=2*af(u,v)' onde 'af' é uma função valor-escalar
     antisimétrica.  Para a álgebra simplética, <opt_dims> pode mais de
     dois inteiros não negativos, representando a dimensão não
     degenerada e e a dimensão degenerada, respectivamente.  Se
     quaisquer valores <opt_dims> são fornecidos, 'atensor' irá
     configurar os valores de 'adim' e 'aform' apropriadamente.  Caso
     contrário, 'adim' irá por padrão para 0 e 'aform' não será
     definida.

     'lie_envelop': O invólucro da álgebra de Lie é definido pela
     relação de comutação 'u.v-v.u=2*av(u,v)' onde 'av' é uma função
     antisimétrica.

     A função 'init_atensor' também reconhece muitos tipos pré-definidos
     de álgebra:

     'complex' implementa a álgebra de números complexos como a álgebra
     de Clifford Cl(0,1).  A chamada 'init_atensor(complex)' é
     equivalente a 'init_atensor(clifford,0,0,1)'.

     'quaternion' implementa a álgebra de quatérnios.  A chamada
     'init_atensor(quaternion)' é equivalente a
     'init_atensor(clifford,0,0,2)'.

     'pauli' implementa a álgebra de Pauli-spinors como a
     Clifford-álgebra Cl(3,0).  Uma chamada a 'init_atensor(pauli)' é
     equivalente a 'init_atensor(clifford,3)'.

     'dirac' implementa a álgebra de Dirac-spinors como a
     Clifford-álgebra Cl(3,1).  Uma chamada a 'init_atensor(dirac)' é
     equivalente a 'init_atensor(clifford,3,0,1)'.

 -- Função: atensimp (<expr>)

     Simplifica a expressão algébrica de tensores <expr> conforme as
     regras configuradas por uma chamada a 'init_atensor'.
     Simplificações incluem aplicação recursiva de relações comutativas
     e resoluções de chamadas a 'sf', 'af', e 'av' onde for aplicável.
     Uma salvaguarda é usada para garantir que a função sempre termine,
     mesmo para expressões complexas.

 -- Função: alg_type

     O tipo de álgebra.  Valores válidos sáo 'universal', 'grassmann',
     'clifford', 'symmetric', 'symplectic' e 'lie_envelop'.

 -- Variável: adim
     Valor padrão: 0

     A dimensionalidade da álgebra.  'atensor' usa o valor de 'adim'
     para determinar se um objeto indexado é uma base vetorial válida.
     Veja 'abasep'.

 -- Variável: aform

     Valor padrão para as formas bilineares 'sf', 'af', e 'av'.  O
     padrão é a matriz identidade 'ident(3)'.

 -- Variável: asymbol
     Valor padrão: 'v'

     O símbolo para bases vetoriais.

 -- Função: sf (<u>, <v>)

     É uma função escalar simétrica que é usada em relações comutativas.
     A implementação padrão verifica se ambos os argumentos são bases
     vetoriais usando 'abasep' e se esse for o caso, substitui o valor
     correspondente da matriz 'aform'.

 -- Função: af (<u>, <v>)

     É uma função escalar antisimétrica que é usada em relações
     comutativas.  A implementação padrão verifica se ambos os
     argumentos são bases vetoriais usando 'abasep' e se esse for o
     caso, substitui o valor correspondente da matriz 'aform'.

 -- Função: av (<u>, <v>)

     É uma função antisimétrica que é usada em relações comutativas.  A
     implementação padrão verifica se ambos os argumentos são bases
     vetoriais usando 'abasep' e se esse for o caso, substitui o valor
     correspondente da matriz 'aform'.

     Por exemplo:

          (%i1) load(atensor);
          (%o1)       /share/tensor/atensor.mac
          (%i2) adim:3;
          (%o2)                                  3
          (%i3) aform:matrix([0,3,-2],[-3,0,1],[2,-1,0]);
                                         [  0    3   - 2 ]
                                         [               ]
          (%o3)                          [ - 3   0    1  ]
                                         [               ]
                                         [  2   - 1   0  ]
          (%i4) asymbol:x;
          (%o4)                                  x
          (%i5) av(x[1],x[2]);
          (%o5)                                 x
                                                 3

 -- Função: abasep (<v>)

     Verifica se esse argumento é uma base vetorial 'atensor' .  E será,
     se ele for um símbolo indexado, com o símbolo sendo o mesmo que o
     valor de 'asymbol', e o índice tiver o mesmo valor numérico entre 1
     e 'adim'.


File: maxima.info,  Node: Séries,  Next: Teoria dos Números,  Prev: Pacote atensor,  Up: Top

30 Séries
*********

* Menu:

* Introdução a Séries::
* Funções e Variáveis Definidas para Séries::


File: maxima.info,  Node: Introdução a Séries,  Next: Funções e Variáveis Definidas para Séries,  Prev: Séries,  Up: Séries

30.1 Introdução a Séries
========================

Maxima contém funções 'taylor' e 'powerseries' (séries de potência) para
encontrar as séries de funções diferenciáveis.  Maxima também tem
ferramentas tais como 'nusum' capazes de encontrar a forma fechada de
algumas séries.  Operações tais como adição e multiplicação travalham da
forma usual sobre séries.  Essa seção apresenta as variáveis globais que
controlam a expansão.


File: maxima.info,  Node: Funções e Variáveis Definidas para Séries,  Prev: Introdução a Séries,  Up: Séries

30.2 Funções e Variáveis Definidas para Séries
==============================================

 -- Variável de opção: cauchysum
     Valor padrão: 'false'

     Quando multiplicando adições jutas com 'inf' como seus limites
     superiores, se 'sumexpand' for 'true' e 'cauchysum' for 'true'
     então o produto de Cauchy será usado em lugar do produto usual.  No
     produto de Cauchy o índice do somatório interno é uma função do
     índice do externo em lugar de variar independentemente.

     Exemplo:

          (%i1) sumexpand: false$
          (%i2) cauchysum: false$
          (%i3) s: sum (f(i), i, 0, inf) * sum (g(j), j, 0, inf);
                                inf         inf
                                ====        ====
                                \           \
          (%o3)                ( >    f(i))  >    g(j)
                                /           /
                                ====        ====
                                i = 0       j = 0
          (%i4) sumexpand: true$
          (%i5) cauchysum: true$
          (%i6) ''s;
                           inf     i1
                           ====   ====
                           \      \
          (%o6)             >      >     g(i1 - i2) f(i2)
                           /      /
                           ====   ====
                           i1 = 0 i2 = 0

 -- Função: deftaylor (<f_1>(<x_1>), <expr_1>, ..., <f_n>(<x_n>),
          <expr_n>)
     Para cada função <f_i> de uma variável <x_i>, 'deftaylor' define
     <expr_i> como a séries de Taylor sobre zero.  <expr_i> é
     tipicamente um polinômio em <x_i> ou um somatório; expressões mais
     gerais são aceitas por 'deftaylor' sem reclamações.

     'powerseries (<f_i>(<x_i>), <x_i>, 0)' retorna as séries definidas
     por 'deftaylor'.

     'deftaylor' retorna uma lista das funções <f_1>, ..., <f_n>.
     'deftaylor' avalia seus argumentos.

     Exemplo:

          (%i1) deftaylor (f(x), x^2 + sum(x^i/(2^i*i!^2), i, 4, inf));
          (%o1)                          [f]
          (%i2) powerseries (f(x), x, 0);
                                inf
                                ====      i1
                                \        x         2
          (%o2)                  >     -------- + x
                                /       i1    2
                                ====   2   i1!
                                i1 = 4
          (%i3) taylor (exp (sqrt (f(x))), x, 0, 4);
                                2         3          4
                               x    3073 x    12817 x
          (%o3)/T/     1 + x + -- + ------- + -------- + . . .
                               2     18432     307200

 -- Variável de opção: maxtayorder
     Valor padrão: 'true'

     Quando 'maxtayorder' for 'true', durante a manipulação algébrica de
     séries (truncadas) de Taylor, 'taylor' tenta reter tantos termos
     quantos forem conhecidos serem corretos.

 -- Função: niceindices (<expr>)
     Renomeia os índices de adições e produtos em <expr>.  'niceindices'
     tenta renomear cada índice para o valor de 'niceindicespref[1]', a
     menos que o nome apareça nas parcelas do somatório ou produtório,
     nesses casos 'niceindices' tenta os elementos seguintes de
     'niceindicespref' por sua vez, até que uma varável não usada unused
     variable seja encontrada.  Se a lista inteira for exaurida, índices
     adicionais são constrídos através da anexaao de inteiros ao valor
     de 'niceindicespref[1]', e.g., 'i0', 'i1', 'i2', ....

     'niceindices' retorna uma expressão.  'niceindices' avalia seu
     argumento.

     Exemplo:

          (%i1) niceindicespref;
          (%o1)                  [i, j, k, l, m, n]
          (%i2) product (sum (f (foo + i*j*bar), foo, 1, inf), bar, 1, inf);
                           inf    inf
                          /===\   ====
                           ! !    \
          (%o2)            ! !     >      f(bar i j + foo)
                           ! !    /
                          bar = 1 ====
                                  foo = 1
          (%i3) niceindices (%);
                               inf  inf
                              /===\ ====
                               ! !  \
          (%o3)                ! !   >    f(i j l + k)
                               ! !  /
                              l = 1 ====
                                    k = 1

 -- Variável de opção: niceindicespref
     Valor padrão: '[i, j, k, l, m, n]'

     'niceindicespref' é a lista da qual 'niceindices' pega os nomes dos
     índices de adições e produtos products.

     Os elementos de 'niceindicespref' são tipicamente nomes de
     variáveis, embora que não seja imposto por 'niceindices'.

     Exemplo:

          (%i1) niceindicespref: [p, q, r, s, t, u]$
          (%i2) product (sum (f (foo + i*j*bar), foo, 1, inf), bar, 1, inf);
                           inf    inf
                          /===\   ====
                           ! !    \
          (%o2)            ! !     >      f(bar i j + foo)
                           ! !    /
                          bar = 1 ====
                                  foo = 1
          (%i3) niceindices (%);
                               inf  inf
                              /===\ ====
                               ! !  \
          (%o3)                ! !   >    f(i j q + p)
                               ! !  /
                              q = 1 ====
                                    p = 1

 -- Função: nusum (<expr>, <x>, <i_0>, <i_1>)
     Realiza o somatório hipergeométrico indefinido de <expr> com
     relação a <x> usando um procedimento de decisão devido a R.W.
     Gosper.  <expr> e o resultado deve ser expressável como produtos de
     expoentes inteiros, fatoriais, binomios, e funções recionais.

     Os termos "definido" and "e somatório indefinido" são usados
     analogamente a "definida" and "integração indefinida".  Adicionar
     indefinidamente significa dar um resultado simólico para a adição
     sobre intervalos de comprimentos de variáveis, não apenas e.g.  0 a
     infinito.  Dessa forma, uma vez que não existe fórmula para a
     adição parcial geral de séries binomiais, 'nusum' não pode fazer
     isso.

     'nusum' e 'unsum' conhecem um porco sobre adições e subtrações de
     produtos finitos.  Veja também 'unsum'.

     Exemplos:

          (%i1) nusum (n*n!, n, 0, n);

          Dependent equations eliminated:  (1)
          (%o1)                     (n + 1)! - 1
          (%i2) nusum (n^4*4^n/binomial(2*n,n), n, 0, n);
                               4        3       2              n
                2 (n + 1) (63 n  + 112 n  + 18 n  - 22 n + 3) 4      2
          (%o2) ------------------------------------------------ - ------
                              693 binomial(2 n, n)                 3 11 7
          (%i3) unsum (%, n);
                                        4  n
                                       n  4
          (%o3)                   ----------------
                                  binomial(2 n, n)
          (%i4) unsum (prod (i^2, i, 1, n), n);
                              n - 1
                              /===\
                               ! !   2
          (%o4)              ( ! !  i ) (n - 1) (n + 1)
                               ! !
                              i = 1
          (%i5) nusum (%, n, 1, n);

          Dependent equations eliminated:  (2 3)
                                      n
                                    /===\
                                     ! !   2
          (%o5)                      ! !  i  - 1
                                     ! !
                                    i = 1

 -- Função: pade (<taylor_series>, <numer_deg_bound>, <denom_deg_bound>)
     Retorna uma lista de todas as funções racionais que possuem a dada
     expansão da séries de Taylor onde a adição dos graus do numerador e
     do denominador é menor que ou igual ao nível de truncação das
     séries de potência, i.e.  são "melhores" aproximações, e que
     adicionalmente satisfazem o grau especificado associado.

     <taylor_series> é uma séries de Taylor de uma variável.
     <numer_deg_bound> e <denom_deg_bound> são inteiros positivos
     especificando o grau associado sobre o numerador e o denominador.

     <taylor_series> podem também ser séries de Laurent, e o grau
     associado pode ser 'inf' que acarreta todas funções racionais cujo
     grau total for menor que ou igual ao comprimento das séries de
     potências a serem retornadas.  O grau total é definido como
     '<numer_deg_bound> + <denom_deg_bound>'.  O comprimento de séries
     de potência é definido como '"nível de trncação" + 1 - min(0,
     "ordem das séries")'.

          (%i1) taylor (1 + x + x^2 + x^3, x, 0, 3);
                                        2    3
          (%o1)/T/             1 + x + x  + x  + . . .
          (%i2) pade (%, 1, 1);
                                           1
          (%o2)                       [- -----]
                                         x - 1
          (%i3) t: taylor(-(83787*x^10 - 45552*x^9 - 187296*x^8
                             + 387072*x^7 + 86016*x^6 - 1507328*x^5
                             + 1966080*x^4 + 4194304*x^3 - 25165824*x^2
                             + 67108864*x - 134217728)
                 /134217728, x, 0, 10);
                              2    3       4       5       6        7
                       x   3 x    x    15 x    23 x    21 x    189 x
          (%o3)/T/ 1 - - + ---- - -- - ----- + ----- - ----- - ------
                       2    16    32   1024    2048    32768   65536

                                            8         9          10
                                      5853 x    2847 x    83787 x
                                    + ------- + ------- - --------- + . . .
                                      4194304   8388608   134217728
          (%i4) pade (t, 4, 4);
          (%o4)                          []

     Não existe função racional de grau 4 numerador/denominador, com
     essa expansão de série de potência.  Você obrigatoriamente em geral
     tem grau do numerador e grau do denominador adicionando para cima
     ao menor grau das séries de potência, com o objetivo de ter
     disponível coeficientes desconhecidos para resolver.

          (%i5) pade (t, 5, 5);
                               5                4                 3
          (%o5) [- (520256329 x  - 96719020632 x  - 489651410240 x

                            2
           - 1619100813312 x  - 2176885157888 x - 2386516803584)

                         5                 4                  3
          /(47041365435 x  + 381702613848 x  + 1360678489152 x

                            2
           + 2856700692480 x  + 3370143559680 x + 2386516803584)]

 -- Variável de opção: powerdisp
     Valor padrão: 'false'

     Quando 'powerdisp' for 'true', uma adição é mostrada com seus
     termos em ordem do crescimento do expoente.  Dessa forma um
     polinômio é mostrado como séries de potências truncadas, com o
     termo constante primeiro e o maior expoente por último.

     Por padão, termos de uma adição são mostrados em ordem do expoente
     decrescente.

 -- Função: powerseries (<expr>, <x>, <a>)
     Retorna a forma geral expansão de séries de potência para <expr> na
     variável <x> sobre o ponto <a> (o qual pode ser 'inf' para
     infinito).

     Se 'powerseries' incapaz de expandir <expr>, 'taylor' pode dar os
     primeiros muitos termos de séries.

     Quando 'verbose' for 'true', 'powerseries' mostra mensagens de
     progresso.

          (%i1) verbose: true$
          (%i2) powerseries (log(sin(x)/x), x, 0);
          can't expand
                                           log(sin(x))
          so we'll try again after applying the rule:
                                                  d
                                                / -- (sin(x))
                                                [ dx
                                  log(sin(x)) = i ----------- dx
                                                ]   sin(x)
                                                /
          in the first simplification we have returned:
                                       /
                                       [
                                       i cot(x) dx - log(x)
                                       ]
                                       /
                              inf
                              ====        i1  2 i1             2 i1
                              \      (- 1)   2     bern(2 i1) x
                               >     ------------------------------
                              /                i1 (2 i1)!
                              ====
                              i1 = 1
          (%o2)                -------------------------------------
                                                2

 -- Variável de opção: psexpand
     Valor padrão: 'false'

     Quando 'psexpand' for 'true', uma expressão função racional
     extendida é mostrada completamente expandida.  O comutador
     'ratexpand' tem o mesmo efeito.

     Quando 'psexpand' for 'false', uma expressão de várias variáveis é
     mostrada apenas como no pacote de função racional.

     Quando 'psexpand' for 'multi', então termos com o mesmo grau total
     nas variáveis são agrupados juntos.

 -- Função: revert (<expr>, <x>)
 -- Função: revert2 (<expr>, <x>, <n>)
     Essas funções retornam a reversão de <expr>, uma série de Taylor
     sobre zero na variável <x>.  'revert' retorna um polinômio de grau
     igual ao maior expoente em <expr>.  'revert2' retorna um polinômio
     de grau <n>, o qual pode ser maior que, igual a, ou menor que o
     grau de <expr>.

     'load ("revert")' chama essas funções.

     Exemplos:

          (%i1) load ("revert")$
          (%i2) t: taylor (exp(x) - 1, x, 0, 6);
                             2    3    4    5     6
                            x    x    x    x     x
          (%o2)/T/      x + -- + -- + -- + --- + --- + . . .
                            2    6    24   120   720
          (%i3) revert (t, x);
                         6       5       4       3       2
                     10 x  - 12 x  + 15 x  - 20 x  + 30 x  - 60 x
          (%o3)/R/ - --------------------------------------------
                                          60
          (%i4) ratexpand (%);
                               6    5    4    3    2
                              x    x    x    x    x
          (%o4)             - -- + -- - -- + -- - -- + x
                              6    5    4    3    2
          (%i5) taylor (log(x+1), x, 0, 6);
                              2    3    4    5    6
                             x    x    x    x    x
          (%o5)/T/       x - -- + -- - -- + -- - -- + . . .
                             2    3    4    5    6
          (%i6) ratsimp (revert (t, x) - taylor (log(x+1), x, 0, 6));
          (%o6)                           0
          (%i7) revert2 (t, x, 4);
                                    4    3    2
                                   x    x    x
          (%o7)                  - -- + -- - -- + x
                                   4    3    2

 -- Função: taylor (<expr>, <x>, <a>, <n>)
 -- Função: taylor (<expr>, [<x_1>, <x_2>, ...], <a>, <n>)
 -- Função: taylor (<expr>, [<x>, <a>, <n>, 'asymp])
 -- Função: taylor (<expr>, [<x_1>, <x_2>, ...], [<a_1>, <a_2>, ...],
          [<n_1>, <n_2>, ...])
 -- Função: taylor (<expr>, [<x_1>, <a_1>, <n_1>], [<x_2>, <a_2>,
          <n_2>], ...)
     'taylor (<expr>, <x>, <a>, <n>)' expande a expressão <expr> em uma
     série truncada de Taylor ou de Laurent na variável <x> em torno do
     ponto <a>, contendo termos até '(<x> - <a>)^<n>'.

     Se <expr> é da forma '<f>(<x>)/<g>(<x>)' e '<g>(<x>)' não possui de
     grau acima do grau <n> então 'taylor' tenta expandir '<g>(<x>)'
     acima do gau '2 <n>'.  Se existe ainda termos não zero, 'taylor'
     dobra o grau de expansão de '<g>(<x>)' contanto que o grau da
     expansão o grau da expansão seja menor que ou igual a '<n>
     2^taylordepth'.

     'taylor (<expr>, [<x_1>, <x_2>, ...], <a>, <n>)' retorna uma série
     de potência truncada de grau <n> em todas as variáveis <x_1>,
     <x_2>, ...  sobre o ponto '(<a>, <a>, ...)'.

     'taylor (<expr>, [<x_1>, <a_1>, <n_1>], [<x_2>, <a_2>, <n_2>],
     ...)' retorna uma série de potência truncada nas variáveis <x_1>,
     <x_2>, ...  sobre o ponto '(<a_1>, <a_2>, ...)', truncada em <n_1>,
     <n_2>, ....

     'taylor (<expr>, [<x_1>, <x_2>, ...], [<a_1>, <a_2>, ...], [<n_1>,
     <n_2>, ...])' retorna uma série de potência truncada nas variáveis
     <x_1>, <x_2>, ...  sobre o ponto '(<a_1>, <a_2>, ...)', truncada em
     <n_1>, <n_2>, ....

     'taylor (<expr>, [<x>, <a>, <n>, 'asymp])' retorna uma expansão de
     <expr> em expoentes negativos de '<x> - <a>'.  O termo de maior
     ordem é '(<x> - <a>)^<-n>'.

     Quando 'maxtayorder' for 'true', então durante maniplulação
     algébrica da séries de Taylor (truncada), 'taylor' tenta reter
     tantos termos quantos forem conhecidos serem corretos.

     Quando 'psexpand' for 'true', uma expressão de função racional
     extendida é mostrada completamente expandida.  O comutador
     'ratexpand' tem o mesmo efeito.  Quando 'psexpand' for 'false', uma
     expressão de várias variáveis é mostrada apenas como no pacote de
     função racional.  Quando 'psexpand' for 'multi', então os termos
     com o mesmo grau total nas variáveis são agrupados juntos.

     Veja também o comutador 'taylor_logexpand' para controlar a
     expansão.

     Exemplos:

          (%i1) taylor (sqrt (sin(x) + a*x + 1), x, 0, 3);
                                     2             2
                       (a + 1) x   (a  + 2 a + 1) x
          (%o1)/T/ 1 + --------- - -----------------
                           2               8

                                             3      2             3
                                         (3 a  + 9 a  + 9 a - 1) x
                                       + -------------------------- + . . .
                                                     48
          (%i2) %^2;
                                              3
                                             x
          (%o2)/T/           1 + (a + 1) x - -- + . . .
                                             6
          (%i3) taylor (sqrt (x + 1), x, 0, 5);
                                 2    3      4      5
                            x   x    x    5 x    7 x
          (%o3)/T/      1 + - - -- + -- - ---- + ---- + . . .
                            2   8    16   128    256
          (%i4) %^2;
          (%o4)/T/                  1 + x + . . .
          (%i5) product ((1 + x^i)^2.5, i, 1, inf)/(1 + x^2);
                                   inf
                                  /===\
                                   ! !    i     2.5
                                   ! !  (x  + 1)
                                   ! !
                                  i = 1
          (%o5)                   -----------------
                                        2
                                       x  + 1
          (%i6) ev (taylor(%, x,  0, 3), keepfloat);
                                         2           3
          (%o6)/T/    1 + 2.5 x + 3.375 x  + 6.5625 x  + . . .
          (%i7) taylor (1/log (x + 1), x, 0, 3);
                                         2       3
                           1   1   x    x    19 x
          (%o7)/T/         - + - - -- + -- - ----- + . . .
                           x   2   12   24    720
          (%i8) taylor (cos(x) - sec(x), x, 0, 5);
                                          4
                                     2   x
          (%o8)/T/                - x  - -- + . . .
                                         6
          (%i9) taylor ((cos(x) - sec(x))^3, x, 0, 5);
          (%o9)/T/                    0 + . . .
          (%i10) taylor (1/(cos(x) - sec(x))^3, x, 0, 5);
                                                         2          4
                      1     1       11      347    6767 x    15377 x
          (%o10)/T/ - -- + ---- + ------ - ----- - ------- - --------
                       6      4        2   15120   604800    7983360
                      x    2 x    120 x

                                                                    + . . .
          (%i11) taylor (sqrt (1 - k^2*sin(x)^2), x, 0, 6);
                         2  2       4      2   4
                        k  x    (3 k  - 4 k ) x
          (%o11)/T/ 1 - ----- - ----------------
                          2            24

                                              6       4       2   6
                                         (45 k  - 60 k  + 16 k ) x
                                       - -------------------------- + . . .
                                                    720
          (%i12) taylor ((x + 1)^n, x, 0, 4);
                                2       2     3      2         3
                              (n  - n) x    (n  - 3 n  + 2 n) x
          (%o12)/T/ 1 + n x + ----------- + --------------------
                                   2                 6

                                         4      3       2         4
                                       (n  - 6 n  + 11 n  - 6 n) x
                                     + ---------------------------- + . . .
                                                    24
          (%i13) taylor (sin (y + x), x, 0, 3, y, 0, 3);
                         3                 2
                        y                 y
          (%o13)/T/ y - -- + . . . + (1 - -- + . . .) x
                        6                 2

                              3                       2
                         y   y            2      1   y            3
                    + (- - + -- + . . .) x  + (- - + -- + . . .) x  + . . .
                         2   12                  6   12
          (%i14) taylor (sin (y + x), [x, y], 0, 3);
                               3        2      2      3
                              x  + 3 y x  + 3 y  x + y
          (%o14)/T/   y + x - ------------------------- + . . .
                                          6
          (%i15) taylor (1/sin (y + x), x, 0, 3, y, 0, 3);
                    1   y              1    1               1            2
          (%o15)/T/ - + - + . . . + (- -- + - + . . .) x + (-- + . . .) x
                    y   6               2   6                3
                                       y                    y

                                                     1            3
                                                + (- -- + . . .) x  + . . .
                                                      4
                                                     y
          (%i16) taylor (1/sin (y + x), [x, y], 0, 3);
                                       3         2       2        3
                      1     x + y   7 x  + 21 y x  + 21 y  x + 7 y
          (%o16)/T/ ----- + ----- + ------------------------------- + . . .
                    x + y     6                   360

 -- Variável de opção: taylordepth
     Valor padrão: 3

     Se existem ainda termos não zero, 'taylor' dobra o grau da expansão
     de '<g>(<x>)' contanto que o grau da expansão seja menor que ou
     igual a '<n> 2^taylordepth'.

 -- Função: taylorinfo (<expr>)
     Retorna information about the séries de Taylor <expr>.  O valor de
     retorno é uma lista de listas.  Cada lista compreende o nome de uma
     variável, o ponto de expansão, e o grau da expansão.

     'taylorinfo' retorna 'false' se <expr> não for uma séries de
     Taylor.

     Exemplo:

          (%i1) taylor ((1 - y^2)/(1 - x), x, 0, 3, [y, a, inf]);
                            2                       2
          (%o1)/T/ - (y - a)  - 2 a (y - a) + (1 - a )

                   2                        2
           + (1 - a  - 2 a (y - a) - (y - a) ) x

                   2                        2   2
           + (1 - a  - 2 a (y - a) - (y - a) ) x

                   2                        2   3
           + (1 - a  - 2 a (y - a) - (y - a) ) x  + . . .
          (%i2) taylorinfo(%);
          (%o2)               [[y, a, inf], [x, 0, 3]]

 -- Função: taylorp (<expr>)
     Retorna 'true' se <expr> for uma séries de Taylor, e 'false' de
     outra forma.

 -- Variável de opção: taylor_logexpand
     Valor padrão: 'true'

     'taylor_logexpand' controla expansão de logarítmos em séries de
     'taylor'.

     Quando 'taylor_logexpand' for 'true', todos logarítmos são
     expandidos completamente dessa forma problemas de reconhecimento de
     zero envolvendo envolvendo identidades logarítmicas não atrapalham
     o processo de expansão.  Todavia, esse esquema não é sempre
     maematicamente correto uma vez que isso ignora informações de ramo.

     Quando 'taylor_logexpand' for escolhida para 'false', então a
     expansão logarítmica que ocorre é somente aquela que for necessária
     para obter uma séries de potência formal.

 -- Variável de opção: taylor_order_coefficients
     Valor padrão: 'true'

     'taylor_order_coefficients' controla a ordenação dos coeficientes
     em uma série de Taylor.

     Quando 'taylor_order_coefficients' for 'true', coeficientes da
     séries de Taylor são ordenados canonicamente.

 -- Função: taylor_simplifier (<expr>)
     Simplifica coeficientes da séries de potência <expr>.  'taylor'
     chama essa função.

 -- Variável de opção: taylor_truncate_polynomials
     Valor padrão: 'true'

     Quando 'taylor_truncate_polynomials' for 'true', polinômios são
     truncados baseados sobre a entrada de níveis de truncação.

     De outra forma, entrada de polinômios para 'taylor' são
     consideradas terem precisão infinita.

 -- Função: taytorat (<expr>)
     Converte <expr> da forma 'taylor' para a forma de expressão
     racional canônica (CRE). O efeito é o mesmo que 'rat (ratdisrep
     (<expr>))', mas mais rápido.

 -- Função: trunc (<expr>)
     Coloca notas na representação interna da expressão geral <expr> de
     modo que isso é mostrado como se suas adições forem séries de
     Taylor truncadas.  <expr> is not otherwise modified.

     Exemplo:

          (%i1) expr: x^2 + x + 1;
                                      2
          (%o1)                      x  + x + 1
          (%i2) trunc (expr);
                                          2
          (%o2)                  1 + x + x  + . . .
          (%i3) is (expr = trunc (expr));
          (%o3)                         true

 -- Função: unsum (<f>, <n>)
     Retorna a primeira diferençã de trás para frente '<f>(<n>) -
     <f>(<n> - 1)'.  Dessa forma 'unsum' logicamente é a inversa de
     'sum'.

     Veja também 'nusum'.

     Exemplos:

          (%i1) g(p) := p*4^n/binomial(2*n,n);
                                               n
                                            p 4
          (%o1)               g(p) := ----------------
                                      binomial(2 n, n)
          (%i2) g(n^4);
                                        4  n
                                       n  4
          (%o2)                   ----------------
                                  binomial(2 n, n)
          (%i3) nusum (%, n, 0, n);
                               4        3       2              n
                2 (n + 1) (63 n  + 112 n  + 18 n  - 22 n + 3) 4      2
          (%o3) ------------------------------------------------ - ------
                              693 binomial(2 n, n)                 3 11 7
          (%i4) unsum (%, n);
                                        4  n
                                       n  4
          (%o4)                   ----------------
                                  binomial(2 n, n)

 -- Variável de opção: verbose
     Valor padrão: 'false'

     Quando 'verbose' for 'true', 'powerseries' mostra mensagens de
     progresso.


File: maxima.info,  Node: Teoria dos Números,  Next: Simetrias,  Prev: Séries,  Up: Top

31 Teoria dos Números
*********************

* Menu:

* Funções e Variáveis Definidas para Teoria dos Números::


File: maxima.info,  Node: Funções e Variáveis Definidas para Teoria dos Números,  Prev: Teoria dos Números,  Up: Teoria dos Números

31.1 Funções e Variáveis Definidas para Teoria dos Números
==========================================================

 -- Função: bern (<n>)
     Retorna o <n>'ésimo número de Bernoulli para o inteiro <n>.
     Números de Bernoulli iguais a zero são suprimidos se 'zerobern' for
     'false'.

     Veja também 'burn'.

          (%i1) zerobern: true$
          (%i2) map (bern, [0, 1, 2, 3, 4, 5, 6, 7, 8]);
                            1  1       1      1        1
          (%o2)       [1, - -, -, 0, - --, 0, --, 0, - --]
                            2  6       30     42       30
          (%i3) zerobern: false$
          (%i4) map (bern, [0, 1, 2, 3, 4, 5, 6, 7, 8]);
                      1  1    1   5     691   7    3617  43867
          (%o4) [1, - -, -, - --, --, - ----, -, - ----, -----]
                      2  6    30  66    2730  6    510    798

 -- Função: bernpoly (<x>, <n>)
     Retorna o <n>'ésimo polinômio de Bernoulli na variável <x>.

 -- Função: bfzeta (<s>, <n>)
     Retorna a função zeta de Riemann para o argumento <s>.  O valor de
     retorno é um grande inteiro em ponto flutuante (bfloat); <n> é o
     número de dígitos no valor de retorno.

     'load ("bffac")' chama essa função.

 -- Função: bfhzeta (<s>, <h>, <n>)
     Retorna a função zeta de Hurwitz para os argumentos <s> e <h>.  O
     valor de retorno é um grande inteiro em ponto flutuante (bfloat);
     <n> é o números de dígitos no valor de retorno.

     A função zeta de Hurwitz é definida como

          sum ((k+h)^-s, k, 0, inf)

     'load ("bffac")' chama essa função.

 -- Função: binomial (<x>, <y>)
     O coeficiente binomial '<x>!/(<y>! (<x> - <y>)!)'.  Se <x> e <y>
     forem inteiros, então o valor numérico do coeficiente binomial é
     calculado.  Se <y>, ou <x - y>, for um inteiro, o the coeficiente
     binomial é expresso como um polinômio.

     Exemplos:

          (%i1) binomial (11, 7);
          (%o1)                          330
          (%i2) 11! / 7! / (11 - 7)!;
          (%o2)                          330
          (%i3) binomial (x, 7);
                  (x - 6) (x - 5) (x - 4) (x - 3) (x - 2) (x - 1) x
          (%o3)   -------------------------------------------------
                                        5040
          (%i4) binomial (x + 7, x);
                (x + 1) (x + 2) (x + 3) (x + 4) (x + 5) (x + 6) (x + 7)
          (%o4) -------------------------------------------------------
                                         5040
          (%i5) binomial (11, y);
          (%o5)                    binomial(11, y)

 -- Função: burn (<n>)
     Retorna o <n>'ésimo número de Bernoulli para o inteiro <n>.  'burn'
     pode ser mais eficitente que 'bern' para valores grandes e isolados
     de <n> (talvez <n> maior que 105 ou algo parecido), como 'bern'
     calcula todos os números de Bernoulli até o índice <n> antes de
     retornar.

     'burn' explora a observação que números de Bernoulli (racionais)
     podem ser aproximados através de zetas (transcendentes) com
     eficiência tolerável.

     'load ("bffac")' chama essa função.

 -- Função: cf (<expr>)
     Converte <expr> em uma fração contínua.  <expr> é uma expressão
     compreendendo frações contínuas e raízes quadradas de inteiros.
     Operandos na expressão podem ser combinados com operadores
     aritméticos.  Com excessão de frações contínuas e raízes quadradas,
     fatores na expressão devem ser números inteiros ou racionais.
     Maxima não conhece operações sobre frações contínuas fora de 'cf'.

     'cf' avalia seus argumentos após associar 'listarith' a 'false'.
     'cf' retorna uma fração contínua, representada como uma lista.

     Uma fração contínua 'a + 1/(b + 1/(c + ...))' é representada
     através da lista '[a, b, c, ...]'.  Os elementos da lista 'a', 'b',
     'c', ...  devem avaliar para inteiros.  <expr> pode também conter
     'sqrt (n)' onde 'n' é um inteiro.  Nesse caso 'cf' fornecerá tantos
     termos de fração contínua quantos forem o valor da variável
     'cflength' vezes o período.

     Uma fração contínua pode ser avaliada para um número através de
     avaliação da representação aritmética retornada por 'cfdisrep'.
     Veja também 'cfexpand' para outro caminho para avaliar uma fração
     contínua.

     Veja também 'cfdisrep', 'cfexpand', e 'cflength'.

     Exemplos:

        * <expr> é uma expressão compreendendo frações contínuas e
          raízes quadradas de inteiros.

               (%i1) cf ([5, 3, 1]*[11, 9, 7] + [3, 7]/[4, 3, 2]);
               (%o1)               [59, 17, 2, 1, 1, 1, 27]
               (%i2) cf ((3/17)*[1, -2, 5]/sqrt(11) + (8/13));
               (%o2)        [0, 1, 1, 1, 3, 2, 1, 4, 1, 9, 1, 9, 2]

        * 'cflength' controla quantos períodos de fração contínua são
          computados para números algébricos, números irracionais.

               (%i1) cflength: 1$
               (%i2) cf ((1 + sqrt(5))/2);
               (%o2)                    [1, 1, 1, 1, 2]
               (%i3) cflength: 2$
               (%i4) cf ((1 + sqrt(5))/2);
               (%o4)               [1, 1, 1, 1, 1, 1, 1, 2]
               (%i5) cflength: 3$
               (%i6) cf ((1 + sqrt(5))/2);
               (%o6)           [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 2]

        * Um fração contínua pode ser avaliado através da avaliação da
          representação aritmética retornada por 'cfdisrep'.

               (%i1) cflength: 3$
               (%i2) cfdisrep (cf (sqrt (3)))$
               (%i3) ev (%, numer);
               (%o3)                   1.731707317073171

        * Maxima não conhece operações sobre frações contínuas fora de
          'cf'.

               (%i1) cf ([1,1,1,1,1,2] * 3);
               (%o1)                     [4, 1, 5, 2]
               (%i2) cf ([1,1,1,1,1,2]) * 3;
               (%o2)                  [3, 3, 3, 3, 3, 6]

 -- Função: cfdisrep (<list>)
     Constrói e retorna uma expressão aritmética comum da forma 'a +
     1/(b + 1/(c + ...))' a partir da representação lista de uma fração
     contínua '[a, b, c, ...]'.

          (%i1) cf ([1, 2, -3] + [1, -2, 1]);
          (%o1)                     [1, 1, 1, 2]
          (%i2) cfdisrep (%);
                                            1
          (%o2)                     1 + ---------
                                              1
                                        1 + -----
                                                1
                                            1 + -
                                                2

 -- Função: cfexpand (<x>)
     Retorna uma matriz de numeradores e denominadores dos último
     (columa 1) e penúltimo (columa 2) convergentes da fração contínua
     <x>.

          (%i1) cf (rat (ev (%pi, numer)));

          `rat' replaced 3.141592653589793 by 103993/33102 = 3.141592653011902
          (%o1)                  [3, 7, 15, 1, 292]
          (%i2) cfexpand (%);
                                   [ 103993  355 ]
          (%o2)                    [             ]
                                   [ 33102   113 ]
          (%i3) %[1,1]/%[2,1], numer;
          (%o3)                   3.141592653011902

 -- Variável de opção: cflength
     Valor padrão: 1

     'cflength' controla o número de termos da fração contínua que a
     função 'cf' fornecerá, como o valor de 'cflength' vezes o período.
     Dessa forma o padrão é fornecer um período.

          (%i1) cflength: 1$
          (%i2) cf ((1 + sqrt(5))/2);
          (%o2)                    [1, 1, 1, 1, 2]
          (%i3) cflength: 2$
          (%i4) cf ((1 + sqrt(5))/2);
          (%o4)               [1, 1, 1, 1, 1, 1, 1, 2]
          (%i5) cflength: 3$
          (%i6) cf ((1 + sqrt(5))/2);
          (%o6)           [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 2]

 -- Função: divsum (<n>, <k>)
 -- Função: divsum (<n>)

     'divsum (<n>, <k>)' retorna a adição dos divisores de <n> elevados
     à <k>'ésima potência.

     'divsum (<n>)' retorna a adição dos divisores de <n>.

          (%i1) divsum (12);
          (%o1)                          28
          (%i2) 1 + 2 + 3 + 4 + 6 + 12;
          (%o2)                          28
          (%i3) divsum (12, 2);
          (%o3)                          210
          (%i4) 1^2 + 2^2 + 3^2 + 4^2 + 6^2 + 12^2;
          (%o4)                          210

 -- Função: euler (<n>)
     Retorna o <n>'ésimo número de Euler para o inteiro <n> não
     negativo.

     Para a constante de Euler-Mascheroni, veja '%gamma'.

          (%i1) map (euler, [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10]);
          (%o1)    [1, 0, - 1, 0, 5, 0, - 61, 0, 1385, 0, - 50521]

 -- Constante: %gamma
     A constante de Euler-Mascheroni, 0.5772156649015329 ....

 -- Função: factorial (<x>)
     Representa a função fatorial.  Maxima trata 'factorial (<x>)' da
     mesma forma que '<x>!'.  Veja '!'.

 -- Função: fib (<n>)
     Retorna o <n>'ésimo número de Fibonacci.  'fib(0)' igual a 0 e
     'fib(1)' igual a 1, e 'fib (-<n>)' igual a '(-1)^(<n> + 1) *
     fib(<n>)'.

     Após chamar 'fib', 'prevfib' é iguala 'fib (<x> - 1)', o número de
     Fibonacci anterior ao último calculado.

          (%i1) map (fib, [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10]);
          (%o1)         [0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55]

 -- Função: fibtophi (<expr>)
     Expressa números de Fibonacci que aparecem em <expr> em termos da
     constante '%phi', que é '(1 + sqrt(5))/2', aproximadamente
     1.61803399.

     Exemplos:

          (%i1) fibtophi (fib (n));
                                     n             n
                                 %phi  - (1 - %phi)
          (%o1)                  -------------------
                                     2 %phi - 1
          (%i2) fib (n-1) + fib (n) - fib (n+1);
          (%o2)          - fib(n + 1) + fib(n) + fib(n - 1)
          (%i3) fibtophi (%);
                      n + 1             n + 1       n             n
                  %phi      - (1 - %phi)        %phi  - (1 - %phi)
          (%o3) - --------------------------- + -------------------
                          2 %phi - 1                2 %phi - 1
                                                    n - 1             n - 1
                                                %phi      - (1 - %phi)
                                              + ---------------------------
                                                        2 %phi - 1
          (%i4) ratsimp (%);
          (%o4)                           0

 -- Função: ifactors (<n>)
     Para um inteiro positivo <n> retorna a fatoração de <n>.  Se
     'n=p1^e1..pk^nk' for a decomposição de <n> em fatores primos,
     'ifactors' retorna '[[p1, e1], ... , [pk, ek]]'.

     Os métodos de fatoração usados são divisões triviais por primos até
     9973, o método rho de Pollard e o método da curva elíptica.

          (%i1) ifactors(51575319651600);
          (%o1)     [[2, 4], [3, 2], [5, 2], [1583, 1], [9050207, 1]]
          (%i2) apply("*", map(lambda([u], u[1]^u[2]), %));
          (%o2)                        51575319651600

 -- Função: inrt (<x>, <n>)
     Retorna a parte inteira da <n>'ésima raíz do valor absoluto de <x>.

          (%i1) l: [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12]$
          (%i2) map (lambda ([a], inrt (10^a, 3)), l);
          (%o2) [2, 4, 10, 21, 46, 100, 215, 464, 1000, 2154, 4641, 10000]

 -- Função: inv_mod (<n>, <m>)
     Calcula o inverso de <n> módulo <m>.  'inv_mod (n,m)' retorna
     'false', se <n> modulo <m> for zero.

          (%i1) inv_mod(3, 41);
          (%o1)                           14
          (%i2) ratsimp(3^-1), modulus=41;
          (%o2)                           14
          (%i3) inv_mod(3, 42);
          (%o3)                          false

 -- Função: jacobi (<p>, <q>)
     Retorna símbolo de Jacobi de <p> e <q>.

          (%i1) l: [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12]$
          (%i2) map (lambda ([a], jacobi (a, 9)), l);
          (%o2)         [1, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 0]

 -- Função: lcm (<expr_1>, ..., <expr_n>)
     Retorna o menor múltiplo comum entre seus argumentos.  Os
     argumentos podem ser expressões gerais também inteiras.

     'load ("functs")' chama essa função.

 -- Função: minfactorial (<expr>)
     Examina <expr> procurando por ocorrências de dois fatoriais que
     diferem por um inteiro.  'minfactorial' então converte um em um
     polinômio vezes o outro.

          (%i1) n!/(n+2)!;
                                         n!
          (%o1)                       --------
                                      (n + 2)!
          (%i2) minfactorial (%);
                                          1
          (%o2)                    ---------------
                                   (n + 1) (n + 2)

 -- Função: next_prime (<n>)
     Retorna o menor primo maior que <n>.

          (%i1) next_prime(27);
          (%o1)                       29

 -- Função: partfrac (<expr>, <var>)
     Expande a expressão <expr> em frações parciais com relação à
     variável principal <var>.  'partfrac' faz uma decomposição completa
     de fração parcial.  O algorítmo utilizado é baseado no fato que os
     denominadores de uma expansão de fração parcial (os fatores do
     denominador original) são relativamente primos.  Os numeradores
     podem ser escritos como combinação linear dos denominadores, e a
     expansão acontece.

          (%i1) 1/(1+x)^2 - 2/(1+x) + 2/(2+x);
                                2       2        1
          (%o1)               ----- - ----- + --------
                              x + 2   x + 1          2
                                              (x + 1)
          (%i2) ratsimp (%);
                                           x
          (%o2)                 - -------------------
                                   3      2
                                  x  + 4 x  + 5 x + 2
          (%i3) partfrac (%, x);
                                2       2        1
          (%o3)               ----- - ----- + --------
                              x + 2   x + 1          2
                                              (x + 1)

 -- Função: power_mod (<a>, <n>, <m>)
     Usa um algorítmo modular para calcular 'a^n mod m' onde <a> e <n>
     são inteiros e <m> é um inteiro positivo.  Se <n> for negativo,
     'inv_mod' é usada para encontrar o inverso modular.

          (%i1) power_mod(3, 15, 5);
          (%o1)                          2
          (%i2) mod(3^15,5);
          (%o2)                          2
          (%i3) power_mod(2, -1, 5);
          (%o3)                          3
          (%i4) inv_mod(2,5);
          (%o4)                          3

 -- Função: primep (<n>)
     Teste de primalidade.  Se 'primep (n)' retornar 'false', <n> é um
     número compostro e se esse teste retornar 'true', <n> é um número
     primo com grande probabilidade.

     Para <n> menor que 341550071728321 uma versão deterministra do
     teste de Miller-Rabin é usada.  Se 'primep (n)' retornar 'true',
     então <n> é um número primo.

     Para <n> maior que 34155071728321 'primep' usa
     'primep_number_of_tests' que é os testes de pseudo-primalidade de
     Miller-Rabin e um teste de pseudo-primalidade de Lucas.  A
     probabilidade que <n> irá passar por um teste de Miller-Rabin é
     menor que 1/4.  Usando o valor padrão 25 para
     'primep_number_of_tests', a probabilidade de <n> passar no teste
     sendo composto é muito menor que 10^-15.

 -- Variável de opção: primep_number_of_tests
     Valor padrão: 25

     Número de testes de Miller-Rabin usados em 'primep'.

 -- Função: prev_prime (<n>)
     Retorna o maior primo menor que <n>.

          (%i1) prev_prime(27);
          (%o1)                       23

 -- Função: qunit (<n>)
     Retorna a principal unidade do campo dos números quadráticos reais
     'sqrt (<n>)' onde <n> é um inteiro, i.e., o elemento cuja norma é
     unidade.  Isso é importante para resolver a equação de Pell 'a^2 -
     <n> b^2 = 1'.

          (%i1) qunit (17);
          (%o1)                     sqrt(17) + 4
          (%i2) expand (% * (sqrt(17) - 4));
          (%o2)                           1

 -- Função: totient (<n>)
     Retorna o número de inteiros menores que ou iguais a <n> que são
     relativamente primos com <n>.

 -- Variável de opção: zerobern
     Valor padrão: 'true'

     Quando 'zerobern' for 'false', 'bern' exclui os números de
     Bernoulli que forem iguais a zero.  Veja 'bern'.

 -- Função: zeta (<n>)
     Retorna a função zeta de Riemann se <x> for um inteiro negativo, 0,
     1, ou número par positivo, e retorna uma forma substantiva 'zeta
     (<n>)' para todos os outros argumentos, incluindo não inteiros
     racionais, ponto flutuante, e argumentos complexos.

     Veja também 'bfzeta' e 'zeta%pi'.

          (%i1) map (zeta, [-4, -3, -2, -1, 0, 1, 2, 3, 4, 5]);
                                               2              4
                     1        1     1       %pi            %pi
          (%o1) [0, ---, 0, - --, - -, inf, ----, zeta(3), ----, zeta(5)]
                    120       12    2        6              90

 -- Variável de opção: zeta%pi
     Valor padrão: 'true'

     Quando 'zeta%pi' for 'true', 'zeta' retorna uma expressão
     proporcional a '%pi^n' para inteiro par 'n'.  De outra forma,
     'zeta' retorna uma forma substantiva 'zeta (n)' para inteiro par
     'n'.

          (%i1) zeta%pi: true$
          (%i2) zeta (4);
                                           4
                                        %pi
          (%o2)                         ----
                                         90
          (%i3) zeta%pi: false$
          (%i4) zeta (4);
          (%o4)                        zeta(4)


File: maxima.info,  Node: Simetrias,  Next: Grupos,  Prev: Teoria dos Números,  Up: Top

32 Simetrias
************

* Menu:

* Funções e Variáveis Definidas para Simetrias::


File: maxima.info,  Node: Funções e Variáveis Definidas para Simetrias,  Prev: Simetrias,  Up: Simetrias

32.1 Funções e Variáveis Definidas para Simetrias
=================================================

32.1.1 Mudando a base do sistema de numeração
---------------------------------------------

 -- Função: comp2pui (<n>, <L>)
     implementa a passagem das funções simétricas completamente
     simétricas fornecidas na lista <L> para as funções simétricas
     elementares de 0 a <n>.  Se a lista <L> contiver menos que <n+1>
     elementos, será completada com valores formais do tipo <h1>, <h2>,
     etc.  Se o primeiro elemento da lista <L> existir, ele é
     interpretado como sendo o tamanho do alfabeto, de outra forma o
     tamanho é escolhido para <n>.

          (%i1) comp2pui (3, [4, g]);
                                  2                    2
          (%o1)    [4, g, 2 h2 - g , 3 h3 - g h2 + g (g  - 2 h2)]

 -- Função: ele2pui (<m>, <L>)
     vai de funções simétricas elementares para as funções completas.
     Similar a 'comp2ele' e 'comp2pui'.

     Outras funções para mudanças de base: 'comp2ele'.

 -- Função: ele2comp (<m>, <L>)
     Vai de funções simétricas elementares para funções completas.
     Similar a 'comp2ele' e a 'comp2pui'.

     Outras funções para mudanças de base: 'comp2ele'.

 -- Função: elem (<ele>, <sym>, <lvar>)
     decompõe o polinômio simétrico <sym>, nas variáveis contidas na
     lista <lvar>, em termos de funções elementares simétricas
     fornecidas na lista <ele>.  Se o primeiro elemento de <ele> for
     fornecido, esse primeiro elemento será o tamanho do alfabeto, de
     outra forma o tamanho será o grau do polinômio <sym>.  Se valores
     forem omitidos na lista <ele>, valores formais do tipo <e1>, <e2>,
     etc.  serão adicionados.  O polinômio <sym> pode ser fornecido de
     três diferentes formas: contraída ('elem' pode então ser 1, seu
     valor padrão), particionada ('elem' pode ser 3), ou extendida (i.e.
     o polinômio completo, e 'elem' pode então ser 2).  A função 'pui' é
     usada então da mesma forma.

     sobre um alfabeto de tamanho 3 com <e1>, a primeira funçào
     elementar simétrica, com valor 7, o polinômio simétrico em 3
     variáveis cuja forma contraída (que aqui depende de duas de suas
     variáveis) é <x^4-2*x*y> decomposto como segue em funções
     elementares simétricas:

          (%i1) elem ([3, 7], x^4 - 2*x*y, [x, y]);
          (%o1) 7 (e3 - 7 e2 + 7 (49 - e2)) + 21 e3

                                                   + (- 2 (49 - e2) - 2) e2
          (%i2) ratsimp (%);
                                        2
          (%o2)             28 e3 + 2 e2  - 198 e2 + 2401

     Outras funções para mudanças de base: 'comp2ele'.

 -- Function: mon2schur (<L>)
     a lsita <L> representa a função de Schur S_L: temos L = [i_1, i_2,
     ..., i_q], com i_1 <= i_2 <= ... <= i_q.  A função de Schur S_[i_1,
     i_2, ..., i_q] é a menor da matriz infinita h_[i-j], i <= 1, j <=
     1, consistindo das q primeiras linhas e as colunas 1 + i_1, +2 +
     i_2, ..., q + i_q.

     Essa função de Schur pode ser escrita em termos de monômios usando
     'treinat' e 'kostka'.  A forma retornada é um polinômio simétrico
     na representação contraída nas variáveis x_1,x_2,\ldots.

          (%i1) mon2schur ([1, 1, 1]);
          (%o1)                       x1 x2 x3
          (%i2) mon2schur ([3]);
                                            2        3
          (%o2)                x1 x2 x3 + x1  x2 + x1
          (%i3) mon2schur ([1, 2]);
                                                2
          (%o3)                  2 x1 x2 x3 + x1  x2

     o qual significa que para 3 variáveis fornece:

             2 x1 x2 x3 + x1^2 x2 + x2^2 x1 + x1^2 x3 + x3^2 x1
              + x2^2 x3 + x3^2 x2
     Outras funções para mudanças de base: 'comp2ele'.

 -- Função: multi_elem (<l_elem>, <multi_pc>, <l_var>)
     decompões um polinômio multi-simétrico na forma multi-contraída
     <multi_pc> nos grupos de variáveis contidas na lista de listas
     <l_var> en termos de funções elementares simétricas contidas em
     <l_elem>.

          (%i1) multi_elem ([[2, e1, e2], [2, f1, f2]], a*x + a^2 + x^3, [[x, y], [a, b]]);
                                                            3
          (%o1)         - 2 f2 + f1 (f1 + e1) - 3 e1 e2 + e1
          (%i2) ratsimp (%);
                                   2                       3
          (%o2)         - 2 f2 + f1  + e1 f1 - 3 e1 e2 + e1

     Outras funções para mudanças de base: 'comp2ele'.

 -- Função: multi_pui
     é para a função 'pui' o que a função 'multi_elem' é para a função
     'elem'.

          (%i1) multi_pui ([[2, p1, p2], [2, t1, t2]], a*x + a^2 + x^3, [[x, y], [a, b]]);
                                                      3
                                          3 p1 p2   p1
          (%o1)              t2 + p1 t1 + ------- - ---
                                             2       2

 -- Função: pui (<L>, <sym>, <lvar>)
     decompõe o polinômio simétrico <sym>, nas variáveis na lista
     <lvar>, em termos de funções exponenciais na lista <L>.  Se o
     primeiro elemento de <L> for fornecido, esse primeiro elemento será
     o tamanho do alfabeto, de outra forma o tamanho será o grau do
     polinômio <sym>.  Se valores forem omitidos na lista <L>, valores
     formais do tipo <p1>, <p2> , etc.  serão adicionados.  O polinômio
     <sym> pode ser fornecido de três diferentes formas: contraída
     ('elem' pode então ser 1, seu valor padrão), particionada ('elem'
     pode ser 3), ou extendida (i.e.  o polinômio completo, e 'elem'
     pode então ser 2).  A função 'pui' é usada da mesma forma.

          (%i1) pui;
          (%o1)                           1
          (%i2) pui ([3, a, b], u*x*y*z, [x, y, z]);
                                 2
                             a (a  - b) u   (a b - p3) u
          (%o2)              ------------ - ------------
                                  6              3
          (%i3) ratsimp (%);
                                                 3
                                (2 p3 - 3 a b + a ) u
          (%o3)                 ---------------------
                                          6
     Outras funções para mudanças de base: 'comp2ele'.

 -- Função: pui2comp (<n>, <lpui>)
     converte a dista das primeiras <n> funções completas (com o
     comprimento em primeiro lugar) em termos de funções exponenciais
     fornecidas na lista <lpui>.  se a lista <lpui> for vazia, o
     cardinal é <n>, de outra forma o cardinal será seu primeiro
     elemento (como em 'comp2ele' e em 'comp2pui').

          (%i1) pui2comp (2, []);
                                                 2
                                          p2 + p1
          (%o1)                   [2, p1, --------]
                                             2
          (%i2) pui2comp (3, [2, a1]);
                                                      2
                                           a1 (p2 + a1 )
                                   2  p3 + ------------- + a1 p2
                            p2 + a1              2
          (%o2)     [2, a1, --------, --------------------------]
                               2                  3
          (%i3) ratsimp (%);
                                      2                     3
                               p2 + a1   2 p3 + 3 a1 p2 + a1
          (%o3)        [2, a1, --------, --------------------]
                                  2               6
     Outras funções para mudanças de base: 'comp2ele'.

 -- Função: pui2ele (<n>, <lpui>)
     efetiva a passagem de funções exponenciais para as funções
     elementares simétricas.  Se o sinalizador 'pui2ele' for 'girard',
     'pui2ele' irá retornar a lista de funções elementares simétricas de
     1 a <n>, e se o sinalizador for 'close', 'pui2ele' retornará a
     <n>-ésima função simétrica elementar.

     Outras funções para mudanças de base: 'comp2ele'.

 -- Função: puireduc (<n>, <lpui>)
     <lpui> é uma lista cujo primeiro elemento é um inteiro <m>.
     'puireduc' fornece as primeiras <n> funções exponenciais em termos
     das primeiras <m> funções.

          (%i1) puireduc (3, [2]);
                                                   2
                                             p1 (p1  - p2)
          (%o1)          [2, p1, p2, p1 p2 - -------------]
                                                   2
          (%i2) ratsimp (%);
                                                     3
                                         3 p1 p2 - p1
          (%o2)              [2, p1, p2, -------------]
                                               2

 -- Função: schur2comp (<P>, <l_var>)
     <P> é um polinômio nas variáveis da lista <l_var>.  Cada uma dessas
     variáveis represetna uma função simétrica completa.  Na lista
     <l_var> o <i>-ésima função simétrica completa é representada
     através da concatenação da letra 'h' com o inteiro <i>: 'h<i>'.
     Essa função expressa <P> em termos de funções de Schur.

          (%i1) schur2comp (h1*h2 - h3, [h1, h2, h3]);
          (%o1)                         s
                                         1, 2
          (%i2) schur2comp (a*h3, [h3]);
          (%o2)                         s  a
                                         3

32.1.2 Modificando represetnações
---------------------------------

 -- Função: cont2part (<pc>, <lvar>)
     Retorna o polinômio particionado associado à forma contraída <pc>
     cujas variáveis estão em <lvar>.

          (%i1) pc: 2*a^3*b*x^4*y + x^5;
                                     3    4      5
          (%o1)                   2 a  b x  y + x
          (%i2) cont2part (pc, [x, y]);
                                             3
          (%o2)              [[1, 5, 0], [2 a  b, 4, 1]]

 -- Função: contract (<psym>, <lvar>)
     retorna uma forma contraída (i.e.  um monômio de grupo ssimétrico)
     do polinômio <psym> nas variáveis contidas na lista <lvar>.  A
     função 'explose' executa a operação inversa.  A função 'tcontract'
     testa a simétria do polinômio.

          (%i1) psym: explose (2*a^3*b*x^4*y, [x, y, z]);
                   3      4      3      4      3    4        3    4
          (%o1) 2 a  b y z  + 2 a  b x z  + 2 a  b y  z + 2 a  b x  z

                                                     3      4      3    4
                                                + 2 a  b x y  + 2 a  b x  y
          (%i2) contract (psym, [x, y, z]);
                                        3    4
          (%o2)                      2 a  b x  y

 -- Função: explose (<pc>, <lvar>)
     retorna o polinômio simétrico associado com a forma contraída <pc>.
     A lista <lvar> conté as variáveis.

          (%i1) explose (a*x + 1, [x, y, z]);
          (%o1)                  a z + a y + a x + 1

 -- Função: part2cont (<ppart>, <lvar>)
     vai da forma particionada para a forma contraída de um polinômio
     simétrico.  A forma contraída é convertida com as variáveis em
     <lvar>.

          (%i1) part2cont ([[2*a^3*b, 4, 1]], [x, y]);
                                        3    4
          (%o1)                      2 a  b x  y

 -- Função: partpol (<psym>, <lvar>)
     <psym> é um polinômio simétrico nas variáveis da lista <lvar>.
     Essa função retorna sua represetnação particionada.

          (%i1) partpol (-a*(x + y) + 3*x*y, [x, y]);
          (%o1)               [[3, 1, 1], [- a, 1, 0]]

 -- Função: tcontract (<pol>, <lvar>)
     testa se o polinômio <pol> é simétrico nas variáveis da lista
     <lvar>.  Se for, 'tcontract' retorna uma representação contraída
     como o faz a função 'contract'.

 -- Função: tpartpol (<pol>, <lvar>)
     testa se o polinômio <pol> é simétrico nas variáveis da lista
     <lvar>.  Se for, 'tpartpol' retorna sua represetnação particionada
     como o faz a função 'partpol'.

32.1.3 Grupos e órbitas
-----------------------

 -- Função: direct ([<p_1>, ..., <p_n>], <y>, <f>, [<lvar_1>, ...,
          <lvar_n>])
     calcula a imagem direta (see M. Giusti, D. Lazard et A. Valibouze,
     ISSAC 1988, Rome) associada à função <f>, na lista de variáveis
     <lvar_1>, ..., <lvar_n>, e nos polinômios <p_1>, ..., <p_n> na
     variável <y>.  A quantidade de argumetnos que a funçào <f> pode
     receber é importante para o cálculo.  Dessa forma, se a expressão
     para <f> não depende de alguma variável, é inútil incluir essa
     variável, e não incluir essa variável irá também reduzir
     consideravelmente o montante cálculos efetuados.

          (%i1) direct ([z^2  - e1* z + e2, z^2  - f1* z + f2],
                        z, b*v + a*u, [[u, v], [a, b]]);
                 2
          (%o1) y  - e1 f1 y

                                           2            2             2   2
                            - 4 e2 f2 - (e1  - 2 e2) (f1  - 2 f2) + e1  f1
                          + -----------------------------------------------
                                                   2
          (%i2) ratsimp (%);
                        2                2                   2
          (%o2)        y  - e1 f1 y + (e1  - 4 e2) f2 + e2 f1
          (%i3) ratsimp (direct ([z^3-e1*z^2+e2*z-e3,z^2  - f1* z + f2],
                        z, b*v + a*u, [[u, v], [a, b]]));
                 6            5         2                        2    2   4
          (%o3) y  - 2 e1 f1 y  + ((2 e1  - 6 e2) f2 + (2 e2 + e1 ) f1 ) y

                                    3                               3   3
           + ((9 e3 + 5 e1 e2 - 2 e1 ) f1 f2 + (- 2 e3 - 2 e1 e2) f1 ) y

                   2       2        4    2
           + ((9 e2  - 6 e1  e2 + e1 ) f2

                              2       2       2                   2    4
           + (- 9 e1 e3 - 6 e2  + 3 e1  e2) f1  f2 + (2 e1 e3 + e2 ) f1 )

            2          2                      2     3          2
           y  + (((9 e1  - 27 e2) e3 + 3 e1 e2  - e1  e2) f1 f2

                           2            2    3                5
           + ((15 e2 - 2 e1 ) e3 - e1 e2 ) f1  f2 - 2 e2 e3 f1 ) y

                     2                   3           3     2   2    3
           + (- 27 e3  + (18 e1 e2 - 4 e1 ) e3 - 4 e2  + e1  e2 ) f2

                   2      3                   3    2   2
           + (27 e3  + (e1  - 9 e1 e2) e3 + e2 ) f1  f2

                             2    4        2   6
           + (e1 e2 e3 - 9 e3 ) f1  f2 + e3  f1

     Encontrando um polinômio cujas raízes são somatórios a+u onde a é
     uma raíz de z^2 - e_1 z + e_2 e u é uma raíz de z^2 - +f_1 z + f_2.

          (%i1) ratsimp (direct ([z^2 - e1* z + e2, z^2 - f1* z + f2],
                                    z, a + u, [[u], [a]]));
                 4                    3             2
          (%o1) y  + (- 2 f1 - 2 e1) y  + (2 f2 + f1  + 3 e1 f1 + 2 e2

               2   2                              2               2
           + e1 ) y  + ((- 2 f1 - 2 e1) f2 - e1 f1  + (- 2 e2 - e1 ) f1

                            2                     2            2
           - 2 e1 e2) y + f2  + (e1 f1 - 2 e2 + e1 ) f2 + e2 f1  + e1 e2 f1

               2
           + e2

     'direct' aceita dois sinalizadores: 'elementaires' (elementares) e
     'puissances' (exponenciais - valor padrão) que permitem a
     decomposição de polinômios simétricos que aparecerem nesses
     cálculos em funções simétricas elementares ou em funções
     exponenciais respectivamente.

     Funções de 'sym' utilizadas nesta função :

     'multi_orbit' (portanto 'orbit'), 'pui_direct', 'multi_elem'
     (portanto 'elem'), 'multi_pui' (portanto 'pui'), 'pui2ele',
     'ele2pui' (se o sinalizador 'direct' for escolhido para
     'puissances').

 -- Função: multi_orbit (<P>, [<lvar_1>, <lvar_2>,..., <lvar_p>])

     <P> é um polinômio no conjunto de variáveis contidas nas lista
     <lvar_1>, <lvar_2>, ..., <lvar_p>.  Essa função retorna a órbita do
     polinômio <P> sob a ação do produto dos grupos simétricos dos
     conjuntos de variáveis represetnadas nas <p> listas.

          (%i1) multi_orbit (a*x + b*y, [[x, y], [a, b]]);
          (%o1)                [b y + a x, a y + b x]
          (%i2) multi_orbit (x + y + 2*a, [[x, y], [a, b, c]]);
          (%o2)        [y + x + 2 c, y + x + 2 b, y + x + 2 a]
     Veja também: 'orbit' para a ação de um grupo simétrico simples.

 -- Função: multsym (<ppart_1>, <ppart_2>, <n>)
     retorna oproduto de dois polinômios simétricos em <n> varieis
     trabalhando somente módulo a ação do grupo simétrico de ordem <n>.
     O polinômios estão em sua forma particionada.

     Dados 2 polinômio simétricos em <x>, <y>: '3*(x + y) + 2*x*y' e
     '5*(x^2 + y^2)' cujas formas particionadas são '[[3, 1], [2, 1,
     1]]' e '[[5, 2]]', seu produto irá ser

          (%i1) multsym ([[3, 1], [2, 1, 1]], [[5, 2]], 2);
          (%o1)         [[10, 3, 1], [15, 3, 0], [15, 2, 1]]
     isso é '10*(x^3*y + y^3*x) + 15*(x^2*y + y^2*x) + 15*(x^3 + y^3)'.

     Funções para mudar as representacões de um polinômio simétrico:

     'contract', 'cont2part', 'explose', 'part2cont', 'partpol',
     'tcontract', 'tpartpol'.

 -- Função: orbit (<P>, <lvar>)
     calcula a órbita do polinômio <P> nas variáveis na lista <lvar> sob
     a ação do grupo simétrico do conjunto das variáveis na lista
     <lvar>.

          (%i1) orbit (a*x + b*y, [x, y]);
          (%o1)                [a y + b x, b y + a x]
          (%i2) orbit (2*x + x^2, [x, y]);
                                  2         2
          (%o2)                 [y  + 2 y, x  + 2 x]
     Veja também 'multi_orbit' para a ação de um produto de grupos
     simétricos sobre um polinômio.

 -- Função: pui_direct (<orbite>, [<lvar_1>, ..., <lvar_n>], [<d_1>,
          <d_2>, ..., <d_n>])

     Tomemos <f> para ser um polinômio em <n> blocos de variáveis
     <lvar_1>, ..., <lvar_n>.  Façamos <c_i> ser o n;umero de variáveis
     em <lvar_i>, e <SC> ser o produto de <n> grupos simétricos de grau
     <c_1>, ..., <c_n>.  Essas ações dos grupos naturalmente sobre <f>.
     A lista <orbite> é a órbita, denotada '<SC>(<f>)', da função <f>
     sob a ação de <SC>.  (Essa lista pode ser obtida através da função
     'multi_orbit'.)  Os <di> são inteiros de forma que c_1 \le d_1, c_2
     \le d_2, \ldots, c_n \le d_n.

     Tomemos <SD> para ser o produto dos grupos simétricos S_[d_1] x
     S_[d_2] x ... x S_[d_n].  A função 'pui_direct' retorna as
     primeiras <n> funções exponenciais de '<SD>(<f>)' deduzidas das
     funções exponenciais de '<SC>(<f>)', onde <n> é o tamanho de
     '<SD>(<f>)'.

     O resultado está na multi-forma contraída com relação a <SD>, i.e.
     somente um elemento é mantido por órbita, sob a ação de <SD>.

          (%i1) l: [[x, y], [a, b]];
          (%o1)                   [[x, y], [a, b]]
          (%i2) pui_direct (multi_orbit (a*x + b*y, l), l, [2, 2]);
                                                 2  2
          (%o2)               [a x, 4 a b x y + a  x ]
          (%i3) pui_direct (multi_orbit (a*x + b*y, l), l, [3, 2]);
                                       2  2     2    2        3  3
          (%o3) [2 a x, 4 a b x y + 2 a  x , 3 a  b x  y + 2 a  x ,

              2  2  2  2      3    3        4  4
          12 a  b  x  y  + 4 a  b x  y + 2 a  x ,

              3  2  3  2      4    4        5  5
          10 a  b  x  y  + 5 a  b x  y + 2 a  x ,

              3  3  3  3       4  2  4  2      5    5        6  6
          40 a  b  x  y  + 15 a  b  x  y  + 6 a  b x  y + 2 a  x ]
          (%i4) pui_direct ([y + x + 2*c, y + x + 2*b, y + x + 2*a], [[x, y], [a, b, c]], [2, 3]);
                                       2              2
          (%o4) [3 x + 2 a, 6 x y + 3 x  + 4 a x + 4 a ,

                           2                   3        2       2        3
                        9 x  y + 12 a x y + 3 x  + 6 a x  + 12 a  x + 8 a ]

32.1.4 Partições
----------------

 -- Função: kostka (<part_1>, <part_2>)
     escrita por P. Esperet, calcula o número de Kostka da partição
     <part_1> e <part_2>.

          (%i1) kostka ([3, 3, 3], [2, 2, 2, 1, 1, 1]);
          (%o1)                           6

 -- Função: lgtreillis (<n>, <m>)
     retorna a lista de partições de peso <n> e comprimento <m>.

          (%i1) lgtreillis (4, 2);
          (%o1)                   [[3, 1], [2, 2]]
     Veja também: 'ltreillis', 'treillis' e 'treinat'.

 -- Função: ltreillis (<n>, <m>)
     retorna a lista de partições de peso <n> e comprimento menor que ou
     igual a <m>.

          (%i1) ltreillis (4, 2);
          (%o1)               [[4, 0], [3, 1], [2, 2]]
     Veja também: 'lgtreillis', 'treillis' e 'treinat'.

 -- Função: treillis (<n>)
     retorna todas as partições de peso <n>.

          (%i1) treillis (4);
          (%o1)    [[4], [3, 1], [2, 2], [2, 1, 1], [1, 1, 1, 1]]

     Veja também: 'lgtreillis', 'ltreillis' e 'treinat'.

 -- Função: treinat (<part>)
     retorna a lista de partições inferiores à partiçào <part> com
     relação à ordem natural.

          (%i1) treinat ([5]);
          (%o1)                         [[5]]
          (%i2) treinat ([1, 1, 1, 1, 1]);
          (%o2) [[5], [4, 1], [3, 2], [3, 1, 1], [2, 2, 1], [2, 1, 1, 1],

                                                           [1, 1, 1, 1, 1]]
          (%i3) treinat ([3, 2]);
          (%o3)                 [[5], [4, 1], [3, 2]]

     Veja também: 'lgtreillis', 'ltreillis' e 'treillis'.

32.1.5 Polinômios e suas raízes
-------------------------------

 -- Função: ele2polynome (<L>, <z>)
     retorna o polinômio em <z> de forma que as funções elementares
     simétricas de suas raízes estejam na lista '<L> = [<n>, <e_1>, ...,
     <e_n>]', onde <n> é o grau dos polinômios e <e_i> é a <i>-ésima
     função simétrica elementar.

          (%i1) ele2polynome ([2, e1, e2], z);
                                    2
          (%o1)                    z  - e1 z + e2
          (%i2) polynome2ele (x^7 - 14*x^5 + 56*x^3  - 56*x + 22, x);
          (%o2)          [7, 0, - 14, 0, 56, 0, - 56, - 22]
          (%i3) ele2polynome ([7, 0, -14, 0, 56, 0, -56, -22], x);
                            7       5       3
          (%o3)            x  - 14 x  + 56 x  - 56 x + 22
     o inverso: 'polynome2ele (<P>, <z>)'.

     Veja também: 'polynome2ele', 'pui2polynome'.

 -- Função: polynome2ele (<P>, <x>)
     fornece a lista '<l> = [<n>, <e_1>, ..., <e_n>]' onde <n> é o grau
     do polinômio <P> na variável <x> e <e_i> é a <i>-ésima função
     simétrica elementar das raízes de <P>.

          (%i1) polynome2ele (x^7 - 14*x^5 + 56*x^3 - 56*x + 22, x);
          (%o1)          [7, 0, - 14, 0, 56, 0, - 56, - 22]
          (%i2) ele2polynome ([7, 0, -14, 0, 56, 0, -56, -22], x);
                            7       5       3
          (%o2)            x  - 14 x  + 56 x  - 56 x + 22
     A inversa: 'ele2polynome (<l>, <x>)'

 -- Função: prodrac (<L>, <k>)
     <L> é uma lista contendo as funções simétricas elementares sobre um
     conjunto <A>.  'prodrac' retorna o polinômio cujas raízes são os
     produtos <k> por <k> dos elementos de <A>.

     Veja também 'somrac'.

 -- Função: pui2polynome (<x>, <lpui>)
     calcula o polinômio em <x> cujas funções exponenciais das raízes
     são dadas na lista <lpui>.

          (%i1) pui;
          (%o1)                           1
          (%i2) kill(labels);
          (%o0)                         done
          (%i1) polynome2ele (x^3 - 4*x^2 + 5*x - 1, x);
          (%o1)                     [3, 4, 5, 1]
          (%i2) ele2pui (3, %);
          (%o2)                     [3, 4, 6, 7]
          (%i3) pui2polynome (x, %);
                                  3      2
          (%o3)                  x  - 4 x  + 5 x - 1
     Veja também: 'polynome2ele', 'ele2polynome'.

 -- Função: somrac (<L>, <k>)
     A lista <L> contains função simétrica elementars de um polynomial
     <P> .  The function computes the polinômio whose roots are the <k>
     by <k> distinct sums of the roots of <P>.

     Also see 'prodrac'.

32.1.6 Resolvents
-----------------

 -- Função: resolvante (<P>, <x>, <f>, [<x_1>,..., <x_d>])
     calcula a resilvente do polinômio <P> em <x> de grau <n> >= <d>
     através da fFunção <f> expressa nas variáveis <x_1>, ..., <x_d>.
     Para eficiência de computação é importante não incluir na lista as
     variáveis '[<x_1>, ..., <x_d>]' que não aparecem na função de
     transformação <f>.

     Para melhorar a eficiência do cálculo se pode escolher
     sinalizadores em 'resolvante' de forma a usar os algorítmos
     apropriados:

     Se a função <f> for unitária :
        * um polinômio em uma variável simples,
        * linear ,
        * alternando,
        * um somatório,
        * simétrico,
        * um produto,
        * a função da resolvente de Cayley (utilizável de grau 5 em
          diante)

               (x1*x2 + x2*x3 + x3*x4 + x4*x5 + x5*x1 -
                    (x1*x3 + x3*x5 + x5*x2 + x2*x4 + x4*x1))^2

          geral,
     o sinalizador da 'resolvante' poderá ser respectivamente :
        * unitaire,
        * lineaire,
        * alternee,
        * somme,
        * produit,
        * cayley,
        * generale.

          (%i1) resolvante: unitaire$
          (%i2) resolvante (x^7 - 14*x^5 + 56*x^3 - 56*x + 22, x, x^3 - 1, [x]);

          " resolvante unitaire " [7, 0, 28, 0, 168, 0, 1120, - 154, 7840, - 2772, 56448, - 33880,

          413952, - 352352, 3076668, - 3363360, 23114112, - 30494464,

          175230832, - 267412992, 1338886528, - 2292126760]
            3       6      3       9      6      3
          [x  - 1, x  - 2 x  + 1, x  - 3 x  + 3 x  - 1,

           12      9      6      3       15      12       9       6      3
          x   - 4 x  + 6 x  - 4 x  + 1, x   - 5 x   + 10 x  - 10 x  + 5 x

                 18      15       12       9       6      3
           - 1, x   - 6 x   + 15 x   - 20 x  + 15 x  - 6 x  + 1,

           21      18       15       12       9       6      3
          x   - 7 x   + 21 x   - 35 x   + 35 x  - 21 x  + 7 x  - 1]
          [- 7, 1127, - 6139, 431767, - 5472047, 201692519, - 3603982011]
                 7      6        5         4          3           2
          (%o2) y  + 7 y  - 539 y  - 1841 y  + 51443 y  + 315133 y

                                                        + 376999 y + 125253
          (%i3) resolvante: lineaire$
          (%i4) resolvante (x^4 - 1, x, x1 + 2*x2 + 3*x3, [x1, x2, x3]);

          " resolvante lineaire "
                 24       20         16            12             8
          (%o4) y   + 80 y   + 7520 y   + 1107200 y   + 49475840 y

                                                              4
                                                 + 344489984 y  + 655360000
          (%i5) resolvante: general$
          (%i6) resolvante (x^4 - 1, x, x1 + 2*x2 + 3*x3, [x1, x2, x3]);

          " resolvante generale "
                 24       20         16            12             8
          (%o6) y   + 80 y   + 7520 y   + 1107200 y   + 49475840 y

                                                              4
                                                 + 344489984 y  + 655360000
          (%i7) resolvante (x^4 - 1, x, x1 + 2*x2 + 3*x3, [x1, x2, x3, x4]);

          " resolvante generale "
                 24       20         16            12             8
          (%o7) y   + 80 y   + 7520 y   + 1107200 y   + 49475840 y

                                                              4
                                                 + 344489984 y  + 655360000
          (%i8) direct ([x^4 - 1], x, x1 + 2*x2 + 3*x3, [[x1, x2, x3]]);
                 24       20         16            12             8
          (%o8) y   + 80 y   + 7520 y   + 1107200 y   + 49475840 y

                                                              4
                                                 + 344489984 y  + 655360000
          (%i9) resolvante :lineaire$
          (%i10) resolvante (x^4 - 1, x, x1 + x2 + x3, [x1, x2, x3]);

          " resolvante lineaire "
                                        4
          (%o10)                       y  - 1
          (%i11) resolvante: symetrique$
          (%i12) resolvante (x^4 - 1, x, x1 + x2 + x3, [x1, x2, x3]);

          " resolvante symetrique "
                                        4
          (%o12)                       y  - 1
          (%i13) resolvante (x^4 + x + 1, x, x1 - x2, [x1, x2]);

          " resolvante symetrique "
                                     6      2
          (%o13)                    y  - 4 y  - 1
          (%i14) resolvante: alternee$
          (%i15) resolvante (x^4 + x + 1, x, x1 - x2, [x1, x2]);

          " resolvante alternee "
                      12      8       6        4        2
          (%o15)     y   + 8 y  + 26 y  - 112 y  + 216 y  + 229
          (%i16) resolvante: produit$
          (%i17) resolvante (x^7 - 7*x + 3, x, x1*x2*x3, [x1, x2, x3]);

          " resolvante produit "
                  35      33         29        28         27        26
          (%o17) y   - 7 y   - 1029 y   + 135 y   + 7203 y   - 756 y

                   24           23          22            21           20
           + 1323 y   + 352947 y   - 46305 y   - 2463339 y   + 324135 y

                    19           18             17              15
           - 30618 y   - 453789 y   - 40246444 y   + 282225202 y

                       14              12             11            10
           - 44274492 y   + 155098503 y   + 12252303 y   + 2893401 y

                        9            8            7             6
           - 171532242 y  + 6751269 y  + 2657205 y  - 94517766 y

                      5             3
           - 3720087 y  + 26040609 y  + 14348907
          (%i18) resolvante: symetrique$
          (%i19) resolvante (x^7 - 7*x + 3, x, x1*x2*x3, [x1, x2, x3]);

          " resolvante symetrique "
                  35      33         29        28         27        26
          (%o19) y   - 7 y   - 1029 y   + 135 y   + 7203 y   - 756 y

                   24           23          22            21           20
           + 1323 y   + 352947 y   - 46305 y   - 2463339 y   + 324135 y

                    19           18             17              15
           - 30618 y   - 453789 y   - 40246444 y   + 282225202 y

                       14              12             11            10
           - 44274492 y   + 155098503 y   + 12252303 y   + 2893401 y

                        9            8            7             6
           - 171532242 y  + 6751269 y  + 2657205 y  - 94517766 y

                      5             3
           - 3720087 y  + 26040609 y  + 14348907
          (%i20) resolvante: cayley$
          (%i21) resolvante (x^5 - 4*x^2 + x + 1, x, a, []);

          " resolvente de Cayley "
                  6       5         4          3            2
          (%o21) x  - 40 x  + 4080 x  - 92928 x  + 3772160 x  + 37880832 x

                                                                 + 93392896

     Para a resolvente de Cayley, os 2 últimos argumentos são neutros e
     o polinômio fornecido na entrada deve ser necessáriamente de grau
     5.

     Veja também :

     'resolvante_bipartite', 'resolvante_produit_sym',
     'resolvante_unitaire', 'resolvante_alternee1', 'resolvante_klein',
     'resolvante_klein3', 'resolvante_vierer', 'resolvante_diedrale'.

 -- Função: resolvante_alternee1 (<P>, <x>)
     calcula a transformação de '<P>(<x>)' de grau <n> pela função
     $\prod_{1\leq i<j\leq n-1} (x_i-x_j)$.  product(x_i - x_j, 1 <= i <
     j <= n - 1).

     Veja também :

     'resolvante_produit_sym', 'resolvante_unitaire', 'resolvante' ,
     'resolvante_klein', 'resolvante_klein3', 'resolvante_vierer',
     'resolvante_diedrale', 'resolvante_bipartite'.

 -- Função: resolvante_bipartite (<P>, <x>)
     calcula a trasformação de '<P>(<x>)' de mesmo grau <n> através da
     função x_1 x_2 ... x_[n/2] + x_[n/2 + 1] ... x_n.

     Veja também :

     'resolvante_produit_sym', 'resolvante_unitaire', 'resolvante' ,
     'resolvante_klein', 'resolvante_klein3', 'resolvante_vierer',
     'resolvante_diedrale', 'resolvante_alternee1'.

          (%i1) resolvante_bipartite (x^6 + 108, x);
                        10        8           6             4
          (%o1)        y   - 972 y  + 314928 y  - 34012224 y

     Veja também :

     'resolvante_produit_sym', 'resolvante_unitaire', 'resolvante',
     'resolvante_klein', 'resolvante_klein3', 'resolvante_vierer',
     'resolvante_diedrale', 'resolvante_alternee1'.

 -- Função: resolvante_diedrale (<P>, <x>)
     calcula a transformação de '<P>(<x>)' através da função '<x_1>
     <x_2> + <x_3> <x_4>'.

          (%i1) resolvante_diedrale (x^5 - 3*x^4 + 1, x);
                 15       12       11       10        9         8         7
          (%o1) x   - 21 x   - 81 x   - 21 x   + 207 x  + 1134 x  + 2331 x

                  6         5          4          3          2
           - 945 x  - 4970 x  - 18333 x  - 29079 x  - 20745 x  - 25326 x

           - 697

     Veja também :

     'resolvante_produit_sym', 'resolvante_unitaire',
     'resolvante_alternee1', 'resolvante_klein', 'resolvante_klein3',
     'resolvante_vierer', 'resolvante'.

 -- Função: resolvante_klein (<P>, <x>)
     +calculates the transformation of '<P>(<x>)' by the function
     +'<x_1> <x_2> <x_4> + <x_4>'.

     Veja também :

     'resolvante_produit_sym', 'resolvante_unitaire',
     'resolvante_alternee1', 'resolvante', 'resolvante_klein3',
     'resolvante_vierer', 'resolvante_diedrale'.

 -- Função: resolvante_klein3 (<P>, <x>)
     calcula a transformação de '<P>(<x>)' através da função '<x_1>
     <x_2> <x_4> + <x_4>'.

     Veja também :

     'resolvante_produit_sym', 'resolvante_unitaire',
     'resolvante_alternee1', 'resolvante_klein', 'resolvante',
     'resolvante_vierer', 'resolvante_diedrale'.

 -- Função: resolvante_produit_sym (<P>, <x>)
     calcula a lista de todas as resolventes de produto do polinômio
     '<P>(<x>)'.

          (%i1) resolvante_produit_sym (x^5 + 3*x^4 + 2*x - 1, x);
                  5      4             10      8       7       6       5
          (%o1) [y  + 3 y  + 2 y - 1, y   - 2 y  - 21 y  - 31 y  - 14 y

              4       3      2       10      8       7    6       5       4
           - y  + 14 y  + 3 y  + 1, y   + 3 y  + 14 y  - y  - 14 y  - 31 y

                 3      2       5      4
           - 21 y  - 2 y  + 1, y  - 2 y  - 3 y - 1, y - 1]
          (%i2) resolvante: produit$
          (%i3) resolvante (x^5 + 3*x^4 + 2*x - 1, x, a*b*c, [a, b, c]);

          " resolvente produto "
                 10      8       7    6        5       4       3     2
          (%o3) y   + 3 y  + 14 y  - y  - 14 y  - 31 y  - 21 y  - 2 y  + 1

     Veja também :

     'resolvante', 'resolvante_unitaire', 'resolvante_alternee1',
     'resolvante_klein', 'resolvante_klein3', 'resolvante_vierer',
     'resolvante_diedrale'.

 -- Função: resolvante_unitaire (<P>, <Q>, <x>)
     calcula a resolvente do polinômio '<P>(<x>)' através do polinomio
     '<Q>(<x>)'.

     Veja também :

     'resolvante_produit_sym', 'resolvante', 'resolvante_alternee1',
     'resolvante_klein', 'resolvante_klein3', 'resolvante_vierer',
     'resolvante_diedrale'.

 -- Função: resolvante_vierer (<P>, <x>)
     calcula a transformação de '<P>(<x>)' pela função '<x_1> <x_2> -
     <x_3> <x_4>'.

     Veja também :

     'resolvante_produit_sym', 'resolvante_unitaire',
     'resolvante_alternee1', 'resolvante_klein', 'resolvante_klein3',
     'resolvante', 'resolvante_diedrale'.

32.1.7 Miscelânia
-----------------

 -- Função: multinomial (<r>, <part>)
     onde <r> é o peso da partição <part>.  Essa função retorna o
     coefinciente multinomial associado: se as partes de <part> forem
     <i_1>, <i_2>, ..., <i_k>, o resultado é '<r>!/(<i_1>! <i_2>! ...
     <i_k>!)'.

 -- Função: permut (<L>)
     retorna a lista de permutações da lista <L>.


File: maxima.info,  Node: Grupos,  Next: Ambiente em Tempo de Execução,  Prev: Simetrias,  Up: Top

33 Grupos
*********

* Menu:

* Funções e Variáveis Definidas para Grupos::


File: maxima.info,  Node: Funções e Variáveis Definidas para Grupos,  Prev: Grupos,  Up: Grupos

33.1 Funções e Variáveis Definidas para Grupos
==============================================

 -- Função: todd_coxeter (<relação>, <subgroupo>)
 -- Função: todd_coxeter (<relação>)

     Acha a ordem de G/H onde G é o módulo do Grupo Livre <relação>, e H
     é o subgroupo de G gerado por <subgroupo>.  <subgroupo> é um
     argumento opcional, cujo valor padrão é [].  Em fazendo isso a
     função produz uma tabela de multiplicação à direita de G sobre G/H,
     onde os co-conjuntos são enumerados [H,Hg2,Hg3,...].  Isso pode ser
     visto internamente no 'todd_coxeter_state'.

     Exemplo:

          (%i1) symet(n):=create_list(
                  if (j - i) = 1 then (p(i,j))^^3 else
                      if (not i = j) then (p(i,j))^^2 else
                          p(i,i) , j, 1, n-1, i, 1, j);
                                                                 <3>
          (%o1) symet(n) := create_list(if j - i = 1 then p(i, j)

                                          <2>
           else (if not i = j then p(i, j)    else p(i, i)), j, 1, n - 1,

          i, 1, j)
          (%i2) p(i,j) := concat(x,i).concat(x,j);
          (%o2)        p(i, j) := concat(x, i) . concat(x, j)
          (%i3) symet(5);
                   <2>           <3>    <2>           <2>           <3>
          (%o3) [x1   , (x1 . x2)   , x2   , (x1 . x3)   , (x2 . x3)   ,

                      <2>           <2>           <2>           <3>    <2>
                    x3   , (x1 . x4)   , (x2 . x4)   , (x3 . x4)   , x4   ]
          (%i4) todd_coxeter(%o3);

          Rows tried 426
          (%o4)                          120
          (%i5) todd_coxeter(%o3,[x1]);

          Rows tried 213
          (%o5)                          60
          (%i6) todd_coxeter(%o3,[x1,x2]);

          Rows tried 71
          (%o6)                          20


File: maxima.info,  Node: Ambiente em Tempo de Execução,  Next: Opções Diversas,  Prev: Grupos,  Up: Top

34 Ambiente em Tempo de Execução
********************************

* Menu:

* Introdução a Ambiente em Tempo de Execução::
* Interrupções::
* Funções e Variáveis Definidas para Ambiente em Tempo de Execução::


File: maxima.info,  Node: Introdução a Ambiente em Tempo de Execução,  Next: Interrupções,  Prev: Ambiente em Tempo de Execução,  Up: Ambiente em Tempo de Execução

34.1 Introdução a Ambiente em Tempo de Execução
===============================================

'maxima-init.mac' é um arquivo que é chamado automaticamente quando o
Maxima inicia.  Você pode usar 'maxima-init.mac' para personalizar seu
ambiente Maxima.  'maxima-init.mac', se existir, é tipicamente colocado
no diretório chamado por 'maxima_userdir', embora possa estar em
qualquer outro diretório procurado pela função 'file_search'.

   Aqui está um exemplo do arquivo 'maxima-init.mac':

     setup_autoload ("specfun.mac", ultraspherical, assoc_legendre_p);
     showtime:all;

   Nesse Exemplo, 'setup_autoload' diz ao Maxima para chamar o arquivo
especificado ('specfun.mac') se qualquer das funções ('ultraspherical',
'assoc_legendre_p') forem chamadas sem estarem definidas.  Dessa forma
você não precisa lembrar de chamar o arquivo antes das funções.

   A declaração 'showtime: all' diz ao Maxima escolher a variável
'showtime'.  O arquivo 'maxima-init.mac' pode conter qualquer outras
atribuições ou outras declarações do Maxima.


File: maxima.info,  Node: Interrupções,  Next: Funções e Variáveis Definidas para Ambiente em Tempo de Execução,  Prev: Introdução a Ambiente em Tempo de Execução,  Up: Ambiente em Tempo de Execução

34.2 Interrupções
=================

O usuário pode parar uma computação que consome muito tempo com o
caractere ^C (control-C). A ação padrão é parar a computação e mostrar
outra linha de comando do usuário.  Nesse caso, não é possível continuar
a computação interrompida.

   Se a variável Lisp '*debugger-hook*' é escolhida para 'nil', através
do comando

     :lisp (setq *debugger-hook* nil)

então na ocasião do recebimento do ^C, Maxima iniciará o depurador Lisp,
e o usuário pode usar o depurador para inspecionar o ambiente Lisp.  A
computação interrompida pode ser retomada através do comando 'continue'
no depurador Lisp.  O método de retorno para ao Maxima partindo do
depurador Lisp (outro como executando a computação para complementação)
é diferente para cada versão do Lisp.

   Em sistemas Unix, o caratere ^Z (control-Z) faz com que Maxima pare
tudo e aguarde em segundo plano, e o controle é retornado para a linha
de comando do shell.  O comando 'fg' faz com que o Maxima retorne ao
primeiro plano e continue a partir do ponto no qual foi interrompido.


File: maxima.info,  Node: Funções e Variáveis Definidas para Ambiente em Tempo de Execução,  Prev: Interrupções,  Up: Ambiente em Tempo de Execução

34.3 Funções e Variáveis Definidas para Ambiente em Tempo de Execução
=====================================================================

 -- Declaração: feature
     Maxima compreende dois tipos distintos de recurso, recursos do
     sistema e recursos aplicados a expressões matemáticas.  Veja Também
     'status' para informações sobre recursos do sistema.  Veja Também
     'features' e 'featurep' para informações sobre recursos
     matemáticos.

     'feature' por si mesmo não é o nome de uma função ou variável.

 -- Função: featurep (<a>, <f>)
     Tenta determinar se o objeto <a> tem o recurso <f> na base dos
     fatos dentro base de dados corrente.  Se possue, é retornado
     'true', de outra forma é retornado 'false'.

     Note que 'featurep' retorna 'false' quando nem <f> nem a negação de
     <f> puderem ser estabelecidas.

     'featurep' avalia seus argumentos.

     Veja também 'declare' e 'features'.

          (%i1) declare (j, even)$
          (%i2) featurep (j, integer);
          (%o2)                           true

 -- Variável de sistema: maxima_tempdir

     'maxima_tempdir' nomeia o diretório no qual Maxima cria alguns
     arquivos temporários.  Em particular, arquivos temporários para
     impressão são criados no 'maxima_tempdir'.

     O valor inicial de 'maxima_tempdir' é o diretório do usuário, se o
     maxima puder localizá-lo; de outra forma Maxima supõe um diretório
     adequado.

     A 'maxima_tempdir' pode ser atribuído uma seqüência de caracteres
     que corresponde a um diretório.

 -- Variável de sistema: maxima_userdir

     'maxima_userdir' nomeia um diretório no qual Maxima espera
     encontrar seus próprios arquivos e os do arquivos do Lisp.  (Maxima
     procura em alguns outros diretórios também; 'file_search_maxima' e
     'file_search_lisp' possuem a lista completa.)

     O valor inicial de 'maxima_userdir' é um subdiretório do diretório
     do usuário, se Maxima puder localizá-lo; de outra forma Maxima
     supõe um diretório adequado.

     A 'maxima_userdir' pode ser atribuído uma seqüência de caracteres
     que corresponde a um diretório.  Todavia, fazendo uma atribuição a
     'maxima_userdir' não muda automaticamente o valor de
     'file_search_maxima' e de 'file_search_lisp'; Essas variáveis devem
     ser modificadas separadamente.

 -- Função: room ()
 -- Função: room (true)
 -- Função: room (false)
     Mostra uma descrição do estado de armazenamento e gerenciamento de
     pilha no Maxima.  'room' chama a função Lisp de mesmo nome.

        * 'room ()' mostra uma descrição moderada.
        * 'room (true)' mostra uma descrição detalhada.
        * 'room (false)' mostra uma descrição resumida.

 -- Função: status (feature)
 -- Função: status (feature, <recurso_ativo>)
 -- Função: status (status)
     Retorna informações sobre a presença ou ausência de certos recursos
     dependentes do sistema operacional.

        * 'status (feature)' retorna uma lista dos recursos do sistema.
          Inclui a versão do Lisp, tipo de sistema operacional, etc.  A
          lista pode variar de um tipo de Lisp para outro.
        * 'status (feature, <recurso_ativo>)' retorna 'true' se
          <recurso_ativo> está na lista de ítens retornada através de
          'status (feature)' e 'false' de outra forma.  'status' não
          avalia o argumento <recurso_ativo>.  O operador
          apóstrofo-apóstrofo, '''', evita a avaliação.  Um recurso cujo
          nome contém um caractere especial, tal como um hífem, deve ser
          fornecido como um argumento em forma de seqüência de
          caracteres.  Por Exemplo, 'status (feature, "ansi-cl")'.
        * 'status (status)' retorna uma lista de dois elementos
          '[feature, status]'.  'feature' e 'status' são dois argumentos
          aceitos pela função 'status'; Não está claro se essa lista tem
          significância adicional.

     A variável 'features' contém uma lista de recursos que se aplicam a
     expressões matemáticas.  Veja 'features' e 'featurep' para maiores
     informações.

 -- Função: time (%o1, %o2, %o3, ...)
     Retorna uma lista de tempos, em segundos, usados para calcular as
     linhas de saída '%o1', '%o2', '%o3', ....  O tempo retornado é uma
     estimativa do Maxima do tempo interno de computação, não do tempo
     decorrido.  'time' pode somente ser aplicado a variáveis(rótulos)
     de saída de linha; para quaisquer outras variáveis, 'time' retorna
     'unknown' (tempo desconhecido).

     Escolha 'showtime: true' para fazer com que Maxima moste o tempo de
     computação e o tempo decorrido a cada linha de saída.

 -- Função: timedate ()
     Retorna uma seqüência de caracteres representando a data e hora
     atuais.  A seqüência de caracteres tem o formato 'HH:MM:SS Dia,
     mm/dd/aaaa (GMT-n)', Onde os campos são horas, minutos, segundos,
     dia da semana, mês, dia do mês, ano, e horas que diferem da hora
     GMT.

     O valor de retorno é uma seqüência de caracteres Lisp.

     Exemplo:

          (%i1) d: timedate ();
          (%o1) 08:05:09 Wed, 11/02/2005 (GMT-7)
          (%i2) print ("timedate mostra o tempo atual", d)$
          timedate reports current time 08:05:09 Wed, 11/02/2005 (GMT-7)

 -- Função: absolute_real_time ()

     Retorna o número de segundos desde a meia noite do dia primeiro de
     janeiro de 1900 (UTC). O valor de retorno é um inteiro.

     Veja também 'elapsed_real_time' e 'elapsed_run_time'.

     Exemplo:

          (%i1) absolute_real_time ();
          (%o1)                      3385045277
          (%i2) 1900 + absolute_real_time () / (365.25 * 24 * 3600);
          (%o2)                   2007.265612087104

 -- Função: elapsed_real_time ()

     Retorna o n;umero de segundos (incluindo frações de segundo) desde
     que Maxima tenha sido recentemente iniciado ou reiniciado.  O valor
     de retorno é um número em ponto flutuante.

     Veja também 'absolute_real_time' e 'elapsed_run_time'.

     Exemplo:

          (%i1) elapsed_real_time ();
          (%o1)                       2.559324
          (%i2) expand ((a + b)^500)$
          (%i3) elapsed_real_time ();
          (%o3)                       7.552087

 -- Função: elapsed_run_time ()

     Retorna uma estimativa do número de segundos (incluindo frações de
     segundo) que o Maxima gastou em computações desde que Maxima tenha
     sido recentemente iniciado ou reiniciado.  O valor de retorno é um
     número em ponto flutuante.

     Veja também 'absolute_real_time' e 'elapsed_real_time'.

     Exemplo:

          (%i1) elapsed_run_time ();
          (%o1)                         0.04
          (%i2) expand ((a + b)^500)$
          (%i3) elapsed_run_time ();
          (%o3)                         1.26


File: maxima.info,  Node: Opções Diversas,  Next: Regras e Modelos,  Prev: Ambiente em Tempo de Execução,  Up: Top

35 Opções Diversas
******************

* Menu:

* Introdução a Opções Diversas::
* Compartilhado::
* Funções e Variáveis Definidas para Opções Diversas::


File: maxima.info,  Node: Introdução a Opções Diversas,  Next: Compartilhado,  Prev: Opções Diversas,  Up: Opções Diversas

35.1 Introdução a Opções Diversas
=================================

Nessa seção várias opções são tratadas pelo fato de possuirem um efeito
global sobre a operação do Maxima.  Também várias listas tais como a
lista de todas as funções definidas pelo usuário, são discutidas.


File: maxima.info,  Node: Compartilhado,  Next: Funções e Variáveis Definidas para Opções Diversas,  Prev: Introdução a Opções Diversas,  Up: Opções Diversas

35.2 Compartilhado
==================

O diretório "share" do Maxima contém programas e outros arquivos de
interesse para os usuários do Maxima, mas que não são parte da
implementação do núcleo do Maxima.  Esses programas são tipicamente
chamados via 'load' ou 'setup_autoload'.

   ':lisp *maxima-sharedir*' mostra a localização do diretório
compartilhado dentro do sistema de arquivos do usuário.

   'printfile ("share.usg")' imprime uma lista de pacotes desatualizados
dos pacotes compartilhados.  Usuários podem encontrar isso de forma mais
detalhada navegando no diretório compartilhado usando um navegador de
sistema de arquivo.


File: maxima.info,  Node: Funções e Variáveis Definidas para Opções Diversas,  Prev: Compartilhado,  Up: Opções Diversas

35.3 Funções e Variáveis Definidas para Opções Diversas
=======================================================

 -- Variável de sistema: aliases
     Valor padrão: '[]'

     'aliases' é a lista de átomos que possuem um alias definido pelo
     usuário (escolhido através das funções 'alias', 'ordergreat',
     'orderless' ou através da declaração do átomo como sendo um 'noun'
     (substantivo) com 'declare').

 -- Declaração: alphabetic
     'alphabetic' é uma declaração reconhecida por 'declare'.  A
     expressão 'declare(<s>, alphabetic)' diz ao Maxima para reconhecer
     como alfabético todos os caracteres em <s>, que deve ser uma
     seqüência de caracteres.

     Veja também *note Identificadores::.

     Exemplo:

          (%i1) xx\~yy\`\@ : 1729;
          (%o1)                         1729
          (%i2) declare ("~`@", alphabetic);
          (%o2)                         done
          (%i3) xx~yy`@ + @yy`xx + `xx@@yy~;
          (%o3)               `xx@@yy~ + @yy`xx + 1729
          (%i4) listofvars (%);
          (%o4)                  [@yy`xx, `xx@@yy~]

 -- Função: apropos (<string>)
     Procura por nomes Maxima que possuem <string> aparecendo em
     qualquer lugar dentro de seu nome.  Dessa forma, 'apropos (exp)'
     retorna uma lista de todos os sinalizadores e funções que possuem
     'exp' como parte de seus nomes, tais como 'expand', 'exp', e
     'exponentialize'.  Dessa forma você pode somente lembra parte do
     nome de alguma coisa você pode usar esse comando para achar o
     restante do nome.  Similarmente, você pode dizer 'apropos (tr_)'
     para achar uma lista de muitos dos comutadores relatando para o
     tradutor, muitos dos quais começam com 'tr_'.

 -- Função: args (<expr>)
     Retorna a lista de argumentos de 'expr', que pode ser de qualquer
     tipo de expressão outra como um átomo.  Somente os argumentos do
     operador de nível mais alto são extraídos; subexpressões de 'expr'
     aparecem como elementos ou subexpressões de elementos da lista de
     argumentos.

     A ordem dos ítens na lista pode depender do sinalizador global
     'inflag'.

     'args (<expr>)' é equivalente a 'substpart ("[", <expr>, 0)'.  Veja
     também 'substpart' e 'op'.

 -- Variável de opção: genindex
     Valor padrão: 'i'

     'genindex' é o prefixo usado para gerar a próxima variável do
     somatório quando necessário.

 -- Variável de opção: gensumnum
     Valor padrão: 0

     'gensumnum' é o sufixo numérico usado para gerar variável seguinte
     do somatório.  Se isso for escolhido para 'false' então o índice
     consistirá somente de 'genindex' com um sufixo numérico.

 -- Constante: inf
     Infinito positivo real.

 -- Constante: infinity
     Infinito complexo, uma magnitude infinita de ângulo de fase
     arbitrária.  Veja também 'inf' e 'minf'.

 -- Variável de sistema: infolists
     Valor padrão: '[]'

     'infolists' é uma lista dos nomes de todas as listas de informação
     no Maxima.  São elas:

     'labels'
          Todos associam '%i', '%o', e rótulos '%t'.
     'values'
          Todos associam átomos que são variáveis de usuário, não opções
          do Maxima ou comutadores, criados através de ':' ou '::' ou
          associando funcionalmente.

     'functions'
          Todas as funções definidas pelo usuário, criadas através de
          ':=' ou 'define'.

     'arrays'
          Todos os arrays declarados e não declarados, criados através
          de ':', '::', ou ':='.
     'macros'
          Todas as macros definidas pelo usuário.

     'myoptions'
          Todas as opções alguma vez alteradas pelo usuário (mesmo que
          tenham ou não elas tenham mais tarde retornadas para seus
          valores padrão).

     'rules'
          Todos os modelos definidos pelo usuário que coincidirem e
          regras de simplificação, criadas através de 'tellsimp',
          'tellsimpafter', 'defmatch', ou 'defrule'.

     'aliases'
          Todos os átomos que possuem um alias definido pelo usuário,
          criado através das funções 'alias', 'ordergreat', 'orderless'
          ou declarando os átomos como um 'noun' com 'declare'.

     'dependencies'
          Todos os átomos que possuem dependências funcionais, criadas
          através das funções 'depends' ou 'gradef'.

     'gradefs'
          Todas as funções que possuem derivadas definidas pelo usuário,
          cridas através da função 'gradef'.

     'props'
          Todos os átomos que possuem quaisquer propriedades outras que
          não essas mencionadas acima, tais como propriedades
          estabelecidas por 'atvalue' , 'matchdeclare', etc., também
          propriedades estabelecidas na função 'declare'.

     'let_rule_packages'
          Todos os pacote de régras em uso definidos pelo usuário mais o
          pacote especial 'default_let_rule_package'.
          ('default_let_rule_package' é o nome do pacote de régras usado
          quando um não está explicitamente escolhido pelo usuário.)

 -- Função: integerp (<expr>)
     Retorna 'true' se <expr> é um inteiro numérico literal, de outra
     forma retorna 'false'.

     'integerp' retorna 'false' se seu argumento for um símbolo, mesmo
     se o argumento for declarado inteiro.

     Exemplos:

          (%i1) integerp (0);
          (%o1)                         true
          (%i2) integerp (1);
          (%o2)                         true
          (%i3) integerp (-17);
          (%o3)                         true
          (%i4) integerp (0.0);
          (%o4)                         false
          (%i5) integerp (1.0);
          (%o5)                         false
          (%i6) integerp (%pi);
          (%o6)                         false
          (%i7) integerp (n);
          (%o7)                         false
          (%i8) declare (n, integer);
          (%o8)                         done
          (%i9) integerp (n);
          (%o9)                         false

 -- Variável de opção: m1pbranch
     Valor padrão: 'false'

     'm1pbranch' é principal descendente de '-1' a um expoente.
     Quantidades tais como '(-1)^(1/3)' (isto é, um expoente racional
     "ímpar") e '(-1)^(1/4)' (isto é, um expoente racional "par") são
     manuseados como segue:

                        domain:real

          (-1)^(1/3):      -1
          (-1)^(1/4):   (-1)^(1/4)

                       domain:complex
          m1pbranch:false          m1pbranch:true
          (-1)^(1/3)               1/2+%i*sqrt(3)/2
          (-1)^(1/4)              sqrt(2)/2+%i*sqrt(2)/2

 -- Função: numberp (<expr>)
     Retorna 'true' se <expr> for um inteiro literal, número racional,
     número em ponto flutuante, ou um grande número em ponto flutuante,
     de outra forma retorna 'false'.

     'numberp' retorna 'false' se seu argumento for um símbolo, mesmo se
     o argumento for um número simbólico tal como '%pi' ou '%i', ou
     declarado ser 'even', 'odd', 'integer', 'rational', 'irrational',
     'real', 'imaginary', or 'complex'.  Nota de Tradução: par, ímpar,
     inteiro, racional, irracional, real, imaginário, ou complexo.

     Exemplos:

          (%i1) numberp (42);
          (%o1)                         true
          (%i2) numberp (-13/19);
          (%o2)                         true
          (%i3) numberp (3.14159);
          (%o3)                         true
          (%i4) numberp (-1729b-4);
          (%o4)                         true
          (%i5) map (numberp, [%e, %pi, %i, %phi, inf, minf]);
          (%o5)      [false, false, false, false, false, false]
          (%i6) declare (a, even, b, odd, c, integer, d, rational,
               e, irrational, f, real, g, imaginary, h, complex);
          (%o6)                         done
          (%i7) map (numberp, [a, b, c, d, e, f, g, h]);
          (%o7) [false, false, false, false, false, false, false, false]

 -- Função: properties (<a>)
     Retorna uma lista de nomes de todas as propriedades associadas com
     o átomo <a>.

 -- Símbolo especial: props
     'props' são átomos que possuem qualquer propriedade outra como
     essas explicitamente mencionadas em 'infolists', tais como
     especificado através de 'atvalue', 'matchdeclare', etc., e também
     propriedades especificadas na função 'declare'.

 -- Função: propvars (<prop>)
     Retorna uma lista desses átomos sobre a lista 'props' que possui a
     propriedade indicada através de <prop>.  Dessa forma 'propvars
     (atvalue)' retorna uma lista de átomos que possuem atvalues.

 -- Função: put (<átomo>, <valor>, <indicador>)
     Atribui <valor> para a propriedade (especificada através de
     <indicador>) do <átomo>.  <indicador> pode ser o nome de qualquer
     propriedade, não apenas uma propriedade definida pelo sistema.

     'put' avalia seus argumentos.  'put' retorna <valor>.

     Exemplos:

          (%i1) put (foo, (a+b)^5, expr);
                                             5
          (%o1)                       (b + a)
          (%i2) put (foo, "Hello", str);
          (%o2)                         Hello
          (%i3) properties (foo);
          (%o3)            [[user properties, str, expr]]
          (%i4) get (foo, expr);
                                             5
          (%o4)                       (b + a)
          (%i5) get (foo, str);
          (%o5)                         Hello

 -- Função: qput (<átomo>, <valor>, <indicador>)
     Atribui <valor> para a propriedade (especificada através de
     <indicador>) do <átomo>.  Isso é o mesmo que 'put', exceto que os
     argumentos nã são avaliados.

     Exemplo:

          (%i1) foo: aa$
          (%i2) bar: bb$
          (%i3) baz: cc$
          (%i4) put (foo, bar, baz);
          (%o4)                          bb
          (%i5) properties (aa);
          (%o5)                [[user properties, cc]]
          (%i6) get (aa, cc);
          (%o6)                          bb
          (%i7) qput (foo, bar, baz);
          (%o7)                          bar
          (%i8) properties (foo);
          (%o8)            [value, [user properties, baz]]
          (%i9) get ('foo, 'baz);
          (%o9)                          bar

 -- Função: rem (<átomo>, <indicador>)
     Remove a propriedade indicada através de <indicador> do <átomo>.

 -- Função: remove (<a_1>, <p_1>, ..., <a_n>, <p_n>)
 -- Função: remove ([<a_1>, ..., <a_m>], [<p_1>, ..., <p_n>], ...)
 -- Função: remove ("<a>", operator)
 -- Função: remove (<a>, transfun)
 -- Função: remove (all, <p>)
     Remove propriedades associadas a átomos.

     'remove (<a_1>, <p_1>, ..., <a_n>, <p_n>)' remove a propriedade
     'p_k' do átomo 'a_k'.

     'remove ([<a_1>, ..., <a_m>], [<p_1>, ..., <p_n>], ...)' remove as
     propriedades '<p_1>, ..., <p_n>' dos átomos <a_1>, ..., <a_m>.
     Pode existir mais que um par de listas.

     'remove (all, <p>)' remove a propriedade <p> de todos os átomos que
     a possuem.

     A propriedade removida pode ser definida pelo sistema tal como
     'function', 'macro' ou 'mode_declare', ou propriedades definidas
     pelo usuário.

     uma propriedade pode ser 'transfun' para remover a versão traduzida
     Lisp de uma função.  Após executar isso, a versão Maxima da função
     é executada em lugar da versão traduzida.

     'remove ("<a>", operator)' ou, equivalentemente, 'remove ("<a>",
     op)' remove de <a> as propriedades 'operator' declaradas através de
     'prefix', 'infix', 'nary', 'postfix', 'matchfix', ou 'nofix'.  Note
     que o nome do operador deve ser escrito como uma seqüência de
     caracteres com apóstofo.

     'remove' sempre retorna 'done' se um átomo possui ou não uma
     propriedade especificada.  Esse comportamento é diferente das
     funções remove mais específicas 'remvalue', 'remarray',
     'remfunction', e 'remrule'.

 -- Função: remvalue (<nome_1>, ..., <nome_n>)
 -- Função: remvalue (all)
     Remove os valores de Variáveis de usuário <nome_1>, ..., <nome_n>
     (que podem ser subscritas) do sistema.

     'remvalue (all)' remove os valores de todas as variáveis em
     'values', a lista de todas as variáveis nomeadas através do usuário
     (em oposição a essas que são automaticamente atribuídas através do
     Maxima).

     Veja também 'values'.

 -- Função: rncombine (<expr>)
     Transforma <expr> combinando todos os termos de <expr> que possuem
     denominadores idênticos ou denominadores que diferem de cada um dos
     outros apenas por fatores numéricos somente.  Isso é ligeiramente
     diferente do comportamento de de 'combine', que coleta termos que
     possuem denominadores idênticos.

     Escolhendo 'pfeformat: true' e usando 'combine' retorna resultados
     similares a esses que podem ser obtidos com 'rncombine', mas
     'rncombine' pega o passo adicional de multiplicar cruzado fatores
     numérios do denominador.  Esses resultados em forma ideal, e a
     possibilidade de reconhecer alguns cancelamentos.

     Para usar essa função escreva primeiramente 'load(rncomb)'.

 -- Função: scalarp (<expr>)
     Retorna 'true' se <expr> for um número, constante, ou variável
     declarada 'scalar' com 'declare', ou composta inteiramente de
     números, constantes, e tais Variáveis, bmas não contendo matrizes
     ou listas.

 -- Função: setup_autoload (<nomearquivo>, <função_1>, ..., <função_n>)
     Especifica que se qualquer entre <função_1>, ..., <função_n> for
     referenciado e não ainda definido, <nomedeqrquivo> é chamado via
     'load'.  <nomearquivo> usualmente contém definições para as funções
     especificadas, embora isso não seja obrigatório.

     'setup_autoload' não trabalha para funções array.

     'setup_autoload' não avalia seus argumentos.

     Exemplo:

          (%i1) legendre_p (1, %pi);
          (%o1)                  legendre_p(1, %pi)
          (%i2) setup_autoload ("specfun.mac", legendre_p, ultraspherical);
          (%o2)                         done
          (%i3) ultraspherical (2, 1/2, %pi);
          Warning - you are redefining the Macsyma função ultraspherical
          Warning - you are redefining the Macsyma função legendre_p
                                      2
                           3 (%pi - 1)
          (%o3)            ------------ + 3 (%pi - 1) + 1
                                2
          (%i4) legendre_p (1, %pi);
          (%o4)                          %pi
          (%i5) legendre_q (1, %pi);
                                        %pi + 1
                                %pi log(-------)
                                        1 - %pi
          (%o5)                 ---------------- - 1
                                       2


File: maxima.info,  Node: Regras e Modelos,  Next: Listas,  Prev: Opções Diversas,  Up: Top

36 Regras e Modelos
*******************

* Menu:

* Introdução a Regras e Modelos::
* Funções e Variáveis Definidas para Regras e Modelos::


File: maxima.info,  Node: Introdução a Regras e Modelos,  Next: Funções e Variáveis Definidas para Regras e Modelos,  Prev: Regras e Modelos,  Up: Regras e Modelos

36.1 Introdução a Regras e Modelos
==================================

Essa seção descreve coincidências de modelos definidos pelo usuário e
regras de simplificação.  Existem dois grupos de funções que implementam
até certo ponto diferentes esquemas de coincidência de modelo.  Em um
grupo estão 'tellsimp', 'tellsimpafter', 'defmatch', 'defrule',
'apply1', 'applyb1', e 'apply2'.  Em outro grupo estão 'let' e
'letsimp'.  Ambos os esquemas definem modelos em termos de variáveis de
modelo declaradas por 'matchdeclare'.

   Regras de coincidência de modelos definidas por 'tellsimp' e
'tellsimpafter' são aplicadas automaticamente através do simplificador
do Maxima.  Regras definidas através de 'defmatch', 'defrule', e 'let'
são aplicadas através de uma chamada explícita de função.

   Existe mecanismos adicionais para regras aplicadas a polinômios
através de 'tellrat', e para álgebra comutativa e não comutativa no
pacote 'affine'.


File: maxima.info,  Node: Funções e Variáveis Definidas para Regras e Modelos,  Prev: Introdução a Regras e Modelos,  Up: Regras e Modelos

36.2 Funções e Variáveis Definidas para Regras e Modelos
========================================================

 -- Função: apply1 (<expr>, <rule_1>, ..., <rule_n>)
     Repetidamente aplica <rule_1> a <expr> até que isso falhe, então
     repetidamente aplica a mesma regra a todas as subexpressões de
     <expr>, da esquerda para a direita, até que <rule_1> tenha falhado
     sobre todas as subexpressões.  Chama o resultado da transformação
     de <expr> dessa maneira de <expr_2>.  Então <rule_2> é aplicada no
     mesmo estilo iniciando no topo de <expr_2>.  Quando <rule_n> falhar
     na subexpressão final, o resultado é retornado.

     'maxapplydepth' é a intensidade de nível mais distante de
     subexpressões processadas por 'apply1' e 'apply2'.

     Veja também 'applyb1', 'apply2', e 'let'.

 -- Função: apply2 (<expr>, <rule_1>, ..., <rule_n>)
     Se <rule_1> falhar sobre uma dada subexpressão, então <rule_2> é
     repetidamente aplicada, etc.  Somente se todas as regras falharem
     sobre uma dada subexpressão é que o conjunto completo de regras é
     repetidamente aplicada à próxima subexpressão.  Se uma das regras
     obtém sucesso, então a mesma subexpressão é reprocessada, iniciando
     com a primeira regra.

     'maxapplydepth' é a intensidade do nível mais distante de
     subexpressões processadas através de 'apply1' e 'apply2'.

     Veja também 'apply1' e 'let'.

 -- Função: applyb1 (<expr>, <rule_1>, ..., <rule_n>)
     Repetidamente aplica <rule_1> para a subexpressão mais distante de
     <expr> até falhar, então repetidamente aplica a mesma regra um
     nível mais acima (i.e., subexpressãos mais larga), até que <rule_1>
     tenha falhado sobre a expressão de nível mais alto.  Então <rule_2>
     é aplicada com o mesmo estilo para o resultado de <rule_1>.  após
     <rule_n> ter sido aplicada à expressão de nível mais elevado, o
     resultado é retornado.

     'applyb1' é similar a 'apply1' mas trabalha da base para cima em
     lugar de do topo para baixo.

     'maxapplyheight' é o ápice que 'applyb1' encontra antes de
     interromper.

     Veja também 'apply1', 'apply2', e 'let'.

 -- Variável de opção: current_let_rule_package
     Valor padrão: 'default_let_rule_package'

     'current_let_rule_package' é o nome do pacote de regras que está
     sendo usado por funções no pacote 'let' ('letsimp', etc.)  se
     nenhum outro pacote de regras for especificado.  A essa variável
     pode ser atribuído o nome de qualquer pacote de regras definido via
     comando 'let'.

     Se uma chamada tal como 'letsimp (expr, nome_pct_regras)' for
     feita, o pacote de regras 'nome_pct_regras' é usado para aquela
     chamada de função somente, e o valor de 'current_let_rule_package'
     não é alterado.

 -- Variável de opção: default_let_rule_package
     Valor padrão: 'default_let_rule_package'

     'default_let_rule_package' é o nome do pacote de regras usado
     quando um não for explicitamente escolhido pelo usuário com 'let'
     ou através de alteração do valor de 'current_let_rule_package'.

 -- Função: defmatch (<prognome>, <modelo>, <x_1>, ..., <x_n>)
 -- Função: defmatch (<prognome>, <modelo>)
     Define uma função '<prognome>(<expr>, <x_1>, ..., <x_n>)' que testa
     <expr> para ver se essa expressão coincide com <modelo>.

     <modelo> é uma expressão contendo os argumentos modelo <x_1>, ...,
     <x_n> (se existir algum) e alguns modelos de variáveis (se existir
     algum).  os argumentos modelo são fornecidos explicitamente como
     argumentos para 'defmatch' enquanto os modelos de variáveis são
     declarados através da função 'matchdeclare'.  Qualquer variável não
     declarada como modelo em 'matchdeclare' ou como um argumento modelo
     em 'defmatch' coincide somente com si mesma.

     O primeiro argumento para a função criada <prognome> é uma
     expressão a serem comparadas contra o modelo e os outros argumentos
     são os atuais argumetnos que correspondem às variáveis respectivas
     <x_1>, ..., <x_n> no modelo.

     Se a tentativa de coincidência obtiver sucesso, <prognome> retorna
     uma lista de equações cujos lados esquerdos são os argumetnos de
     modelo e variáveis de modelo, e cujo lado direito forem as
     subexpressões cujos argumentos de modelo e as variáveis coincidem.
     Os modelos de variáveis, mas não tos argumentos de modelo, são
     atribuídos às subexpressões que coincidirem.  Se a coincidência
     falhar, <prognome> retorna 'false'.

     Um modelo literal (isto é, um modelo que não contiver nem
     argumentos de modelo nem variáveis de modelo) retorna 'true' se a
     coincidência ocorrer.

     Veja também 'matchdeclare', 'defrule', 'tellsimp', e
     'tellsimpafter'.

     Exemplos:

     Define uma função 'linearp(expr, x)' que testa 'expr' para ver se
     essa expressão da forma 'a*x + b' tal que 'a' e 'b' não contenham
     'x' e 'a' seja não nulo.  Essa função de coincidência coincide com
     expressões que sejam lineares em qualquer variável, por que o
     argumento de modelo 'x' é fornecido para 'defmatch'.

          (%i1) matchdeclare (a, lambda ([e], e#0 and freeof(x, e)), b, freeof(x));
          (%o1)                         done
          (%i2) defmatch (linearp, a*x + b, x);
          (%o2)                        linearp
          (%i3) linearp (3*z + (y + 1)*z + y^2, z);
                                   2
          (%o3)              [b = y , a = y + 4, x = z]
          (%i4) a;
          (%o4)                         y + 4
          (%i5) b;
                                          2
          (%o5)                          y
          (%i6) x;
          (%o6)                           x

     Define uma função 'linearp(expr)' que testa 'expr' para ver se essa
     expressão é da forma 'a*x + b' tal que 'a' e 'b' não contenham 'x'
     e 'a' seja não nulo.  Essa função de coincidência somente coincide
     com expressões lineares em 'x', não em qualquer outra variável,
     porque nenhum argumento de modelo é fornecido a 'defmatch'.

          (%i1) matchdeclare (a, lambda ([e], e#0 and freeof(x, e)), b, freeof(x));
          (%o1)                         done
          (%i2) defmatch (linearp, a*x + b);
          (%o2)                        linearp
          (%i3) linearp (3*z + (y + 1)*z + y^2);
          (%o3)                         false
          (%i4) linearp (3*x + (y + 1)*x + y^2);
                                       2
          (%o4)                  [b = y , a = y + 4]

     Define uma função 'checklimits(expr)' que testa 'expr' para ver se
     essa expressão é uma integral definida.

          (%i1) matchdeclare ([a, f], true);
          (%o1)                         done
          (%i2) constinterval (l, h) := constantp (h - l);
          (%o2)        constinterval(l, h) := constantp(h - l)
          (%i3) matchdeclare (b, constinterval (a));
          (%o3)                         done
          (%i4) matchdeclare (x, atom);
          (%o4)                         done
          (%i5) simp : false;
          (%o5)                         false
          (%i6) defmatch (checklimits, 'integrate (f, x, a, b));
          (%o6)                      checklimits
          (%i7) simp : true;
          (%o7)                         true
          (%i8) 'integrate (sin(t), t, %pi + x, 2*%pi + x);
                                 x + 2 %pi
                                /
                                [
          (%o8)                 I          sin(t) dt
                                ]
                                /
                                 x + %pi
          (%i9) checklimits (%);
          (%o9)    [b = x + 2 %pi, a = x + %pi, x = t, f = sin(t)]

 -- Função: defrule (<nomeregra>, <modelo>, <substituição>)
     Define e nomeia uma regra de substituição para o modelo dado.  Se a
     regra nomeada <nomeregra> for aplicada a uma expressão (através de
     'apply1', 'applyb1', ou 'apply2'), toda subexpressão coincidindo
     com o modelo será substituída por 'substituição'.  Todas as
     variáveis em 'substituição' que tiverem sido atribuidos valores
     pela coincidência com o modelo são atribuidas esses valores na
     'substituição' que é então simplificado.

     As regras por si mesmas podem ser tratadas como funções que
     transforma uma expressão através de uma operação de coincidência de
     modelo e substituição.  Se a coincidência falhar, a função da regra
     retorna 'false'.

 -- Função: disprule (<nomeregra_1>, ..., <nomeregra_2>)
 -- Função: disprule (all)
     Mostra regras com os nomes <nomeregra_1>, ..., <nomeregra_n>, como
     retornado por 'defrule', 'tellsimp', ou 'tellsimpafter', ou um
     modelo definido por meio de 'defmatch'.  Cada regra é mostrada com
     um rótulo de expressão intermediária ('%t').

     'disprule (all)' mostra todas as regras.

     'disprule' não avalia seus argumentos.  'disprule' retorna a lista
     de rótulos de expressões intermedáirias correspondendo às regras
     mostradas.

     Veja também 'letrules', que mostra regras definidas através de
     'let'.

     Examples:

          (%i1) tellsimpafter (foo (x, y), bar (x) + baz (y));
          (%o1)                   [foorule1, false]
          (%i2) tellsimpafter (x + y, special_add (x, y));
          (%o2)                   [+rule1, simplus]
          (%i3) defmatch (quux, mumble (x));
          (%o3)                         quux
          (%i4) disprule (foorule1, "+rule1", quux);
          (%t4)        foorule1 : foo(x, y) -> baz(y) + bar(x)

          (%t5)          +rule1 : y + x -> special_add(x, y)

          (%t6)                quux : mumble(x) -> []

          (%o6)                    [%t4, %t5, %t6]
          (%i6) ''%;
          (%o6) [foorule1 : foo(x, y) -> baz(y) + bar(x),
          +rule1 : y + x -> special_add(x, y), quux : mumble(x) -> []]

 -- Função: let (<prod>, <repl>, <prednome>, <arg_1>, ..., <arg_n>)
 -- Função: let ([<prod>, <repl>, <prednome>, <arg_1>, ..., <arg_n>],
          <nome_pacote>)
     Define uma regra de substituição para 'letsimp' tal que <prod> é
     substituído por <repl>.  <prod> é um produto de expoentes positivos
     ou negativos dos seguintes termos:

        * Atomos que 'letsimp' irá procurar literalmente a menos que
          previamente chamando 'letsimp' a função 'matchdeclare' é usada
          para associar um predicado com o átomo.  Nesse caso 'letsimp'
          irá coincidir com o átomo para qualquer termo de um produto
          satisfazendo o predicado.
        * Núcleos tais como 'sin(x)', 'n!', 'f(x,y)', etc.  Como com
          átomos acima 'letsimp' irá olhar um literal coincidente a
          menos que 'matchdeclare' seja usada para associar um predicado
          com o argumento do núcleo.

     Um termo para um expoente positivo irá somente coincidir com um
     termo tendo ao menos aquele expoente.  Um termo para um expoente
     negativo por outro lado irá somente coincidir com um termo com um
     expoente ao menos já negativo.  o caso de expentes negativos em
     <prod> o comutador 'letrat' deve ser escolhido para 'true'.  Veja
     também 'letrat'.

     Se um predicado for incluído na função 'let' seguido por uma lista
     de argumentos, uma tentativa de coincidência (i.e.  uma que pode
     ser aceita se o predicado fosse omitido) é aceita somente se
     'prednome (arg_1', ..., arg_n')' avaliar para 'true' onde <arg_i'>
     é o valor coincidente com <arg_i>.  O <arg_i> pode ser o nome de
     qualquer átomo ou o argumento de qualquer núcleo aparecendo em
     <prod>.  <repl> pode ser qualquer expressão racional.  Se quaisquer
     dos átomos ou argumentos de <prod> aparecer em <repl> a
     substituição é feita.

     O sinalizador global 'letrat' controla a simplificação dos
     quocientes através de 'letsimp'.  Quando 'letrat' for 'false',
     'letsimp' simplifica o numerador e o denominador de <expr>
     separadamente, e não simplifica o quociente.  Substituições tais
     como 'n!/n' vão para '(n-1)!' então falham quando 'letrat' for
     'false'.  Quando 'letrat' for 'true', então o numerador, o
     denominador, e o quociente são simplificados nessa ordem.

     Essas funções de substituição permitem a você trabalhar com muitos
     pacotes de regras.  Cada pacote de regras pode conter qualquer
     número de regras 'let' e é referenciado através de um nome definido
     pelo usuário.  'let ([<prod>, <repl>, <prednome>, <arg_1>, ...,
     <arg_n>], <nome_pacote>)' adiciona a regra <prednome> ao pacote de
     regras <nome_pacote>.  'letsimp (<expr>, <nome_pacote>)' aplica as
     regras em <nome_pacote>.  'letsimp (<expr>, <nome_pacote1>,
     <nome_pacote2>, ...)' é equivalente a 'letsimp (<expr>,
     <nome_pacote1>)' seguido por 'letsimp (%, <nome_pacote2>)', ....

     'current_let_rule_package' é o nome do pacote de regras que está
     atualmente sendo usando.  Essa variável pode receber o nome de
     qualquer pacote de regras definidos via o comando 'let'.  Quando
     qualquer das funções compreendidas no pacote 'let' são chamadas sem
     o nome do pacote, o pacote nomeado por 'current_let_rule_package' é
     usado.  Se uma chamada tal como 'letsimp (<expr>,
     <nome_pct_regras>)' é feita, o pacote de regras <nome_pct_regras> é
     usado somente para aquele comando 'letsimp', e
     'current_let_rule_package' não é alterada.  Se não especificado de
     outra forma, 'current_let_rule_package' avalia de forma padronizada
     para 'default_let_rule_package'.

          (%i1) matchdeclare ([a, a1, a2], true)$
          (%i2) oneless (x, y) := is (x = y-1)$
          (%i3) let (a1*a2!, a1!, oneless, a2, a1);
          (%o3)         a1 a2! --> a1! where oneless(a2, a1)
          (%i4) letrat: true$
          (%i5) let (a1!/a1, (a1-1)!);
                                  a1!
          (%o5)                   --- --> (a1 - 1)!
                                  a1
          (%i6) letsimp (n*m!*(n-1)!/m);
          (%o6)                      (m - 1)! n!
          (%i7) let (sin(a)^2, 1 - cos(a)^2);
                                  2               2
          (%o7)                sin (a) --> 1 - cos (a)
          (%i8) letsimp (sin(x)^4);
                                  4           2
          (%o8)                cos (x) - 2 cos (x) + 1

 -- Variável de opção: letrat
     Valor padrão: 'false'

     Quando 'letrat' for 'false', 'letsimp' simplifica o numerador e o
     denominador de uma razão separadamente, e não simplifica o
     quociente.

     Quando 'letrat' for 'true', o numerador, o denominador, e seu
     quocienten são simplificados nessa ordem.

          (%i1) matchdeclare (n, true)$
          (%i2) let (n!/n, (n-1)!);
                                   n!
          (%o2)                    -- --> (n - 1)!
                                   n
          (%i3) letrat: false$
          (%i4) letsimp (a!/a);
                                         a!
          (%o4)                          --
                                         a
          (%i5) letrat: true$
          (%i6) letsimp (a!/a);
          (%o6)                       (a - 1)!

 -- Função: letrules ()
 -- Função: letrules (<nome_pacote>)
     Mostra as regras em um pacote de regras.  'letrules ()' mostra as
     regras no pacote de regras corrente.  'letrules (<nome_pacote>)'
     mostra as regras em 'nome_pacote'.

     O pacote de regras corrente é nomeado por
     'current_let_rule_package'.  Se não especificado de outra forma,
     'current_let_rule_package' avalia de forma padrão para
     'default_let_rule_package'.

     Veja também 'disprule', que mostra regras defindas por 'tellsimp' e
     'tellsimpafter'.

 -- Função: letsimp (<expr>)
 -- Função: letsimp (<expr>, <nome_pacote>)
 -- Função: letsimp (<expr>, <nome_pacote_1>, ..., <nome_pacote_n>)
     Repetidamente aplica a substituição definida por 'let' até que
     nenhuma mudança adicional seja feita para <expr>.

     'letsimp (<expr>)' usa as regras de 'current_let_rule_package'.

     'letsimp (<expr>, <nome_pacote>)' usa as regras de <nome_pacote>
     sem alterar 'current_let_rule_package'.

     'letsimp (<expr>, <nome_pacote_1>, ..., <nome_pacote_n>)' é
     equivalente a 'letsimp (<expr>, <nome_pacote_1>', seguido por
     'letsimp (%, <nome_pacote_2>)', e assim sucessivamente.

 -- Variável de opção: let_rule_packages
     Valor padrão: '[default_let_rule_package]'

     'let_rule_packages' é uma lista de todos os pacotes de regras 'let'
     definidos pelo usuário mais o pacote padrão
     'default_let_rule_package'.

 -- Função: matchdeclare (<a_1>, <pred_1>, ..., <a_n>, <pred_n>)
     Associa um predicado <pred_k> com uma variável ou lista de
     variáveis <a_k> de forma que <a_k> coincida com expressões para as
     quais o predicado retorne qualquer coisa que não 'false'.

     Umpredicado é o nome de uma função, ou de uma expressão lambda, ou
     uma chamada de função ou chamada de função lambda iomitindo o
     úlltimo argumento, ou 'true' ou 'all'.  Qualquer expressão coincide
     com 'true' ou 'all'.  Se o predicado for especificado como uma
     chamada de função ou chamada de função lambda, a expressão a ser
     testada é anexada ao final da lista de argumentos; os argumentos
     são avaliados ao mesmo tempo que a coincidência é avaliada.  De
     outra forma, o predicado é especificado como um nome de função ou
     expressão lambda, e a expressão a ser testada é o argumento
     sozinho.  Uma função predicado não precisa ser definida quando
     'matchdeclare' for chamada; o predicado não é avaliado até que uma
     coincidência seja tentada.

     Um predicado pode retornar uma expressão Booleana além de 'true' ou
     'false'.  Expressões Booleanas são avaliadas por 'is' dentro da
     função da regra construída, de forma que não é necessário chamar
     'is' dentro do predicado.

     Se uma expressão satisfaz uma coincidência de predicado, a variável
     de coincidência é atribuída à expressão, exceto para variáveis de
     coincidência que são operandos de adição '+' ou multiplicação '*'.
     Somente adição e multiplicação são manuseadas de forma especial;
     outros operadores enários (ambos os definidos internamente e os
     definidos pelo usuário) são tratados como funções comuns.

     No caso de adição e multiplicação, a variável de coincidência pode
     ser atribuida a uma expressão simples que satisfaz o predicado de
     coincidência, ou uma adição ou um produto (respectivamente) de tais
     expressões.  Tal coincidência de termo multiplo é gulosa:
     predicados são avaliados na ordem em que suas variáveis associadas
     aparecem no modelo de coincidência, e o termo que satisfizer mais
     que um predicado é tomado pelo primeiro predicado que satisfizer.
     Cada predicado é testado contra todos os operandos de adição ou
     produto antes que o próximo predicado seja avaliado.
     Adicionalmente, se 0 ou 1 (respectivamente) satisfazem um predicado
     de coincidência, e não existe outros termos que satisfaçam o
     predicado, 0 ou 1 é atribuído para a variável de coincidência
     associada com o predicado.

     O algorítmo para processar modelos contendo adição e multiplicação
     faz alguns resultados de coincidência (por exemplo, um modelo no
     qual uma variável "coincida com qualquer coisa" aparecer)
     dependerem da ordem dos termos no modelo de coincidência e na
     expressão a ser testada a coincidência.  Todavia, se todos os
     predicados de coincidência são mutuamente exclusivos, o resultado
     de coincidência é insensível a ordenação, como um predicado de
     coincidência não pode aceitar termos de coincidência de outro.

     Chamado 'matchdeclare' com uma variável <a> como um argumento muda
     a propriedade 'matchdeclare' para <a>, se a variável <a> tiver sido
     declarada anteriormente; somente o 'matchdeclare' mais recente está
     em efeito quando uma regra é definida, mudanças posteriores para a
     propriedade 'matchdeclare' (via 'matchdeclare' ou 'remove') não
     afetam regras existentes.

     'propvars (matchdeclare)' retorna a lista de todas as variáveis
     para as quais exista uma propriedade 'matchdeclare'.  'printprops
     (<a>, matchdeclare)' retorna o predicado para a variável 'a'.
     'printprops (all, matchdeclare)' retorna a lista de predicados para
     todas as variáveis 'matchdeclare'.  'remove (<a>, matchdeclare)'
     remove a propriedade 'matchdeclare' da variável <a>.

     As funções 'defmatch', 'defrule', 'tellsimp', 'tellsimpafter', e
     'let' constroem regras que testam expressões contra modelos.

     'matchdeclare' coloca apóstrofo em seus argumentos.  'matchdeclare'
     sempre retorna 'done'.

     Exemplos:

     Um predicado é o nome de uma função, ou uma expressão lambda, ou
     uma chamada de função ou chamada a função lambda omitindo o último
     argumento, or 'true' or 'all'.

          (%i1) matchdeclare (aa, integerp);
          (%o1)                         done
          (%i2) matchdeclare (bb, lambda ([x], x > 0));
          (%o2)                         done
          (%i3) matchdeclare (cc, freeof (%e, %pi, %i));
          (%o3)                         done
          (%i4) matchdeclare (dd, lambda ([x, y], gcd (x, y) = 1) (1728));
          (%o4)                         done
          (%i5) matchdeclare (ee, true);
          (%o5)                         done
          (%i6) matchdeclare (ff, all);
          (%o6)                         done

     Se uma expressão satisfaz um predicado de coincidência, a variável
     de coincidência é atribuída à expressão.

          (%i1) matchdeclare (aa, integerp, bb, atom);
          (%o1)                         done
          (%i2) defrule (r1, bb^aa, ["integer" = aa, "atom" = bb]);
                              aa
          (%o2)        r1 : bb   -> [integer = aa, atom = bb]
          (%i3) r1 (%pi^8);
          (%o3)               [integer = 8, atom = %pi]

     No caso de adição e multiplicação, à variável de coincidência pode
     ser atribuída uma expressão simples que satisfaz o predicado de
     coincidência, ou um somatório ou produtório (respectivamente) de
     tais expressões.

          (%i1) matchdeclare (aa, atom, bb, lambda ([x], not atom(x)));
          (%o1)                         done
          (%i2) defrule (r1, aa + bb, ["all atoms" = aa, "all nonatoms" = bb]);
          bb + aa partitions `sum'
          (%o2)  r1 : bb + aa -> [all atoms = aa, all nonatoms = bb]
          (%i3) r1 (8 + a*b + sin(x));
          (%o3)     [all atoms = 8, all nonatoms = sin(x) + a b]
          (%i4) defrule (r2, aa * bb, ["all atoms" = aa, "all nonatoms" = bb]);
          bb aa partitions `product'
          (%o4)   r2 : aa bb -> [all atoms = aa, all nonatoms = bb]
          (%i5) r2 (8 * (a + b) * sin(x));
          (%o5)    [all atoms = 8, all nonatoms = (b + a) sin(x)]

     Quando coincidindo argumentos de '+' e '*', se todos os predicados
     de coincidência forem mutuamente exclusivos, o resultado da
     coincidência é insensíve à ordenação, como um predicado de
     coincidência não pode aceitar termos que coincidiram com outro.

          (%i1) matchdeclare (aa, atom, bb, lambda ([x], not atom(x)));
          (%o1)                         done
          (%i2) defrule (r1, aa + bb, ["all atoms" = aa, "all nonatoms" = bb]);
          bb + aa partitions `sum'
          (%o2)  r1 : bb + aa -> [all atoms = aa, all nonatoms = bb]
          (%i3) r1 (8 + a*b + %pi + sin(x) - c + 2^n);
                                                               n
          (%o3) [all atoms = %pi + 8, all nonatoms = sin(x) + 2  - c + a b]
          (%i4) defrule (r2, aa * bb, ["all atoms" = aa, "all nonatoms" = bb]);
          bb aa partitions `product'
          (%o4)   r2 : aa bb -> [all atoms = aa, all nonatoms = bb]
          (%i5) r2 (8 * (a + b) * %pi * sin(x) / c * 2^n);
                                                            n
                                                   (b + a) 2  sin(x)
          (%o5) [all atoms = 8 %pi, all nonatoms = -----------------]
                                                           c

     As funções 'propvars' e 'printprops' retornam informações sobre
     variávels de coincidência.

          (%i1) matchdeclare ([aa, bb, cc], atom, [dd, ee], integerp);
          (%o1)                         done
          (%i2) matchdeclare (ff, floatnump, gg, lambda ([x], x > 100));
          (%o2)                         done
          (%i3) propvars (matchdeclare);
          (%o3)             [aa, bb, cc, dd, ee, ff, gg]
          (%i4) printprops (ee, matchdeclare);
          (%o4)                    [integerp(ee)]
          (%i5) printprops (gg, matchdeclare);
          (%o5)              [lambda([x], x > 100, gg)]
          (%i6) printprops (all, matchdeclare);
          (%o6) [lambda([x], x > 100, gg), floatnump(ff), integerp(ee),
                                integerp(dd), atom(cc), atom(bb), atom(aa)]

 -- Função: matchfix (<delimitador_e>, <delimitador_d>)
 -- Função: matchfix (<delimitador_e>, <delimitador_d>, <arg_pos>,
          <pos>)
     Declara um operador 'matchfix' com delimitadores esquerdo e direito
     <delimitador_e> e <delimitador_d>.  Os delimitadores são
     especificados como seqüêcias de caracteres.

     Um operador "matchfix" é uma função que aceita qualquer número de
     argumentos, tal que os argumentos ocorram entre os delimitadores
     correspondentes esquerdo e direito.  Os delimitadores podem ser
     quaisquer seqüêcias de caracteres, contanto que o analisador de
     expressões do Maxima possa distingüir os delimitadores dos
     operandos e de outras expressões e operadores.  Na prática essas
     regras excluem delimitadores não analisáveis tais como '%', ',',
     '$' e ';', e pode ser necessário isolar os delimitadores com
     espaços em branco.  O delimitador da direita pode ser o mesmo ou
     diferente do delimitador da esquerda.

     Um delimitador esquerdo pode ser associado com somente um
     delimitador direito; dois diferentes operadores 'matchfix' não
     podem ter o mesmo delimitador esquerdo.

     Um operador existente pode ser redeclarado com um operador
     'matchfix' sem alterar suas outras propriedades.  Particularmente,
     operadores internos tais como adição '+' podem ser declarados
     'matchfix', mas funções operadores não podem ser definidas para
     operadores internos.

     'matchfix (<delimitador_e>, <delimitador_d>, <arg_pos>, <pos>)'
     declara o argumento <arg_pos> como sendo um entre: expressão
     lógica, expressão comum do Maxima mas que não seja do tipo
     anterior, e qualquer outro tipo de expressão que não esteja
     incluída nos dois primeiros tipos.  Essa declaração resulta em
     <pos> sendo um entre: expressão lógica, expressão comum do Maxima
     mas que não seja do tipo anterior, e qualquer outro tipo de
     expressão que não esteja incluída nos dois primeiros tipos e os
     delimitadores <delimitador_e> e <delimitador_d>.

     A função para realizar uma operação 'matchfix' é uma função comum
     definida pelo usuário.  A função operador é definida da forma usual
     com o operador de definição de função ':=' ou 'define'.  Os
     argumentos podem ser escritos entre os delimitadores, ou com o
     delimitador esquerdo com uma seqüência de caracteres com apóstrofo
     e os argumentos seguindo entre parêntesis.  'dispfun
     (<delimitador_e>)' mostra a definição da função operador.

     O único operador interno 'matchfix' é o construtor de listas '[ ]'.
     Parêntesis '( )' e aspas duplas '" "' atuam como operadores
     'matchfix', mas não são tratados como tal pelo analisador do
     Maxima.

     'matchfix' avalia seus argumentos.  'matchfix' retorna seu primeiro
     argumento, <delimitador_e>.

     Exemplos:

        * Delimitadores podem ser quase quaisquer seqüência de
          caracteres.
          (%i1) matchfix ("@@", "~");
          (%o1)                          @@
          (%i2) @@ a, b, c ~;
          (%o2)                      @@a, b, c~
          (%i3) matchfix (">>", "<<");
          (%o3)                          >>
          (%i4) >> a, b, c <<;
          (%o4)                      >>a, b, c<<
          (%i5) matchfix ("foo", "oof");
          (%o5)                          foo
          (%i6) foo a, b, c oof;
          (%o6)                     fooa, b, coof
          (%i7) >> w + foo x, y oof + z << / @@ p, q ~;
                               >>z + foox, yoof + w<<
          (%o7)                ----------------------
                                      @@p, q~

        * Operadores 'matchfix' são funções comuns definidas pelo
          usuário.
          (%i1) matchfix ("!-", "-!");
          (%o1)                         "!-"
          (%i2) !- x, y -! := x/y - y/x;
                                              x   y
          (%o2)                   !-x, y-! := - - -
                                              y   x
          (%i3) define (!-x, y-!, x/y - y/x);
                                              x   y
          (%o3)                   !-x, y-! := - - -
                                              y   x
          (%i4) define ("!-" (x, y), x/y - y/x);
                                              x   y
          (%o4)                   !-x, y-! := - - -
                                              y   x
          (%i5) dispfun ("!-");
                                              x   y
          (%t5)                   !-x, y-! := - - -
                                              y   x

          (%o5)                         done
          (%i6) !-3, 5-!;
                                          16
          (%o6)                         - --
                                          15
          (%i7) "!-" (3, 5);
                                          16
          (%o7)                         - --
                                          15

 -- Função: remlet (<prod>, <nome>)
 -- Função: remlet ()
 -- Função: remlet (all)
 -- Função: remlet (all, <nome>)
     Apaga a regra de substituiçao, prod -> repl, mais recentemente
     definida através dea função 'let'.  Se 'nome' for fornecido a regra
     é apagada do pacote de regras chamado 'nome'.

     'remlet()' e 'remlet(all)' apagam todas as regras de substituição
     do pacote de regras corrente.  Se o nome de um pacote de regras for
     fornecido, e.g.  'remlet (all, <nome>)', o pacote de regras <nome>
     é também apagado.

     Se uma substituição é para ser mudada usando o mesmo produto,
     'remlet' não precisa ser chamada, apenas redefina a substituição
     usando o mesmo produto (literalmente) com a função 'let' e a nova
     substituição e/ou nome de predicado.  Pode agora 'remlet (<prod>)'
     ser chamada e a regra de substituição original é ressuscitada.

     Veja também 'remrule', que remove uma regra definida através de
     'tellsimp' ou de 'tellsimpafter'.

 -- Função: remrule (<op>, <nomeregra>)
 -- Função: remrule (<op>, all)
     Remove regras definidas por 'tellsimp', ou 'tellsimpafter'.

     'remrule (<op>, <nomeregra>)' remove a regra com o nome 'nomeregra'
     do operador <op>.  Quando <op> for um operador interno ou um
     operador definido pelo usuário (como definido por 'infix',
     'prefix', etc.), <op> e <rulename> devem ser colocados entre aspas
     duplas.

     'remrule (<op>, all)' remove todas as regras para o operador <op>.

     Veja também 'remlet', que remove uma regra definida através de
     'let'.

     Examples:

          (%i1) tellsimp (foo (aa, bb), bb - aa);
          (%o1)                   [foorule1, false]
          (%i2) tellsimpafter (aa + bb, special_add (aa, bb));
          (%o2)                   [+rule1, simplus]
          (%i3) infix ("@@");
          (%o3)                          @@
          (%i4) tellsimp (aa @@ bb, bb/aa);
          (%o4)                   [@@rule1, false]
          (%i5) tellsimpafter (quux (%pi, %e), %pi - %e);
          (%o5)                  [quuxrule1, false]
          (%i6) tellsimpafter (quux (%e, %pi), %pi + %e);
          (%o6)             [quuxrule2, quuxrule1, false]
          (%i7) [foo (aa, bb), aa + bb, aa @@ bb, quux (%pi, %e),
                 quux (%e, %pi)];
                                               bb
          (%o7) [bb - aa, special_add(aa, bb), --, %pi - %e, %pi + %e]
                                               aa
          (%i8) remrule (foo, foorule1);
          (%o8)                          foo
          (%i9) remrule ("+", "+rule1");
          (%o9)                           +
          (%i10) remrule ("@@", "@@rule1");
          (%o10)                         @@
          (%i11) remrule (quux, all);
          (%o11)                        quux
          (%i12) [foo (aa, bb), aa + bb, aa @@ bb, quux (%pi, %e),
                  quux (%e, %pi)];
          (%o12) [foo(aa, bb), bb + aa, aa @@ bb, quux(%pi, %e),
                                                   quux(%e, %pi)]

 -- Função: tellsimp (<pattern>, <replacement>)
     é similar a 'tellsimpafter' mas coloca nova informação antes da
     antiga de forma que essa nova regra seja aplicada antes das regras
     de simplificação internas.

     'tellsimp' é usada quando for importante modificar a expressão
     antes que o simplificador trabalhe sobre ela, por exemplo se o
     simplificador "sabe" alguma coisa sobre a expressão, mas o que ele
     retorna não é para sua apreciação.  Se o simplificador "sabe"
     alguma coisa sobre o principal operador da expressão, mas está
     simplesmente escondendo de você, você provavelmente quer usar
     'tellsimpafter'.

     O modelo pode não ser uma adição, um produto, variável simples, ou
     número.

     'rules' é a lista de regras definidas por 'defrule', 'defmatch',
     'tellsimp', e 'tellsimpafter'.

     Exemplos:

          (%i1) matchdeclare (x, freeof (%i));
          (%o1)                         done
          (%i2) %iargs: false$
          (%i3) tellsimp (sin(%i*x), %i*sinh(x));
          (%o3)                 [sinrule1, simp-%sin]
          (%i4) trigexpand (sin (%i*y + x));
          (%o4)         sin(x) cos(%i y) + %i cos(x) sinh(y)
          (%i5) %iargs:true$
          (%i6) errcatch(0^0);
           0
          0  has been generated
          (%o6)                          []
          (%i7) ev (tellsimp (0^0, 1), simp: false);
          (%o7)                  [^rule1, simpexpt]
          (%i8) 0^0;
          (%o8)                           1
          (%i9) remrule ("^", %th(2)[1]);
          (%o9)                           ^
          (%i10) tellsimp (sin(x)^2, 1 - cos(x)^2);
          (%o10)                 [^rule2, simpexpt]
          (%i11) (1 + sin(x))^2;
                                                2
          (%o11)                    (sin(x) + 1)
          (%i12) expand (%);
                                             2
          (%o12)               2 sin(x) - cos (x) + 2
          (%i13) sin(x)^2;
                                            2
          (%o13)                     1 - cos (x)
          (%i14) kill (rules);
          (%o14)                        done
          (%i15) matchdeclare (a, true);
          (%o15)                        done
          (%i16) tellsimp (sin(a)^2, 1 - cos(a)^2);
          (%o16)                 [^rule3, simpexpt]
          (%i17) sin(y)^2;
                                            2
          (%o17)                     1 - cos (y)

 -- Função: tellsimpafter (<modelo>, <substituição>)
     Define a uma regra de simplificação que o simplificador do Maxima
     aplica após as regras de simplificação internas.  <modelo> é uma
     expressão, compreendendo variáveis de modelo (declaradas através de
     'matchdeclare') e outros átomos e operações, considerados literais
     para o propósito de coincidência de modelos.  <substituição> é
     substituída para uma expressão atual que coincide com <modelo>;
     variáveis de modelo em <substituição> são atribuidas a valores
     coincidentes na expressão atual.

     <modelo> pode ser qualquer expressão não atômica na qual o
     principal operador não é uma variável de modelo; a regra de
     simplificação está associada com o operador principal.  Os nomes de
     funções (com uma excessão, descrita abaixo), listas, e arrays podem
     aparecer em <modelo> como o principal operador somente como
     literais (não variáveis de modelo); essas regras fornecem
     expressões tais como 'aa(x)' e 'bb[y]' como modelos, se 'aa' e 'bb'
     forem variáveis de modelo.  Nomes de funções, listas, e arrays que
     são variáveis de modelo podem aparecer como operadores outros que
     não o operador principal em <modelo>.

     Existe uma excessão para o que foi dito acima com relação a regras
     e nomes de funções.  O nome de uma função subscrita em uma
     expressão tal como 'aa[x](y)' pode ser uma variável de modelo,
     porque o operador principal não é 'aa' mas ao contrário o átomo
     Lisp 'mqapply'.  Isso é uma conseqüência da representação de
     expressões envolvendo funções subscritas.

     Regras de simplificação são aplicadas após avaliação (se não
     suprimida através de colocação de apóstrofo ou do sinalizador
     'noeval').  Regras estabelecidas por 'tellsimpafter' são aplicadas
     na ordem em que forem definidas, e após quaisquer regras internas.
     Regras são aplicadas de baixo para cima, isto é, aplicadas primeiro
     a subexpressões antes de ser aplicada à expressão completa.  Isso
     pode ser necessário para repetidamente simplificar um resultado
     (por exemplo, via o operador apóstrofo-apóstrofo '''' ou o
     sinalizador 'infeval') para garantir que todas as regras são
     aplicadas.

     Variáveis de modelo são tratadas como variáveis locais em regras de
     simplificação.  Assim que uma regra é definida, o valor de uma
     variável de modelo não afeta a regra, e não é afetado pela regra.
     Uma atribuição para uma variável de modelo que resulta em uma
     coincidência de regra com sucesso não afeta a atribuição corrente
     (ou necessita disso) da variável de modelo.  Todavia, como com
     todos os átomos no Maxima, as propriedades de variáveis de modelo
     (como declarado por 'put' e funções relacionadas) são globais.

     A regra construída por 'tellsimpafter' é nomeada após o operador
     principal de 'modelo'.  Regras para operadores internos, e
     operadores definidos pelo usuário definidos por meio de 'infix',
     'prefix', 'postfix', 'matchfix', e 'nofix', possuem nomes que são
     seqüências de caracteres do Maxima.  Regras para outras funções
     possuem nomes que são identificadores comuns do Maxima.

     O tratamento de substantivos e formas verbais é desprezívelmente
     confuso.  Se uma regra é definida para uma forma substantiva (ou
     verbal) e uma regra para o verbo correspondente (ou substantivo) já
     existe, então a nova regra definida aplica-se a ambas as formas
     (substantiva e verbal).  Se uma regra para a correspondente forma
     verbal (ou substantiva) não existe, a nova regra definida
     aplicar-se-á somente para a forma substantiva (ou verbal).

     A regra construída através de 'tellsimpafter' é uma função Lisp
     comum.  Se o nome da regra for '$foorule1', a construção ':lisp
     (trace $foorule1)' rastreia a função, e ':lisp (symbol-function
     '$foorule1' mostra sua definição.

     'tellsimpafter' não avalia seus argumentos.  'tellsimpafter'
     retorna a lista de regras para o operador principal de <modelo>,
     incluindo a mais recente regra estabelecia.

     Veja também 'matchdeclare', 'defmatch', 'defrule', 'tellsimp',
     'let', 'kill', 'remrule', e 'clear_rules'.

     Exemplos:

     <modelo> pode ser qualquer expressão não atômica na qual o
     principal operador não é uma variável de modelo.

          (%i1) matchdeclare (aa, atom, [ll, mm], listp, xx, true)$
          (%i2) tellsimpafter (sin (ll), map (sin, ll));
          (%o2)                 [sinrule1, simp-%sin]
          (%i3) sin ([1/6, 1/4, 1/3, 1/2, 1]*%pi);
                              1  sqrt(2)  sqrt(3)
          (%o3)              [-, -------, -------, 1, 0]
                              2     2        2
          (%i4) tellsimpafter (ll^mm, map ("^", ll, mm));
          (%o4)                  [^rule1, simpexpt]
          (%i5) [a, b, c]^[1, 2, 3];
                                          2   3
          (%o5)                      [a, b , c ]
          (%i6) tellsimpafter (foo (aa (xx)), aa (foo (xx)));
          (%o6)                   [foorule1, false]
          (%i7) foo (bar (u - v));
          (%o7)                    bar(foo(u - v))

     Regras são aplicadas na ordem em que forem definidas.  Se duas
     regras podem coincidir com uma expressão, a regra que foi primeiro
     definida é a que será aplicada.

          (%i1) matchdeclare (aa, integerp);
          (%o1)                         done
          (%i2) tellsimpafter (foo (aa), bar_1 (aa));
          (%o2)                   [foorule1, false]
          (%i3) tellsimpafter (foo (aa), bar_2 (aa));
          (%o3)              [foorule2, foorule1, false]
          (%i4) foo (42);
          (%o4)                       bar_1(42)

     variáveis de modelo são tratadas como variáveis locais em regras de
     simplificação.  (Compare a 'defmatch', que trata variáveis de
     modelo como variáveis globais.)

          (%i1) matchdeclare (aa, integerp, bb, atom);
          (%o1)                         done
          (%i2) tellsimpafter (foo(aa, bb), bar('aa=aa, 'bb=bb));
          (%o2)                   [foorule1, false]
          (%i3) bb: 12345;
          (%o3)                         12345
          (%i4) foo (42, %e);
          (%o4)                 bar(aa = 42, bb = %e)
          (%i5) bb;
          (%o5)                         12345

     Como com todos os átomos, propriedades de variáveis de modelo são
     globais embora valores sejam locais.  Nesse exemplo, uma
     propriedade de atribuição é declarada via 'define_variable'.  Essa
     é a propriedade do átomo 'bb' através de todo o Maxima.

          (%i1) matchdeclare (aa, integerp, bb, atom);
          (%o1)                         done
          (%i2) tellsimpafter (foo(aa, bb), bar('aa=aa, 'bb=bb));
          (%o2)                   [foorule1, false]
          (%i3) foo (42, %e);
          (%o3)                 bar(aa = 42, bb = %e)
          (%i4) define_variable (bb, true, boolean);
          (%o4)                         true
          (%i5) foo (42, %e);
          Error: bb was declared mode boolean, has value: %e
           -- an error.  Quitting.  To debug this try debugmode(true);

     Regras são nomeadas após operadores principais.  Nomes de regras
     para operadores internos e operadores definidos pelo usuário são
     seqüências de caracteres, enquanto nomes para outras funções são
     identificadores comuns.

          (%i1) tellsimpafter (foo (%pi + %e), 3*%pi);
          (%o1)                   [foorule1, false]
          (%i2) tellsimpafter (foo (%pi * %e), 17*%e);
          (%o2)              [foorule2, foorule1, false]
          (%i3) tellsimpafter (foo (%i ^ %e), -42*%i);
          (%o3)         [foorule3, foorule2, foorule1, false]
          (%i4) tellsimpafter (foo (9) + foo (13), quux (22));
          (%o4)                   [+rule1, simplus]
          (%i5) tellsimpafter (foo (9) * foo (13), blurf (22));
          (%o5)                  [*rule1, simptimes]
          (%i6) tellsimpafter (foo (9) ^ foo (13), mumble (22));
          (%o6)                  [^rule1, simpexpt]
          (%i7) rules;
          (%o7) [trigrule0, trigrule1, trigrule2, trigrule3, trigrule4,
          htrigrule1, htrigrule2, htrigrule3, htrigrule4, foorule1,
          foorule2, foorule3, +rule1, *rule1, ^rule1]
          (%i8) foorule_name: first (%o1);
          (%o8)                       foorule1
          (%i9) plusrule_name: first (%o4);
          (%o9)                        +rule1
          (%i10) [?mstringp (foorule_name), symbolp (foorule_name)];
          (%o10)                    [false, true]
          (%i11) [?mstringp (plusrule_name), symbolp (plusrule_name)];
          (%o11)                    [true, true]
          (%i12) remrule (foo, foorule1);
          (%o12)                         foo
          (%i13) remrule ("^", "^rule1");
          (%o13)                          ^

     Um exemplo trabalhado: multiplicação anticomutativa.

          (%i1) gt (i, j) := integerp(j) and i < j;
          (%o1)           gt(i, j) := integerp(j) and i < j
          (%i2) matchdeclare (i, integerp, j, gt(i));
          (%o2)                         done
          (%i3) tellsimpafter (s[i]^^2, 1);
          (%o3)                 [^^rule1, simpncexpt]
          (%i4) tellsimpafter (s[i] . s[j], -s[j] . s[i]);
          (%o4)                   [.rule1, simpnct]
          (%i5) s[1] . (s[1] + s[2]);
          (%o5)                    s  . (s  + s )
                                    1     2    1
          (%i6) expand (%);
          (%o6)                      1 - s  . s
                                          2    1
          (%i7) factor (expand (sum (s[i], i, 0, 9)^^5));
          (%o7) 100 (s  + s  + s  + s  + s  + s  + s  + s  + s  + s )
                      9    8    7    6    5    4    3    2    1    0

 -- Função: clear_rules ()
     Executa 'kill (rules)' e então re-escolhe o próximo número de regra
     para 1 para adição '+', multiplicação '*', e exponenciação '^'.


File: maxima.info,  Node: Listas,  Next: Conjuntos,  Prev: Regras e Modelos,  Up: Top

37 Listas
*********

* Menu:

* Introdução a Listas::
* Funções e Variáveis Definidas para Listas::


File: maxima.info,  Node: Introdução a Listas,  Next: Funções e Variáveis Definidas para Listas,  Prev: Listas,  Up: Listas

37.1 Introdução a Listas
========================

Listas são o bloco básico de construção para Maxima e Lisp.**Todos os
outros tipos de dado como arrays, tabelas desordenadas, números são
representados como listas Lisp.  Essas listas Lisp possuem a forma

     ((MPLUS) $A 2)

para indicar a expressão 'a+2'.**No nível um do Maxima poderemos ver a
notação infixa 'a+2'.**Maxima também tem listas que foram impressas como

     [1, 2, 7, x+y]

para uma lista com 4 elementos.**Internamente isso corresponde a uma
lista Lisp da forma

     ((MLIST) 1  2  7  ((MPLUS)  $X $Y ))

O sinalizador que denota o tipo campo de uma expressão Maxima é uma
lista em si mesmo, após ter sido adicionado o simplificador a lista
poderá transforma-se

     ((MLIST SIMP) 1 2 7 ((MPLUS SIMP) $X $Y))


File: maxima.info,  Node: Funções e Variáveis Definidas para Listas,  Prev: Introdução a Listas,  Up: Listas

37.2 Funções e Variáveis Definidas para Listas
==============================================

 -- Função: append (<list_1>, ..., <list_n>)
     Retorna uma lista simples dos elementos de <list_1> seguidos pelos
     elementos de <list_2>, ....  'append' também trabalha sobre
     expressões gerais, e.g.  'append (f(a,b), f(c,d,e));' retorna
     'f(a,b,c,d,e)'.

     Faça 'example(append);' para um exemplo.

 -- Função: assoc (<key>, <list>, <default>)
 -- Função: assoc (<key>, <list>)
     Essa função procura pela chave <key> do lado esquerdo da entrada
     <list> que é da forma '[x,y,z,...]' onde cada elemento de <list> é
     uma expressão de um operando binário e 2 elementos.  Por exemplo
     'x=1', '2^3', '[a,b]' etc.  A chave <key> é verificada contra o
     primeiro operando.  'assoc' retorna o segundo operando se 'key' for
     achada.  Se a chave 'key' não for achada isso retorna o valor
     padrão <default>.  <default> é opcional e o padrão é 'false'.

 -- Função: atom (<expr>)
     Retorna 'true' se <expr> for atomica (i.e.  um número, nome ou
     seqüência de caracteres) de outra forma retorna 'false'.  Desse
     modo 'atom(5)' é 'true' enquanto 'atom(a[1])' e 'atom(sin(x))' São
     'false' (assumindo 'a[1]' e 'x' não estão associados).

 -- Função: cons (<expr>, <list>)
     Retorna uma nova lista construída do elemento <expr> como seu
     primeiro elemento, seguido por elementos de <list>.  'cons' também
     trabalha sobre outras expressões, e.g.  'cons(x, f(a,b,c));' ->
     'f(x,a,b,c)'.

 -- Função: copylist (<list>)
     Retorna uma cópia da lista <list>.

 -- Função: create_list (<form>, <x_1>, <list_1>, ..., <x_n>, <list_n>)

     Cria uma lista por avaliação de <form> com <x_1> associando a cada
     elemento <list_1>, e para cada tal associação anexa <x_2> para cada
     elemento de <list_2>, ....  O número de elementos no resultado será
     o produto do número de elementos de cada lista.  Cada variável
     <x_i> pode atualmente ser um síbolo -o qual não pode ser avaliado.
     A lista de argumentos será avaliada uma única vez no início do
     bloco de repetição.

          (%i82) create_list1(x^i,i,[1,3,7]);
          (%o82) [x,x^3,x^7]

     Com um bloco de repetição duplo:

          (%i79) create_list([i,j],i,[a,b],j,[e,f,h]);
          (%o79) [[a,e],[a,f],[a,h],[b,e],[b,f],[b,h]]

     Em lugar de <list_i> dois argumentos podem ser fornecidos cada um
     dos quais será avaliado como um número.  Esses podem vir a ser
     inclusive o limite inferior e superior do bloco de repetição.

          (%i81) create_list([i,j],i,[1,2,3],j,1,i);
          (%o81) [[1,1],[2,1],[2,2],[3,1],[3,2],[3,3]]

     Note que os limites ou lista para a variável 'j' podem depender do
     valor corrente de 'i'.

 -- Função: delete (<expr_1>, <expr_2>)
 -- Função: delete (<expr_1>, <expr_2>, <n>)
     Remove todas as ocorrências de <expr_1> em <expr_2>.  <expr_1> pode
     ser uma parcela de <expr_2> (se isso for uma adição) ou um fator de
     <expr_2> (se isso for um produto).

          (%i1) delete(sin(x), x+sin(x)+y);
          (%o1)                         y + x


     'delete(<expr_1>, <expr_2>, <n>)' remove as primeiras <n>
     ocorrências de <expr_1> em <expr_2>.  Se houver menos que <n>
     ocorrências de <expr_1> em <expr_2> então todas as corrências seram
     excluídas.

          (%i1) delete(a, f(a,b,c,d,a));
          (%o1)                      f(b, c, d)
          (%i2) delete(a, f(a,b,a,c,d,a), 2);
          (%o2)                     f(b, c, d, a)


 -- Função: eighth (<expr>)
     Retorna o oitavo item de uma expressão ou lista <expr>.  Veja
     'first' para maiores detalhes.

 -- Função: endcons (<expr>, <list>)
     Retorna uma nova lista consistindo de elementos de 'list' seguidos
     por <expr>.  'endcons' também trabalha sobre expressões gerais,
     e.g.  'endcons(x, f(a,b,c));' -> 'f(a,b,c,x)'.

 -- Função: fifth (<expr>)
     Retorna o quinto item da expressão ou lista <expr>.  Veja 'first'
     para maiores detalhes.

 -- Função: first (<expr>)
     Retorna a primeira parte de <expr> que pode resultar no primeiro
     elemento de uma lista, a primeira linha de uma matriz, a primeira
     parcela de uma adição, etc.  Note que 'first' e suas funções
     relacionadas, 'rest' e 'last', trabalham sobre a forma de <expr>
     que é mostrada não da forma que é digitada na entrada.  Se a
     variável 'inflag' é escolhida para 'true' todavia, essa funções
     olharão na forma interna de <expr>.  Note que o simplificador
     re-ordena expressões.  Desse modo 'first(x+y)' será 'x' se 'inflag'
     for 'true' e 'y' se 'inflag' for 'false' ('first(y+x)' fornece os
     mesmos resultados).  As funções 'second' ..  'tenth' retornam da
     segunda até a décima parte do seu argumento.

 -- Função: fourth (<expr>)
     Retorna o quarto item da expressõ ou lista <expr>.  Veja 'first'
     para maiores detalhes.

 -- Função: get (<a>, <i>)
     Recupera a propriedade de usuário indicada por <i> associada com o
     átomo <a> ou retorna 'false' se "a" não tem a propriedade <i>.

     'get' avalia seus argumentos.

          (%i1) put (%e, 'transcendental, 'type);
          (%o1)                    transcendental
          (%i2) put (%pi, 'transcendental, 'type)$
          (%i3) put (%i, 'algebraic, 'type)$
          (%i4) typeof (expr) := block ([q],
                  if numberp (expr)
                  then return ('algebraic),
                  if not atom (expr)
                  then return (maplist ('typeof, expr)),
                  q: get (expr, 'type),
                  if q=false
                  then errcatch (error(expr,"is not numeric.")) else q)$
          (%i5) typeof (2*%e + x*%pi);
          x is not numeric.
          (%o5)  [[transcendental, []], [algebraic, transcendental]]
          (%i6) typeof (2*%e + %pi);
          (%o6)     [transcendental, [algebraic, transcendental]]


 -- Função: join (<l>, <m>)
     Cria uma nova lista contendo os elementos das lista <l> e <m>,
     intercaladas.  O resultado tem os elementos '[<l>[1], <m>[1],
     <l>[2], <m>[2], ...]'.  As listas <l> e <m> podem conter qualquer
     tipo de elementos.

     Se as listas forem de diferentes comprimentos, 'join' ignora
     elementos da lista mais longa.

     Maxima reclama se <l> ou <m> não for uma lista.

     Exemplos:

          (%i1) L1: [a, sin(b), c!, d - 1];
          (%o1)                [a, sin(b), c!, d - 1]
          (%i2) join (L1, [1, 2, 3, 4]);
          (%o2)          [a, 1, sin(b), 2, c!, 3, d - 1, 4]
          (%i3) join (L1, [aa, bb, cc, dd, ee, ff]);
          (%o3)        [a, aa, sin(b), bb, c!, cc, d - 1, dd]

 -- Função: last (<expr>)
     Retorna a última parte (parcela, linha, elemento, etc.)  de <expr>.

 -- Função: length (<expr>)
     Retorna (por padrão) o número de partes na forma externa (mostrada)
     de <expr>.  Para listas isso é o número de elementos, para matrizes
     isso é o número de linhas, e para adições isso é o número de
     parcelas (veja 'dispform').

     O comando 'length' é afetado pelo comutador 'inflag'.  Então, e.g.
     'length(a/(b*c));' retorna 2 se 'inflag' for 'false' (Assumindo
     'exptdispflag' sendo 'true'), mas 3 se 'inflag' for 'true' (A
     representação interna é essencialmente 'a*b^-1*c^-1').

 -- Variável de opção: listarith
     Valor padrão: 'true' - se 'false' faz com que quaisquer operações
     aritméticas com listas sejam suprimidas; quando 'true', operações
     lista-matriz são contagiosas fazendo com que listas sejam
     convertidas para matrizes retornando um resultado que é sempre uma
     matriz.  Todavia, operações lista-lista podem retornar listas.

 -- Função: listp (<expr>)
     Retorna 'true' se <expr> for uma lista de outra forma retorna
     'false'.

 -- Função: makelist (<expr>, <i>, <i_0>, <i_1>)
 -- Função: makelist (<expr>, <x>, <list>)
     Constrói e retorna uma lista, cada elemento dessa lista é gerado
     usando <expr>.

     'makelist (<expr>, <i>, <i_0>, <i_1>)' retorna uma lista, o
     'j''ésimo elemento dessa lista é igual a 'ev (<expr>, <i>=j)' para
     'j' variando de <i_0> até <i_1>.

     'makelist (<expr>, <x>, <list>)' retorna uma lista, o 'j''ésimo
     elemento é igual a 'ev (<expr>, <x>=<list>[j])' para 'j' variando
     de 1 até 'length (<list>)'.

     Exemplos:

          (%i1) makelist(concat(x,i),i,1,6);
          (%o1)               [x1, x2, x3, x4, x5, x6]
          (%i2) makelist(x=y,y,[a,b,c]);
          (%o2)                 [x = a, x = b, x = c]


 -- Função: member (<expr_1>, <expr_2>)

     Retorna 'true' se 'is(<expr_1> = <a>)' para algum elemento <a> em
     'args(<expr_2>)', de outra forma retorna 'false'.

     'expr_2' é tipicamente uma lista, nesse caso 'args(<expr_2>) =
     <expr_2>' e 'is(<expr_1> = <a>)' para algum elemento <a> em
     'expr_2' é o teste.

     'member' não inspeciona partes dos argumentos de 'expr_2', então
     'member' pode retornar 'false' mesmo se 'expr_1' for uma parte de
     algum argumento de 'expr_2'.

     Veja também 'elementp'.

     Exemplos:

          (%i1) member (8, [8, 8.0, 8b0]);
          (%o1)                         true
          (%i2) member (8, [8.0, 8b0]);
          (%o2)                         false
          (%i3) member (b, [a, b, c]);
          (%o3)                         true
          (%i4) member (b, [[a, b], [b, c]]);
          (%o4)                         false
          (%i5) member ([b, c], [[a, b], [b, c]]);
          (%o5)                         true
          (%i6) F (1, 1/2, 1/4, 1/8);
                                         1  1  1
          (%o6)                     F(1, -, -, -)
                                         2  4  8
          (%i7) member (1/8, %);
          (%o7)                         true
          (%i8) member ("ab", ["aa", "ab", sin(1), a + b]);
          (%o8)                         true

 -- Função: ninth (<expr>)
     Retorna o nono item da expressão ou lista <expr>.  Veja 'first'
     para maiores detalhes.

 -- Função: rest (<expr>, <n>)
 -- Função: rest (<expr>)
     Retorna <expr> com seus primeiros <n> elementos removidos se <n>
     for positivo e seus últimos '- <n>' elementos removidos se <n> for
     negativo.  Se <n> for 1 isso pode ser omitido.  <expr> pode ser uma
     lista, matriz, ou outra expressão.

 -- Função: reverse (<list>)
     Ordem reversa para os membros de <list> (não os membros em si
     mesmos).  'reverse' também trabalha sobre expressões gerais, e.g.
     'reverse(a=b);' fornece 'b=a'.

 -- Função: second (<expr>)
     Retorna o segundo item da expressão ou lista <expr>.  Veja 'first'
     para maiores detalhes.

 -- Função: seventh (<expr>)
     Retorna o sétimo item da expressão ou lista <expr>.  Veja 'first'
     para maiores detalhes.

 -- Função: sixth (<expr>)
     Retorna o sexto item da expressão ou lista <expr>.  Veja 'first'
     para maiores detalhes.

 -- Função: sublist_indices (<L>, <P>)

     Retorna os índices dos elementos 'x' da lista <L> para os quais o
     predicado 'maybe(<P>(x))' retornar 'true'; isso inclui 'unknown'
     bem como 'false'.  <P> pode ser um nome de função ou uma expressão
     lambda.  <L> deve ser uma lista literal.

     Exemplos:

          (%i1) sublist_indices ('[a, b, b, c, 1, 2, b, 3, b], lambda ([x], x='b));
          (%o1)                     [2, 3, 7, 9]
          (%i2) sublist_indices ('[a, b, b, c, 1, 2, b, 3, b], symbolp);
          (%o2)                  [1, 2, 3, 4, 7, 9]
          (%i3) sublist_indices ([1 > 0, 1 < 0, 2 < 1, 2 > 1, 2 > 0], identity);
          (%o3)                       [1, 4, 5]
          (%i4) assume (x < -1);
          (%o4)                       [x < - 1]
          (%i5) map (maybe, [x > 0, x < 0, x < -2]);
          (%o5)                [false, true, unknown]
          (%i6) sublist_indices ([x > 0, x < 0, x < -2], identity);
          (%o6)                          [2]

 -- Função: tenth (<expr>)
     Retorna o décimo item da expressão ou lista <expr>.  Veja 'first'
     para maiores detalhes.

 -- Função: third (<expr>)
     Retorna o terceiro item da expressão ou lista <expr>.  Veja 'first'
     para maiores detalhes.


File: maxima.info,  Node: Conjuntos,  Next: Definição de Função,  Prev: Listas,  Up: Top

38 Conjuntos
************

* Menu:

* Introdução a Conjuntos::
* Funções e Variáveis Definidas para Conjuntos::


File: maxima.info,  Node: Introdução a Conjuntos,  Next: Funções e Variáveis Definidas para Conjuntos,  Prev: Conjuntos,  Up: Conjuntos

38.1 Introdução a Conjuntos
===========================

Maxima fornece funções de conjunto, tais como intersecção e união, para
conjuntos finitos que são definidos por enumeração explícitamente.
Maxima trata listas e conjuntos como objetos distintos.  Esse recurso
torna possível trabalhar com conjuntos que possuem elementos que são ou
listas ou conjuntos.

   Adicionalmente para funções de conjuntos finitos, Maxima fornece
algumas funoes relacionadas a análise combinatória; essas incluem os
números de Stirling de primero e de segundo tipo, os números de Bell,
coefincientes multinomiais, partições de inteiros não negativos, e umas
poucas outras.  Maxima também define uma função delta de Kronecker.

38.1.1 Utilização
-----------------

Para construir um conjunto com elementos 'a_1, ..., a_n', escreva
'set(a_1, ..., a_n)' ou '{a_1, ..., a_n}'; para construir o conjunto
vazio, escreva 'set()' ou '{}'.  Para inserção de dados, 'set(...)' e '{
... }' são equivalentes.  Conjuntos são sempre mostrados entre chaves
('{ ... }').

   Se um elemento é listado mais de uma vez, a simplificação elimina o
elemento redundante.

     (%i1) set();
     (%o1)                          {}
     (%i2) set(a, b, a);
     (%o2)                        {a, b}
     (%i3) set(a, set(b));
     (%o3)                       {a, {b}}
     (%i4) set(a, [b]);
     (%o4)                       {a, [b]}
     (%i5) {};
     (%o5)                          {}
     (%i6) {a, b, a};
     (%o6)                        {a, b}
     (%i7) {a, {b}};
     (%o7)                       {a, {b}}
     (%i8) {a, [b]};
     (%o8)                       {a, [b]}

   Dois elementos <x> e <y> são redundantes (i.e., considerados o mesmo
para propósito de construção de conjuntos) se e somente se 'is(<x> =
<y>)' retornar 'true'.  Note que 'is(equal(<x>, <y>))' pode retornar
'true' enquanto 'is(<x> = <y>)' retorna 'false'; nesse caso os elementos
<x> e <y> são considerados distintos.

     (%i1) x: a/c + b/c;
                                   b   a
     (%o1)                         - + -
                                   c   c
     (%i2) y: a/c + b/c;
                                   b   a
     (%o2)                         - + -
                                   c   c
     (%i3) z: (a + b)/c;
                                   b + a
     (%o3)                         -----
                                     c
     (%i4) is (x = y);
     (%o4)                         true
     (%i5) is (y = z);
     (%o5)                         false
     (%i6) is (equal (y, z));
     (%o6)                         true
     (%i7) y - z;
                                b + a   b   a
     (%o7)                    - ----- + - + -
                                  c     c   c
     (%i8) ratsimp (%);
     (%o8)                           0
     (%i9) {x, y, z};
                               b + a  b   a
     (%o9)                    {-----, - + -}
                                 c    c   c

   Para construir um conjunto dos elementos de uma lista, use 'setify'.

     (%i1) setify ([b, a]);
     (%o1)                        {a, b}

   Os elementos de conjuntos 'x' e 'y' são iguais fornecendo 'is(x = y)'
avaliando para 'true'.  Dessa forma 'rat(x)' e 'x' são iguais como
elementos de conjuntos; conseqüentemente,

     (%i1) {x, rat(x)};
     (%o1)                          {x}

   Adicionalmente, uma vez que 'is((x - 1)*(x + 1) = x^2 - 1)' avalia
para 'false', '(x - 1)*(x + 1)' e 'x^2 - 1' são distintos elementos de
conjunto; dessa forma

     (%i1) {(x - 1)*(x + 1), x^2 - 1};
                                            2
     (%o1)               {(x - 1) (x + 1), x  - 1}

   Para reduzir esse conjunto a um conjunto simples, apliquemos 'rat' a
cada elemeto do conjunto

     (%i1) {(x - 1)*(x + 1), x^2 - 1};
                                            2
     (%o1)               {(x - 1) (x + 1), x  - 1}
     (%i2) map (rat, %);
                                   2
     (%o2)/R/                    {x  - 1}

   Para remover redundâncias de outros conjuntos, você pode precisar
usar outras funções de simplificação.  Aqui está um exemplo que usa
'trigsimp':

     (%i1) {1, cos(x)^2 + sin(x)^2};
                                 2         2
     (%o1)                {1, sin (x) + cos (x)}
     (%i2) map (trigsimp, %);
     (%o2)                          {1}

   Um conjunto esta'simplificado quando seus elementos não são
redundantes e o conjunto está ordenado.  A versão corrente das funções
de conjunto usam a função do Máxima 'orderlessp' para ordenar conjuntos;
odavia, versões futuras das funções de conjunto podem usar uma função de
ordenação diferente.

   Algumas operações sobre conjuntos, tais como substituições, forçam
automaticamente a uma re-simplificação; por exemplo,

     (%i1) s: {a, b, c}$
     (%i2) subst (c=a, s);
     (%o2)                        {a, b}
     (%i3) subst ([a=x, b=x, c=x], s);
     (%o3)                          {x}
     (%i4) map (lambda ([x], x^2), set (-1, 0, 1));
     (%o4)                        {0, 1}

   Maxima trata listas e conjuntos como objetos distintos; funções tais
como 'union' e 'intersection' reclamam se qualquer argumetno não for um
conjunto.  se você precisar aplicar uma função de conjunto a uma lista,
use a função 'setify' para converter essa lsita para um conjunto.  dessa
forma

     (%i1) union ([1, 2], {a, b});
     Function union expects a set, instead found [1,2]
      -- an error.  Quitting.  To debug this try debugmode(true);
     (%i2) union (setify ([1, 2]), {a, b});
     (%o2)                     {1, 2, a, b}

   Para extrair todos os elemetnos de conjunto de um conjunto 's' que
satisfazem um predicado 'f', use 'subset(s, f)'.  (Um predicado é um uma
função que avalia para os valores booleanos 'true'/'false'.)  Por
exemplo, para encontrar as equações em um dado conjunto que não depende
de uma variável 'z', use

     (%i1) subset ({x + y + z, x - y + 4, x + y - 5}, lambda ([e], freeof (z, e)));
     (%o1)               {- y + x + 4, y + x - 5}

   A seção *note Funções e Variáveis Definidas para Conjuntos:: passui
uma lista completa das funções de conjunto no Maxima.

38.1.2 Iterações entre Elementos de Conjuntos
---------------------------------------------

Existem dois camainhos para fazer iterações sobre elementos de
conjuntos.  Um caminho é usar 'map'; por exemplo:

     (%i1) map (f, {a, b, c});
     (%o1)                  {f(a), f(b), f(c)}

   O outro caminho é usar 'for <x> in <s> do'

     (%i1) s: {a, b, c};
     (%o1)                       {a, b, c}
     (%i2) for si in s do print (concat (si, 1));
     a1
     b1
     c1
     (%o2)                         done

   A função Maxima 'first' e 'rest' trabalham atualmente sobre
conjuntos.  Aplicada a um conjunto, 'first' retorna o primeiro elemento
mostrado de um conjunto; qual élemento que é mostrado pode ser
dependente da implementação.  Se 's' for um conjunto, então 'rest(s)' é
equivalente a 'disjoin(first(s), s)'.  Atualmente, existem outras
funções do Maxima que trabalham corretamente sobre conjuntos.  Em
futuras versões das funções de conjunto, 'first' e 'rest' podem vir a
funcionar diferentemente ou não completamente.

38.1.3 Erros
------------

As funções de conjunto usam a função Maxima 'orderlessp' para organizar
os elementos de cum conjunto e a função (a nível de Lisp) 'like' para
testar a igualdade entre elementos de conjuntos.  Ambas essas funções
possuem falhas conhecidas que podem se manifestar se você tentar usar
conjuntos com elementos que são listas ou matrizes que contenham
expressões na forma racional canônica (CRE). Um exemplo é

     (%i1) {[x], [rat (x)]};
     Maxima encountered a Lisp error:

       The value #:X1440 is not of type LIST.

     Automatically continuing.
     To reenable the Lisp debugger set *debugger-hook* to nil.

   Essa expressão faz com que o Maxima fique exitante com um erro (a
mensagem de erro depende de qual a versão do Lisp seu Maxima está
usando).  Outro exemplo é

     (%i1) setify ([[rat(a)], [rat(b)]]);
     Maxima encountered a Lisp error:

       The value #:A1440 is not of type LIST.

     Automatically continuing.
     To reenable the Lisp debugger set *debugger-hook* to nil.

   Essas falhas são causadas por falhas em 'orderlessp' e 'like'; elas
não são caudadas por falhas nas funções de conjunto.  Para ilustrar,
tente as expressões

     (%i1) orderlessp ([rat(a)], [rat(b)]);
     Maxima encountered a Lisp error:

       The value #:B1441 is not of type LIST.

     Automatically continuing.
     To reenable the Lisp debugger set *debugger-hook* to nil.
     (%i2) is ([rat(a)] = [rat(a)]);
     (%o2)                         false

   Até que essas falhas sejam corrigidas, não construa conjuntos com com
elementos que sejam listas ou matrizes contendo expressões na forma
racional canônica (CRE); um conjunto com um elemento na forma CRE,
todavia, pode não ser um problema:

     (%i1) {x, rat (x)};
     (%o1)                          {x}

   A 'orderlessp' do Maxima possui outra falha que pode causr problemas
com funções de conjunto, sabidamente o predicado de ordenação
'orderlessp' é não transitivo.  o mais simples exemplo conhecido que
mostra isso é

     (%i1) q: x^2$
     (%i2) r: (x + 1)^2$
     (%i3) s: x*(x + 2)$
     (%i4) orderlessp (q, r);
     (%o4)                         true
     (%i5) orderlessp (r, s);
     (%o5)                         true
     (%i6) orderlessp (q, s);
     (%o6)                         false

   Essa falha pode causar problemas com todas as funções de conjutno bem
como com funções Maxima em geral.  É provável, mas não certo, que essa
falha possa ser evitada se todos os elementos do conjunto estiverem ou
na forma CRE ou tiverem sido simplificado usando 'ratsimp'.

   Os mecanismos 'orderless' e 'ordergreat' do Maxima são incompatíveis
com as funções de conjunto.  Se você rpecisar usar ou 'orderless' ou
'ordergreat', chame todas essas funções antes de construir quaisquer
conjuntos, e não chame 'unorder'.

   Se você encontrar alguma coisa que você pense ser uma falha em alguma
funçõ de conjunto, por favor relate isso para a base de dados de falhas
do Maxima.  Veja 'bug_report'.

38.1.4 Autores
--------------

Stavros Macrakis de Cambridge, Massachusetts e Barton Willis da
Universidade e Nebraska e Kearney (UNK) escreveram as fnções de conjunto
do Maxima e sua documentação.


File: maxima.info,  Node: Funções e Variáveis Definidas para Conjuntos,  Prev: Introdução a Conjuntos,  Up: Conjuntos

38.2 Funções e Variáveis Definidas para Conjuntos
=================================================

 -- Função: adjoin (<x>, <a>)

     Retorna a união do conjunto <a> com '{<x>}'.

     'adjoin' reclama se <a> não for um conjunto literal.

     'adjoin(<x>, <a>)' e 'union(set(<x>), <a>)' são equivalentes;
     todavia, 'adjoin' pode ser um pouco mais rápida que 'union'.

     Veja também 'disjoin'.

     Exemplos:

          (%i1) adjoin (c, {a, b});
          (%o1)                       {a, b, c}
          (%i2) adjoin (a, {a, b});
          (%o2)                        {a, b}

 -- Função: belln (<n>)

     Representa o n-ésimo número de Bell number.  'belln(n)' é o número
     de partições de um conjunto <n> elementos.

     Para inteiros não negativos <n>, 'belln(<n>)' simplifica para o
     n-ésimo número de Bell.  'belln' não simplifica para qualquer outro
     tipo de argumento.

     'belln' distribui sobre equações, listas, matrizes e conjuntos.

     Exemplos:

     'belln' aplicado a inteiros não negativos.

          (%i1) makelist (belln (i), i, 0, 6);
          (%o1)               [1, 1, 2, 5, 15, 52, 203]
          (%i2) is (cardinality (set_partitions ({})) = belln (0));
          (%o2)                         true
          (%i3) is (cardinality (set_partitions ({1, 2, 3, 4, 5, 6})) = belln (6));
          (%o3)                         true

     'belln' aplicado a argumentos que não são inteiros não negativos.

          (%i1) [belln (x), belln (sqrt(3)), belln (-9)];
          (%o1)        [belln(x), belln(sqrt(3)), belln(- 9)]

 -- Função: cardinality (<a>)

     Retorna o número de elementos distintos do conjunto <a>.

     'cardinality' ignora elementos redundantes mesmo quando a
     simplificação está dessabilitada.

     Exemplos:

          (%i1) cardinality ({});
          (%o1)                           0
          (%i2) cardinality ({a, a, b, c});
          (%o2)                           3
          (%i3) simp : false;
          (%o3)                         false
          (%i4) cardinality ({a, a, b, c});
          (%o4)                           3

 -- Função: cartesian_product (<b_1>, ... , <b_n>)
     Retorna um conjunto de listas da forma '[<x_1>, ..., <x_n>]', onde
     <x_1>, ..., <x_n> são elementos dos conjuntos <b_1>, ...  , <b_n>,
     respectivamente.

     'cartesian_product' reclama se qualquer argumento não for um
     conjunto literal.

     Exemplos:

          (%i1) cartesian_product ({0, 1});
          (%o1)                      {[0], [1]}
          (%i2) cartesian_product ({0, 1}, {0, 1});
          (%o2)           {[0, 0], [0, 1], [1, 0], [1, 1]}
          (%i3) cartesian_product ({x}, {y}, {z});
          (%o3)                      {[x, y, z]}
          (%i4) cartesian_product ({x}, {-1, 0, 1});
          (%o4)              {[x, - 1], [x, 0], [x, 1]}

 -- Função: disjoin (<x>, <a>)
     Retorna o conjunto <a> sem o elemento <x>.  Se <x> não for um
     elemento de <a>, retorna <a> sem modificações.

     'disjoin' reclama se <a> não for um conjunto literal.

     'disjoin(<x>, <a>)', 'delete(<x>, <a>)', e 'setdifference(<a>,
     set(<x>))' são todos equivalentes.  Desses, 'disjoin' é geralmente
     mais rápido que os outros.

     Exemplos:

          (%i1) disjoin (a, {a, b, c, d});
          (%o1)                       {b, c, d}
          (%i2) disjoin (a + b, {5, z, a + b, %pi});
          (%o2)                      {5, %pi, z}
          (%i3) disjoin (a - b, {5, z, a + b, %pi});
          (%o3)                  {5, %pi, b + a, z}

 -- Função: disjointp (<a>, <b>)
     Retorna 'true' se e somente se os conjuntos <a> e <b> forem
     disjuntos.

     'disjointp' reclama se ou <a> ou <b> não forem conjuntos literais.

     Exemplos:

          (%i1) disjointp ({a, b, c}, {1, 2, 3});
          (%o1)                         true
          (%i2) disjointp ({a, b, 3}, {1, 2, 3});
          (%o2)                         false

 -- Função: divisors (<n>)

     Representa o conjunto dos divisores de <n>.

     'divisors(<n>)' simplifica para um conjunto de inteiros quando <n>
     for um inteiro não nulo.  O cojunto dos divisores inclui os
     elementos 1 e <n>.  Os divisores de um inteiro negativo são os
     divisores de seu valor absoluto.

     'divisors' distribui sobre equações, listas, matrizes, e conjuntos.

     Exemplos:

     Podemos verificar que 28 é um número perfeito: a adição de seus
     divisores (exceto o próprio 28) é 28.

          (%i1) s: divisors(28);
          (%o1)                 {1, 2, 4, 7, 14, 28}
          (%i2) lreduce ("+", args(s)) - 28;
          (%o2)                          28

     'divisors' é uma função de simplificação.  Substituindo 8 por 'a'
     em 'divisors(a)' retorna os divisores sem fazer a reavaliação de
     'divisors(8)'.

          (%i1) divisors (a);
          (%o1)                      divisors(a)
          (%i2) subst (8, a, %);
          (%o2)                     {1, 2, 4, 8}

     'divisors' distribui sobre equações, listas, matrizes, e conjuntos.

          (%i1) divisors (a = b);
          (%o1)               divisors(a) = divisors(b)
          (%i2) divisors ([a, b, c]);
          (%o2)        [divisors(a), divisors(b), divisors(c)]
          (%i3) divisors (matrix ([a, b], [c, d]));
                            [ divisors(a)  divisors(b) ]
          (%o3)             [                          ]
                            [ divisors(c)  divisors(d) ]
          (%i4) divisors ({a, b, c});
          (%o4)        {divisors(a), divisors(b), divisors(c)}

 -- Função: elementp (<x>, <a>)
     Retorna 'true' se e somente se <x> for um elemento do conjunto <a>.

     'elementp' reclama se <a> não for um conjunto literal.

     Exemplos:

          (%i1) elementp (sin(1), {sin(1), sin(2), sin(3)});
          (%o1)                         true
          (%i2) elementp (sin(1), {cos(1), cos(2), cos(3)});
          (%o2)                         false

 -- Função: emptyp (<a>)
     Retorna 'true' se e somente se <a> for o conjunto vazio ou a lista
     vazia.

     Exemplos:

          (%i1) map (emptyp, [{}, []]);
          (%o1)                     [true, true]
          (%i2) map (emptyp, [a + b, {{}}, %pi]);
          (%o2)                 [false, false, false]

 -- Função: equiv_classes (<s>, <F>)
     Retorna um conjunto das classes de equivalências do conjunto <s>
     com relação à relação de equivalência <F>.

     <F> é uma função de duas variáveis definida sobre o produto
     cartesiano <s> por <s>.  O valor de retorno de <F> é ou 'true' ou
     'false', ou uma expressão <expr> tal que 'is(<expr>)' é ou 'true'
     ou 'false'.

     Quando <F> nõ for um relação de equivalência, 'equiv_classes'
     aceita sem reclamação, mas o resultado é geralmente incorreto nesse
     caso.

     Exemplos:

     A relação de equivalência é uma expressão lambda a qual retorna
     'true' ou 'false'.

          (%i1) equiv_classes ({1, 1.0, 2, 2.0, 3, 3.0}, lambda ([x, y], is (equal (x, y))));
          (%o1)            {{1, 1.0}, {2, 2.0}, {3, 3.0}}

     A relação de equivalência é o nome de uma função relacional que
     avalia para 'true' ou 'false'.

          (%i1) equiv_classes ({1, 1.0, 2, 2.0, 3, 3.0}, equal);
          (%o1)            {{1, 1.0}, {2, 2.0}, {3, 3.0}}

     As classes de equivalência são números que diferem por um multiplo
     de 3.

          (%i1) equiv_classes ({1, 2, 3, 4, 5, 6, 7}, lambda ([x, y], remainder (x - y, 3) = 0));
          (%o1)              {{1, 4, 7}, {2, 5}, {3, 6}}

 -- Função: every (<f>, <s>)
 -- Função: every (<f>, <L_1>, ..., <L_n>)

     Retorna 'true' se o predicado <f> for 'true' para todos os
     argumentos fornecidos.

     Dado um conjunto como sgundo argumento, 'every(<f>, <s>)' retorna
     'true' se 'is(<f>(<a_i>))' retornar 'true' para todos os <a_i> em
     <s>.  'every' pode ou não avaliar <f> para todos os <a_i> em <s>.
     Uma vez que conjuntos são desordenados, 'every' pode avaliar
     '<f>(<a_i>)' em qualquer ordem.

     Dada uma ou mais listas como argumentos, 'every(<f>, <L_1>, ...,
     <L_n>)' retorna 'true' se 'is(<f>(<x_1>, ..., <x_n>))' retornar
     'true' para todos os <x_1>, ..., <x_n> em <L_1>, ..., <L_n>,
     respectivamente.  'every' pode ou não avaliar <f> para toda
     combinação <x_1>, ..., <x_n>.  'every' avalia listas na ordem de
     incremento do índice.

     Dado um conjunto vazio '{}' ou uma lista vazia '[]' como
     argumentos, 'every' retorna 'false'.

     Quando o sinalizador global 'maperror' for 'true', todas as listas
     <L_1>, ..., <L_n> devem ter o mesmo comprimento.  Quando 'maperror'
     for 'false', argumentos listas são efetivamente truncados para o
     comprimento da menor lista.

     Retorna valores do predicado <f> que avaliam (via 'is') para alguma
     coisa outra que não 'true' ou 'false' são governados através do
     sinalizador global 'prederror'.  Quando 'prederror' for 'true',
     tais valores são tratados como 'false', e o valor de retorno de
     'every' é 'false'.  Quando 'prederror' for 'false', tais valores
     são tratados como 'unknown', e o valor de retorno de 'every' é
     'unknown'.

     Exemplos:

     'every' aplicada a um conjunto simples.  O predicado é uma função
     de um argumento.

          (%i1) every (integerp, {1, 2, 3, 4, 5, 6});
          (%o1)                         true
          (%i2) every (atom, {1, 2, sin(3), 4, 5 + y, 6});
          (%o2)                         false

     'every' aplicada a duas listas.  O predicado é uma função de dois
     argumentos.

          (%i1) every ("=", [a, b, c], [a, b, c]);
          (%o1)                         true
          (%i2) every ("#", [a, b, c], [a, b, c]);
          (%o2)                         false

     Retorna valores do predicado <f> que avalia para alguma coisa outra
     que não 'true' ou 'false' são governados por meio do sinalizador
     global 'prederror'.

          (%i1) prederror : false;
          (%o1)                         false
          (%i2) map (lambda ([a, b], is (a < b)), [x, y, z], [x^2, y^2, z^2]);
          (%o2)              [unknown, unknown, unknown]
          (%i3) every ("<", [x, y, z], [x^2, y^2, z^2]);
          (%o3)                        unknown
          (%i4) prederror : true;
          (%o4)                         true
          (%i5) every ("<", [x, y, z], [x^2, y^2, z^2]);
          (%o5)                         false

 -- Função: extremal_subset (<s>, <f>, max)
 -- Função: extremal_subset (<s>, <f>, min)

     Retorna o subconjunto de <s> para o qual a função <f> toma valore
     máximos ou mínimos.

     'extremal_subset(<s>, <f>, max)' retorna o subconjunto do conjunto
     ou lista <s> para os quais a função real <f> assume valor maximo.

     'extremal_subset(<s>, <f>, min)' retorna o subconjuno do conjunto
     ou lista <s> para a qual a função real <f> assume valor mínimo.

     Exemplos:

          (%i1) extremal_subset ({-2, -1, 0, 1, 2}, abs, max);
          (%o1)                       {- 2, 2}
          (%i2) extremal_subset ({sqrt(2), 1.57, %pi/2}, sin, min);
          (%o2)                       {sqrt(2)}

 -- Função: flatten (<expr>)

     Recebe argumentos de subexpressões que possuem o mesmo operator
     como <expr> e constrói uma expressão a partir desses argumentos
     coletados.

     subexpressões nas quais o operador é diferente do operador
     principal de 'expr' são copiadas sem modificação, mesmo se elas, in
     turn, contiverem a mesma subexpressão na qual o operador seja o
     mesmo que em 'expr'.

     Pode ser possível para 'flatten' construir expressões nas quais o
     número de argumentos difira dos argumentos declarados para um
     operador; isso pode provocar uma mensagem de erro do simplificador
     ou do avaliador.  'flatten' não tenta detectar tais situações.

     Expressões com representações especiais, por exemplo, expressãoes
     racionais canônicas (CRE), não podem usar a função 'flatten';
     nesses casos, 'flatten' retorna seus argumentos sem modificação.

     Exemplos:

     Aplicado a uma lista, 'flatten' reune todos os elementos de lista
     que são listas.

          (%i1) flatten ([a, b, [c, [d, e], f], [[g, h]], i, j]);
          (%o1)            [a, b, c, d, e, f, g, h, i, j]

     Aplicado a um conjunto, 'flatten' reune todos os elementos de
     conjunto que são conjuntos.

          (%i1) flatten ({a, {b}, {{c}}});
          (%o1)                       {a, b, c}
          (%i2) flatten ({a, {[a], {a}}});
          (%o2)                       {a, [a]}

     'flatten' é similar ao efeito de declarar o operador principal para
     ser enário.  Todavia, 'flatten' não faz efeito sobre subexpressões
     que possuem um operador diferente do operador principal, enquanto
     uma declaração enária faz efeito.

          (%i1) expr: flatten (f (g (f (f (x)))));
          (%o1)                     f(g(f(f(x))))
          (%i2) declare (f, nary);
          (%o2)                         done
          (%i3) ev (expr);
          (%o3)                      f(g(f(x)))

     'flatten' trata funções subscritas da mesma forma que qualquer
     outro operador.

          (%i1) flatten (f[5] (f[5] (x, y), z));
          (%o1)                      f (x, y, z)
                                      5

     Pode ser possível para 'flatten' construir expressões nas quais o
     número de argumentos difira dos argumentos declarados para um
     operador;

          (%i1) 'mod (5, 'mod (7, 4));
          (%o1)                   mod(5, mod(7, 4))
          (%i2) flatten (%);
          (%o2)                     mod(5, 7, 4)
          (%i3) ''%, nouns;
          Wrong number of arguments to mod
           -- an error.  Quitting.  To debug this try debugmode(true);

 -- Função: full_listify (<a>)
     Substitui todo oeradr de conjutno em <a> por um operadro de lista,
     e retorna o resultado.  'full_listify' substitui operadores de
     conjunto em subexpressões restantes, mesmo se o operadro principal
     não for conjunto ('set').

     'listify' substitui somente o operador principal.

     Exemplos:

          (%i1) full_listify ({a, b, {c, {d, e, f}, g}});
          (%o1)               [a, b, [c, [d, e, f], g]]
          (%i2) full_listify (F (G ({a, b, H({c, d, e})})));
          (%o2)              F(G([a, b, H([c, d, e])]))

 -- Função: fullsetify (<a>)
     Quando <a> for uma lista, substitui o operador de lista por um
     operador de conjunto, e aplica 'fullsetify' a cada elemento que for
     um conjunto.  Quando <a> não for uma lista, essa não lista é
     retornada em sua forma original e sem modificações.

     'setify' substitui somente o operador principal.

     Exemplos:

     Na linha (%o2), o argumento de 'f' não é convertido para um
     conjunto porque o operador principal de 'f([b])' não é uma lista.

          (%i1) fullsetify ([a, [a]]);
          (%o1)                       {a, {a}}
          (%i2) fullsetify ([a, f([b])]);
          (%o2)                      {a, f([b])}

 -- Função: identity (<x>)

     Retorna <x> para qualquer argumento <x>.

     Exemplos:

     'identity' pode ser usado como um predicado quando os argumentos
     forem valores Booleanos.

          (%i1) every (identity, [true, true]);
          (%o1)                         true

 -- Função: integer_partitions (<n>)
 -- Função: integer_partitions (<n>, <len>)

     Retorna partições inteiras de <n>, isto é, listas de inteiros cuja
     soma dos elementos de cada lista é <n>.

     'integer_partitions(<n>)' retorna o conjunto de todas as partições
     do inteiro <n>.  Cada partição é uma lista ordenada do maior para o
     menor.

     'integer_partitions(<n>, <len>)' retorna todas as partições que
     possuem comprimento <len> ou menor; nesse caso, zeros são anexado
     ao final de cada partição de comprimento menor que <len> terms to
     make each partition have exactly <len> terms.  Each partition is a
     list sorted from greatest to least.

     Uma lista [a_1, ..., a_m] é uma partição de inteiros não negativos
     n quando (1) cada a_i é um inteiro não nulo, e (2) a_1 + ... + a_m
     = n. Dessa forma 0 não tem partiçãoes.

     Exemplos:

          (%i1) integer_partitions (3);
          (%o1)               {[1, 1, 1], [2, 1], [3]}
          (%i2) s: integer_partitions (25)$
          (%i3) cardinality (s);
          (%o3)                         1958
          (%i4) map (lambda ([x], apply ("+", x)), s);
          (%o4)                         {25}
          (%i5) integer_partitions (5, 3);
          (%o5) {[2, 2, 1], [3, 1, 1], [3, 2, 0], [4, 1, 0], [5, 0, 0]}
          (%i6) integer_partitions (5, 2);
          (%o6)               {[3, 2], [4, 1], [5, 0]}

     Para encontrar todas as partições que satisfazem uma condição, use
     a função 'subset'; aqui está um exemplo que encontra todas as
     partições de 10 cujos elementos da lista são números primos.

          (%i1) s: integer_partitions (10)$
          (%i2) cardinality (s);
          (%o2)                          42
          (%i3) xprimep(x) := integerp(x) and (x > 1) and primep(x)$
          (%i4) subset (s, lambda ([x], every (xprimep, x)));
          (%o4) {[2, 2, 2, 2, 2], [3, 3, 2, 2], [5, 3, 2], [5, 5], [7, 3]}

 -- Função: intersect (<a_1>, ..., <a_n>)

     'intersect' é o mesmo que 'intersection', como veremos.

 -- Função: intersection (<a_1>, ..., <a_n>)
     Retorna um conjunto contendo os elementos que são comuns aos
     conjuntos <a_1> até <a_n>.

     'intersection' reclama se qualquer argumento não for um conjunto
     literal.

     Exemplos:

          (%i1) S_1 : {a, b, c, d};
          (%o1)                     {a, b, c, d}
          (%i2) S_2 : {d, e, f, g};
          (%o2)                     {d, e, f, g}
          (%i3) S_3 : {c, d, e, f};
          (%o3)                     {c, d, e, f}
          (%i4) S_4 : {u, v, w};
          (%o4)                       {u, v, w}
          (%i5) intersection (S_1, S_2);
          (%o5)                          {d}
          (%i6) intersection (S_2, S_3);
          (%o6)                       {d, e, f}
          (%i7) intersection (S_1, S_2, S_3);
          (%o7)                          {d}
          (%i8) intersection (S_1, S_2, S_3, S_4);
          (%o8)                          {}

 -- Função: kron_delta (<x>, <y>)

     Representa a função delta de Kronecker.

     'kron_delta' simplifica para 1 quando <x> e <y> forem identicos ou
     demonstadamente equivalentes, e simplifica para 0 quando <x> e <y>
     demonstradamente não equivalentes.  De outra forma, se não for
     certo que <x> e <y> são equivalentes, e 'kron_delta' simplifica
     para uma expressão substantiva.  'kron_delta' implementa uma
     política de segurança para expressões em ponto flutuante: se a
     diferença '<x> - <y>' for um número em ponto flutuante,
     'kron_delta' simplifica para uma expressão substantiva quando <x>
     for aparentemente equivalente a <y>.

     Specificamente, 'kron_delta(<x>, <y>)' simplifica para 1 quando
     'is(x = y)' for 'true'.  'kron_delta' também simplifica para 1
     quando 'sign(abs(<x> - <y>))' for 'zero' e '<x> - <y>' não for um
     número em ponto flutuante (e também não for um número de precisão
     simples em ponto flutuante e também não for um número de precisão
     dupla em poto flutuante, isto é, não for um bigfloat).
     'kron_delta' simplifica para 0 quando 'sign(abs(<x> - <y>))' for
     'pos'.

     De outra forma, 'sign(abs(<x> - <y>))' é alguma coisa outra que não
     'pos' ou 'zero', ou se for 'zero' e '<x> - <y>' for umnúmero em
     ponto flutuante.  Nesses casos, 'kron_delta' retorna um expressão
     substantiva.

     'kron_delta' é declarada para ser simétrica.  Isto é,
     'kron_delta(<x>, <y>)' é igual a 'kron_delta(<y>, <x>)'.

     Exemplos:

     Os argumentos de 'kron_delta' são identicos.  'kron_delta'
     simplifica para 1.

          (%i1) kron_delta (a, a);
          (%o1)                           1
          (%i2) kron_delta (x^2 - y^2, x^2 - y^2);
          (%o2)                           1
          (%i3) float (kron_delta (1/10, 0.1));
          (%o3)                           1

     Os argumentos de 'kron_delta' são equivalentes, e a diferença entre
     eles não é um número em ponto flutuante.  'kron_delta' simplifica
     para 1.

          (%i1) assume (equal (x, y));
          (%o1)                     [equal(x, y)]
          (%i2) kron_delta (x, y);
          (%o2)                           1

     Os argumentos de 'kron_delta' não são equivalentes.  'kron_delta'
     simplifica para 0.

          (%i1) kron_delta (a + 1, a);
          (%o1)                           0
          (%i2) assume (a > b)$
          (%i3) kron_delta (a, b);
          (%o3)                           0
          (%i4) kron_delta (1/5, 0.7);
          (%o4)                           0

     Os argumentos de 'kron_delta' podem ou não serem equivalentes.
     'kron_delta' simplifica para uma expressão substantiva.

          (%i1) kron_delta (a, b);
          (%o1)                   kron_delta(a, b)
          (%i2) assume(x >= y)$
          (%i3) kron_delta (x, y);
          (%o3)                   kron_delta(x, y)

     Os argumentos de 'kron_delta' são equivalentes, mas a diferença
     entre eles é um número em ponto flutuante.  'kron_delta' simplifica
     para uma expressão substantiva.

          (%i1) 1/4 - 0.25;
          (%o1)                          0.0
          (%i2) 1/10 - 0.1;
          (%o2)                          0.0
          (%i3) 0.25 - 0.25b0;
          Warning:  Float to bigfloat conversion of 0.25
          (%o3)                         0.0b0
          (%i4) kron_delta (1/4, 0.25);
                                            1
          (%o4)                  kron_delta(-, 0.25)
                                            4
          (%i5) kron_delta (1/10, 0.1);
                                            1
          (%o5)                  kron_delta(--, 0.1)
                                            10
          (%i6) kron_delta (0.25, 0.25b0);
          Warning:  Float to bigfloat conversion of 0.25
          (%o6)               kron_delta(0.25, 2.5b-1)

     'kron_delta' é simétrica.

          (%i1) kron_delta (x, y);
          (%o1)                   kron_delta(x, y)
          (%i2) kron_delta (y, x);
          (%o2)                   kron_delta(x, y)
          (%i3) kron_delta (x, y) - kron_delta (y, x);
          (%o3)                           0
          (%i4) is (equal (kron_delta (x, y), kron_delta (y, x)));
          (%o4)                         true
          (%i5) is (kron_delta (x, y) = kron_delta (y, x));
          (%o5)                         true

 -- Função: listify (<a>)

     Retorna uma lista contendo os elementos de <a> quando <a> for um
     conjunto.  De outra forma, 'listify' retorna <a>.

     'full_listify' substitui todos os operadores de conjunto em <a> por
     operadores de lista.

     Exemplos:

          (%i1) listify ({a, b, c, d});
          (%o1)                     [a, b, c, d]
          (%i2) listify (F ({a, b, c, d}));
          (%o2)                    F({a, b, c, d})

 -- Função: lreduce (<F>, <s>)
 -- Função: lreduce (<F>, <s>, <s_0>)

     Extende a função de dois operadores <F> para uma função de 'n'
     operadores usando composição, onde <s> é uma lista.

     'lreduce(<F>, <s>)' returns 'F(... F(F(s_1, s_2), s_3), ... s_n)'.
     Quando o argumento opcional <s_0> estiver presente, o resultado é
     equivalente a 'lreduce(<F>, cons(<s_0>, <s>))'.

     A função <F> é primeiramente aplicada à lista de elementos leftmost
     - mais à esquerda, daí o nome "lreduce".

     Veja também 'rreduce', 'xreduce', e 'tree_reduce'.

     Exemplos:

     'lreduce' sem o argumento opcional.

          (%i1) lreduce (f, [1, 2, 3]);
          (%o1)                     f(f(1, 2), 3)
          (%i2) lreduce (f, [1, 2, 3, 4]);
          (%o2)                  f(f(f(1, 2), 3), 4)

     'lreduce' com o argumento opcional.

          (%i1) lreduce (f, [1, 2, 3], 4);
          (%o1)                  f(f(f(4, 1), 2), 3)

     'lreduce' aplicada a operadores de dois argumentos internos (já
     definidos por padrão) do Maxima.  '/' é o operador de divisão.

          (%i1) lreduce ("^", args ({a, b, c, d}));
                                         b c d
          (%o1)                       ((a ) )
          (%i2) lreduce ("/", args ({a, b, c, d}));
                                          a
          (%o2)                         -----
                                        b c d

 -- Função: makeset (<expr>, <x>, <s>)

     Retorna um conjunto com elementos gerados a partir da expressão
     <expr>, onde <x> é uma lista de variáveis em <expr>, e <s>é um
     conjunto ou lista de listas.  Para gerar cada elemento do conjunto,
     <expr> é avaliada com as variáveis <x> paralelamente a um elemento
     de <s>.

     Cada elemento de <s> deve ter o mesmo comprimento que <x>.  A lista
     de variáveis <x> deve ser uma lista de símbolos, sem subscritos.
     Mesmo se existir somente um símbolo, <x> deve ser uma lista de um
     elemento, e cada elemento de <s> deve ser uma lista de um elemento.

     Veja também 'makelist'.

     Exemplos:

          (%i1) makeset (i/j, [i, j], [[1, a], [2, b], [3, c], [4, d]]);
                                     1  2  3  4
          (%o1)                     {-, -, -, -}
                                     a  b  c  d
          (%i2) S : {x, y, z}$
          (%i3) S3 : cartesian_product (S, S, S);
          (%o3) {[x, x, x], [x, x, y], [x, x, z], [x, y, x], [x, y, y],
          [x, y, z], [x, z, x], [x, z, y], [x, z, z], [y, x, x],
          [y, x, y], [y, x, z], [y, y, x], [y, y, y], [y, y, z],
          [y, z, x], [y, z, y], [y, z, z], [z, x, x], [z, x, y],
          [z, x, z], [z, y, x], [z, y, y], [z, y, z], [z, z, x],
          [z, z, y], [z, z, z]}
          (%i4) makeset (i + j + k, [i, j, k], S3);
          (%o4) {3 x, 3 y, y + 2 x, 2 y + x, 3 z, z + 2 x, z + y + x,
                                                 z + 2 y, 2 z + x, 2 z + y}
          (%i5) makeset (sin(x), [x], {[1], [2], [3]});
          (%o5)               {sin(1), sin(2), sin(3)}

 -- Função: moebius (<n>)

     Representa a função de Moebius.

     Quando <n> for o produto de k primos distintos, 'moebius(<n>)'
     simplifica para (-1)^k; quando <n> = 1, simplifica para 1; e
     simplifica para 0 para todos os outros inteiros positivos.

     'moebius' distribui sobre equações, listas, matrizes, e conjuntos.

     Exemplos:

          (%i1) moebius (1);
          (%o1)                           1
          (%i2) moebius (2 * 3 * 5);
          (%o2)                          - 1
          (%i3) moebius (11 * 17 * 29 * 31);
          (%o3)                           1
          (%i4) moebius (2^32);
          (%o4)                           0
          (%i5) moebius (n);
          (%o5)                      moebius(n)
          (%i6) moebius (n = 12);
          (%o6)                    moebius(n) = 0
          (%i7) moebius ([11, 11 * 13, 11 * 13 * 15]);
          (%o7)                      [- 1, 1, 1]
          (%i8) moebius (matrix ([11, 12], [13, 14]));
                                     [ - 1  0 ]
          (%o8)                      [        ]
                                     [ - 1  1 ]
          (%i9) moebius ({21, 22, 23, 24});
          (%o9)                      {- 1, 0, 1}

 -- Função: multinomial_coeff (<a_1>, ..., <a_n>)
 -- Função: multinomial_coeff ()

     Retorna o coeficiente multinomial.

     Quando cada <a_k> for um inteiro não negativo, o coeficiente
     multinomial fornece o número de formas possíveis de colocar '<a_1>
     + ... + <a_n>' objetos distintos em n caixas com <a_k> elementos na
     k'ésima caixa.  Em geral, 'multinomial_coeff (<a_1>, ..., <a_n>)'
     avalia para '(<a_1> + ... + <a_n>)!/(<a_1>! ... <a_n>!)'.

     'multinomial_coeff()' (sem argumentos) avalia para 1.

     'minfactorial' pode estar apta a simplificar o valor retornado por
     'multinomial_coeff'.

     Exemplos:

          (%i1) multinomial_coeff (1, 2, x);
                                      (x + 3)!
          (%o1)                       --------
                                        2 x!
          (%i2) minfactorial (%);
                               (x + 1) (x + 2) (x + 3)
          (%o2)                -----------------------
                                          2
          (%i3) multinomial_coeff (-6, 2);
                                       (- 4)!
          (%o3)                       --------
                                      2 (- 6)!
          (%i4) minfactorial (%);
          (%o4)                          10

 -- Função: num_distinct_partitions (<n>)
 -- Função: num_distinct_partitions (<n>, list)

     Retorna o n;umero de partições de inteiros distintos de <n> quando
     <n> for um inteiro não negativo.  De outra forma,
     'num_distinct_partitions' retorna uma expressão substantiva.

     'num_distinct_partitions(<n>, list)' retorna uma lista do número de
     partições distintas de 1, 2, 3, ..., <n>.

     Uma partição distinta de <n> é uma lista de inteiros positivos
     distintos k_1, ..., k_m tais que <n> = k_1 + ... + k_m.

     Exemplos:

          (%i1) num_distinct_partitions (12);
          (%o1)                          15
          (%i2) num_distinct_partitions (12, list);
          (%o2)      [1, 1, 1, 2, 2, 3, 4, 5, 6, 8, 10, 12, 15]
          (%i3) num_distinct_partitions (n);
          (%o3)              num_distinct_partitions(n)

 -- Função: num_partitions (<n>)
 -- Função: num_partitions (<n>, list)

     Retorna o número das partições inteiras de <n> quando <n> for um
     inteiro não negativo.  De outra forma, 'num_partitions' retorna uma
     expressão substantiva.

     'num_partitions(<n>, list)' retorna uma lista do número de
     partições inteiras de 1, 2, 3, ..., <n>.

     Para um inteiro não negativo <n>, 'num_partitions(<n>)' é igual a
     'cardinality(integer_partitions(<n>))'; todavia, 'num_partitions'
     não constrói atualmente o conjunto das partições, nesse sentido
     'num_partitions' é mais rápida.

     Exemplos:

          (%i1) num_partitions (5) = cardinality (integer_partitions (5));
          (%o1)                         7 = 7
          (%i2) num_partitions (8, list);
          (%o2)            [1, 1, 2, 3, 5, 7, 11, 15, 22]
          (%i3) num_partitions (n);
          (%o3)                   num_partitions(n)

 -- Função: partition_set (<a>, <f>)

     Partições do conjunto <a> que satisfazem o predicado <f>.

     'partition_set' retorna uma lista de dois conjuntos.  O primeiro
     conjunto compreende os elementos de <a> para os quais <f> avalia
     para 'false', e o segundo conjunto compreende quaisquer outros
     elementos de <a>.  'partition_set' não aplica 'is' ao valor de
     retorno de <f>.

     'partition_set' reclama se <a> não for um conjunto literal.

     Veja também 'subset'.

     Exemplos:

          (%i1) partition_set ({2, 7, 1, 8, 2, 8}, evenp);
          (%o1)                   [{1, 7}, {2, 8}]
          (%i2) partition_set ({x, rat(y), rat(y) + z, 1}, lambda ([x], ratp(x)));
          (%o2)/R/              [{1, x}, {y, y + z}]

 -- Função: permutations (<a>)

     Retorna um conjunto todas as permutações distintas dos elementos da
     lista ou do conjunto <a>.  Cada permutação é uma lista, não um
     conjunto.

     Quando <a> for uma lista, elementos duplicados de <a> são incluídos
     nas permutações.

     'permutations' reclama se <a> não for um conjunto literal ou uma
     lista literal.

     Veja também 'random_permutation'.

     Exemplos:

          (%i1) permutations ([a, a]);
          (%o1)                       {[a, a]}
          (%i2) permutations ([a, a, b]);
          (%o2)           {[a, a, b], [a, b, a], [b, a, a]}

 -- Função: powerset (<a>)
 -- Função: powerset (<a>, <n>)

     Retorna o conjunto de todos os dubconjuntos de <a>, ou um
     subconjunto de <a>.

     'powerset(<a>)' retorna o conjunto de todos os subconjuntos do
     conjunto <a>.  'powerset(<a>)' tem '2^cardinality(<a>)' elementos.

     'powerset(<a>, <n>)' retorna o conjunto de todos os subconjuntos de
     <a> que possuem cardinalidade <n>.

     'powerset' reclama se <a> não for um conjunto literal, ou se <n>
     não for um inteiro não negativo.

     Exemplos:

          (%i1) powerset ({a, b, c});
          (%o1) {{}, {a}, {a, b}, {a, b, c}, {a, c}, {b}, {b, c}, {c}}
          (%i2) powerset ({w, x, y, z}, 4);
          (%o2)                    {{w, x, y, z}}
          (%i3) powerset ({w, x, y, z}, 3);
          (%o3)     {{w, x, y}, {w, x, z}, {w, y, z}, {x, y, z}}
          (%i4) powerset ({w, x, y, z}, 2);
          (%o4)   {{w, x}, {w, y}, {w, z}, {x, y}, {x, z}, {y, z}}
          (%i5) powerset ({w, x, y, z}, 1);
          (%o5)                 {{w}, {x}, {y}, {z}}
          (%i6) powerset ({w, x, y, z}, 0);
          (%o6)                         {{}}

 -- Função: random_permutation (<a>)

     Retorna uma permutação aleatória do conjunto ou da lista <a>, como
     construído pelo algorítimo de embaralhar desenvolvido por Knuth.

     O valor de retorno é uma nova lista, que é diferente da
     lista/conjunto original podendo inclusive ser a propria lista
     repetida.  Todavia, os elementos do argumento não são copiados.

     Exemplos:

          (%i1) random_permutation ([a, b, c, 1, 2, 3]);
          (%o1)                  [c, 1, 2, 3, a, b]
          (%i2) random_permutation ([a, b, c, 1, 2, 3]);
          (%o2)                  [b, 3, 1, c, a, 2]
          (%i3) random_permutation ({x + 1, y + 2, z + 3});
          (%o3)                 [y + 2, z + 3, x + 1]
          (%i4) random_permutation ({x + 1, y + 2, z + 3});
          (%o4)                 [x + 1, y + 2, z + 3]

 -- Função: rreduce (<F>, <s>)
 -- Função: rreduce (<F>, <s>, <s_{n + 1}>)

     Extende a função de dois argumentos <F> para uma função de <n>
     argumentos usando composição de funções, onde <s> é uma lista.

     'rreduce(<F>, <s>)' retorna 'F(s_1, ... F(s_{n - 2}, F(s_{n - 1},
     s_n)))'.  Quando o argumetno opcional <s_{n + 1}> estiver presente,
     o resultado é equivalente a 'rreduce(<F>, endcons(<s_{n + 1}>,
     <s>))'.

     A função <F> é primeiro aplicada à lista de elementos mais à
     direita - rightmost, daí o nome "rreduce".

     Veja também 'lreduce', 'tree_reduce', e 'xreduce'.

     Exemplos:

     'rreduce' sem o argumento opcional.

          (%i1) rreduce (f, [1, 2, 3]);
          (%o1)                     f(1, f(2, 3))
          (%i2) rreduce (f, [1, 2, 3, 4]);
          (%o2)                  f(1, f(2, f(3, 4)))

     'rreduce' com o argumetno opcional.

          (%i1) rreduce (f, [1, 2, 3], 4);
          (%o1)                  f(1, f(2, f(3, 4)))

     'rreduce' aplicada a operadores de dois argumentos internos (
     definidos por padrão) ao Maxima.  '/' é o operadro de divisão.

          (%i1) rreduce ("^", args ({a, b, c, d}));
                                           d
                                          c
                                         b
          (%o1)                         a
          (%i2) rreduce ("/", args ({a, b, c, d}));
                                         a c
          (%o2)                          ---
                                         b d

 -- Função: setdifference (<a>, <b>)

     Retorna um conjunto contendo os elementos no conjunto <a> que não
     estãono conjunto <b>.

     'setdifference' reclama se ou <a> ou <b> não for um conjunto
     literal.

     Exemplos:

          (%i1) S_1 : {a, b, c, x, y, z};
          (%o1)                  {a, b, c, x, y, z}
          (%i2) S_2 : {aa, bb, c, x, y, zz};
          (%o2)                 {aa, bb, c, x, y, zz}
          (%i3) setdifference (S_1, S_2);
          (%o3)                       {a, b, z}
          (%i4) setdifference (S_2, S_1);
          (%o4)                     {aa, bb, zz}
          (%i5) setdifference (S_1, S_1);
          (%o5)                          {}
          (%i6) setdifference (S_1, {});
          (%o6)                  {a, b, c, x, y, z}
          (%i7) setdifference ({}, S_1);
          (%o7)                          {}

 -- Função: setequalp (<a>, <b>)

     Retorna 'true' se os conjuntos <a> e <b> possuirem o mesmo número
     de elementos e 'is(<x> = <y>)' for 'true' para 'x' nos elementos de
     <a> e 'y' nos elementos de <b>, considerados na ordem determinada
     por 'listify'.  De outra forma, 'setequalp' retorna 'false'.

     Exemplos:

          (%i1) setequalp ({1, 2, 3}, {1, 2, 3});
          (%o1)                         true
          (%i2) setequalp ({a, b, c}, {1, 2, 3});
          (%o2)                         false
          (%i3) setequalp ({x^2 - y^2}, {(x + y) * (x - y)});
          (%o3)                         false

 -- Função: setify (<a>)

     Constrói um conjunto de elementos a partir da lista <a>.  Elementos
     duplicados da lista <a> são apagados e os elementos são ordenados
     de acordo com o predicado 'orderlessp'.

     'setify' reclama se <a> não for uma lista literal.

     Exemplos:

          (%i1) setify ([1, 2, 3, a, b, c]);
          (%o1)                  {1, 2, 3, a, b, c}
          (%i2) setify ([a, b, c, a, b, c]);
          (%o2)                       {a, b, c}
          (%i3) setify ([7, 13, 11, 1, 3, 9, 5]);
          (%o3)                {1, 3, 5, 7, 9, 11, 13}

 -- Função: setp (<a>)

     Retorna 'true' se e somente se <a> for um conjunto na interpretação
     do Maxima.

     'setp' retorna 'true' para conjuntos não simplificados (isto é,
     conjuntos com elementos redundantes) e também para conjuntos
     simplificados.

     'setp' é equivalente à função do Maxima 'setp(a) := not atom(a) and
     op(a) = 'set'.

     Exemplos:

          (%i1) simp : false;
          (%o1)                         false
          (%i2) {a, a, a};
          (%o2)                       {a, a, a}
          (%i3) setp (%);
          (%o3)                         true

 -- Função: set_partitions (<a>)
 -- Função: set_partitions (<a>, <n>)

     Retorna o conjunto de todas as partições de <a>, ou um subconjunto
     daquele conjunto de partições.

     'set_partitions(<a>, <n>)' retorna um conjunto de todas as
     decomposições de <a> em <n> subconjutnos disjuntos não vazios.

     'set_partitions(<a>)' retorna o conjunto de todas as partições.

     'stirling2' retorna a cardinalidade de um conjuntode partições de
     um conjunto.

     Um conjunto de conjuntos P é uma partição de um conjunto S quando

       1. cada elemento de P é um conjunto não vazio,
       2. elementos distintos de P são disjuntos,
       3. a união dos elementos de P é igual a S.

     Exemplos:

     O conjunto vazio é uma partição de si mesmo, as ondições 1 e 2 são
     "vaziamente" verdadeiras.

          (%i1) set_partitions ({});
          (%o1)                         {{}}

     A cardinalidade do conjunto de partições de um conjunto pode ser
     encontrada usando 'stirling2'.

          (%i1) s: {0, 1, 2, 3, 4, 5}$
          (%i2) p: set_partitions (s, 3)$
          (%i3) cardinality(p) = stirling2 (6, 3);
          (%o3)                        90 = 90

     Cada elemento de 'p' pode ter <n> = 3 elementos; vamos verificar.

          (%i1) s: {0, 1, 2, 3, 4, 5}$
          (%i2) p: set_partitions (s, 3)$
          (%i3) map (cardinality, p);
          (%o3)                          {3}

     Finalmente, para cada elementos de 'p', a união de seus elementos
     possivelmente será igua a 's'; novamente vamos comprovar.

          (%i1) s: {0, 1, 2, 3, 4, 5}$
          (%i2) p: set_partitions (s, 3)$
          (%i3) map (lambda ([x], apply (union, listify (x))), p);
          (%o3)                 {{0, 1, 2, 3, 4, 5}}

 -- Função: some (<f>, <a>)
 -- Função: some (<f>, <L_1>, ..., <L_n>)

     Retorna 'true' se o predicado <f> for 'true' para um ou mais
     argumentos dados.

     Given one set as the second argument, 'some(<f>, <s>)' returns
     'true' if 'is(<f>(<a_i>))' returns 'true' for one or more <a_i> in
     <s>.  'some' may or may not evaluate <f> for all <a_i> in <s>.
     Since sets are unordered, 'some' may evaluate '<f>(<a_i>)' in any
     order.

     Dadas uma ou mais listas como argumentos, 'some(<f>, <L_1>, ...,
     <L_n>)' retorna 'true' se 'is(<f>(<x_1>, ..., <x_n>))' retornar
     'true' para um ou mais <x_1>, ..., <x_n> em <L_1>, ..., <L_n>,
     respectivamente.  'some' pode ou não avaliar <f> para algumas
     combinações <x_1>, ..., <x_n>.  'some' avalia listas na ordem do
     índice de incremento.

     Dado um conjunto vazio '{}' ou uma lista vazia '[]' como
     argumentos, 'some' retorna 'false'.

     Quando o sinalizador global 'maperror' for 'true', todas as listas
     <L_1>, ..., <L_n> devem ter obrigatóriamente comprimentos iguais.
     Quando 'maperror' for 'false', argumentos do tipo lista são
     efetivamente truncados para o comprimento da menor lista.

     Retorna o valor de um predicado <f> o qual avalia (por meio de
     'is') para alguma coisa outra que não 'true' ou 'false' e são
     governados pelo sinalizador global 'prederror'.  Quando 'prederror'
     for 'true', tais valores são tratados como 'false'.  Quando
     'prederror' for 'false', tais valores são tratados como 'unknown'
     (desconhecidos).

     Exemplos:

     'some' aplicado a um conjunto simples.  O predicado é uma função de
     um argumento.

          (%i1) some (integerp, {1, 2, 3, 4, 5, 6});
          (%o1)                         true
          (%i2) some (atom, {1, 2, sin(3), 4, 5 + y, 6});
          (%o2)                         true

     'some' aplicada a duas listas.  O predicado é uma função de dois
     argumentos.

          (%i1) some ("=", [a, b, c], [a, b, c]);
          (%o1)                         true
          (%i2) some ("#", [a, b, c], [a, b, c]);
          (%o2)                         false

     Retorna o valor do predicado <f> o qual avalia para alguma coisa
     que não 'true' ou 'false' e são governados através do sinalizador
     global 'prederror'.

          (%i1) prederror : false;
          (%o1)                         false
          (%i2) map (lambda ([a, b], is (a < b)), [x, y, z], [x^2, y^2, z^2]);
          (%o2)              [unknown, unknown, unknown]
          (%i3) some ("<", [x, y, z], [x^2, y^2, z^2]);
          (%o3)                        unknown
          (%i4) some ("<", [x, y, z], [x^2, y^2, z + 1]);
          (%o4)                         true
          (%i5) prederror : true;
          (%o5)                         true
          (%i6) some ("<", [x, y, z], [x^2, y^2, z^2]);
          (%o6)                         false
          (%i7) some ("<", [x, y, z], [x^2, y^2, z + 1]);
          (%o7)                         true

 -- Função: stirling1 (<n>, <m>)

     Representa o número de Stirling de primeiro tipo.

     Quando <n> e <m> forem não negativos inteiros, a magnitude de
     'stirling1 (<n>, <m>)' é o número de permutações de um conjunto com
     <n> elementos que possui <m> ciclos.  Para detalhes, veja Graham,
     Knuth e Patashnik Concrete Mathematics.  Maxima utiliza uma relação
     recursiva para definir 'stirling1 (<n>, <m>)' para <m> menor que 0;
     'stirling1' não é definida para <n> menor que 0 e para argumetnos
     não inteiros.

     'stirling1' é uma função de simplificação.  Maxima conhece as
     seguintes identidades:

       1. stirling1(0, n) = kron_delta(0, n) (Ref.  [1])
       2. stirling1(n, n) = 1 (Ref.  [1])
       3. stirling1(n, n - 1) = binomial(n, 2) (Ref.  [1])
       4. stirling1(n + 1, 0) = 0 (Ref.  [1])
       5. stirling1(n + 1, 1) = n! (Ref.  [1])
       6. stirling1(n + 1, 2) = 2^n - 1 (Ref.  [1])

     Essas identidades são aplicadas quando os argumentos forem inteiros
     literais ou símbolos declarados como inteiros, e o primeiro
     argumento for não negativo.  'stirling1' não simplififca para
     argumentos não inteiros.

     Referências:

     [1] Donald Knuth, The Art of Computer Programming, terceira edição,
     Volume 1, Seção 1.2.6, Equações 48, 49, e 50.

     Exemplos:

          (%i1) declare (n, integer)$
          (%i2) assume (n >= 0)$
          (%i3) stirling1 (n, n);
          (%o3)                           1

     'stirling1' não simplifica para argumentos não inteiros.

          (%i1) stirling1 (sqrt(2), sqrt(2));
          (%o1)              stirling1(sqrt(2), sqrt(2))

     Maxima aplica identidades a 'stirling1'.

          (%i1) declare (n, integer)$
          (%i2) assume (n >= 0)$
          (%i3) stirling1 (n + 1, n);
                                      n (n + 1)
          (%o3)                       ---------
                                          2
          (%i4) stirling1 (n + 1, 1);
          (%o4)                          n!

 -- Função: stirling2 (<n>, <m>)

     Representa o número de Stirling de segundo tipo.

     Quando <n> e <m> forem inteiros não negativos, 'stirling2 (<n>,
     <m>)' é o número de maneiras através dos quais um conjunto com
     cardinalidade <n> pode ser particionado em <m> subconjuntos
     disjuntos.  Maxima utiliza uma relação recursiva para definir
     'stirling2 (<n>, <m>)' para <m> menor que 0; 'stirling2' é
     indefinida para <n> menor que 0 e para argumentos não inteiros.

     'stirling2' é uma função de simplificação.  Maxima conhece as
     seguintes identidades.

       1. stirling2(0, n) = kron_delta(0, n) (Ref.  [1])
       2. stirling2(n, n) = 1 (Ref.  [1])
       3. stirling2(n, n - 1) = binomial(n, 2) (Ref.  [1])
       4. stirling2(n + 1, 1) = 1 (Ref.  [1])
       5. stirling2(n + 1, 2) = 2^n - 1 (Ref.  [1])
       6. stirling2(n, 0) = kron_delta(n, 0) (Ref.  [2])
       7. stirling2(n, m) = 0 when m > n (Ref.  [2])
       8. stirling2(n, m) = sum((-1)^(m - k) binomial(m k) k^n,i,1,m) /
          m! onde m e n são inteiros, e n é não negativo.  (Ref.  [3])

     Essas identidades são aplicadas quando os argumentos forem inteiros
     literais ou símbolos declarados como inteiros, e o primeiro
     argumento for não negativo.  'stirling2' não simplifica para
     argumentos não inteiros.

     Referências:

     [1] Donald Knuth.  The Art of Computer Programming, terceira
     edição, Volume 1, Seção 1.2.6, Equações 48, 49, e 50.

     [2] Graham, Knuth, e Patashnik.  Concrete Mathematics, Tabela 264.

     [3] Abramowitz e Stegun.  Handbook of Mathematical Funçãos, Seção
     24.1.4.

     Exemplos:

          (%i1) declare (n, integer)$
          (%i2) assume (n >= 0)$
          (%i3) stirling2 (n, n);
          (%o3)                           1

     'stirling2' não simplifica para argumentos não inteiros.

          (%i1) stirling2 (%pi, %pi);
          (%o1)                  stirling2(%pi, %pi)

     Maxima aplica identidades a 'stirling2'.

          (%i1) declare (n, integer)$
          (%i2) assume (n >= 0)$
          (%i3) stirling2 (n + 9, n + 8);
                                   (n + 8) (n + 9)
          (%o3)                    ---------------
                                          2
          (%i4) stirling2 (n + 1, 2);
                                        n
          (%o4)                        2  - 1

 -- Função: subset (<a>, <f>)

     Retorna o subconjuntode um conjunto <a> que satisfaz o predicado
     <f>.

     'subset' returns um conjunto which comprises the elements of <a>
     for which <f> returns anything other than 'false'.  'subset' does
     not apply 'is' to the return value of <f>.

     'subset' reclama se <a> não for um conjunto literal.

     See also 'partition_set'.

     Exemplos:

          (%i1) subset ({1, 2, x, x + y, z, x + y + z}, atom);
          (%o1)                     {1, 2, x, z}
          (%i2) subset ({1, 2, 7, 8, 9, 14}, evenp);
          (%o2)                      {2, 8, 14}

 -- Função: subsetp (<a>, <b>)

     Retorna 'true' se e somente se o conjunto <a> for um subconjunto de
     <b>.

     'subsetp' reclama se ou <a> ou <b> não forem um conjunto literal.

     Exemplos:

          (%i1) subsetp ({1, 2, 3}, {a, 1, b, 2, c, 3});
          (%o1)                         true
          (%i2) subsetp ({a, 1, b, 2, c, 3}, {1, 2, 3});
          (%o2)                         false

 -- Função: symmdifference (<a_1>, ..., <a_n>)

     Retorna a diferença simétrica, isto é, o conjunto dos elemetnos que
     ocorrem em exatamente um conjunto <a_k>.

     Given two arguments, 'symmdifference(<a>, <b>)' is the same as
     'union(setdifference(<a>, <b>), setdifference(<b>, <a>))'.

     'symmdifference' reclama se any argument não for um conjunto
     literal.

     Exemplos:

          (%i1) S_1 : {a, b, c};
          (%o1)                       {a, b, c}
          (%i2) S_2 : {1, b, c};
          (%o2)                       {1, b, c}
          (%i3) S_3 : {a, b, z};
          (%o3)                       {a, b, z}
          (%i4) symmdifference ();
          (%o4)                          {}
          (%i5) symmdifference (S_1);
          (%o5)                       {a, b, c}
          (%i6) symmdifference (S_1, S_2);
          (%o6)                        {1, a}
          (%i7) symmdifference (S_1, S_2, S_3);
          (%o7)                        {1, z}
          (%i8) symmdifference ({}, S_1, S_2, S_3);
          (%o8)                        {1, z}

 -- Função: tree_reduce (<F>, <s>)
 -- Função: tree_reduce (<F>, <s>, <s_0>)

     Extende a função binária <F> a uma função enária através de
     composição, onde <s> é um conjunto ou uma lista.

     'tree_reduce' é equivalente ao seguinte: Aplicar <F> a sucessivos
     pares de elementos para formar uma nova lista '[<F>(<s_1>, <s_2>),
     <F>(<s_3>, <s_4>), ...]', mantendo o elemento final inalterado caso
     haja um número ímpar de elementos.  Repetindo então o processo até
     que a lista esteja reduzida a um elemento simples, o qual é o valor
     de retorno da função.

     Quando o argumento opcional <s_0> estiver presente, o resultado é
     equivalente a 'tree_reduce(<F>, cons(<s_0>, <s>)'.

     Para adições em ponto flutuante, 'tree_reduce' pode retornar uma
     soma que possui um menor ero de arredondamento que 'rreduce' ou
     'lreduce'.

     Os elementos da lista <s> e os resultados parciais podem ser
     arranjados em uma árvore binária de profundidade mínima, daí o nome
     "tree_reduce".

     Exemplos:

     'tree_reduce' aplicada a uma lista com um número par de elementos.

          (%i1) tree_reduce (f, [a, b, c, d]);
          (%o1)                  f(f(a, b), f(c, d))

     'tree_reduce' aplicada a uma lista com um número ímpar de
     elementos.

          (%i1) tree_reduce (f, [a, b, c, d, e]);
          (%o1)               f(f(f(a, b), f(c, d)), e)

 -- Função: union (<a_1>, ..., <a_n>)
     Retorna a união dos conjuntos de <a_1> a <a_n>.

     'union()' (sem argumentos) retorna o conjunto vazio.

     'union' reclama se qualquer argumento não for um conjunto literal.

     Exemplos:

          (%i1) S_1 : {a, b, c + d, %e};
          (%o1)                   {%e, a, b, d + c}
          (%i2) S_2 : {%pi, %i, %e, c + d};
          (%o2)                 {%e, %i, %pi, d + c}
          (%i3) S_3 : {17, 29, 1729, %pi, %i};
          (%o3)                {17, 29, 1729, %i, %pi}
          (%i4) union ();
          (%o4)                          {}
          (%i5) union (S_1);
          (%o5)                   {%e, a, b, d + c}
          (%i6) union (S_1, S_2);
          (%o6)              {%e, %i, %pi, a, b, d + c}
          (%i7) union (S_1, S_2, S_3);
          (%o7)       {17, 29, 1729, %e, %i, %pi, a, b, d + c}
          (%i8) union ({}, S_1, S_2, S_3);
          (%o8)       {17, 29, 1729, %e, %i, %pi, a, b, d + c}

 -- Função: xreduce (<F>, <s>)
 -- Função: xreduce (<F>, <s>, <s_0>)

     Extendendo a função <F> para uma função enária por composição, ou,
     se <F> já for enária, aplica-se <F> a <s>.  Quando <F> não for
     enária, 'xreduce' funciona da mesma forma que 'lreduce'.  O
     argumento <s> é uma lista.

     Funções sabidamente enárias inclui adição '+', multiplicação '*',
     'and', 'or', 'max', 'min', e 'append'.  Funções podem também serem
     declaradas enárias por meio de 'declare(<F>, nary)'.  Para essas
     funções, é esperado que 'xreduce' seja mais rápida que ou 'rreduce'
     ou 'lreduce'.

     Quando o argumento opcional <s_0> estiver presente, o resultado é
     equivalente a 'xreduce(<s>, cons(<s_0>, <s>))'.

     Adições em ponto flutuante não são exatamente associativas; quando
     a associatividade ocorrer, 'xreduce' aplica a adição enária do
     Maxima quando <s> contiver números em ponto flutuante.

     Exemplos:

     'xreduce' aplicada a uma função sabidamente enária.  'F' é chamada
     uma vez, com todos os argumentos.

          (%i1) declare (F, nary);
          (%o1)                         done
          (%i2) F ([L]) := L;
          (%o2)                      F([L]) := L
          (%i3) xreduce (F, [a, b, c, d, e]);
          (%o3)         [[[[[("[", simp), a], b], c], d], e]

     'xreduce' aplicada a uma função não sabidamente enária.  'G' é
     chamada muitas vezes, com dois argumentos de cada vez.

          (%i1) G ([L]) := L;
          (%o1)                      G([L]) := L
          (%i2) xreduce (G, [a, b, c, d, e]);
          (%o2)         [[[[[("[", simp), a], b], c], d], e]
          (%i3) lreduce (G, [a, b, c, d, e]);
          (%o3)                 [[[[a, b], c], d], e]


File: maxima.info,  Node: Definição de Função,  Next: Fluxo de Programa,  Prev: Conjuntos,  Up: Top

39 Definição de Função
**********************

* Menu:

* Introdução a Definição de Função::
* Função::
* Macros::
* Funções e Variáveis para Definição de Função::


File: maxima.info,  Node: Introdução a Definição de Função,  Next: Função,  Prev: Definição de Função,  Up: Definição de Função

39.1 Introdução a Definição de Função
=====================================


File: maxima.info,  Node: Função,  Next: Macros,  Prev: Introdução a Definição de Função,  Up: Definição de Função

39.2 Função
===========

39.2.1 Ordinary functions
-------------------------

Para definir uma função no Maxima você usa o operador ':='.  E.g.

     f(x) := sin(x)

define uma função 'f'.  Funções anônimas podem também serem criadas
usando 'lambda'.  Por exemplo

     lambda ([i, j], ...)

pode ser usada em lugar de 'f' onde

     f(i,j) := block ([], ...);
     map (lambda ([i], i+1), l)

retornará uma lista com 1 adicionado a cada termo.

   Você pode também definir uma função com um número variável de
argumentos, teno um argumento final que é atribuído para uma lista de
argumentos extras:

     (%i1) f ([u]) := u;
     (%o1)                      f([u]) := u
     (%i2) f (1, 2, 3, 4);
     (%o2)                     [1, 2, 3, 4]
     (%i3) f (a, b, [u]) := [a, b, u];
     (%o3)               f(a, b, [u]) := [a, b, u]
     (%i4) f (1, 2, 3, 4, 5, 6);
     (%o4)                 [1, 2, [3, 4, 5, 6]]

   O lado direito de uma função é uma expressão.  Desse modo Se você
quer uma seqüência de expressões, você faz

     f(x) := (expr1, expr2, ...., exprn);

   e o valor de <exprn> é que é retornado pela função.

   Se você deseja fazer um 'return' de alguma expressão dentro da função
então você deve usar 'block' e 'return'.

     block ([], expr1, ..., if (a > 10) then return(a), ..., exprn)

   é em si mesma uma expressão, e então poderá ocupar o lugar do lado
direito de uma definição de função.  Aqui pode acontecer que o retorno
aconteça mais facilmente que no exemplo anterior a essa última
expressão.

   O primeiro '[]' no bloco, pode conter uma lista de variáveis e
atribuições de variáveis, tais como '[a: 3, b, c: []]', que farão com
que as três variáveis 'a','b',e 'c' não se refiram a seus valores
globais, mas ao contrário tenham esses valores especiais enquanto o
código estiver executando a parte dentro do bloco 'block', ou dentro da
funções chamadas de dentro do bloco 'block'.  Isso é chamado associação
dynamic, uma vez que as variáveis permanecem do início do bloco pelo
tempo que ele existir.  Uma vez que você retorna do 'block', ou
descarta-o, os valores antigos (quaisquer que sejam) das variáveis serão
restaurados.  É certamente uma boa idéia para proteger suas variáveis
nesse caminho.  Note que as atribuições em variáveis do bloco, são
concluídas em paralelo.  Isso significa, que se tiver usado 'c: a'
acima, o valor de 'c' será o valor de 'a' a partir do momento em que
vocêntrou no bloco, mas antes 'a' foi associado.  Dessa forma fazendo
alguma coisa como

     block ([a: a], expr1, ...  a: a+3, ..., exprn)

   protegerá o valor externo de 'a' de ser alterado, mas impedirá você
acessar o valor antigo.  Dessa forma o lado direito de atribuições, é
avaliado no contexto inserido, antes que qualquer avaliação ocorra.
Usando apenas 'block ([x], ...' faremos com que o 'x' tenha a si mesmo
como valor, apenas como x teria se você tivesse entrado numa breve
sessão do Maxima.

   Os atuais argumentos para uma função são tratados exatamente da mesma
que as variáveis em um bloco.  Dessa forma em

     f(x) := (expr1, ..., exprn);

   e

     f(1);

   teremos um contexto similar para avaliação de expressões como se
tivéssemos concluído

     block ([x: 1], expr1, ..., exprn)

   Dentro de funções, quando o lado direito de uma definição, pode ser
calculado em tempo de execução, isso é úti para usar 'define' e
possivelmente 'buildq'.

39.2.2 Função de Array
----------------------

Uma função de Array armazena o valor da função na primeira vez que ela
for chamada com um argumento dado, e retorna o valor armazenado, sem
recalcular esse valor, quando o mesmo argumento for fornecido.  De modo
que uma função é muitas vezes chamada uma função de memorização.

   Nomes de funções de Array são anexados ao final da lista global
'arrays' (não na lista global 'functions').  O comando 'arrayinfo'
retorna a lista de argumentos para os quais exite valores armazenados, e
'listarray' retorna os valores armazenados.  Os comandos 'dispfun' e
'fundef' retornam a definição da função de array.

   O comando 'arraymake' contrói uma chamada de função de array,
análogamente a 'funmake' para funções comuns.  O comando 'arrayapply'
aplica uma função de array a seus argmentos, análogamente a 'apply' para
funções comuns.  Não existe nada exatamente análogo a 'map' para funções
de array, embora 'map(lambda([<x>], <a>[<x>]), <L>)' ou
'makelist(<a>[<x>], <x>, <L>)', onde <L> é uma lista, não estejam tão
longe disso.

   O comando 'remarray' remove uma definição de função de array
(incluindo qualquer valor armazenado pela função removida), análogo a
'remfunction' para funções comuns.

   o comando 'kill(<a>[<x>])' remove o valor da função de array <a>
armazenado para o argumento <x>; a próxima vez que <a> foor chamada com
o argumento <x>, o valor da função é recomputado.  Todavia, não exite
caminho para remover todos os valores armazenados de uma vez, exceto
para 'kill(<a>)' ou 'remarray(<a>)', o qual remove também remove a
definição da função de array.


File: maxima.info,  Node: Macros,  Next: Funções e Variáveis para Definição de Função,  Prev: Função,  Up: Definição de Função

39.3 Macros
===========

 -- Função: buildq (<L>, <expr>)
     Substitue variáveis nomeadas pela lista <L> dentro da expressão
     <expr>, paralelamente, sem avaliar <expr>.  A expressão resultante
     é simplificada, mas não avaliada, após 'buildq' realizar a
     substituição.

     Os elementos de <L> são símbolos ou expressões de atribuição
     '<símbolo>: <valor>', avaliadas paralelamente.  Isto é, a
     associação de uma variável sobre o lado direito de uma atribuição é
     a associação daquela variável no contexto do qual 'buildq' for
     chamada, não a associação daquela variável na lista <L> de
     variáveis.  Se alguma variável em <L> não dada como uma atribuição
     explícita, sua associação em 'buildq' é a mesma que no contexto no
     qual 'buildq' for chamada.

     Então as variáveis nomeadas em <L> são substituidas em <expr>
     paralelamente.  Isto é, a substituição para cada variável é
     determinada antes que qualquer substituição seja feita, então a
     substituição para uma variável não tem efeito sobre qualquer outra.

     Se qualquer variável <x> aparecer como 'splice (<x>)' em <expr>,
     então <x> deve estar associada para uma lista, e a lista recebe uma
     aplicação da função 'splice' (é interpolada) na <expr> em lugar de
     substituída.

     Quaisquer variáveis em <expr> não aparecendo em <L> são levados no
     resultado tal como foram escritos, mesmo se elas tiverem
     associações no contexto do qual 'buildq' tiver sido chamada.

     Exemplos

     'a' é explicitamente associada a 'x', enquanto 'b' tem a mesma
     associação (nomeadamente 29) como no contexto chamado, e 'c' é
     levada do começo ao fim da forma como foi escrita.  A expressão
     resultante não é avaliada até a avaliação explícita ( com duplo
     apóstrofo - não com aspas - '''%'.

          (%i1) (a: 17, b: 29, c: 1729)$
          (%i2) buildq ([a: x, b], a + b + c);
          (%o2)                      x + c + 29
          (%i3) ''%;
          (%o3)                       x + 1758

     'e' está associado a uma lista, a qual aparece também como tal nos
     argumentos de 'foo', e interpolada nos argumentos de 'bar'.

          (%i1) buildq ([e: [a, b, c]], foo (x, e, y));
          (%o1)                 foo(x, [a, b, c], y)
          (%i2) buildq ([e: [a, b, c]], bar (x, splice (e), y));
          (%o2)                  bar(x, a, b, c, y)

     O resultado é simplificado após substituição.  Se a simplificação
     for aplicada antes da substituição, esses dois resultados podem ser
     iguais.
          (%i1) buildq ([e: [a, b, c]], splice (e) + splice (e));
          (%o1)                    2 c + 2 b + 2 a
          (%i2) buildq ([e: [a, b, c]], 2 * splice (e));
          (%o2)                        2 a b c

     As variáveis em <L> são associadas em paralelo; se associadas
     seqüêncialmente, o primeiro resultado pode ser 'foo (b, b)'.
     Substituições são realizadas em paralelo; compare o segundo
     resultado com o resultado de 'subst', que realiza substituições
     seqüêncialmente.

          (%i1) buildq ([a: b, b: a], foo (a, b));
          (%o1)                       foo(b, a)
          (%i2) buildq ([u: v, v: w, w: x, x: y, y: z, z: u], bar (u, v, w, x, y, z));
          (%o2)                 bar(v, w, x, y, z, u)
          (%i3) subst ([u=v, v=w, w=x, x=y, y=z, z=u], bar (u, v, w, x, y, z));
          (%o3)                 bar(u, u, u, u, u, u)

     Constrói uma lista de euqções com algumas variáveis ou expressões
     sobre o lado esquerdo e seus valores sobre o lado direito.
     'macroexpand' mostra a expressão retornada por 'show_values'.

          (%i1) show_values ([L]) ::= buildq ([L], map ("=", 'L, L));
          (%o1)   show_values([L]) ::= buildq([L], map("=", 'L, L))
          (%i2) (a: 17, b: 29, c: 1729)$
          (%i3) show_values (a, b, c - a - b);
          (%o3)          [a = 17, b = 29, c - b - a = 1683]
          (%i4) macroexpand (show_values (a, b, c - a - b));
          (%o4)    map(=, '([a, b, c - b - a]), [a, b, c - b - a])

 -- Função: macroexpand (<expr>)
     Retorna a expansão da macro de <expr> sem avaliar a expressão,
     quando 'expr' for uma chamada de função de macro.  De outra forma,
     'macroexpand' retorna <expr>.

     Se a expansão de <expr> retorna outra chamada de função de macro,
     aquela chamada de função de macro é também expandida.

     'macroexpand' coloca apóstrofo em seus argumentos, isto é, não os
     avalia.  Todavia, se a expansão de uma chamada de função de macro
     tiver algum efeito, esse efeito colateral é executado.

     Veja também '::=', 'macros', e 'macroexpand1'.

     Exemplos

          (%i1) g (x) ::= x / 99;
                                              x
          (%o1)                      g(x) ::= --
                                              99
          (%i2) h (x) ::= buildq ([x], g (x - a));
          (%o2)            h(x) ::= buildq([x], g(x - a))
          (%i3) a: 1234;
          (%o3)                         1234
          (%i4) macroexpand (h (y));
                                        y - a
          (%o4)                         -----
                                         99
          (%i5) h (y);
                                      y - 1234
          (%o5)                       --------
                                         99

 -- Função: macroexpand1 (<expr>)
     Retorna a expansão de macro de <expr> sem avaliar a expressão,
     quando 'expr' for uma chamada de função de macro.  De outra forma,
     'macroexpand1' retorna <expr>.

     'macroexpand1' não avalia seus argumentos.  Todavia, se a expansão
     de uma chamada de função de macro tiver algum efeito, esse efeito
     colateral é executado.

     Se a expansão de <expr> retornar outra chamada de função de macro,
     aquela chamada de função de macro não é expandida.

     Veja também '::=', 'macros', e 'macroexpand'.

     Exemplos

          (%i1) g (x) ::= x / 99;
                                              x
          (%o1)                      g(x) ::= --
                                              99
          (%i2) h (x) ::= buildq ([x], g (x - a));
          (%o2)            h(x) ::= buildq([x], g(x - a))
          (%i3) a: 1234;
          (%o3)                         1234
          (%i4) macroexpand1 (h (y));
          (%o4)                       g(y - a)
          (%i5) h (y);
                                      y - 1234
          (%o5)                       --------
                                         99

 -- Global variable: macros
     Default value: '[]'

     'macros' é a lista de funções de macro definidas pelo usuário.  O
     operador de definição de função de macro '::=' coloca uma nova
     função de macro nessa lista, e 'kill', 'remove', e 'remfunction'
     removem funções de macro da lista.

     Veja também 'infolists'.

 -- Função: splice (<a>)
     Une como se fosse um elo de ligação (interpola) a lista nomeada
     através do átomo <a> em uma expressão, mas somente se 'splice'
     aparecer dentro de 'buildq'; de outra forma, 'splice' é tratada
     como uma função indefinida.  Se aparecer dentro de 'buildq' com <a>
     sozinho (sem 'splice'), <a> é substituido (não interpolado) como
     uma lista no resultado.  O argumento de 'splice' pode somente ser
     um átomo; não pode ser uma lista lateral ou uma expressão que
     retorna uma lista.

     Tipicamente 'splice' fornece os argumentos para uma função ou
     operador.  Para uma função 'f', a expressão 'f (splice (<a>))'
     dentro de 'buildq' expande para 'f (<a>[1], <a>[2], <a>[3], ...)'.
     Para um operador 'o', a expressão '"o" (splice (<a>)' dentro de
     'buildq' expande para '"o" (<a>[1], <a>[2], <a>[3], ...)', onde 'o'
     pode ser qualquer tipo de operador (tipicamente um que toma
     multiplos argumentos).  Note que o operador deve ser contido dentro
     de aspas duplas '"'.

     Exemplos

          (%i1) buildq ([x: [1, %pi, z - y]], foo (splice (x)) / length (x));
                                 foo(1, %pi, z - y)
          (%o1)                -----------------------
                               length([1, %pi, z - y])
          (%i2) buildq ([x: [1, %pi]], "/" (splice (x)));
                                          1
          (%o2)                          ---
                                         %pi
          (%i3) matchfix ("<>", "<>");
          (%o3)                          <>
          (%i4) buildq ([x: [1, %pi, z - y]], "<>" (splice (x)));
          (%o4)                   <>1, %pi, z - y<>


File: maxima.info,  Node: Funções e Variáveis para Definição de Função,  Prev: Macros,  Up: Definição de Função

39.4 Funções e Variáveis para Definição de Função
=================================================

 -- Função: apply (<F>, [<x_1>, ..., <x_n>])
     Constrói e avalia uma expressãp '<F>(<arg_1>, ..., <arg_n>)'.

     'apply' não tenta distinguir funções de array de funções comuns;
     quando <F> for o nome de uma função de array, 'apply' avalia
     '<F>(...)' (isto é, uma chamada de função com parêntesis em lugar
     de colchêtes).  'arrayapply' avalia uma chamada de função com
     colchêtes nesse caso.

     Exemplos:

     'apply' avalia seus argumentos.  Nesse exemplo, 'min' é aplicado a
     'L'.

          (%i1) L : [1, 5, -10.2, 4, 3];
          (%o1)                 [1, 5, - 10.2, 4, 3]
          (%i2) apply (min, L);
          (%o2)                        - 10.2

     'apply' avalia argumentos, mesmo se a função <F> disser que os
     argumentos não devem ser avaliados.

          (%i1) F (x) := x / 1729;
                                             x
          (%o1)                     F(x) := ----
                                            1729
          (%i2) fname : F;
          (%o2)                           F
          (%i3) dispfun (F);
                                             x
          (%t3)                     F(x) := ----
                                            1729

          (%o3)                         [%t3]
          (%i4) dispfun (fname);
          fname is not the name of a user function.
           -- an error.  Quitting.  To debug this try debugmode(true);
          (%i5) apply (dispfun, [fname]);
                                             x
          (%t5)                     F(x) := ----
                                            1729

          (%o5)                         [%t5]

     'apply' avalia o nome de função <F>.  Apóstrofo ''' evita
     avaliação.  'demoivre' é o nome de uma variável global e também de
     uma função.

          (%i1) demoivre;
          (%o1)                         false
          (%i2) demoivre (exp (%i * x));
          (%o2)                  %i sin(x) + cos(x)
          (%i3) apply (demoivre, [exp (%i * x)]);
          demoivre evaluates to false
          Improper name or value in functional position.
           -- an error.  Quitting.  To debug this try debugmode(true);
          (%i4) apply ('demoivre, [exp (%i * x)]);
          (%o4)                  %i sin(x) + cos(x)

 -- Função: block ([<v_1>, ..., <v_m>], <expr_1>, ..., <expr_n>)
 -- Função: block (<expr_1>, ..., <expr_n>)
     'block' avalia <expr_1>, ..., <expr_n> em seqüência e retorna o
     valor da última expressão avaliada.  A seqüência pode ser
     modificada pelas funções 'go', 'throw', e 'return'.  A última
     expressão é <expr_n> a menos que 'return' ou uma expressão contendo
     'throw' seja avaliada.  Algumas variáveis <v_1>, ..., <v_m> podem
     ser declaradas locais para o bloco; essas são distinguidas das
     variáveis globais dos mesmos nomes.  Se variáveis não forem
     declaradas locais então a lista pode ser omitida.  Dentro do bloco,
     qualquer variável que não <v_1>, ..., <v_m> é uma variável global.

     'block' salva os valores correntes das variáveis <v_1>, ..., <v_m>
     (quaisquer valores) na hora da entrada para o bloco, então libera
     as variáveis dessa forma eles avaliam para si mesmos.  As variáveis
     locais podem ser associadas a valores arbitrários dentro do bloco
     mas quando o bloco é encerrado o valores salvos são restaurados, e
     os valores atribuídos dentro do bloco são perdidos.

     'block' pode aparecer dentro de outro 'block'.  Variáveis locais
     são estabelecidas cada vez que um novo 'block' é avaliado.
     Variáveis locais parecem ser globais para quaisquer blocos
     fechados.  Se uma variável é não local em um bloco, seu valor é o
     valor mais recentemente atribuído por um bloco fechado, quaisquer
     que sejam, de outra forma, seu valor é o valor da variável no
     ambiente global.  Essa política pode coincidir com o entendimento
     usual de "escopo dinâmico".

     Se isso for desejado para salvar e restaurar outras propriedades
     locais ao lado de 'value', por exemplo 'array' (exceto para arrays
     completos), 'function', 'dependencies', 'atvalue', 'matchdeclare',
     'atomgrad', 'constant', e 'nonscalar' então a função 'local' pode
     ser usada dentro do bloco com argumentos sendo o nome das
     variáveis.

     O valor do bloco é o valor da última declaração ou o valor do
     argumento para a função 'return' que pode ser usada para sair
     explicitamente do bloco.  A função 'go' pode ser usada para
     transferir o controle para a declaração do bloco que é identificada
     com o argumento para 'go'.  Para identificar uma declaração,
     coloca-se antes dela um argumento atômico como outra declaração no
     bloco.  Por exemplo: 'block ([x], x:1, loop, x: x+1, ..., go(loop),
     ...)'.  O argumento para 'go' deve ser o nome de um identificador
     que aparece dentro do bloco.  Não se deve usar 'go' para transferir
     para um identificador em um outro bloco a não ser esse que contém o
     'go'.

     Blocos tipicamente aparecem do lado direito de uma definição de
     função mas podem ser usados em outros lugares também.

 -- Função: break (<expr_1>, ..., <expr_n>)
     Avalia e imprime <expr_1>, ..., <expr_n> e então causa uma parada
     do Maxima nesse ponto e o usuário pode examinar e alterar seu
     ambiente.  Nessa situação digite 'exit;' para que o cálculo seja
     retomado.

 -- Função: catch (<expr_1>, ..., <expr_n>)
     Avalia <expr_1>, ..., <expr_n> uma por uma; se qualquer avaliação
     levar a uma avaliação de uma expressão da forma 'throw (arg)',
     então o valor de 'catch' é o valor de 'throw (arg)', e expressões
     adicionais não são avaliadas.  Esse "retorno não local" atravessa
     assim qualquer profundidade de aninhar para o mais próximo contendo
     'catch'.  Se não existe nenhum 'catch' contendo um 'throw', uma
     mensagem de erro é impressa.

     Se a avaliação de argumentos não leva para a avaliação de qualquer
     'throw' então o valor de 'catch' é o valor de <expr_n>.

          (%i1) lambda ([x], if x < 0 then throw(x) else f(x))$
          (%i2) g(l) := catch (map (''%, l))$
          (%i3) g ([1, 2, 3, 7]);
          (%o3)               [f(1), f(2), f(3), f(7)]
          (%i4) g ([1, 2, -3, 7]);
          (%o4)                          - 3

     A função 'g' retorna uma lista de 'f' de cada elemento de 'l' se
     'l' consiste somente de números não negativos; de outra forma, 'g'
     "captura" o primeiro elemento negativo de 'l' e "arremessa-o".

 -- Função: compfile (<nomearquivo>, <f_1>, ..., <f_n>)
 -- Função: compfile (<nomearquivo>, funções)
 -- Função: compfile (<nomearquivo>, all)

     Traduz fuções Maxima para Lisp e escreve o código traduzido no
     arquivo <nomearquivo>.

     'compfile(<nomearquivo>, <f_1>, ..., <f_n>)' traduz as funções
     especificadas.  'compfile(<nomearquivo>, functions)' e
     'compfile(<nomearquivo>, all)' traduz todas as funções definidas
     pelo usuário.

     As traduções Lisp não são avaliadas, nem é o arquivo de saída
     processado pelo compilador Lisp.  'translate' cria e avalia
     traduções Lisp.  'compile_file' traduz Maxima para Lisp, e então
     executa o compilador Lisp.

     Veja também 'translate', 'translate_file', e 'compile_file'.

 -- Função: compile (<f_1>, ..., <f_n>)
 -- Função: compile (funções)
 -- Função: compile (all)
     Traduz funções Maxima <f_1>, ..., <f_n> para Lisp, avalia a
     tradução Lisp, e chama a função Lisp 'COMPILE' sobre cada função
     traduzida.  'compile' retorna uma lista de nomes de funções
     compiladas.

     'compile (all)' ou 'compile (funções)' compila todas as funções
     definidas pelo usuário.

     'compile' não avalia seus argumentos; o operador
     apóstrofo-apóstrofo '''' faz com que ocorra avaliação sobrepondo-se
     ao apóstrofo.

 -- Função: define (<f>(<x_1>, ..., <x_n>), <expr>)
 -- Função: define (<f>[<x_1>, ..., <x_n>], <expr>)
 -- Função: define (funmake (<f>, [<x_1>, ..., <x_n>]), <expr>)
 -- Função: define (arraymake (<f>, [<x_1>, ..., <x_n>]), <expr>)
 -- Função: define (ev (<expr_1>), <expr_2>)

     Define uma função chamada <f> com argumentos <x_1>, ..., <x_n> e
     corpo da função <expr>.  'define' sempre avalia seu segundo
     argumento (a menos que explícitamente receba um apostrofo de forma
     a evitar a avaliação).  A função então definida pode ser uma função
     comum do Maxima (com argumentos contidos entre parêtesis) ou uma
     função de array (com argumentos contidos entre colchêtes).

     Quando o último ou único argumento da função <x_n> for uma lista de
     um elemento, a função definida por 'define' aceita um número
     variável de argumentos.  Os argumentos atuais são atribuídos um a
     um a argumentos formais <x_1>, ..., <x_(n - 1)>, e quaisquer
     argumentos adicionais atuais, se estiverem presentes, são
     atribuídos a <x_n> como uma lista.

     Quando o primeiro argumento de 'define' for uma expressão da forma
     '<f>(<x_1>, ..., <x_n>)' or '<f>[<x_1>, ..., <x_n>]', os argumentos
     são avaliados mas <f> não é avaliada, mesmo se já existe
     anteriormente uma função ou variável com aquele nome.

     Quando o primeiro argumento for uma expressão com operador
     'funmake', 'arraymake', ou 'ev', o primeiro argumento será
     avaliado; isso permite para o nome da função seja calculado, também
     como o corpo.

     Todas as definições de função aparecem no mesmo nível de escopo e
     visibilidade; definindo uma função 'f' dentro de outra função 'g'
     não limita o escopo de 'f' a 'g'.

     Se algum argumento formal <x_k> for um símbolo com apóstrofo (após
     ter sido feita uma avaliação), a função definida por 'define' não
     avalia o correspondente atual argumento.  de outra forma todos os
     argumentos atuais são avaliados.

     Veja também ':=' and '::='.

     Exemplos:

     'define' sempre avalia seu segundo argumento (a menos que
     explícitamente receba um apostrofo de forma a evitar a avaliação).

          (%i1) expr : cos(y) - sin(x);
          (%o1)                    cos(y) - sin(x)
          (%i2) define (F1 (x, y), expr);
          (%o2)              F1(x, y) := cos(y) - sin(x)
          (%i3) F1 (a, b);
          (%o3)                    cos(b) - sin(a)
          (%i4) F2 (x, y) := expr;
          (%o4)                   F2(x, y) := expr
          (%i5) F2 (a, b);
          (%o5)                    cos(y) - sin(x)

     A função definida por 'define' pode ser uma função comum do Maxima
     ou uma função de array.

          (%i1) define (G1 (x, y), x.y - y.x);
          (%o1)               G1(x, y) := x . y - y . x
          (%i2) define (G2 [x, y], x.y - y.x);
          (%o2)                G2     := x . y - y . x
                                 x, y

     Quando o último ou único argumento da função <x_n> for uma lista de
     um único elemento, a função definida por 'define' aceita um número
     variável de argumentos.

          (%i1) define (H ([L]), '(apply ("+", L)));
          (%o1)                H([L]) := apply("+", L)
          (%i2) H (a, b, c);
          (%o2)                       c + b + a

     When the first argument is an expression with operator 'funmake',
     'arraymake', or 'ev', the first argument is evaluated.

          (%i1) [F : I, u : x];
          (%o1)                        [I, x]
          (%i2) funmake (F, [u]);
          (%o2)                         I(x)
          (%i3) define (funmake (F, [u]), cos(u) + 1);
          (%o3)                  I(x) := cos(x) + 1
          (%i4) define (arraymake (F, [u]), cos(u) + 1);
          (%o4)                   I  := cos(x) + 1
                                   x
          (%i5) define (foo (x, y), bar (y, x));
          (%o5)                foo(x, y) := bar(y, x)
          (%i6) define (ev (foo (x, y)), sin(x) - cos(y));
          (%o6)             bar(y, x) := sin(x) - cos(y)

 -- Função: define_variable (<name>, <default_value>, <mode>)

     Introduz uma variável global dentro do ambiente Maxima.
     'define_variable' é útil em pacotes escritos pelo usuário, que são
     muitas vezes traduzidos ou compilados.

     'define_variable' realiza os seguintes passos:

       1. 'mode_declare (<name>, <mode>)' declara o modo de <name> para
          o tradutor.  Veja 'mode_declare' para uma lista dos modos
          possíveis.

       2. Se a variável é não associada, <default_value> é atribuído
          para <name>.

       3. 'declare (<name>, special)' declara essa variável especial.

       4. Associa <name> com uma função de teste para garantir que a
          <name> seja somente atribuído valores do modo declarado.

     A propriedade 'value_check' pode ser atribuída a qualquer variável
     que tenha sido definida via 'define_variable' com um outro modo que
     não 'any'.  A propriedade 'value_check' é uma expressão lambda ou o
     nome de uma função de uma variável, que é chamada quando uma
     tentativa é feita para atribuir um valor a uma variável.  O
     argumento da função 'value_check' é o valor que será atribuído.

     'define_variable' avalia 'default_value', e não avalia 'name' e
     'mode'.  'define_variable' retorna o valor corrente de 'name', que
     é 'default_value' se 'name' não tiver sido associada antes, e de
     outra forma isso é o valor prévio de 'name'.

     Exemplos:

     'foo' é uma variável Booleana, com o valor inicial 'true'.

          (%i1) define_variable (foo, true, boolean);
          (%o1)                         true
          (%i2) foo;
          (%o2)                         true
          (%i3) foo: false;
          (%o3)                         false
          (%i4) foo: %pi;
          Error: foo was declared mode boolean, has value: %pi
           -- an error.  Quitting.  To debug this try debugmode(true);
          (%i5) foo;
          (%o5)                         false

     'bar' é uma variável inteira, que deve ser um número primo.

          (%i1) define_variable (bar, 2, integer);
          (%o1)                           2
          (%i2) qput (bar, prime_test, value_check);
          (%o2)                      prime_test
          (%i3) prime_test (y) := if not primep(y) then error (y, "is not prime.");
          (%o3) prime_test(y) := if not primep(y)

                                             then error(y, "is not prime.")
          (%i4) bar: 1439;
          (%o4)                         1439
          (%i5) bar: 1440;
          1440 é not prime.
          #0: prime_test(y=1440)
           -- an error.  Quitting.  To debug this try debugmode(true);
          (%i6) bar;
          (%o6)                         1439

     'baz_quux' é uma variável que não pode receber a atribuição de um
     valor.  O modo 'any_check' é como 'any', mas 'any_check' habilita o
     mecanismo 'value_check', e 'any' não habilita.

          (%i1) define_variable (baz_quux, 'baz_quux, any_check);
          (%o1)                       baz_quux
          (%i2) F: lambda ([y], if y # 'baz_quux then error ("Cannot assign to `baz_quux'."));
          (%o2) lambda([y], if y # 'baz_quux

                                  then error(Cannot assign to `baz_quux'.))
          (%i3) qput (baz_quux, ''F, value_check);
          (%o3) lambda([y], if y # 'baz_quux

                                  then error(Cannot assign to `baz_quux'.))
          (%i4) baz_quux: 'baz_quux;
          (%o4)                       baz_quux
          (%i5) baz_quux: sqrt(2);
          Cannot assign to `baz_quux'.
          #0: lambda([y],if y # 'baz_quux then error("Cannot assign to `baz_quux'."))(y=sqrt(2))
           -- an error.  Quitting.  To debug this try debugmode(true);
          (%i6) baz_quux;
          (%o6)                       baz_quux

 -- Função: dispfun (<f_1>, ..., <f_n>)
 -- Função: dispfun (all)
     Mostra a definição de funções definidas pelo usuário <f_1>, ...,
     <f_n>.  Cada argumento pode ser o nome de uma macro (definida com
     '::='), uma função comum (definida com ':=' ou 'define'), uma
     função array (definida com ':=' ou com 'define', mas contendo
     argumentos entre colchêtes '[ ]'), uma função subscrita, (definida
     com ':=' ou 'define', mas contendo alguns argumentos entre
     colchêtes e outros entre parêntesis '( )') uma da família de
     funções subscritas selecionadas por um valor subscrito particular,
     ou uma função subscrita definida com uma constante subscrita.

     'dispfun (all)' mostra todas as funções definidas pelo usuário como
     dadas pelas 'functions', 'arrays', e listas de 'macros', omitindo
     funções subscritas definidas com constantes subscritas.

     'dispfun' cria um Rótulo de expressão intermediária ('%t1', '%t2',
     etc.)  para cada função mostrada, e atribui a definição de função
     para o rótulo.  Em contraste, 'fundef' retorna a definição de
     função.

     'dispfun' não avalia seus argumentos; O operador
     apóstrofo-apóstrofo '''' faz com que ocorra avaliação.  'dispfun'
     retorna a lista de rótulos de expressões intermediárias
     correspondendo às funções mostradas.

     Exemplos:

          (%i1) m(x, y) ::= x^(-y);
                                               - y
          (%o1)                   m(x, y) ::= x
          (%i2) f(x, y) :=  x^(-y);
                                               - y
          (%o2)                    f(x, y) := x
          (%i3) g[x, y] :=  x^(-y);
                                              - y
          (%o3)                     g     := x
                                     x, y
          (%i4) h[x](y) :=  x^(-y);
                                              - y
          (%o4)                     h (y) := x
                                     x
          (%i5) i[8](y) :=  8^(-y);
                                              - y
          (%o5)                     i (y) := 8
                                     8
          (%i6) dispfun (m, f, g, h, h[5], h[10], i[8]);
                                               - y
          (%t6)                   m(x, y) ::= x

                                               - y
          (%t7)                    f(x, y) := x

                                              - y
          (%t8)                     g     := x
                                     x, y

                                              - y
          (%t9)                     h (y) := x
                                     x

                                              1
          (%t10)                     h (y) := --
                                      5        y
                                              5

                                               1
          (%t11)                    h  (y) := ---
                                     10         y
                                              10

                                              - y
          (%t12)                    i (y) := 8
                                     8

          (%o12)       [%t6, %t7, %t8, %t9, %t10, %t11, %t12]
          (%i12) ''%;
                               - y              - y            - y
          (%o12) [m(x, y) ::= x   , f(x, y) := x   , g     := x   ,
                                                      x, y
                            - y           1              1             - y
                  h (y) := x   , h (y) := --, h  (y) := ---, i (y) := 8   ]
                   x              5        y   10         y   8
                                          5             10

 -- Variável de sistema: functions
     Valor padrão: '[]'

     'functions' é a lista de todas as funções comuns do Maxima na
     sessão corrente.  Uma função comum é uma função construída através
     de 'define' ou de ':=' e chamada com parêntesis '()'.  Uma função
     pode ser definida pela linha de comando do Maxima de forma
     interativa com o usuário ou em um arquivo Maxima chamado por 'load'
     ou 'batch'.

     Funções de array (chamadas com colchêtes, e.g., 'F[x]') e funções
     com subscritos (chamadas com colchêtes e parêntesis, e.g.,
     'F[x](y)') são lsitados através da variável global 'arrays', e não
     por meio de 'functions'.

     Funções Lisp não são mantidas em nenhuma lista.

     Exemplos:

          (%i1) F_1 (x) := x - 100;
          (%o1)                   F_1(x) := x - 100
          (%i2) F_2 (x, y) := x / y;
                                                x
          (%o2)                    F_2(x, y) := -
                                                y
          (%i3) define (F_3 (x), sqrt (x));
          (%o3)                   F_3(x) := sqrt(x)
          (%i4) G_1 [x] := x - 100;
          (%o4)                    G_1  := x - 100
                                      x
          (%i5) G_2 [x, y] := x / y;
                                               x
          (%o5)                     G_2     := -
                                       x, y    y
          (%i6) define (G_3 [x], sqrt (x));
          (%o6)                    G_3  := sqrt(x)
                                      x
          (%i7) H_1 [x] (y) := x^y;
                                                y
          (%o7)                     H_1 (y) := x
                                       x
          (%i8) functions;
          (%o8)              [F_1(x), F_2(x, y), F_3(x)]
          (%i9) arrays;
          (%o9)                 [G_1, G_2, G_3, H_1]

 -- Função: fundef (<f>)
     Retorna a definição da função <f>.

     O argumento pode ser o nome de uma macro (definida com '::='), uma
     função comum (definida com ':=' ou 'define'), uma função array
     (definida com ':=' ou 'define', mas contendo argumentos entre
     colchêtes '[ ]'), Uma função subscrita, (definida com ':=' ou
     'define', mas contendo alguns argumentos entre colchêtes e
     parêntesis '( )') uma da família de funções subscritas selecionada
     por um valor particular subscrito, ou uma função subscrita definida
     com uma constante subscrita.

     'fundef' não avalia seu argumento; o operador apóstrofo-apóstrofo
     '''' faz com que ocorra avaliação.

     'fundef (<f>)' retorna a definição de <f>.  Em contraste, 'dispfun
     (<f>)' cria um rótulo de expressão intermediária e atribui a
     definição para o rótulo.

 -- Função: funmake (<F>, [<arg_1>, ..., <arg_n>])
     Retorna uma expressão '<F>(<arg_1>, ..., <arg_n>)'.  O valor de
     retorno é simplificado, mas não avaliado, então a função <F> não é
     chamada, mesmo se essa função <F> existir.

     'funmake' não tenta distinguir funções de array de funções comuns;
     quando <F> for o nome de uma função de array, 'funmake' retorna
     '<F>(...)' (isto é, uma chamada de função com parêntesis em lugar
     de colchêtes).  'arraymake' retorna uma chamada de função com
     colchêtes nesse caso.

     'funmake' avalia seus argumentos.

     Exemplos:

     'funmake' aplicada a uma função comum do Maxima.

          (%i1) F (x, y) := y^2 - x^2;
                                             2    2
          (%o1)                  F(x, y) := y  - x
          (%i2) funmake (F, [a + 1, b + 1]);
          (%o2)                    F(a + 1, b + 1)
          (%i3) ''%;
                                        2          2
          (%o3)                  (b + 1)  - (a + 1)

     'funmake' aplicada a uma macro.

          (%i1) G (x) ::= (x - 1)/2;
                                            x - 1
          (%o1)                    G(x) ::= -----
                                              2
          (%i2) funmake (G, [u]);
          (%o2)                         G(u)
          (%i3) ''%;
                                        u - 1
          (%o3)                         -----
                                          2

     'funmake' aplicada a uma função subscrita.

          (%i1) H [a] (x) := (x - 1)^a;
                                                  a
          (%o1)                   H (x) := (x - 1)
                                   a
          (%i2) funmake (H [n], [%e]);
                                                 n
          (%o2)               lambda([x], (x - 1) )(%e)
          (%i3) ''%;
                                              n
          (%o3)                       (%e - 1)
          (%i4) funmake ('(H [n]), [%e]);
          (%o4)                        H (%e)
                                        n
          (%i5) ''%;
                                              n
          (%o5)                       (%e - 1)

     'funmake' aplicada a um símbolo que não é uma função definida de
     qualquer tipo.

          (%i1) funmake (A, [u]);
          (%o1)                         A(u)
          (%i2) ''%;
          (%o2)                         A(u)

     'funmake' avalia seus argumentos, mas não o valor de retorno.

          (%i1) det(a,b,c) := b^2 -4*a*c;
                                              2
          (%o1)              det(a, b, c) := b  - 4 a c
          (%i2) (x : 8, y : 10, z : 12);
          (%o2)                          12
          (%i3) f : det;
          (%o3)                          det
          (%i4) funmake (f, [x, y, z]);
          (%o4)                    det(8, 10, 12)
          (%i5) ''%;
          (%o5)                         - 284

     Maxima simplifica o valor de retorno de 'funmake'.

          (%i1) funmake (sin, [%pi / 2]);
          (%o1)                           1

 -- Função: lambda ([<x_1>, ..., <x_m>], <expr_1>, ..., <expr_n>)
 -- Função: lambda ([[<L>]], <expr_1>, ..., <expr_n>)
 -- Função: lambda ([<x_1>, ..., <x_m>, [<L>]], <expr_1>, ..., <expr_n>)
     Define e retorna uma expressão lambda (que é, uma função anônima) A
     função pode ter argumentos que sejam necessários <x_1>, ..., <x_m>
     e/ou argumentos opcionais <L>, os quais aparecem dentro do corpo da
     função como uma lista.  O valor de retorno da função é <expr_n>.
     Uma expressão lambda pode ser atribuída para uma variável e
     avaliada como uma função comum.  Uma expressão lambda pode aparecer
     em alguns contextos nos quais um nome de função é esperado.

     Quando a função é avaliada, variáveis locais não associadas <x_1>,
     ..., <x_m> são criadas.  'lambda' pode aparecer dentro de 'block'
     ou outra função 'lambda'; variáveis locais são estabelecidas cada
     vez que outro 'block' ou função 'lambda' é avaliada.  Variáveis
     locais parecem ser globais para qualquer coisa contendo 'block' ou
     'lambda'.  Se uma variável é não local, seu valor é o valor mais
     recentemente atribuído em alguma coisa contendo 'block' ou
     'lambda', qualquer que seja, de outra forma, seu valor é o valor da
     variável no ambiente global.  Essa política pode coincidir com o
     entendimento usual de "escopo dinâmico".

     Após variáveis locais serem estabelecidas, <expr_1> até <expr_n>
     são avaliadas novamente.  a variável especial '%%', representando o
     valor da expressão precedente, é reconhecida.  'throw' e 'catch'
     pode também aparecer na lista de expressões.

     'return' não pode aparecer em uma expressão lambda a menos que
     contendo 'block', nesse caso 'return' define o valor de retorno do
     bloco e não da expressão lambda, a menos que o bloco seja <expr_n>.
     Da mesma forma, 'go' não pode aparecer em uma expressão lambda a
     menos que contendo 'block'.

     'lambda' não avalia seus argumentos; o operador apóstrofo-apóstrofo
     '''' faz com que ocorra avaliação.

     Exemplos:

        * A expressão lambda pode ser atribuída para uma variável e
          avaliada como uma função comum.
          (%i1) f: lambda ([x], x^2);
                                                2
          (%o1)                    lambda([x], x )
          (%i2) f(a);
                                          2
          (%o2)                          a
        * Uma expressão lambda pode aparecer em contextos nos quais uma
          avaliação de função é esperada como resposta.
          (%i3) lambda ([x], x^2) (a);
                                          2
          (%o3)                          a
          (%i4) apply (lambda ([x], x^2), [a]);
                                          2
          (%o4)                          a
          (%i5) map (lambda ([x], x^2), [a, b, c, d, e]);
                                  2   2   2   2   2
          (%o5)                 [a , b , c , d , e ]
        * Variáveis argumento são variáveis locais.  Outras variáveis
          aparecem para serem variáveis globais.  Variáveis globais são
          avaliadas ao mesmo tempo em que a expressão lambda é avaliada,
          a menos que alguma avaliação especial seja forçada por alguns
          meios, tais como ''''.
          (%i6) a: %pi$
          (%i7) b: %e$
          (%i8) g: lambda ([a], a*b);
          (%o8)                   lambda([a], a b)
          (%i9) b: %gamma$
          (%i10) g(1/2);
                                       %gamma
          (%o10)                       ------
                                         2
          (%i11) g2: lambda ([a], a*''b);
          (%o11)                lambda([a], a %gamma)
          (%i12) b: %e$
          (%i13) g2(1/2);
                                       %gamma
          (%o13)                       ------
                                         2
        * Expressões lambda podem ser aninhadas.  Variáveis locais
          dentro de outra expressão lambda parece ser global para a
          expressão interna a menos que mascarada por variáveis locais
          de mesmos nomes.
          (%i14) h: lambda ([a, b], h2: lambda ([a], a*b), h2(1/2));
                                                             1
          (%o14)    lambda([a, b], h2 : lambda([a], a b), h2(-))
                                                             2
          (%i15) h(%pi, %gamma);
                                       %gamma
          (%o15)                       ------
                                         2
        * Uma vez que 'lambda' não avalia seus argumentos, a expressão
          lambda 'i' abaixo não define uma função "multiplicação por
          'a'".  Tanto uma função pode ser definida via 'buildq', como
          na expressão lambda 'i2' abaixo.
          (%i16) i: lambda ([a], lambda ([x], a*x));
          (%o16)            lambda([a], lambda([x], a x))
          (%i17) i(1/2);
          (%o17)                  lambda([x], a x)
          (%i18) i2: lambda([a], buildq([a: a], lambda([x], a*x)));
          (%o18)    lambda([a], buildq([a : a], lambda([x], a x)))
          (%i19) i2(1/2);
                                               x
          (%o19)                   lambda([x], -)
                                               2
          (%i20) i2(1/2)(%pi);
                                         %pi
          (%o20)                         ---
                                          2
        * Uma expressão lambda pode receber um número variável de
          argumentos, os quais são indicados por meio de '[<L>]' como o
          argumento único ou argumento final.  Os argumentos aparecem
          dentro do corpo da função como uma lista.
          (%i1) f : lambda ([aa, bb, [cc]], aa * cc + bb);
          (%o1)          lambda([aa, bb, [cc]], aa cc + bb)
          (%i2) f (foo, %i, 17, 29, 256);
          (%o2)       [17 foo + %i, 29 foo + %i, 256 foo + %i]
          (%i3) g : lambda ([[aa]], apply ("+", aa));
          (%o3)             lambda([[aa]], apply(+, aa))
          (%i4) g (17, 29, x, y, z, %e);
          (%o4)                  z + y + x + %e + 46

 -- Função: local (<v_1>, ..., <v_n>)
     Declara as variáveis <v_1>, ..., <v_n> para serem locais com
     relação a todas as propriedades na declaração na qual essa função é
     usada.

     'local' não avalia seus argumentos.  'local' retorna 'done'.

     'local' pode somente ser usada em 'block', no corpo de definições
     de função ou expressões 'lambda', ou na função 'ev', e somente uma
     ocorrêcia é permitida em cada.

     'local' é independente de 'context'.

 -- Variável de opção: macroexpansion
     Valor padrão: 'false'

     'macroexpansion' controla se a expansão (isto é, o valor de
     retorno) de uma função de macro é substituído pela chamada à função
     de macro.  Uma substituição pode aumentar a velocidade de
     subseqüênte avaliações da expressão, ao custo de armazenar a
     expansão.

     'false'
          A expansão de uma função de macro não é substituída pela
          chamada de função de macro.
     'expand'
          Da primeira vez que a função de macro é avaliada, a expansão é
          armazenada.  A expansão não é recalculada sobre chamadas
          subseqüêntes; qualquer efeito colateral (tais como 'print' ou
          atribuições a variáveis globais) ocorrem somente quando
          chamadas à função de macro forem avaliadas primeiramente.
          Expansões em uma expressão não afetam outras expressões que
          possuem a mesma chamada à função de macro.
     'displace'
          Na primeira vez que uma função de macro é avaliada, a expansão
          é substituída pela chamada, dessa forma modificando a
          expressão a partir da qual a função de macro foi chamada.  A
          expansão não é recalculada nas chamadas subseqüêntes; qualquer
          efeito colateral acontece somente quando a chamada à função de
          macro for avaliada primeiramente.  Expansões na expressão não
          afetam outras expressões que possuem a mesma chamada à função
          de macro.

     Exemplos

     Quandon 'macroexpansion' for 'false', uma função de macro é chamada
     a cada vez que a expressão que está chamando é avaliada, e a
     expressão que está chamandonão é modificada.

          (%i1) f (x) := h (x) / g (x);
                                            h(x)
          (%o1)                     f(x) := ----
                                            g(x)
          (%i2) g (x) ::= block (print ("x + 99 is equal to", x), return (x + 99));
          (%o2) g(x) ::= block(print("x + 99 is equal to", x),
                                                            return(x + 99))
          (%i3) h (x) ::= block (print ("x - 99 is equal to", x), return (x - 99));
          (%o3) h(x) ::= block(print("x - 99 is equal to", x),
                                                            return(x - 99))
          (%i4) macroexpansion: false;
          (%o4)                         false
          (%i5) f (a * b);
          x - 99 is equal to x
          x + 99 is equal to x
                                      a b - 99
          (%o5)                       --------
                                      a b + 99
          (%i6) dispfun (f);
                                            h(x)
          (%t6)                     f(x) := ----
                                            g(x)

          (%o6)                         done
          (%i7) f (a * b);
          x - 99 is equal to x
          x + 99 is equal to x
                                      a b - 99
          (%o7)                       --------
                                      a b + 99

     Quando 'macroexpansion' for 'expand', uma função de macro é chamada
     uma única vez, e a expressão que está chamando não é modificada.

          (%i1) f (x) := h (x) / g (x);
                                            h(x)
          (%o1)                     f(x) := ----
                                            g(x)
          (%i2) g (x) ::= block (print ("x + 99 is equal to", x), return (x + 99));
          (%o2) g(x) ::= block(print("x + 99 is equal to", x),
                                                            return(x + 99))
          (%i3) h (x) ::= block (print ("x - 99 is equal to", x), return (x - 99));
          (%o3) h(x) ::= block(print("x - 99 is equal to", x),
                                                            return(x - 99))
          (%i4) macroexpansion: expand;
          (%o4)                        expand
          (%i5) f (a * b);
          x - 99 is equal to x
          x + 99 is equal to x
                                      a b - 99
          (%o5)                       --------
                                      a b + 99
          (%i6) dispfun (f);
                                            h(x)
          (%t6)                     f(x) := ----
                                            g(x)

          (%o6)                         done
          (%i7) f (a * b);
                                      a b - 99
          (%o7)                       --------
                                      a b + 99

     Quando 'macroexpansion' for 'expand', uma função de macro é chamada
     uma única vez, e a expressão que está chamando é modificada.

          (%i1) f (x) := h (x) / g (x);
                                            h(x)
          (%o1)                     f(x) := ----
                                            g(x)
          (%i2) g (x) ::= block (print ("x + 99 is equal to", x), return (x + 99));
          (%o2) g(x) ::= block(print("x + 99 is equal to", x),
                                                            return(x + 99))
          (%i3) h (x) ::= block (print ("x - 99 is equal to", x), return (x - 99));
          (%o3) h(x) ::= block(print("x - 99 is equal to", x),
                                                            return(x - 99))
          (%i4) macroexpansion: displace;
          (%o4)                       displace
          (%i5) f (a * b);
          x - 99 is equal to x
          x + 99 is equal to x
                                      a b - 99
          (%o5)                       --------
                                      a b + 99
          (%i6) dispfun (f);
                                           x - 99
          (%t6)                    f(x) := ------
                                           x + 99

          (%o6)                         done
          (%i7) f (a * b);
                                      a b - 99
          (%o7)                       --------
                                      a b + 99

 -- Variável de opção: mode_checkp
     Valor padrão: 'true'

     Quando 'mode_checkp' é 'true', 'mode_declare' verifica os modos de
     associação de variáveis.

 -- Variável de opção: mode_check_errorp
     Valor padrão: 'false'

     Quando 'mode_check_errorp' é 'true', 'mode_declare' chama a função
     "error".

 -- Variável de opção: mode_check_warnp
     Valor padrão: 'true'

     Quando 'mode_check_warnp' é 'true', modo "errors" são descritos.

 -- Função: mode_declare (<y_1>, <mode_1>, ..., <y_n>, <mode_n>)
     'mode_declare' é usado para declarar os modos de variáveis e
     funções para subseqüênte tradução ou compilação das funções.
     'mode_declare' é tipicamente colocada no início de uma definição de
     função, no início de um script Maxima, ou executado através da
     linha de comando de forma interativa.

     Os argumentos de 'mode_declare' são pares consistindo de uma
     variável e o modo que é um de 'boolean', 'fixnum', 'number',
     'rational', ou 'float'.  Cada variável pode também ser uma lista de
     variáveis todas as quais são declaradas para ter o mesmo modo.

     Se uma variável é um array, e se todo elemento do array que é
     referenciado tiver um valor então 'array (yi, complete, dim1, dim2,
     ...)' em lugar de
          array(yi, dim1, dim2, ...)
     deverá ser usado primeiro declarando as associações do array.  Se
     todos os elementos do array estão no modo 'fixnum' ('float'), use
     'fixnum' ('float') em lugar de 'complete'.  Também se todo elemento
     do array está no mesmo modo, digamos 'm', então

          mode_declare (completearray (yi), m))

     deverá ser usado para uma tradução eficiente.

     Código numéricos usando arrays podem rodar mais rápidamente se for
     decladado o tamanho esperado do array, como em:

          mode_declare (completearray (a [10, 10]), float)

     para um array numérico em ponto flutuante que é 10 x 10.

     Pode-se declarar o modo do resultado de uma função usando 'function
     (f_1, f_2, ...)' como um argumento; aqui 'f_1', 'f_2', ...  são
     nomes de funções.  Por exemplo a expressão,

          mode_declare ([function (f_1, f_2, ...)], fixnum)

     declara que os valores retornados por 'f_1', 'f_2', ...  são
     inteiros palavra simples.

     'modedeclare' é um sinônimo para 'mode_declare'.

 -- Função: mode_identity (<arg_1>, <arg_2>)
     Uma forma especial usada com 'mode_declare' e 'macros' para
     declarar, e.g., uma lista de listas de números em ponto flutuante
     ou outros objetos de dados.  O primeiro argumento para
     'mode_identity' é um valor primitivo nome de modo como dado para
     'mode_declare' (i.e., um de 'float', 'fixnum', 'number', 'list', ou
     'any'), e o segundo argumento é uma expressão que é avaliada e
     retornada com o valor de 'mode_identity'.  Todavia, se o valor de
     retorno não é permitido pelo modo declarado no primeiro argumento,
     um erro ou alerta é sinalizado.  Um ponto importante é que o modo
     da expressão como determinado pelo Maxima para o tradutor Lisp,
     será aquele dado como o primeiro argumento, independente de
     qualquer coisa que vá no segundo argumento.  E.g., 'x: 3.3;
     mode_identity (fixnum, x);' retorna um erro.  'mode_identity
     (flonum, x)' returns 3.3 .  Isso tem númerosas utilidades, e.g., se
     você soube que 'first (l)' retornou um número então você pode
     escrever 'mode_identity (number, first (l))'.  Todavia, um mais
     eficiente caminho para fazer isso é definir uma nova primitiva,

          firstnumb (x) ::= buildq ([x], mode_identity (number, first(x)));

     e usar 'firstnumb' toda vez que você pegar o primeiro de uma lista
     de números.

 -- Variável de opção: transcompile
     Valor padrão: 'true'

     Quando 'transcompile' é 'true', 'translate' e 'translate_file'
     geram declarações para fazer o código traduzido mais adequado para
     compilação.

     'compfile' escolhe 'transcompile: true' para a duração.

 -- Função: translate (<f_1>, ..., <f_n>)
 -- Função: translate (funções)
 -- Função: translate (all)
     Traduz funções definidas pelo usuário <f_1>, ..., <f_n> da
     linguagem de Maxima para Lisp e avalia a tradução Lisp.
     Tipicamente as funções traduzidas executam mais rápido que as
     originais.

     'translate (all)' ou 'translate (funções)' traduz todas as funções
     definidas pelo usuário.

     Funções a serem traduzidas incluir~ao uma chamada para
     'mode_declare' no início quando possível com o objetivo de produzir
     um código mais eficiente.  Por exemplo:

          f (x_1, x_2, ...) := block ([v_1, v_2, ...],
              mode_declare (v_1, mode_1, v_2, mode_2, ...), ...)


     quando <x_1>, <x_2>, ...  são parâmetros para a função e <v_1>,
     <v_2>, ...  são variáveis locais.

     Os nomes de funções traduzidas são removidos da lista 'functions'
     se 'savedef' é 'false' (veja abaixo) e são adicionados nas listas
     'props'.

     Funções não poderão ser traduzidas a menos que elas sejam
     totalmente depuradas.

     Expressões são assumidas simplificadas; se não forem, um código
     correto será gerado mas não será um código ótimo.  Dessa forma, o
     usuário não poderá escolher o comutador 'simp' para 'false' o qual
     inibe simplificação de expressões a serem traduzidas.

     O comutador 'translate', se 'true', causa tradução automatica de
     uma função de usuário para Lisp.

     Note que funções traduzidas podem não executar identicamente para o
     caminho que elas faziam antes da tradução como certas
     incompatabilidades podem existir entre o Lisp e versões do Maxima.
     Principalmente, a função 'rat' com mais de um argumento e a função
     'ratvars' não poderá ser usada se quaisquer variáveis são
     declaradas com 'mode_declare' como sendo expressões rotacionais
     canônicas(CRE). Também a escolha 'prederror: false' não traduzirá.

     'savedef' - se 'true' fará com que a versão Maxima de uma função
     usuário permaneça quando a função é traduzida com 'translate'.
     Isso permite a que definição seja mostrada por 'dispfun' e autoriza
     a função a ser editada.

     'transrun' - se 'false' fará com que a versão interpretada de todas
     as funções sejam executadas (desde que estejam ainda disponíveis)
     em lugar da versão traduzida.

     O resultado retornado por 'translate' é uma lista de nomes de
     funções traduzidas.

 -- Função: translate_file (<maxima_nomearquivo>)
 -- Função: translate_file (<maxima_nomearquivo>, <lisp_nomearquivo>)
     Traduz um arquivo com código Maxima para um arquivo com código
     Lisp.  'translate_file' retorna uma lista de três nomes de arquivo:
     O nome do arquivo Maxima, o nome do arquivo Lisp, e o nome do
     arquivo contendo informações adicionais sobre a tradução.
     'translate_file' avalia seus argumentos.

     'translate_file ("foo.mac"); load("foo.LISP")' é o mesmo que 'batch
     ("foo.mac")' exceto por certas restrições, o uso de '''' e '%', por
     exemplo.

     'translate_file (<maxima_nomearquivo>)' traduz um arquivo Maxima
     <maxima_nomearquivo> para um similarmente chamado arquivo Lisp.
     Por exemplo, 'foo.mac' é traduzido em 'foo.LISP'.  O nome de
     arquivo Maxima pod incluir nome ou nomes de diretório(s), nesse
     caso o arquivo de saída Lisp é escrito para o mesmo diretório que a
     entrada Maxima.

     'translate_file (<maxima_nomearquivo>, <lisp_nomearquivo>)' traduz
     um arquivo Maxima <maxima_nomearquivo> em um arquivo Lisp
     <lisp_nomearquivo>.  'translate_file' ignora a extensão do nome do
     arquivo, se qualquer, de 'lisp_nomearquivo'; a extensão do arquivo
     de saída Lisp é sempre 'LISP'.  O nome de arquivo Lisp pode incluir
     um nome ou nomes de diretórios), nesse caso o arquivo de saída Lisp
     é escrito para o diretório especificado.

     'translate_file' também escreve um arquivo de mensagens de alerta
     do tradutor em vários graus de severidade.  A extensão do nome de
     arquivo desse arquivo é 'UNLISP'.  Esse arquivo pode conter
     informação valiosa, apesar de possivelmente obscura, para rastrear
     erros no código traduzido.  O arquivo 'UNLISP' é sempre escrito
     para o mesmo diretório que a entrada Maxima.

     'translate_file' emite código Lisp o qual faz com que algumas
     definições tenham efeito tão logo o código Lisp é compilado.  Veja
     'compile_file' para mais sobre esse tópico.

     Veja também 'tr_array_as_ref', 'tr_bound_function_applyp',
     'tr_exponent', 'tr_file_tty_messagesp',
     'tr_float_can_branch_complex', 'tr_function_call_default',
     'tr_numer', 'tr_optimize_max_loop', 'tr_semicompile',
     'tr_state_vars', 'tr_warnings_get', 'tr_warn_bad_function_calls',
     'tr_warn_fexpr', 'tr_warn_meval', 'tr_warn_mode',
     'tr_warn_undeclared', e 'tr_warn_undefined_variable'.

 -- Variável de opção: transrun
     Valor padrão: 'true'

     Quando 'transrun' é 'false' fará com que a versão interpretada de
     todas as funções sejam executadas (desde que estejam ainda
     disponíveis) em lugar de versão traduzidas.

 -- Variável de opção: tr_array_as_ref
     Valor padrão: 'true'

     Se 'translate_fast_arrays' for 'false', referências a arrays no
     Código Lisp emitidas por 'translate_file' são afetadas por
     'tr_array_as_ref'.  Quando 'tr_array_as_ref' é 'true', nomes de
     arrays são avaliados, de outra forma nomes de arrays aparecem como
     símbolos literais no código traduzido.

     'tr_array_as_ref' não terão efeito se 'translate_fast_arrays' for
     'true'.

 -- Variável de opção: tr_bound_function_applyp
     Valor padrão: 'true'

     Quando 'tr_bound_function_applyp' for 'true', Maxima emite um
     alerta se uma associação de variável (tal como um argumento de
     função) é achada sendo usada como uma função.
     +'tr_bound_function_applyp' não afeta o código gerado em tais
     casos.

     Por exemplo, uma expressão tal como 'g (f, x) := f (x+1)' irá
     disparar a mensagem de alerta.

 -- Variável de opção: tr_file_tty_messagesp
     Valor padrão: 'false'

     Quando 'tr_file_tty_messagesp' é 'true', messagens geradas por
     'translate_file' durante a tradução de um arquivo são mostradas
     sobre o console e inseridas dentro do arquivo UNLISP. Quando
     'false', messagens sobre traduções de arquivos são somente
     inseridas dentro do arquivo UNLISP.

 -- Variável de opção: tr_float_can_branch_complex
     Valor padrão: 'true'

     Diz ao tradutor Maxima-para-Lisp assumir que as funções 'acos',
     'asin', 'asec', e 'acsc' podem retornar resultados complexos.

     O efeito ostensivo de 'tr_float_can_branch_complex' é mostrado
     adiante.  Todavia, parece que esse sinalizador não tem efeito sobre
     a saída do tradutor.

     Quando isso for 'true' então 'acos(x)' será do modo 'any' sempre
     que 'x' for do modo 'float' (como escolhido por 'mode_declare').
     Quando 'false' então 'acos(x)' será do modo 'float' se e somente se
     'x' for do modo 'float'.

 -- Variável de opção: tr_function_call_default
     Valor padrão: 'general'

     'false' significa abandonando e chamando 'meval', 'expr' significa
     que Lisp assume função de argumento fixado.  'general', o código
     padrão dado como sendo bom para 'mexprs' e 'mlexprs' mas não
     'macros'.  'general' garante que associações de variável são
     corretas em códigos compilados.  No modo 'general', quando
     traduzindo F(X), se F for uma variável associada, então isso
     assumirá que 'apply (f, [x])' é significativo, e traduz como tal,
     com o alerta apropriado.  Não é necessário desabilitar isso.  Com
     as escolhas padrão, sem mensagens de alerta implica compatibilidade
     total do código traduzido e compilado com o interpretador Maxima.

 -- Variável de opção: tr_numer
     Valor padrão: 'false'

     Quando 'tr_numer' for 'true' propriedades 'numer' são usadas para
     átomos que possuem essa propriedade, e.g.  '%pi'.

 -- Variável de opção: tr_optimize_max_loop
     Valor padrão: 100

     'tr_optimize_max_loop' é número máximo de vezes do passo de
     macro-expansão e otimização que o tradutor irá executar
     considerando uma forma.  Isso é para capturar erros de expansão de
     macro, e propriedades de otimização não terminadas.

 -- Variável de opção: tr_semicompile
     Valor padrão: 'false'

     Quando 'tr_semicompile' for 'true', as formas de saída de
     'translate_file' e 'compfile' serão macroexpandidas mas não
     compiladas em código de máquina pelo compilador Lisp.

 -- Variável de sistema: tr_state_vars
     Valor padrão:
          [transcompile, tr_semicompile, tr_warn_undeclared, tr_warn_meval,
          tr_warn_fexpr, tr_warn_mode, tr_warn_undefined_variable,
          tr_function_call_default, tr_array_as_ref,tr_numer]

     A lista de comutadores que afetam a forma de saída da tradução.
     Essa informação é útil para sistemas populares quando tentam
     depurar o tradutor.  Comparando o produto traduzido para o qual
     pode ter sido produzido por um dado estado, isso é possível para
     rastrear erros.

 -- Função: tr_warnings_get ()
     Imprime uma lista de alertas que podem ter sido dadas pelo tradutor
     durante a tradução corrente.

 -- Variável de opção: tr_warn_bad_function_calls
     Valor padrão: 'true'

     - Emite um alerta quando chamadas de função estão sendo feitas por
     um caminho que pode não ser correto devido a declarações impróprias
     que foram feitas em tempo de tradução.

 -- Variável de opção: tr_warn_fexpr
     Valor padrão: 'compfile'

     - Emite um alerta se quaisquer FEXPRs forem encontradas.  FEXPRs
     não poderão normalmente ser saída em código traduzido, todas as
     formas de programa especial legítimo são traduzidas.

 -- Variável: tr_warn_meval
     Valor padrão: 'compfile'

     - Emite um alerta se a função 'meval' recebe chamadas.  Se 'meval'
     é chamada isso indica problemas na tradução.

 -- Variável: tr_warn_mode
     Valor padrão: 'all'

     - Emite um alerta quando a variáveis forem atribuídos valores
     inapropriados para seu modo.

 -- Variável de opção: tr_warn_undeclared
     Valor padrão: 'compile'

     - Determina quando enviar alertas sobre variáveis não declaradas
     para o TTY.

 -- Variável de opção: tr_warn_undefined_variable
     Valor padrão: 'all'

     - Emite um alerta quando variáveis globais indefinidas forem
     vistas.

 -- Função: compile_file (<nomearquivo>)
 -- Função: compile_file (<nomearquivo>, <nomearquivo_compilado>)
 -- Função: compile_file (<nomearquivo>, <nomearquivo_compilado>,
          <lisp_nomearquivo>)
     Traduz o arquivo Maxima <nomearquivo> para Lisp, executa o
     compilador Lisp, e, se a tradução e a compilação obtiverem sucesso,
     chama o código compilado dentro do Maxima.

     'compile_file' retorna uma lista dos nomes de quatro arquivos: o
     arquivo original do Maxima, o nome da tradução Lisp, uma arquivo de
     notas sobre a tradução, e o nome do arquivo que contém o código
     compilado.  Se a compilação falhar, o quarto item é 'false'.

     Algumas declarações e definições passam a ter efeito tão logo o
     código Lisp seja compilado (sem que seja necessário chamar o código
     compilado).  Isso inclui funções definidas com o operador ':=',
     macros definidas com o operador '::=', 'alias', 'declare',
     'define_variable', 'mode_declare', e 'infix', 'matchfix', 'nofix',
     'postfix', 'prefix', e 'compfile'.

     Atribuições e chamadas de função não serão avaliadas até que o
     código compilado seja carregado.  Em particular, dentro do arquivo
     Maxima, atribuições para sinalizadores traduzidos ('tr_numer',
     etc.)  não têm efeito sobre a tradução.

     <nomearquivo> pode não conter declarações ':lisp'.

     'compile_file' avalia seus argumentos.

 -- Função: declare_translated (<f_1>, <f_2>, ...)
     Quando traduzindo um arquivo do código Maxima para Lisp, é
     importante para o programa tradutor saber quais funções no arquivo
     são para serem chamadas como funções traduzidas ou compiladas, e
     quais outras são apenas funções Maxima ou indefinidas.  Colocando
     essa declaração no topo do arquivo, faremos conhecido que embora um
     símbolo diga que não temos ainda um valor de função Lisp, teremos
     uma em tempo de chamada.  '(MFUNCTION-CALL fn arg1 arg2 ...)' é
     gerado quando o tradutor n~ao sabe que 'fn' está sendo compilada
     para ser uma função Lisp.


File: maxima.info,  Node: Fluxo de Programa,  Next: Depurando,  Prev: Definição de Função,  Up: Top

40 Fluxo de Programa
********************

* Menu:

* Introdução a Fluxo de Programa::
* Funções e Variáveis Definidas para Fluxo de Programa::


File: maxima.info,  Node: Introdução a Fluxo de Programa,  Next: Funções e Variáveis Definidas para Fluxo de Programa,  Prev: Fluxo de Programa,  Up: Fluxo de Programa

40.1 Introdução a Fluxo de Programa
===================================

Maxima fornece um 'do' para ciclos iterativos, também contruções mais
primitivas tais como 'go'.


File: maxima.info,  Node: Funções e Variáveis Definidas para Fluxo de Programa,  Prev: Introdução a Fluxo de Programa,  Up: Fluxo de Programa

40.2 Funções e Variáveis Definidas para Fluxo de Programa
=========================================================

 -- Função: backtrace ()
 -- Função: backtrace (<n>)
     Imprime a pilha de chamadas, que é, a lista de funções que foram
     chamadas pela função correntemente ativa.

     'backtrace()' imprime toda a pilha de chamadas.

     'backtrace (<n>)' imprime as <n> mais recentes chamadas a funções,
     incluindo a função correntemente ativa.

     'backtrace' pode ser chamada por um script, uma função, ou a partir
     da linha de comando interativa (não somente em um contexto de
     depuração).

     Exemplos:

        * 'backtrace()' imprime toda a pilha de chamadas.

               (%i1) h(x) := g(x/7)$
               (%i2) g(x) := f(x-11)$
               (%i3) f(x) := e(x^2)$
               (%i4) e(x) := (backtrace(), 2*x + 13)$
               (%i5) h(10);
               #0: e(x=4489/49)
               #1: f(x=-67/7)
               #2: g(x=10/7)
               #3: h(x=10)
                                             9615
               (%o5)                         ----
                                              49

        * 'backtrace (<n>)' imprime as <n> mais recentes chamadas a
          funções, incluindo a função correntemente ativa.

               (%i1) h(x) := (backtrace(1), g(x/7))$
               (%i2) g(x) := (backtrace(1), f(x-11))$
               (%i3) f(x) := (backtrace(1), e(x^2))$
               (%i4) e(x) := (backtrace(1), 2*x + 13)$
               (%i5) h(10);
               #0: h(x=10)
               #0: g(x=10/7)
               #0: f(x=-67/7)
               #0: e(x=4489/49)
                                             9615
               (%o5)                         ----
                                              49

 -- Operador especial: do
     A declaração 'do' é usada para executar iteração.  Devido à sua
     grande generalidade a declaração 'do' será descrita em duas partes.
     Primeiro a forma usual será dada que é análoga à forma que é usada
     em muitas outras linguagens de programação (Fortran, Algol, PL/I,
     etc.); em segundo lugar os outros recursos serão mencionados.

     Existem três variantes do operador especial 'do' que diferem
     somente por suas condições de encerramento.  São elas:

        * 'for <Variável>: <valor_inicial> step <incremento> thru
          <limite> do <corpo>'
        * 'for <Variável>: <valor_inicial> step <incremento> while
          <condição> do <corpo>'
        * 'for <Variável>: <valor_inicial> step <incremento> unless
          <condição> do <corpo>'

     (Alternativamente, o 'step' pode ser dado após a <condição> de
     encerramento ou limite.)

     <valor_inicial>, <incremento>, <limite>, e <corpo> podem ser
     quaisquer expressões.  Se o incremento for 1 então "'step 1'" pode
     ser omitido.

     A execução da declaração 'do' processa-se primeiro atribuindo o
     'valor_inicial' para a variável (daqui em diante chamada a variável
     de controle).  Então: (1) Se a variável de controle excede o limite
     de uma especificação 'thru', ou se a condição de 'unless' for
     'true', ou se a condição de 'while' for 'false' então o 'do' será
     encerrado.  (2) O <corpo> é avaliado.  (3) O incremento é
     adicionado à variável de controle.  O processo de (1) a (3) é
     executado repetidamente até que a condição de encerramento seja
     satisfeita.  Pode-se também dar muitas condições de encerramento e
     nesse caso o 'do' termina quando qualquer delas for satisfeita.

     Em geral o teste 'thru' é satisfeito quando a variável de controle
     for maior que o <limite> se o incremento for não negativo, ou
     quando a variável de controle for menor que o <limite> se o
     <incremento> for negativo.  O <incremento> e o <limite> podem ser
     expressões não numéricas enquanto essa desigualdade puder ser
     determinada.  Todavia, a menos que o <incremento> seja
     sintaticamente negativo (e.g.  for um número negativo) na hora em
     que a declaração 'do' for iniciada, Maxima assume que o incremento
     e o limite serão positivos quando o 'do' for executado.  Se o
     limite e o incremento não forem positivos, então o 'do' pode não
     terminar propriamente.

     Note que o <limite>, <incremento>, e <condição> de encerramento são
     avaliados cada vez que ocorre um ciclo.  Dessa forma se qualquer
     desses for responsável por muitos cálculos, e retornar um resultado
     que não muda durante todas as execuções do <corpo>, então é mais
     eficiente escolher uma variável para seu valor prévio para o 'do' e
     usar essa variável na forma 'do'.

     O valor normalmente retornado por uma declaração 'do' é o átomo
     'done'.  Todavia, a função 'return' pode ser usada dentro do
     <corpo> para sair da delcaração 'do' prematuramente e dar a isso
     qualquer valor desejado.  Note todavia que um 'return' dentro de um
     'do' que ocorre em um 'block' encerrará somente o 'do' e não o
     'block'.  Note também que a função 'go' não pode ser usada para
     sair de dentro de um 'do' dentro de um 'block' que o envolve.

     A variável de controle é sempre local para o 'do' e dessa forma
     qualquer variável pode ser usada sem afetar o valor de uma variável
     com o mesmo nome fora da declaração 'do'.  A variável de controle é
     liberada após o encerramento da declaração 'do'.

          (%i1) for a:-3 thru 26 step 7 do display(a)$
                                       a = - 3

                                        a = 4

                                       a = 11

                                       a = 18

                                       a = 25

          (%i1) s: 0$
          (%i2) for i: 1 while i <= 10 do s: s+i;
          (%o2)                         done
          (%i3) s;
          (%o3)                          55

     Note que a condição 'while i <= 10' é equivalente a 'unless i > 10'
     e também 'thru 10'.

          (%i1) series: 1$
          (%i2) term: exp (sin (x))$
          (%i3) for p: 1 unless p > 7 do
                    (term: diff (term, x)/p,
                     series: series + subst (x=0, term)*x^p)$
          (%i4) series;
                            7    6     5    4    2
                           x    x     x    x    x
          (%o4)            -- - --- - -- - -- + -- + x + 1
                           90   240   15   8    2

     que fornece 8 termos da série de Taylor para 'e^sin(x)'.

          (%i1) poly: 0$
          (%i2) for i: 1 thru 5 do
                    for j: i step -1 thru 1 do
                        poly: poly + i*x^j$
          (%i3) poly;
                            5      4       3       2
          (%o3)          5 x  + 9 x  + 12 x  + 14 x  + 15 x
          (%i4) guess: -3.0$
          (%i5) for i: 1 thru 10 do
                    (guess: subst (guess, x, 0.5*(x + 10/x)),
                     if abs (guess^2 - 10) < 0.00005 then return (guess));
          (%o5)                  - 3.162280701754386

     Esse exemplo calcula a raíz quadrada negativa de 10 usando a
     iteração de Newton- Raphson um maximum de 10 vezes.  Caso o
     critério de convergêcia não tenha sido encontrado o valor retornado
     pode ser 'done'.  Em lugar de sempre adicionar uma quantidade à
     variável de controle pode-se algumas vezes desejar alterar isso de
     alguma outra forma para cada iteração.  Nesse caso pode-se usar
     'next <expressão>' em lugar de 'step <incremento>'.  Isso fará com
     que a variável de controle seja escolhida para o resultado de
     avaliação da <expressão> cada vez que o ciclo de repetição for
     executado.

          (%i6) for count: 2 next 3*count thru 20 do display (count)$
                                      count = 2

                                      count = 6

                                     count = 18

     Como uma alternativa para 'for <Variável>: <valor> ...do...' a
     sintaxe 'for <Variável> from <valor> ...do...' pode ser usada.
     Isso permite o 'from <valor>' ser colocado após o 'step' ou após o
     <next> valor ou após a <condição> de encerramento.  Se 'from
     <valor>' for omitido então 1 é usado como o valor inicial.

     Algumas vezes se pode estar interessado em executar uma iteração
     onde a variável de controle nunca seja usada.  Isso é permissível
     para dar somente as condições de encerramento omitindo a
     inicialização e a informação de atualização como no exemplo
     seguinte para para calcular a raíz quadrada de 5 usando uma fraca
     suposição inicial.

          (%i1) x: 1000$
          (%i2) thru 20 do x: 0.5*(x + 5.0/x)$
          (%i3) x;
          (%o3)                   2.23606797749979
          (%i4) sqrt(5), numer;
          (%o4)                   2.23606797749979

     Se isso for desejado pode-se sempre omitir as condições de
     encerramento inteiramente e apenas dar o 'do <corpo>' que o <corpo>
     continuará a ser avaliado indefinidamente.  Nesse caso a função
     'return' será usada para encerrar a execução da declaração 'do'.

          (%i1) newton (f, x):= ([y, df, dfx], df: diff (f ('x), 'x),
                    do (y: ev(df), x: x - f(x)/y,
                        if abs (f (x)) < 5e-6 then return (x)))$
          (%i2) sqr (x) := x^2 - 5.0$
          (%i3) newton (sqr, 1000);
          (%o3)                   2.236068027062195

     (Note que 'return', quando executado, faz com que o valor corrente
     de 'x' seja retornado como o valor da declaração 'do'.  O 'block' é
     encerrado e esse valor da declaração 'do' é retornado como o valor
     do 'block' porque o 'do' é a última declaração do 'block'.)

     Uma outra forma de 'do' é disponível no Maxima.  A sintaxe é:

          for <Variável> in <list> <end_tests> do <corpo>

     Os elementos de <list> são quaisquer expressões que irão
     sucessivamente ser atribuídas para a <variável> a cada iteração do
     <corpo>.  O teste opcional <end_tests> pode ser usado para encerrar
     a execução da declaração 'do'; de outra forma o 'do' terminará
     quando a <lista> for exaurida ou quando um 'return' for executado
     no <corpo>.  (De fato, a <lista> pode ser qualquer expressão não
     atômica, e partes sucessivas são usadas.)

          (%i1)  for f in [log, rho, atan] do ldisp(f(1))$
          (%t1)                                  0
          (%t2)                                rho(1)
                                               %pi
          (%t3)                                 ---
                                                4
          (%i4) ev(%t3,numer);
          (%o4)                             0.78539816

 -- Função: errcatch (<expr_1>, ..., <expr_n>)
     Avalia <expr_1>, ..., <expr_n> uma por uma e retorna '[<expr_n>]'
     (uma lista) se nenhum erro ocorrer.  Se um erro ocorrer na
     avaliação de qualquer argumento, 'errcatch' evita que o erro se
     propague e retorna a lista vazia '[]' sem avaliar quaisquer mais
     argumentos.

     'errcatch' é útil em arquivos 'batch' onde se suspeita que um erro
     possa estar ocorrendo o 'errcatch' terminará o 'batch' se o erro
     não for detectado.

 -- Função: error (<expr_1>, ..., <expr_n>)
 -- Variável de sistema: error
     Avalia e imprime <expr_1>, ..., <expr_n>, e então causa um retorno
     de erro para o nível mais alto do Maxima ou para o mais próximo
     contendo 'errcatch'.

     A variável 'error' é escolhida para uma lista descrevendo o erro.
     O primeiro elemento de 'error' é uma seqüência de caracteres de
     formato, que junta todas as seqüências de caracteres entre os
     argumentos <expr_1>, ..., <expr_n>, e os elementos restantes são os
     valores de quaisquer argumentos que não são seqüências de
     caracteres.

     'errormsg()' formata e imprime 'error'.  Isso efetivamente
     reimprime a mais recente mensagem de erro.

 -- Função: errormsg ()
     Reimprime a mais recente mensagem de erro.  A variável 'error'
     recebe a mensagem, e 'errormsg' formata e imprime essa mensagem.

 -- Operador especial: for
     Usado em iterações.  Veja 'do' para uma descrição das facilidades
     de iteração do Maxima.

 -- Função: go (<tag>)
     é usada dentro de um 'block' para transferir o controle para a
     declaração do bloco que for identificada com o argumento para 'go'.
     Para identificar uma declaração, coloque antes dessa declaração um
     argumento atômico como outra declaração no 'block'.  Por exemplo:

          block ([x], x:1, loop, x+1, ..., go(loop), ...)

     O argumento para 'go' deve ser o nome de um identificardor
     aparecendo no mesmo 'block'.  Não se pode usar 'go' para transferir
     para um identificador em um outro 'block' que não seja o próprio
     contendo o 'go'.

 -- Operador especial: if
     Representa avaliação condicional.  Várias formas de expressões 'if'
     são reconhecidas.  'if <cond_1> then <expr_1> else <expr_0>' avalia
     para <expr_1> se <cond_1> avaliar para 'true', de outra forma a
     expressão avalia para 'expr_0'.

     'if <cond_1> then <expr_1> elseif <cond_2> then <expr_2> elseif ...
     else <expr_0>' avalia para <expr_k> se <cond_k> for 'true' e todas
     as condições precedentes forem 'false'.  Se nenhuma das condições
     forem 'true', a expressão avalia para 'expr_0'.

     O comportamento 'else false' é assumido se 'else' for omitido.
     Isso é, 'if <cond_1> then <expr_1>' é equivalente a 'if <cond_1>
     then <expr_1> else false', e 'if <cond_1> then <expr_1> elseif ...
     elseif <cond_n> then <expr_n>' é equivalente a 'if <cond_1> then
     <expr_1> elseif ... elseif <cond_n> then <expr_n> else false'.

     As alternativas <expr_0>, ..., <expr_n> podem ser quaisquer
     expressões do Maxima, incluíndo expressões 'if' aninhadas ( if
     dentro de if).  As alternativas não são nem simplificadas nem
     avaliadas a menos que a correspondente condição seja 'true'.

     As condições <cond_1>, ..., <cond_n> são expressões as quais
     potencialmente ou atualmente avaliem para 'true' ou para 'false'.
     Quando uma condição não avalia atualmente para para 'true' ou para
     'false', o comportamento de 'if' é governado pelo sinalizador
     global 'prederror'.  Quando 'prederror' for 'true', isso é um erro
     se qualquer condição avaliada não avaliar para 'true' ou 'false'.
     De outra forma, condições que não avaliem para 'true' ou 'false'
     são aceitas, e o resultado é uma expressão condicional.

     Entre outros elementos, condições podem compreender operadores
     lógicos e relacionais como segue.

          Operação             Símbolo      Tipo

          menor que            <           infixo relacional
          menor que            <=
            ou igual a                     infixo relacional
          igualdade            =
            (sintática)                    infixo relacional
          negação de =         #           infixo relacional
          igualdade (valor)    equal       função relacional
          negação de           notequal
            igualdade                      função relacional
          maior que            >=
            ou igual a                     infixo relacional
          maior que            >           infixo relacional
          e                    and         infixo lógico
          ou                   or          infixo lógico
          não                  not         prefixo lógico

 -- Função: map (<f>, <expr_1>, ..., <expr_n>)
     Retorna uma expressão cujo operador principal é o mesmo que o das
     expressões <expr_1>, ..., <expr_n> mas cujas subpartes são os
     resultados da aplicação de <f> nas correspondentes subpartes das
     expressões.  <f> é ainda o nome de uma função de n argumentos ou é
     uma forma 'lambda' de n argumentos.

     'maperror' - se 'false' fará com que todas as funções mapeadas (1)
     parem quando elas terminarem retornando a menor <exp_i> se não
     forem todas as <exp_i> do mesmo comprimento e (2) aplique fn a
     [exp1, exp2,...]  se <exp_i> não forem todas do mesmo tipo de
     objeto.  Se 'maperror' for 'true' então uma mensagem de erro será
     dada nas duas instâncias acima.

     Um dos usos dessa função é para mapear ('map') uma função (e.g.
     'partfrac') sobre cada termo de uma expressão muito larga onde isso
     comumente não poderia ser possível usar a função sobre a expressão
     inteira devido a uma exaustão de espaço da lista de armazenamento
     no decorrer da computação.

          (%i1) map(f,x+a*y+b*z);
          (%o1)                        f(b z) + f(a y) + f(x)
          (%i2) map(lambda([u],partfrac(u,x)),x+1/(x^3+4*x^2+5*x+2));
                                     1       1        1
          (%o2)                     ----- - ----- + -------- + x
                                   x + 2   x + 1          2
                                                   (x + 1)
          (%i3) map(ratsimp, x/(x^2+x)+(y^2+y)/y);
                                                1
          (%o3)                            y + ----- + 1
                                              x + 1
          (%i4) map("=",[a,b],[-0.5,3]);
          (%o4)                          [a = - 0.5, b = 3]



 -- Função: mapatom (<expr>)
     Retorna 'true' se e somente se <expr> for tratada pelas rotinas de
     mapeamento como um átomo.  "Mapatoms" são átomos, números
     (incluíndo números racioanais), e variáveis subscritas.

 -- Variável de opção: maperror
     Valor padrão: 'true'

     Quando 'maperror' é 'false', faz com que todas as funções mapeadas,
     por exemplo

          map (f, <expr_1>, <expr_2>, ...)

     para (1) parar quando elas terminarem retornando a menor <exp_i> se
     não forem todas as <exp_i> do mesmo comprimento e (2) aplique 'f' a
     '[<expr_1>, <expr_2>, ...]' se 'expr_i' não forem todas do mesmo
     tipo de objeto.

     Se 'maperror' for 'true' então uma ,mensagem de erro é mostrada nas
     duas instâncias acima.

 -- Função: maplist (<f>, <expr_1>, ..., <expr_n>)
     Retorna uma lista de aplicações de <f> em todas as partes das
     expressões <expr_1>, ..., <expr_n>.  <f> é o nome de uma função, ou
     uma expressão lambda.

     'maplist' difere de 'map (<f>, <expr_1>, ..., <expr_n>)' que
     retorna uma expressão com o mesmo operador principal que <expr_i>
     tem (exceto para simplificações e o caso onde 'map' faz um
     'apply').

 -- Variável de opção: prederror
     Valor padrão: 'true'

     Quando 'prederror' for 'true', uma mensagem de erro é mostrada
     sempre que o predicado de uma declaração 'if' ou uma função 'is'
     falha em avaliar ou para 'true' ou para 'false'.

     Se 'false', 'unknown' é retornado no lugar nesse caso.  O modo
     'prederror: false' não é suportado no código traduzido; todavia,
     'maybe' é suportado no código traduzido.

     Veja também 'is' e 'maybe'.

 -- Função: return (<valor>)
     Pode ser usada para sair explicitamente de um bloco, levando seu
     argumento.  Veja 'block' para mais informação.

 -- Função: scanmap (<f>, <expr>)
 -- Função: scanmap (<f>, <expr>, bottomup)
     Recursivamente aplica <f> a <expr>, de cima para baixo.  Isso é
     muito útil quando uma fatoração completa é desejada, por exemplo:

          (%i1) exp:(a^2+2*a+1)*y + x^2$
          (%i2) scanmap(factor,exp);
                                              2      2
          (%o2)                         (a + 1)  y + x

     Note o caminho através do qual 'scanmap' aplica a dada função
     'factor' para as subexpressões constituintes de <expr>; se outra
     forma de <expr> é apresentada para 'scanmap' então o resultado pode
     ser diferente.  Dessa forma, '%o2' não é recuperada quando
     'scanmap' é aplicada para a forma expandida de <exp>:

          (%i3) scanmap(factor,expand(exp));
                                     2                  2
          (%o3)                      a  y + 2 a y + y + x

     Aqui está um outro exemplo do caminho no qual 'scanmap' aplica
     recursivamente uma função dada para todas as subexpressões,
     incluindo expoentes:

          (%i4) expr : u*v^(a*x+b) + c$
          (%i5) scanmap('f, expr);
                              f(f(f(a) f(x)) + f(b))
          (%o5) f(f(f(u) f(f(v)                      )) + f(c))

     'scanmap (<f>, <expr>, bottomup)' aplica <f> a <expr> de baixo para
     cima.  E.g., para 'f' indefinida,

          scanmap(f,a*x+b) ->
             f(a*x+b) -> f(f(a*x)+f(b)) -> f(f(f(a)*f(x))+f(b))
          scanmap(f,a*x+b,bottomup) -> f(a)*f(x)+f(b)
              -> f(f(a)*f(x))+f(b) ->
               f(f(f(a)*f(x))+f(b))

     Nesse caso, você pega a mesma resposta em ambos os caminhos.

 -- Função: throw (<expr>)
     Avalia <expr> e descarta o valor retornado para o mais recente
     'catch'.  'throw' é usada com 'catch' como um mecanismo de retorno
     não local.

 -- Operador especial: while
     Veja 'do'.

 -- Função: outermap (<f>, <a_1>, ..., <a_n>)
     Aplica a função <f> para cada um dos elementos do produto externo
     <a_1> vezes <a_2> ...  vezes <a_n>.

     <f> é o nome de uma função de n argumentos ou uma expressão lambda
     de n argumentos.  Cada argumento <a_k> pode ser uma lista simples
     ou lista aninhada ( lista contendo listas como elementos ), ou uma
     matrz, ou qualquer outro tip de expressão.

     O valor de retorno de 'outermap' é uma estrutura aninhada.  Tomemos
     <x> como sendo o valor de retorno.  Então <x> tem a mesma estrutura
     da primeira lista, lista aninhada, ou argumento matriz,
     '<x>[i_1]...[i_m]' tem a mesma estrutura que a segunda lista, lista
     aninhada, ou argumento matriz, '<x>[i_1]...[i_m][j_1]...[j_n]' tem
     a mesma estrutura que a terceira lista, lista aninhada, ou
     argumento matriz, e assim por diante, onde <m>, <n>, ...  são os
     números dos índices requeridos para acessar os elementos de cada
     argumento (um para uma lista, dois para uma matriz, um ou mais para
     uma lista aninhada).  Argumentos que não forem listas ou matrizes
     não afetam a estrutura do valor de retorno.

     Note que o efeito de 'outermap' é diferente daquele de aplicar <f>
     a cada um dos elementos do produto externo retornado por
     'cartesian_product'.  'outermap' preserva a estrutura dos
     argumentos no valor de retorno, enquanto 'cartesian_product' não
     reserva essa mesma estrutura.

     'outermap' avalia seus argumentos.

     Veja também 'map', 'maplist', e 'apply'.

     Exemplos: Exemplos elementares de 'outermap'.  Para mostrar a a
     combinação de argumentos mais claramente, 'F' está indefinida à
     esquerda.

          (%i1) outermap (F, [a, b, c], [1, 2, 3]);
          (%o1) [[F(a, 1), F(a, 2), F(a, 3)], [F(b, 1), F(b, 2), F(b, 3)],
                                               [F(c, 1), F(c, 2), F(c, 3)]]
          (%i2) outermap (F, matrix ([a, b], [c, d]), matrix ([1, 2], [3, 4]));
                   [ [ F(a, 1)  F(a, 2) ]  [ F(b, 1)  F(b, 2) ] ]
                   [ [                  ]  [                  ] ]
                   [ [ F(a, 3)  F(a, 4) ]  [ F(b, 3)  F(b, 4) ] ]
          (%o2)    [                                            ]
                   [ [ F(c, 1)  F(c, 2) ]  [ F(d, 1)  F(d, 2) ] ]
                   [ [                  ]  [                  ] ]
                   [ [ F(c, 3)  F(c, 4) ]  [ F(d, 3)  F(d, 4) ] ]
          (%i3) outermap (F, [a, b], x, matrix ([1, 2], [3, 4]));
                 [ F(a, x, 1)  F(a, x, 2) ]  [ F(b, x, 1)  F(b, x, 2) ]
          (%o3) [[                        ], [                        ]]
                 [ F(a, x, 3)  F(a, x, 4) ]  [ F(b, x, 3)  F(b, x, 4) ]
          (%i4) outermap (F, [a, b], matrix ([1, 2]), matrix ([x], [y]));
                 [ [ F(a, 1, x) ]  [ F(a, 2, x) ] ]
          (%o4) [[ [            ]  [            ] ],
                 [ [ F(a, 1, y) ]  [ F(a, 2, y) ] ]
                                        [ [ F(b, 1, x) ]  [ F(b, 2, x) ] ]
                                        [ [            ]  [            ] ]]
                                        [ [ F(b, 1, y) ]  [ F(b, 2, y) ] ]
          (%i5) outermap ("+", [a, b, c], [1, 2, 3]);
          (%o5) [[a + 1, a + 2, a + 3], [b + 1, b + 2, b + 3],
                                                     [c + 1, c + 2, c + 3]]

     Uma explanação final do valor de retorno de 'outermap'.  Os
     argumentos primeiro, segundo, e terceiro são matriz, lista, e
     matriz, respectivamente.  O valor de retorno é uma matriz.  Cada
     elementos daquela matriz é uma lista, e cada elemento de cada lista
     é uma matriz.

          (%i1) arg_1 :  matrix ([a, b], [c, d]);
                                      [ a  b ]
          (%o1)                       [      ]
                                      [ c  d ]
          (%i2) arg_2 : [11, 22];
          (%o2)                       [11, 22]
          (%i3) arg_3 : matrix ([xx, yy]);
          (%o3)                      [ xx  yy ]
          (%i4) xx_0 : outermap (lambda ([x, y, z], x / y + z), arg_1, arg_2, arg_3);
                         [  [      a        a  ]  [      a        a  ]  ]
                         [ [[ xx + --  yy + -- ], [ xx + --  yy + -- ]] ]
                         [  [      11       11 ]  [      22       22 ]  ]
          (%o4)  Col 1 = [                                              ]
                         [  [      c        c  ]  [      c        c  ]  ]
                         [ [[ xx + --  yy + -- ], [ xx + --  yy + -- ]] ]
                         [  [      11       11 ]  [      22       22 ]  ]
                           [  [      b        b  ]  [      b        b  ]  ]
                           [ [[ xx + --  yy + -- ], [ xx + --  yy + -- ]] ]
                           [  [      11       11 ]  [      22       22 ]  ]
                   Col 2 = [                                              ]
                           [  [      d        d  ]  [      d        d  ]  ]
                           [ [[ xx + --  yy + -- ], [ xx + --  yy + -- ]] ]
                           [  [      11       11 ]  [      22       22 ]  ]
          (%i5) xx_1 : xx_0 [1][1];
                     [      a        a  ]  [      a        a  ]
          (%o5)     [[ xx + --  yy + -- ], [ xx + --  yy + -- ]]
                     [      11       11 ]  [      22       22 ]
          (%i6) xx_2 : xx_0 [1][1] [1];
                                [      a        a  ]
          (%o6)                 [ xx + --  yy + -- ]
                                [      11       11 ]
          (%i7) xx_3 : xx_0 [1][1] [1] [1][1];
                                            a
          (%o7)                        xx + --
                                            11
          (%i8) [op (arg_1), op (arg_2), op (arg_3)];
          (%o8)                  [matrix, [, matrix]
          (%i9) [op (xx_0), op (xx_1), op (xx_2)];
          (%o9)                  [matrix, [, matrix]

     'outermap' preserves the structure of the arguments in the return
     value, while 'cartesian_product' does not.

          (%i1) outermap (F, [a, b, c], [1, 2, 3]);
          (%o1) [[F(a, 1), F(a, 2), F(a, 3)], [F(b, 1), F(b, 2), F(b, 3)],
                                               [F(c, 1), F(c, 2), F(c, 3)]]
          (%i2) setify (flatten (%));
          (%o2) {F(a, 1), F(a, 2), F(a, 3), F(b, 1), F(b, 2), F(b, 3),
                                                 F(c, 1), F(c, 2), F(c, 3)}
          (%i3) map (lambda ([L], apply (F, L)), cartesian_product ({a, b, c}, {1, 2, 3}));
          (%o3) {F(a, 1), F(a, 2), F(a, 3), F(b, 1), F(b, 2), F(b, 3),
                                                 F(c, 1), F(c, 2), F(c, 3)}
          (%i4) is (equal (%, %th (2)));
          (%o4)                         true


File: maxima.info,  Node: Depurando,  Next: augmented_lagrangian,  Prev: Fluxo de Programa,  Up: Top

41 Depurando
************

* Menu:

* Depurando o Código Fonte::
* Comandos Palavra Chave::
* Funções e Variáveis Definidas para Depuração::


File: maxima.info,  Node: Depurando o Código Fonte,  Next: Comandos Palavra Chave,  Up: Depurando

41.1 Depurando o Código Fonte
=============================

Maxima tem um depurador interno de código fonte.  O usuário pode
escolher um ponto de parada em uma função, e então caminhar linha por
linha a partir daí.  A pilha de chamadas po ser examinada, juntamente
com as variáveis associadas àquele nível.

   O comando ':help' ou ':h' mostra a lista de comando de depuração.
(Em geral, comandos podem ser abreviados se a abreviação for única.  Se
não for única, as alternativas podem ser listadas.)  Dentro do
depurador, o usuário pode também usar qualquer funções comuns do Maxima
para examinar, definir, e manipular variáveis e expressões.

   Um ponto de parada é escolhido através do comando ':br' na linha de
comando do Maxima.  Dentro do depurador, o usuário pode avançar uma
linha de cada vez usando o comando ':n' ("next").  o comando ':bt'
("backtrace") mostra uma lista da pilha de frames.  O comando ':r'
("resume") sai do depurador e continua com a execução.  Esses comandos
são demostrados no exemplo abaixo.

     (%i1) load ("/tmp/foobar.mac");

     (%o1)                           /tmp/foobar.mac

     (%i2) :br foo
     Turning on debugging debugmode(true)
     Bkpt 0 for foo (in /tmp/foobar.mac line 1)

     (%i2) bar (2,3);
     Bkpt 0:(foobar.mac 1)
     /tmp/foobar.mac:1::

     (dbm:1) :bt                        <-- :bt digitado aqui lista os frames
     #0: foo(y=5)(foobar.mac line 1)
     #1: bar(x=2,y=3)(foobar.mac line 9)

     (dbm:1) :n                         <-- Aqui digite :n para avançar linha
     (foobar.mac 2)
     /tmp/foobar.mac:2::

     (dbm:1) :n                         <-- Aqui digite :n para avançar linha
     (foobar.mac 3)
     /tmp/foobar.mac:3::

     (dbm:1) u;                         <-- Investiga o valor de u
     28

     (dbm:1) u: 33;                     <-- Altera u para ser 33
     33

     (dbm:1) :r                         <-- Digite :r para retomar a computação

     (%o2)                                1094

   O arquivo '/tmp/foobar.mac' é o seguinte:

     foo(y) := block ([u:y^2],
       u: u+3,
       u: u^2,
       u);

     bar(x,y) := (
       x: x+2,
       y: y+2,
       x: foo(y),
       x+y);

   USO DO DEPURADOR ATRAVÉS DO EMACS

   Se o usuário estiver rodando o código sob o GNU emacs em uma janela
shell (shell dbl), ou está rodando a versão de interface gráfica,
Xmaxima, então se ele para em um ponto de parada, ele verá sua posição
corrente no arquivo fonte a qua será mostrada na outra metade da janela,
ou em vermelho brilhante, ou com um pequeno seta apontando na direita da
linha.  Ele pode avançar uma linha por vez digitando M-n (Alt-n).

   Sob Emacs você pode executar em um shell 'dbl', o qual requer o
arquivo 'dbl.el' no diretório elisp.  Tenha certeza que instalou os
arquivos elisp ou adicionou o diretório elisp do Macima ao seu caminho:
e.g., adicione o seguinte ao seu arquivo '.emacs' ou ao seu arquivo
'site-init.el'

     (setq load-path (cons "/usr/share/maxima/5.9.1/emacs" load-path))
     (autoload 'dbl "dbl")

   então no emacs

     M-x dbl

   pode iniciar uma janela shell na qual você pode executar programas,
por exemplo Maxima, gcl, gdb etc.  Essa janela de shell também reconhece
informações sobre depuração de código fonte, e mostra o código fonte em
outra janela.

   O usuário pode escolher um ponto de parada em certa linha do arquivo
digitando 'C-x space'.  Isso encontra qual a função que o cursor está
posicionado, e então mostra qual a linha daquela função que o cursor
está habilitado.  Se o cursor estiver habilitado, digamos, na linha 2 de
'foo', então isso irá inserir na outra janela o comando, "':br foo 2'",
para parar 'foo' nessa segunda linha.  Para ter isso habilitado, o
usuário deve ter maxima-mode.el habilitado na janela na qual o arquivo
'foobar.mac' estiver interagindo.  Existe comandos adicional disponíveis
naquela janela de arquivo, tais como avaliando a função dentro do
Maxima, através da digitação de 'Alt-Control-x'.


File: maxima.info,  Node: Comandos Palavra Chave,  Next: Funções e Variáveis Definidas para Depuração,  Prev: Depurando o Código Fonte,  Up: Depurando

41.2 Comandos Palavra Chave
===========================

Comandos palavra chave são palavras chaves especiais que não são
interpretadas como expressões do Maxima.  Um comando palavra chave pode
ser inserido na linha de comando do Maxima ou na linha de comando do
depurador, embora não possa ser inserido na linha de comando de parada.
Comandos palavra chave iniciam com um dois pontos, ':'.  Por exemplo,
para avaliar uma forma Lisp você pode digitar ':lisp' seguido pela forma
a ser avaliada.

     (%i1) :lisp (+ 2 3)
     5

   O número de argumentos tomados depende do comando em particular.
Também, você não precisa digitar o comando completo, apenas o suficiente
para ser único no meio das palavras chave de parada.  Dessa forma ':br'
será suficiente para ':break'.

   Os comandos de palavra chave são listados abaixo.

':break F n'
     Escolhe um ponto de parada em uma função 'F' na linha 'n' a partir
     do início da função.  Se 'F' for dado como uma seqüência de
     caracteres, então essa seqüência de caracteres é assumida
     referir-se a um arquivo, e 'n' é o deslocamente a partir do início
     do arquivo.  O deslocamento é opcional.  Se for omitido, é assumido
     ser zero (primeira linha da função ou do arquivo).
':bt'
     Imprime na tela uma lista da pilha de frames
':continue'
     Continua a computação
':delete'
     Remove o ponto de parada selecionado, ou todos se nenum for
     especificado
':disable'
     Desabilita os pontos de parada selecionados, ou todos se nenhum for
     especificado
':enable'
     Habilita os pontos de de parada especificados, ou todos se nenhum
     for especificado
':frame n'
     Imprime na tela a pilha de frame 'n', ou o corrente frame se nenhum
     for especificado
':help'
     Imprime na tela a ajuda sobre um comando do depurador, ou todos os
     comandos se nenhum for especificado
':info'
     Imprime na tela informações sobre um item
':lisp alguma-forma'
     Avalia 'alguma-forma' como uma forma Lisp
':lisp-quiet alguma-forma'
     Avalia a forma Lisp 'alguma-forma' sem qualquer saída
':next'
     Como ':step', exceto ':next' passos sobre chamadas de fução
':quit'
     Sai do nível corrente do depurador sem concluir a computação
':resume'
     Continua a computação
':step'
     Continua a computação até encontraruma nova linha de códico
':top'
     Retorne para a linha de comando do Maxima (saindo de qualquer nível
     do depurador) sem completar a computação


File: maxima.info,  Node: Funções e Variáveis Definidas para Depuração,  Prev: Comandos Palavra Chave,  Up: Depurando

41.3 Funções e Variáveis Definidas para Depuração
=================================================

 -- Variável de opção: refcheck
     Valor padrão: 'false'

     Quando 'refcheck' for 'true', Maxima imprime uma mensagem cada vez
     que uma variável associada for usada pela primeira vez em uma
     computação.

 -- Variável de opção: setcheck
     Valor padrão: 'false'

     Se 'setcheck' for escolhido para uma lista de variáveis (as quais
     podem ser subscritas), Maxima mostra uma mensagem quando as
     variáveis, ou ocorrências subscritas delas, forem associadas com o
     operador comum de atribuição ':', o operador '::' de atribuição, ou
     associando argumentos de função, mas não com o operador de
     atribuição de função ':=' nem o operador de atribuição '::=' de
     macro.  A mensagem compreende o nome das variáveis e o valor
     associado a ela.

     'setcheck' pode ser escolhida para 'all' ou 'true' incluindo desse
     modo todas as variáveis.

     Cada nova atribuição de 'setcheck' estabelece uma nova lista de
     variáveis para verificar, e quaisquer variáveis previamente
     atribuídas a 'setcheck' são esquecidas.

     Os nomes atribuídos a 'setcheck' devem ter um apóstrofo no início
     se eles forem de outra forma avaliam para alguma outra coisa que
     não eles mesmo.  Por exemplo, se 'x', 'y', e 'z' estiverem
     atualmente associados, então digite

          setcheck: ['x, 'y, 'z]$

     para colocá-los na lista de variáveis monitoradas.

     Nenhuma saída é gerada quando uma variável na lista 'setcheck' for
     atribuída a sí mesma, e.g., 'X: 'X'.

 -- Variável de opção: setcheckbreak
     Valor padrão: 'false'

     Quando 'setcheckbreak' for 'true', Maxima mostrará um ponto de
     parada quando uma variável sob a lista 'setcheck' for atribuída a
     um novo valor.  A parada ocorre antes que a atribuíção seja
     concluída.  Nesse ponto, 'setval' retém o valor para o qual a
     variável está para ser atribuída.  Conseqüentemente, se pode
     atribuir um valor diferente através da atribuição a 'setval'.

     Veja também 'setcheck' e 'setval'.

 -- Variável de sistema: setval
     Mantém o valor para o qual a variável está para ser escolhida
     quando um 'setcheckbreak' ocorrer.  Conseqüentemente, se pode
     atribuir um valor diferente através da atribuição a 'setval'.

     Veja também 'setcheck' e 'setcheckbreak'.

 -- Função: timer (<f_1>, ..., <f_n>)
 -- Função: timer (all)
 -- Função: timer ()
     Dadas as funções <f_1>, ..., <f_n>, 'timer' coloca cada uma na
     lista de funções para as quais cronometragens estatísticas são
     coletadas.  'timer(f)$ timer(g)$' coloca 'f' e então 'g' sobre a
     lista; a lista acumula de uma chamada para a chamada seguinte.

     'timer(all)' coloca todas as funções definidas pelo usuário (a
     saber pela variável global 'functions') na lista de funções
     monitoradas pela função 'time'.

     Sem argumentos, 'timer' retorna a lista das funções tempo
     estatisticamente monitoradas.

     Maxima armazena quanto tempo é empregado executando cada função na
     lista de funções tempo estatisticamente monitoradas.  'timer_info'
     retorna a coronometragem estatística, incluindo o tempo médio
     decorrido por chamada de função, o número de chamadas, e o tempo
     total decorrido.  'untimer' remove funções da lista de funções
     tempo estatisticamente monitoradas.

     'timer' não avalia seus argumentos.  'f(x) := x^2$ g:f$ timer(g)$'
     não coloca 'f' na lista de funções estatisticamente monitoradas.

     Se 'trace(f)' está vigorando, então 'timer(f)' não tem efeito;
     'trace' e 'timer' não podem ambas atuarem ao mesmo tempo.

     Veja também 'timer_devalue'.

 -- Função: untimer (<f_1>, ..., <f_n>)
 -- Função: untimer ()
     Dadas as funções <f_1>, ..., <f_n>, 'untimer' remove cada uma das
     funções listadas da lista de funções estatisticamente monitoradas.

     Sem argumentos, 'untimer' remove todas as funções atualmente na
     lista de funções estatisticamente monitoradas.

     Após 'untimer (f)' ser executada, 'timer_info (f)' ainda retorna
     estatisticas de tempo previamente coletadas, embora 'timer_info()'
     (sem argumentos) não retorna informações sobre qualquer função que
     não estiver atualmente na lista de funções tempo estatisticamente
     monitoradas.  'timer (f)' reposiciona todas as estatisticas de
     tempo para zero e coloca 'f' na lista de funções estatisticamente
     monitoradas novamente.

 -- Variável de opção: timer_devalue
     Valor Padrão: 'false'

     Quando 'timer_devalue' for 'true', Maxima subtrai de cada função
     estatisticamente monitorada o tempo empregado em ou funções
     estatisticamente monitoradas.  De outra forma, o tempo reportado
     para cada função inclui o tempo empregado em outras funções.  Note
     que tempo empregado em funções não estatisticamente monitoradas não
     é subtraído do tempo total.

     Veja também 'timer' e 'timer_info'.

 -- Função: timer_info (<f_1>, ..., <f_n>)
 -- Função: timer_info ()
     Dadas as funções <f_1>, ..., <f_n>, 'timer_info' retorna uma matriz
     contendo informações de cronometragem para cada função.  Sem
     argumentos, 'timer_info' retorna informações de cronometragem para
     todas as funções atualmente na lista de funções estatisticamente
     monitoradas.

     A matriz retornada através de 'timer_info' contém o nome da função,
     tempo por chamda de função, número de chamadas a funções,tempo
     total, e 'gctime', cujja forma "tempo de descarte" no Macsyma
     original mas agora é sempre zero.

     Os dados sobre os quais 'timer_info' constrói seu valor de retorno
     podem também serem obtidos através da função 'get':

          get(f, 'calls);  get(f, 'runtime);  get(f, 'gctime);

     Veja também 'timer'.

 -- Função: trace (<f_1>, ..., <f_n>)
 -- Função: trace (all)
 -- Função: trace ()
     Dadas as funções <f_1>, ..., <f_n>, 'trace' instrui Maxima para
     mostrar informações de depuração quando essas funções forem
     chamadas.  'trace(f)$ trace(g)$' coloca 'f' e então 'g' na lista de
     funções para serem colocadas sob a ação de 'trace'; a lista acumula
     de uma chamada para a seguinte.

     'trace(all)' coloca todas as funções definidas pelo usuário (a
     saber pela variável global 'functions') na lista de funções a serem
     monitoradas pela função 'trace'.

     Sem argumentos, 'trace' retorna uma lista de todas as funções
     atualmente sob a ação de 'trace'.

     A função 'untrace' desabilita a ação de 'trace'.  Veja também
     'trace_options'.

     'trace' não avalia seus argumentos.  Dessa forma, 'f(x) := x^2$
     g:f$ trace(g)$' não coloca 'f' sobre a lista de funções monitoradas
     pela função 'trace'.

     Quando uma função for redefinida, ela é removida da lista de
     'timer'.  Dessa forma após 'timer(f)$ f(x) := x^2$', a função 'f'
     não mais está na lista de 'timer'.

     Se 'timer (f)' estiver em efeito, então 'trace (f)' não está
     agindo; 'trace' e 'timer' não podem ambas estar agindo para a mesma
     função.

 -- Função: trace_options (<f>, <option_1>, ..., <option_n>)
 -- Função: trace_options (<f>)
     Escolhe as opções de 'trace' para a função <f>.  Quaisquer opções
     anteriores são substituídas.  'trace_options (<f>, ...)' não tem
     efeito a menos que 'trace (<f>)' tenha sido também chamada (ou
     antes ou após 'trace_options').

     'trace_options (<f>)' reposiciona todas as opções para seus valores
     padrão.

     As opções de palavra chave são:

        * 'noprint' Não mostre uma mensagem na entrada da função e saia.
        * 'break' Coloque um ponto de parada antes da função ser
          inserida, e após a funçãos er retirada.  Veja 'break'.
        * 'lisp_print' Mostre argumentos e valores de retorno com
          objetos Lisp.
        * 'info' Mostre '-> true' na entrada da funçào e saia.
        * 'errorcatch' Capture os erros, fornecendo a opção para
          sinalizar um erro, tentar novamente a chamada de função, ou
          especificar um valor de retorno.

     Opções para 'trace' são especificadas em duas formas.  A presença
     da palavra chave de opção sozinha coloca a opção para ter efeito
     incondicionalmente.  (Note que opção <foo> não coloca para ter
     efeito especificando '<foo>: true' ou uma forma similar; note
     também que palavras chave não precisam estar com apóstrofo.)
     Especificando a opção palavra chave com uma função predicado torna
     a opção condicional sobre o predicado.

     A lista de argumentos para a função predicado é sempre '[level,
     direction, function, item]' onde 'level' é o nível rerecursão para
     a função, 'direction' é ou 'enter' ou 'exit', 'function' é o nome
     da função, e 'item' é a lista de argumentos (sobre entrada) ou o
     valor de retorno (sobre a saída).

     Aqui está um exemplo de opções incondicionais de 'trace':

          (%i1) ff(n) := if equal(n, 0) then 1 else n * ff(n - 1)$

          (%i2) trace (ff)$

          (%i3) trace_options (ff, lisp_print, break)$

          (%i4) ff(3);

     Aqui está a mesma função, com a opção 'break' condicional sobre um
     predicado:

          (%i5) trace_options (ff, break(pp))$

          (%i6) pp (level, direction, function, item) := block (print (item),
              return (function = 'ff and level = 3 and direction = exit))$

          (%i7) ff(6);

 -- Função: untrace (<f_1>, ..., <f_n>)
 -- Função: untrace ()
     Dadas as funções <f_1>, ..., <f_n>, 'untrace' desabilita a a
     monitoração habilitada pela função 'trace'.  Sem argumentos,
     'untrace' desabilita a atuação da função 'trade' para todas as
     funções.

     'untrace' retorne uma lista das funções para as quais 'untrace'
     desabilita a atuação de 'trace'.


File: maxima.info,  Node: augmented_lagrangian,  Next: bode,  Prev: Depurando,  Up: Top

42 augmented_lagrangian
***********************

* Menu:

* Funções e Variáveis Definidas para augmented_lagrangian::


File: maxima.info,  Node: Funções e Variáveis Definidas para augmented_lagrangian,  Prev: augmented_lagrangian,  Up: augmented_lagrangian

42.1 Funções e Variáveis Definidas para augmented_lagrangian
============================================================

 -- Função: augmented_lagrangian_method (<FOM>, <xx>, <C>, <yy>)
 -- Função: augmented_lagrangian_method (<FOM>, <xx>, <C>, <yy>,
          args_opcionais)

     Retorna um mínimo aproximado da expressão <FOM> com relação às
     variáveis <xx>, mantendo restrito o valor de <C> a zero.  <yy> é
     uma lista de suposições iniciais para <xx>.  O método utilizado é o
     método do Lagrangiano aumentado (veja referências [1] e [2]).

     'args_opcionais' representam argumentos adicionais, especificados
     como '<símbolo> = <valor>'.  Os argumentos opcionais que podem ser
     colocados no lugar de <símbolo>:

     'niter'
          Número de iterações do algorítmo do Langrangiano aumentado
     'lbfgs_tolerance'
          Tolerância forneceida a LBFGS (Limited-memory, Broyden,
          Fletcher, Goldfarb, Shanno)
     'iprint'
          Parâmetro IPRINT (uma lista de dois inteiros que controlam o
          nível de informação) fornecido a LBFGS
     '%lambda'
          Valor inicial de '%lambda' a ser usado durante o cálculo do
          Lagrangiano aumentado

     Essa implementação minimiza o Lagrangiano aumentado pela pela
     aplicação do algorítmo de memória limitada BFGS (LBFGS), que é um
     algorítmo quasi-Newton.

     'load(augmented_lagrangian)' chama essa função.

     Veja também 'lbfgs'.

     References:

     [1]
     http://www-fp.mcs.anl.gov/otc/Guide/OptWeb/continuous/constrained/nonlinearcon/auglag.html

     [2] http://www.cs.ubc.ca/spider/ascher/542/chap10.pdf

     Exemplo:

          (%i2) load (augmented_lagrangian);
          (%o2) /home/robert/tmp/maxima-release-branch/maxima/share/contri\
          b/augmented_lagrangian.mac
          (%i3) FOM: x^2 + 2*y^2;
                                         2    2
          (%o3)                       2 y  + x
          (%i4) xx: [x, y];
          (%o4)                        [x, y]
          (%i5) C: [x + y - 1];
          (%o5)                      [y + x - 1]
          (%o6)                        [1, 1]
          (%i7) augmented_lagrangian_method (FOM, xx, C, yy, iprint = [-1, 0]);
          (%o7) [[x = 0.6478349888525, y = 0.32391749442625],
                                           %lambda = [- 1.267422460983745]]


File: maxima.info,  Node: bode,  Next: contrib_ode,  Prev: augmented_lagrangian,  Up: Top

43 bode
*******

* Menu:

* Funções e Variáveis Definidas para bode::


File: maxima.info,  Node: Funções e Variáveis Definidas para bode,  Prev: bode,  Up: bode

43.1 Funções e Variáveis Definidas para bode
============================================

 -- Função: bode_gain (<H>, <range>, ...<plot_opts>...)
     Função para desenhar gráficos de ganho para Bode.

     Exemplos (1 a 7 provenientes de
          http://www.swarthmore.edu/NatSci/echeeve1/Ref/Bode/BodeHow.html,
     8 proveniente de Ron Crummett):
          (%i1) load("bode")$

          (%i2) H1 (s) := 100 * (1 + s) / ((s + 10) * (s + 100))$

          (%i3) bode_gain (H1 (s), [w, 1/1000, 1000])$

          (%i4) H2 (s) := 1 / (1 + s/omega0)$

          (%i5) bode_gain (H2 (s), [w, 1/1000, 1000]), omega0 = 10$

          (%i6) H3 (s) := 1 / (1 + s/omega0)^2$

          (%i7) bode_gain (H3 (s), [w, 1/1000, 1000]), omega0 = 10$

          (%i8) H4 (s) := 1 + s/omega0$

          (%i9) bode_gain (H4 (s), [w, 1/1000, 1000]), omega0 = 10$

          (%i10) H5 (s) := 1/s$

          (%i11) bode_gain (H5 (s), [w, 1/1000, 1000])$

          (%i12) H6 (s) := 1/((s/omega0)^2 + 2 * zeta * (s/omega0) + 1)$

          (%i13) bode_gain (H6 (s), [w, 1/1000, 1000]),
                            omega0 = 10, zeta = 1/10$

          (%i14) H7 (s) := (s/omega0)^2 + 2 * zeta * (s/omega0) + 1$

          (%i15) bode_gain (H7 (s), [w, 1/1000, 1000]),
                            omega0 = 10, zeta = 1/10$

          (%i16) H8 (s) := 0.5 / (0.0001 * s^3 + 0.002 * s^2 + 0.01 * s)$

          (%i17) bode_gain (H8 (s), [w, 1/1000, 1000])$

     Para usar essa função escreva primeiramente 'load("bode")'.  Veja
     também 'bode_phase'

 -- Função: bode_phase (<H>, <range>, ...<plot_opts>...)
     Função para desenhar gráficos de fase para Bode

     Exemplos (1 a 7 provenientes de
          http://www.swarthmore.edu/NatSci/echeeve1/Ref/Bode/BodeHow.html,
     8 proveniente de Ron Crummett):
          (%i1) load("bode")$

          (%i2) H1 (s) := 100 * (1 + s) / ((s + 10) * (s + 100))$

          (%i3) bode_phase (H1 (s), [w, 1/1000, 1000])$

          (%i4) H2 (s) := 1 / (1 + s/omega0)$

          (%i5) bode_phase (H2 (s), [w, 1/1000, 1000]), omega0 = 10$

          (%i6) H3 (s) := 1 / (1 + s/omega0)^2$

          (%i7) bode_phase (H3 (s), [w, 1/1000, 1000]), omega0 = 10$

          (%i8) H4 (s) := 1 + s/omega0$

          (%i9) bode_phase (H4 (s), [w, 1/1000, 1000]), omega0 = 10$

          (%i10) H5 (s) := 1/s$

          (%i11) bode_phase (H5 (s), [w, 1/1000, 1000])$

          (%i12) H6 (s) := 1/((s/omega0)^2 + 2 * zeta * (s/omega0) + 1)$

          (%i13) bode_phase (H6 (s), [w, 1/1000, 1000]),
                             omega0 = 10, zeta = 1/10$

          (%i14) H7 (s) := (s/omega0)^2 + 2 * zeta * (s/omega0) + 1$

          (%i15) bode_phase (H7 (s), [w, 1/1000, 1000]),
                             omega0 = 10, zeta = 1/10$

          (%i16) H8 (s) := 0.5 / (0.0001 * s^3 + 0.002 * s^2 + 0.01 * s)$

          (%i17) bode_phase (H8 (s), [w, 1/1000, 1000])$

          (%i18) block ([bode_phase_unwrap : false],
                        bode_phase (H8 (s), [w, 1/1000, 1000]));

          (%i19) block ([bode_phase_unwrap : true],
                        bode_phase (H8 (s), [w, 1/1000, 1000]));

     Para usar essa função escreva primeiramente 'load("bode")'.  Veja
     também 'bode_gain'


File: maxima.info,  Node: contrib_ode,  Next: descriptive,  Prev: bode,  Up: Top

44 contrib_ode
**************

* Menu:

* Introdução a contrib_ode::
* Funções e Variáveis Definidas para contrib_ode::
* Possibilidades de melhorias em contrib_ode::
* Casos de teste para contrib_ode::
* Referências bibliográficas para contrib_ode::


File: maxima.info,  Node: Introdução a contrib_ode,  Next: Funções e Variáveis Definidas para contrib_ode,  Prev: contrib_ode,  Up: contrib_ode

44.1 Introdução a contrib_ode
=============================

O resolvedor de equações diferenciais ordinárias (EDO) do MAXIMA, o
'ode2', resolve EDO's elementares de primeira e segunda ordem.  A função
'contrib_ode' extende 'ode2' com métodos adicionais para EDO's lineares
e EDO's não lineares de primeira ordem e EDO's lineares homogêneas de
segunda ordem.  O código está ainda em desenvolvimemto e a seqüência de
chamada da função pode mudar em futuras versões.  Uma vez que o código
estiver estabilizado essa função pode ser movida do diretório contrib e
integrada dentro do MAXIMA.

   Esse pacote deve torna-se disponível para uso com o comando
'load('contrib_ode)' em primeiro lugar.

   A convenção de chamada para 'contrib_ode' é idêntica a 'ode2'.  Toma
três argumentos: uma EDO (somente o lado esquerdo precisa ser fornecido
se o lado direito for 0), a variável dependente, e a variável
independente.  Quando 'contrib_ode' obtiver sucesso, retorna uma lista
de soluções.

   A forma de retorno da lista de solução difere de 'ode2'.  Como
equações não lineares podem ter múltiplas soluções, 'contrib_ode'
retorna uma lista de soluções.  Cada solução pode ter várias formas:
   * uma solução explícita para a variável dependente,

   * uma solução implícita para a variável dependente,

   * uma solução paramétrica em termos de variável %t, ou

   * uma transfrmação em outra EDO na variável %u.

   '%c' é usado para representar a constante de integração para equações
de primeira ordem.  '%k1' e '%k2' são constantes para equações de
segunda ordem.  Se 'contrib_ode' não puder obter uma solução por
qualquer razão, 'false' é retornado, após talvez mostrar uma mensagem de
erro.

   Isso é necessário para retornar uma lista de soluções, como mesmo
EDO's de primeira ordem não lineares podem ter soluções multiplas.  Por
exemplo:

     (%i1) load('contrib_ode)$

     (%i2) eqn:x*'diff(y,x)^2-(1+x*y)*'diff(y,x)+y=0;

                         dy 2             dy
     (%o2)            x (--)  - (x y + 1) -- + y = 0
                         dx               dx
     (%i3) contrib_ode(eqn,y,x);

                                                  x
     (%o3)             [y = log(x) + %c, y = %c %e ]
     (%i4) method;

     (%o4)                        factor

   EDO's não lineares podem ter soluções singulares sem constantes de
integração, como na segunda solução do seguinte exemplo:

     (%i1) load('contrib_ode)$

     (%i2) eqn:'diff(y,x)^2+x*'diff(y,x)-y=0;

                            dy 2     dy
     (%o2)                 (--)  + x -- - y = 0
                            dx       dx
     (%i3) contrib_ode(eqn,y,x);

                                                2
                                      2        x
     (%o3)              [y = %c x + %c , y = - --]
                                               4
     (%i4) method;

     (%o4)                       clairault

   A seguinte EDO possui duas soluções paramétricas em termos da
variável fictícia %t.  Nesse caso as soluções paramétricaspodem ser
manipuladas para fornecer soluções explícitas.

     (%i1) load('contrib_ode)$

     (%i2) eqn:'diff(y,x)=(x+y)^2;

                               dy          2
     (%o2)                     -- = (y + x)
                               dx
     (%i3) contrib_ode(eqn,y,x);

     (%o3) [[x = %c - atan(sqrt(%t)), y = - x - sqrt(%t)],
                          [x = atan(sqrt(%t)) + %c, y = sqrt(%t) - x]]
     (%i4) method;

     (%o4)                       lagrange

   O seguinte exemplo (Kamke 1.112) demonstra uma solução implícita.

     (%i1) load('contrib_ode)$

     (%i2) assume(x>0,y>0);

     (%o2)                    [x > 0, y > 0]
     (%i3) eqn:x*'diff(y,x)-x*sqrt(y^2+x^2)-y;

                          dy           2    2
     (%o3)              x -- - x sqrt(y  + x ) - y
                          dx
     (%i4) contrib_ode(eqn,y,x);

                                       y
     (%o4)                  [x - asinh(-) = %c]
                                       x
     (%i5) method;

     (%o5)                          lie

   A seguinte equação de Riccati é transformada em uma EDO linear de
segunda ordem na variável %u.  MAXIMA não está apto a resolver a nova
EDO, de forma que essa nova EDO é retornada sem avaliação.
     (%i1) load('contrib_ode)$

     (%i2) eqn:x^2*'diff(y,x)=a+b*x^n+c*x^2*y^2;

                         2 dy      2  2      n
     (%o2)              x  -- = c x  y  + b x  + a
                           dx
     (%i3) contrib_ode(eqn,y,x);

                    d%u
                    ---                            2
                    dx        2     n - 2   a     d %u
     (%o3)  [[y = - ----, %u c  (b x      + --) + ---- c = 0]]
                    %u c                     2      2
                                            x     dx
     (%i4) method;

     (%o4)                        riccati

   Para EDO's de primeira ordem 'contrib_ode' chama 'ode2'.  'ode2'
tenta então os seguintes métodos: fatoração, Clairault, Lagrange,
Riccati, Abel e os métodos de simetria de Lie.  O método de Lie não é
tentado sobre equações de Abel se o método de Abel falhar, mas é tendado
se o método de Riccati uma EDO de segunda ordem não resolvida.

   Para EDO's de segunda ordem 'contrib_ode' chama 'ode2' e em seguida
'odelin'.

   Rastros extensivos de depuração mensagens são mostradas se o comando
'put('contrib_ode,true,'verbose)' for executado.


File: maxima.info,  Node: Funções e Variáveis Definidas para contrib_ode,  Next: Possibilidades de melhorias em contrib_ode,  Prev: Introdução a contrib_ode,  Up: contrib_ode

44.2 Funções e Variáveis Definidas para contrib_ode
===================================================

 -- Função: contrib_ode (<eqn>, <y>, <x>)

     Retorna uma lista de soluções da EDO <eqn> com variável
     independente <x> e variável dependente <y>.

 -- Função: odelin (<eqn>, <y>, <x>)

     'odelin' resolve EDO's lineares homogêneas de primeira e segunda
     ordem com variável independente <x> e variável dependente <y>.
     'odelin' retorna um conjunto solução fundamental da EDO.

     para EDO's de segunda ordem, 'odelin' usa um método, devido a
     Bronstein e Lafaille, que busca por soluções em termos de funções
     especiais dadas.

          (%i1) load('contrib_ode);

          (%i2) odelin(x*(x+1)*'diff(y,x,2)+(x+5)*'diff(y,x,1)+(-4)*y,y,x);
          ...trying factor method
          ...solving 7 equations in 4 variables
          ...trying the Bessel solver
          ...solving 1 equations in 2 variables
          ...trying the F01 solver
          ...solving 1 equations in 3 variables
          ...trying the spherodial wave solver
          ...solving 1 equations in 4 variables
          ...trying the square root Bessel solver
          ...solving 1 equations in 2 variables
          ...trying the 2F1 solver
          ...solving 9 equations in 5 variables
                 gauss_a(- 6, - 2, - 3, - x)  gauss_b(- 6, - 2, - 3, - x)
          (%o2) {---------------------------, ---------------------------}
                              4                            4
                             x                            x


 -- Função: ode_check (<eqn>, <sol>)

     Retorna o valor da EDO <eqn> após substituir uma possível solução
     <sol>.  O valor é igual a zero se <sol> for uma solução of <eqn>.

          (%i1) load('contrib_ode)$

          (%i2) eqn:'diff(y,x,2)+(a*x+b)*y;

                                   2
                                  d y
          (%o2)                   --- + (a x + b) y
                                    2
                                  dx
          (%i3) ans:[y = bessel_y(1/3,2*(a*x+b)^(3/2)/(3*a))*%k2*sqrt(a*x+b)
                   +bessel_j(1/3,2*(a*x+b)^(3/2)/(3*a))*%k1*sqrt(a*x+b)];

                                            3/2
                              1  2 (a x + b)
          (%o3) [y = bessel_y(-, --------------) %k2 sqrt(a x + b)
                              3       3 a
                                                    3/2
                                      1  2 (a x + b)
                           + bessel_j(-, --------------) %k1 sqrt(a x + b)]
                                      3       3 a
          (%i4) ode_check(eqn,ans[1]);

          (%o4)                           0

 -- Variável global: 'method'

     A variável 'method' é escolhida para o método que resolver com
     sucesso uma dada EDO.

 -- Variável: '%c'

     '%c' é a constante de integração para EDO's de primeira ordem.

 -- Variável: '%k1'

     '%k1' é a primeira constante de integração para EDO's de segunda
     ordem.

 -- Variável: '%k2'

     '%k2' é a segunda constante de integração para EDO's de segunda
     ordem.

 -- Função: gauss_a (<a>, <b>, <c>, <x>)

     'gauss_a(a,b,c,x)' e 'gauss_b(a,b,c,x)' são funções
     hipergeométricas 2F1.  Elas represetnam quaisquer duas soluções
     independentes da equação diferencial hipergeométrica 'x(1-x)
     diff(y,x,2) + [c-(a+b+1)x diff(y,x) - aby = 0' (A&S 15.5.1).

     O único uso dessas funções é em soluções de EDO's retornadas por
     'odelin' e 'contrib_ode'.  A definição e o uso dessas funções pode
     mudar em futuras versões do maxima.

     Veja também 'gauss_b', 'dgauss_a' e 'gauss_b'.

 -- Função: gauss_b (<a>, <b>, <c>, <x>)
     Veja 'gauss_a'.

 -- Função: dgauss_a (<a>, <b>, <c>, <x>)
     A derivada em relação a x de 'gauss_a(a,b,c,x)'.

 -- Função: dgauss_b (<a>, <b>, <c>, <x>)
     A derivada em relação a x de 'gauss_b(a,b,c,x)'.

 -- Função: kummer_m (<a>, <b>, <x>)

     A função M de Kummer, como definida em Abramowitz e Stegun,
     Handbook of Mathematical Functions, Section 13.1.2.

     O único uso dessas funções é em soluções de EDO's retornadas por
     'odelin' e 'contrib_ode'.  A definição e o uso dessas funções pode
     mudar em futuras versões do maxima.

     Veja também 'kummer_u', 'dkummer_m' e 'dkummer_u'.

 -- Função: kummer_u (<a>, <b>, <x>)

     A função U de Kummer, como definida em Abramowitz e Stegun,
     Handbook of Mathematical Functions, Section 13.1.3.

     Veja 'kummer_m'.

 -- Função: dkummer_m (<a>, <b>, <x>)
     A derivada com relação a x de 'kummer_m(a,b,x)'.

 -- Função: dkummer_u (<a>, <b>, <x>)
     A derivada com relação a x de 'kummer_u(a,b,x)'.


File: maxima.info,  Node: Possibilidades de melhorias em contrib_ode,  Next: Casos de teste para contrib_ode,  Prev: Funções e Variáveis Definidas para contrib_ode,  Up: contrib_ode

44.3 Possibilidades de melhorias em contrib_ode
===============================================

Essas rotinas aida estão sendo aperfeiçoadas.  É necessário ainda:

   * Extender o método FACTOR 'ode1_factor' para trabalhar com raízes
     multiplas.

   * Extender o método FACTOR 'ode1_factor' para tentar resolver fatores
     de mais alta ordem.  Atualmente somente tenta resolver fatores
     lineares.

   * Corrigir a rotina de LAGRANGE 'ode1_lagrange' para preferiraízes
     reais a raízes complexas.

   * Aumentar a quantidade de métodos adicionais para equações de
     Riccati.

   * Melhorar a detecção de equações de Abel do segundo tipo.  O modelo
     existente de coincidência é fraco.

   * Trabalho sobre a rotina do grupo de simetria de Lie 'ode1_lie'.
     Existem poucos porém grandes problemas com essa rotina: algumas
     partes precisam de implementação; alguns casos de teste parecem
     executar indefinidamente; outros casos de teste abortam
     inesplicavelmente; outros ainda retorna "soluções" muito complexas.
     Seria surpreendente se estivesse pronto para se liberar uma versão
     estável.

   * Adicionar mais casos de teste.


File: maxima.info,  Node: Casos de teste para contrib_ode,  Next: Referências bibliográficas para contrib_ode,  Prev: Possibilidades de melhorias em contrib_ode,  Up: contrib_ode

44.4 Casos de teste para contrib_ode
====================================

Asrotinas foram tesadas sobre aproximadamente mil casos de teste por
Murphy, Kamke, Zwillinger e outros.  Esses testes estão incluídos no
subdiretório de testes.

   * A rotina de Clairault 'ode1_clairault' encontra todas as soluções
     conhecidas, incluindo soluções singulares, das equações de
     Clairault em Murphy e Kamke.

   * As outras rotinas muitas vezes retornam uma solução simples quando
     existem multiplas soluções.

   * Algumas das "soluções" de 'ode1_lie' são extremamente complexas e
     impossíveis de verificar.

   * Existe algumas interrupções inexplicávies de execução.


File: maxima.info,  Node: Referências bibliográficas para contrib_ode,  Prev: Casos de teste para contrib_ode,  Up: contrib_ode

44.5 Referências bibliográficas para contrib_ode
================================================

  1. E Kamke, Differentialgleichungen Losungsmethoden und Losungen, Vol
     1, Geest & Portig, Leipzig, 1961

  2. G M Murphy, Ordinary Differential Equations and Their Solutions,
     Van Nostrand, New York, 1960

  3. D Zwillinger, Handbook of Differential Equations, 3rd edition,
     Academic Press, 1998

  4. F Schwarz, Symmetry Analysis of Abel's Equation, Studies in Applied
     Mathematics, 100:269-294 (1998)

  5. F Schwarz, Algorithmic Solution of Abel's Equation, Computing 61,
     39-49 (1998)

  6. E. S. Cheb-Terrab, A. D. Roche, Symmetries and First Order EDO
     Patterns, Computer Physics Communications 113 (1998), p 239.
     (http://lie.uwaterloo.ca/papers/ode_vii.pdf)

  7. E. S. Cheb-Terrab, T. Koloknikov, First Order EDO's, Symmetries and
     Linear Transformations, European Journal of Applied Mathematics,
     Vol.  14, No.  2, pp.  231-246 (2003).
     (http://arxiv.org/abs/math-ph/0007023)
     (http://lie.uwaterloo.ca/papers/ode_iv.pdf)

  8. G W Bluman, S C Anco, Symmetry and Integration Methods for
     Differential Equations, Springer, (2002)

  9. M Bronstein, S Lafaille, Solutions of linear ordinary equações
     diferenciais in terms of special functions, Proceedings of ISSAC
     2002, Lille, ACM Press, 23-28.
     (http://www-sop.inria.fr/cafe/Manuel.Bronstein/publications/issac2002.pdf)


File: maxima.info,  Node: descriptive,  Next: diag,  Prev: contrib_ode,  Up: Top

45 descriptive
**************

* Menu:

* Introdução ao pacote descriptive::
* Funções e Variáveis Definidas para manipulação da dados::
* Funções e Variáveis Definidas para estatística descritiva::
* Funções e Variáveis Definidas específicas para estatística descritiva de várias variáveis::
* Funções e Variáveis Definidas para gráficos estatísticos::


File: maxima.info,  Node: Introdução ao pacote descriptive,  Next: Funções e Variáveis Definidas para manipulação da dados,  Prev: descriptive,  Up: descriptive

45.1 Introdução ao pacote descriptive
=====================================

O pacote 'descriptive' contém um conjunto de funções para fazer cálculos
de estatística descritiva e desenhar gráficos.  Juntamente com o código
fonte três conjuntos de dados em suar árvore do Maxima: 'pidigits.data',
'wind.data' e 'biomed.data'.  Eles também podem ser baixados a partir de
'www.biomates.net'.

   Qualque manual de estatística pode ser usado como referência para as
funções no pacote 'descriptive'.

   Para comentários, erros ou sugestões, por favor entre em contato
comigo em <'mario AT edu DOT xunta DOT es'>.

   Aqui está um exemplo sobre como as funções de estatística descritiva
no pacote 'descriptive' fazem esse trabalho, dependendo da natureza de
seus argumentos, listas e matrizes,

     (%i1) load (descriptive)$
     (%i2) /* univariate sample */   mean ([a, b, c]);
                                 c + b + a
     (%o2)                       ---------
                                     3
     (%i3) matrix ([a, b], [c, d], [e, f]);
                                 [ a  b ]
                                 [      ]
     (%o3)                       [ c  d ]
                                 [      ]
                                 [ e  f ]
     (%i4) /* amostra de várias variáveis */ mean (%);
                           e + c + a  f + d + b
     (%o4)                [---------, ---------]
                               3          3

   Note que em amostras de várias variáveis a média é calculada em cada
coluna.

   No caso de muitas amostras amostras com possíveis tamanhos
diferentes, A função do Maxima 'map' pode ser usada para pegar os
resultados desejados de cada amostra,

     (%i1) load (descriptive)$
     (%i2) map (mean, [[a, b, c], [d, e]]);
                             c + b + a  e + d
     (%o2)                  [---------, -----]
                                 3        2

   Nesse caso, duas amostras de tamanhos 3 e 2 foram armazenadas em uma
lista.

   Amostras de uma única variável devem ser armazenadas em listas como

     (%i1) s1 : [3, 1, 4, 1, 5, 9, 2, 6, 5, 3, 5];
     (%o1)           [3, 1, 4, 1, 5, 9, 2, 6, 5, 3, 5]

   e amostras de várias variáveis em matrizes como em

     (%i1) s2 : matrix ([13.17, 9.29], [14.71, 16.88], [18.50, 16.88],
                  [10.58, 6.63], [13.33, 13.25], [13.21,  8.12]);
                             [ 13.17  9.29  ]
                             [              ]
                             [ 14.71  16.88 ]
                             [              ]
                             [ 18.5   16.88 ]
     (%o1)                   [              ]
                             [ 10.58  6.63  ]
                             [              ]
                             [ 13.33  13.25 ]
                             [              ]
                             [ 13.21  8.12  ]

   Nesse caso, o número de colunas é igual à dimensão (ao número) de
variáveis e o n;umero de linhas é o tamano da amostra.

   Dados podem ser introduzidos manualmente, mas grandes amostras são
usualmente armazenadas em arquivos no formato texto plano.  Por exemplo,
o arquivo 'pidigits.data' contém os primeiros 100 dígitos do número
'%pi':
           3
           1
           4
           1
           5
           9
           2
           6
           5
           3 ...

   Com o objetivo de chamar esses dígitos no Maxima,

     (%i1) load (numericalio)$
     (%i2) s1 : read_list (file_search ("pidigits.data"))$
     (%i3) length (s1);
     (%o3)                          100

   Por outro lado, o arquivo 'wind.data' contém a média diária de
velocidades do ventoem 5 estações meteorológicas na República da Irlanda
(Esses dados são parte de um conjunto de dados tomados em 12 estações
meteorológicas.  O arquivo original está disponivel livremente para
download no Repositório de Dados StatLib e sua análise é discutida em
Haslett, J., Raftery, A. E. (1989) <Space-time Modelling with
Long-memory Dependence: Assessing Ireland's Wind Power Resource, with
Discussion>.  Applied Statistics 38, 1-50).  As linhas seguintes mostram
como tornar os dados disponíveis para o Maxima:

     (%i1) load (numericalio)$
     (%i2) s2 : read_matrix (file_search ("wind.data"))$
     (%i3) length (s2);
     (%o3)                          100
     (%i4) s2 [%]; /* last record */
     (%o4)            [3.58, 6.0, 4.58, 7.62, 11.25]

   Algumas amostras possuem dados não numéricos.  Como um exemplo, o
arquivo 'biomed.data' (que é parte de outro grande arquivo tomado do
Repósitório de Dados StatLib) contém quatro medidas sangüíneas tomadas
de dois grupos de pacientes, 'A' e 'B', de diferentes idades,

     (%i1) load (numericalio)$
     (%i2) s3 : read_matrix (file_search ("biomed.data"))$
     (%i3) length (s3);
     (%o3)                          100
     (%i4) s3 [1]; /* first record */
     (%o4)            [A, 30, 167.0, 89.0, 25.6, 364]

   O primeiro indivíduo pertence ao grupo 'A', com 30 anos de idade e
suas medidas sangüíneas foram 167.0, 89.0, 25.6 e 364.

   Se deve tomar cuidado quando se trabalha com dados divididos por
categorias.  no exemplo seguinte, ao símbolo 'a' é atribuído um valor em
algum momento anterior e então a amostra com valores divididos por
categoria 'a' é interpretada como,

     (%i1) a : 1$
     (%i2) matrix ([a, 3], [b, 5]);
                                 [ 1  3 ]
     (%o2)                       [      ]
                                 [ b  5 ]


File: maxima.info,  Node: Funções e Variáveis Definidas para manipulação da dados,  Next: Funções e Variáveis Definidas para estatística descritiva,  Prev: Introdução ao pacote descriptive,  Up: descriptive

45.2 Funções e Variáveis Definidas para manipulação da dados
============================================================

 -- Função: continuous_freq (<list>)
 -- Função: continuous_freq (<list>, <m>)
     O argumetno de 'continuous_freq' deve ser uma lista de números, que
     serão então agrupadas em intervalos e contado quantos desses dados
     pertencem a cada grupo.  Opcionalmente, a função 'continuous_freq'
     admite um segundo argumento indicando o número de classes, 10 é o
     valor padrão,

          (%i1) load (numericalio)$
          (%i2) load (descriptive)$
          (%i3) s1 : read_list (file_search ("pidigits.data"))$
          (%i4) continuous_freq (s1, 5);
          (%o4) [[0, 1.8, 3.6, 5.4, 7.2, 9.0], [16, 24, 18, 17, 25]]

     A primeira lista contém os limites de intervalos e o segundo a
     correspondente contagem: existem 16 algarismos da parte decimal de
     '%pi' dentro do intervalo '[0, 1.8]', isto é 0's e 1's, 24
     algarismos em '(1.8, 3.6]', isto é 2's e 3's, e assim por diante.

 -- Função: discrete_freq (<list>)
     Conta as freqüências absolutas em amostras discretas, em amostras
     numéricas e em amostras divididas em categorias.  Seu único
     argumento é uma lista,

          (%i1) load (descriptive)$
          (%i2) load (numericalio)$
          (%i3) s1 : read_list (file_search ("pidigits.data"));
          (%o3) [3, 1, 4, 1, 5, 9, 2, 6, 5, 3, 5, 8, 9, 7, 9, 3, 2, 3, 8,
          4, 6, 2, 6, 4, 3, 3, 8, 3, 2, 7, 9, 5, 0, 2, 8, 8, 4, 1, 9, 7,
          1, 6, 9, 3, 9, 9, 3, 7, 5, 1, 0, 5, 8, 2, 0, 9, 7, 4, 9, 4, 4,
          5, 9, 2, 3, 0, 7, 8, 1, 6, 4, 0, 6, 2, 8, 6, 2, 0, 8, 9, 9, 8,
          6, 2, 8, 0, 3, 4, 8, 2, 5, 3, 4, 2, 1, 1, 7, 0, 6, 7]
          (%i4) discrete_freq (s1);
          (%o4) [[0, 1, 2, 3, 4, 5, 6, 7, 8, 9],
                                       [8, 8, 12, 12, 10, 8, 9, 8, 12, 13]]

     A primeira lista fornece os valores da amostra e a segunda seuas
     freqüências absolutas.  Os comandos '? col' e '? transpose' podem
     ajudar a você a entender a última entrada.

 -- Função: subsample (<matriz_de_dados>, <expressão_lógica>)
 -- Função: subsample (<matriz_de_dados>, <expressão_lógica>, <col_num>,
          <col_num>, ...)
     Essas funções são um tipo de variação da função 'submatrix' do
     Maxima.  O primeiro argumento é o nome da matriz de dados, o
     segundo argumento é uma expressão lógica que recebeu apóstrofo e os
     argumentos opcionais adicionais são o número de colunas a serem
     tomadas.  Esse comportamento é melhor entendido com exemplos,

          (%i1) load (descriptive)$
          (%i2) load (numericalio)$
          (%i3) s2 : read_matrix (file_search ("wind.data"))$
          (%i4) subsample (s2, '(%c[1] > 18));
                        [ 19.38  15.37  15.12  23.09  25.25 ]
                        [                                   ]
                        [ 18.29  18.66  19.08  26.08  27.63 ]
          (%o4)         [                                   ]
                        [ 20.25  21.46  19.95  27.71  23.38 ]
                        [                                   ]
                        [ 18.79  18.96  14.46  26.38  21.84 ]

     Existem registros de várias variáveis nos quais a velocidade do
     vento na primeira estação meteorológica foram maiores que 18.  Veja
     que na expressão lógica que recebeu apóstrofo o <i>-ésimo
     componente é referenciado como '%c[i]'.  O símbolo '%c[i]' é usado
     dentro da função 'subsample', portanto quando usado como uma
     variável de uma categoria, Maxima fica confuso.  No seguinte
     exemplo, requisitamos somente o primeiro, o segundo e o quinto
     componentes desses registro com velocidades de vento maiores que ou
     igual a 16 nós na estação meteorológica número 1 e menor que 25 nós
     na estação meteorológica número 4,

          (%i1) load (descriptive)$
          (%i2) load (numericalio)$
          (%i3) s2 : read_matrix (file_search ("wind.data"))$
          (%i4) subsample (s2, '(%c[1] >= 16 and %c[4] < 25), 1, 2, 5);
                               [ 19.38  15.37  25.25 ]
                               [                     ]
                               [ 17.33  14.67  19.58 ]
          (%o4)                [                     ]
                               [ 16.92  13.21  21.21 ]
                               [                     ]
                               [ 17.25  18.46  23.87 ]

     Aqui está um exemplo com as variáveis divididas em categorias do
     arquivo 'biomed.data'.  Queremos os registros correspondentes a
     aqueles pacientes no grupo 'B' que possuem idade maior que 38 anos,

          (%i1) load (descriptive)$
          (%i2) load (numericalio)$
          (%i3) s3 : read_matrix (file_search ("biomed.data"))$
          (%i4) subsample (s3, '(%c[1] = B and %c[2] > 38));
                          [ B  39  28.0  102.3  17.1  146 ]
                          [                               ]
                          [ B  39  21.0  92.4   10.3  197 ]
                          [                               ]
                          [ B  39  23.0  111.5  10.0  133 ]
                          [                               ]
                          [ B  39  26.0  92.6   12.3  196 ]
          (%o4)           [                               ]
                          [ B  39  25.0  98.7   10.0  174 ]
                          [                               ]
                          [ B  39  21.0  93.2   5.9   181 ]
                          [                               ]
                          [ B  39  18.0  95.0   11.3  66  ]
                          [                               ]
                          [ B  39  39.0  88.5   7.6   168 ]

     Probavelmente, a análise estatística irá envolver somente as
     medidas sangüíneas,

          (%i1) load (descriptive)$
          (%i2) load (numericalio)$
          (%i3) s3 : read_matrix (file_search ("biomed.data"))$
          (%i4) subsample (s3, '(%c[1] = B and %c[2] > 38), 3, 4, 5, 6);
                             [ 28.0  102.3  17.1  146 ]
                             [                        ]
                             [ 21.0  92.4   10.3  197 ]
                             [                        ]
                             [ 23.0  111.5  10.0  133 ]
                             [                        ]
                             [ 26.0  92.6   12.3  196 ]
          (%o4)              [                        ]
                             [ 25.0  98.7   10.0  174 ]
                             [                        ]
                             [ 21.0  93.2   5.9   181 ]
                             [                        ]
                             [ 18.0  95.0   11.3  66  ]
                             [                        ]
                             [ 39.0  88.5   7.6   168 ]

     Essa é a média de várias variáveis de 's3',

          (%i1) load (descriptive)$
          (%i2) load (numericalio)$
          (%i3) s3 : read_matrix (file_search ("biomed.data"))$
          (%i4) mean (s3);
                 65 B + 35 A  317          6 NA + 8145.0
          (%o4) [-----------, ---, 87.178, -------------, 18.123,
                     100      10                100
                                                              3 NA + 19587
                                                              ------------]
                                                                  100
     Aqui, a primeira componente é sem sentido, uma vez que 'A' e 'B'
     são categorias, o segundo componente é a idade média dos indivíduos
     na forma racional, e o quarto eo último valores exibem um
     comportamento estranho.  Isso ocorre porque o símbolo 'NA' é usado
     aqui para indicar dado não disponível (<non available> em inglês),
     e as duas médias são certamente sem sentido.  Uma solução possível
     pode ser jogar fora a matriz cujas linhas possuam símbolos 'NA',
     embora isso cause alguma perda de informação,

          (%i1) load (descriptive)$
          (%i2) load (numericalio)$
          (%i3) s3 : read_matrix (file_search ("biomed.data"))$
          (%i4) mean (subsample (s3, '(%c[4] # NA and %c[6] # NA), 3, 4, 5, 6));
          (%o4) [79.4923076923077, 86.2032967032967, 16.93186813186813,
                                                                      2514
                                                                      ----]
                                                                       13


File: maxima.info,  Node: Funções e Variáveis Definidas para estatística descritiva,  Next: Funções e Variáveis Definidas específicas para estatística descritiva de várias variáveis,  Prev: Funções e Variáveis Definidas para manipulação da dados,  Up: descriptive

45.3 Funções e Variáveis Definidas para estatística descritiva
==============================================================

 -- Função: mean (<lista>)
 -- Função: mean (<matriz>)
     Essa função calcula a média de uma amostra, definida como
                                 n
                               ====
                       _   1   \
                       x = -    >    x
                           n   /      i
                               ====
                               i = 1

     Exemplo:

          (%i1) load (descriptive)$
          (%i2) load (numericalio)$
          (%i3) s1 : read_list (file_search ("pidigits.data"))$
          (%i4) mean (s1);
                                         471
          (%o4)                          ---
                                         100
          (%i5) %, numer;
          (%o5)                         4.71
          (%i6) s2 : read_matrix (file_search ("wind.data"))$
          (%i7) mean (s2);
          (%o7)     [9.9485, 10.1607, 10.8685, 15.7166, 14.8441]

 -- Função: var (<list>)
 -- Função: var (<matrix>)
     This is the sample variance, defined as
                               n
                             ====
                     2   1   \          _ 2
                    s  = -    >    (x - x)
                         n   /       i
                             ====
                             i = 1

     Exemplo:

          (%i1) load (descriptive)$
          (%i2) load (numericalio)$
          (%i3) s1 : read_list (file_search ("pidigits.data"))$
          (%i4) var (s1), numer;
          (%o4)                   8.425899999999999

     See also function 'var1'.

 -- Função: var1 (<lista>)
 -- Função: var1 (<matriz>)
     Essa função calcula a variância da amostra, definida como
                               n
                             ====
                         1   \          _ 2
                        ---   >    (x - x)
                        n-1  /       i
                             ====
                             i = 1

     Exemplo:

          (%i1) load (descriptive)$
          (%i2) load (numericalio)$
          (%i3) s1 : read_list (file_search ("pidigits.data"))$
          (%i4) var1 (s1), numer;
          (%o4)                    8.5110101010101
          (%i5) s2 : read_matrix (file_search ("wind.data"))$
          (%i6) var1 (s2);
          (%o6) [17.39586540404041, 15.13912778787879, 15.63204924242424,
                                      32.50152569696971, 24.66977392929294]

     See also function 'var'.

 -- Função: std (<lista>)
 -- Função: std (<matriz>)
     A raíz quadrada da função 'var', a variância com denominador n.

     Exemplo:

          (%i1) load (descriptive)$
          (%i2) load (numericalio)$
          (%i3) s1 : read_list (file_search ("pidigits.data"))$
          (%i4) std (s1), numer;
          (%o4)                   2.902740084816414
          (%i5) s2 : read_matrix (file_search ("wind.data"))$
          (%i6) std (s2);
          (%o6) [4.149928523480858, 3.871399812729241, 3.933920277534866,
                                      5.672434260526957, 4.941970881136392]

     Veja também as funções 'var' e 'std1'.

 -- Função: std1 (<lista>)
 -- Função: std1 (<matriz>)
     É a raíz quadrada da função 'var1', a variância com denominador
     n-1.

     Exemplo:

          (%i1) load (descriptive)$
          (%i2) load (numericalio)$
          (%i3) s1 : read_list (file_search ("pidigits.data"))$
          (%i4) std1 (s1), numer;
          (%o4)                   2.917363553109228
          (%i5) s2 : read_matrix (file_search ("wind.data"))$
          (%i6) std1 (s2);
          (%o6) [4.17083509672109, 3.89090320978032, 3.953738641137555,
                                      5.701010936401517, 4.966867617451963]

     Veja também as funções 'var1' e 'std'.

 -- Função: noncentral_moment (<lista>, <k>)
 -- Função: noncentral_moment (<matriz>, <k>)
     O momento não central de ordem k, definido como
                                 n
                               ====
                           1   \      k
                           -    >    x
                           n   /      i
                               ====
                               i = 1

     Exemplo:

          (%i1) load (descriptive)$
          (%i2) load (numericalio)$
          (%i3) s1 : read_list (file_search ("pidigits.data"))$
          (%i4) noncentral_moment (s1, 1), numer; /* the mean */
          (%o4)                         4.71
          (%i6) s2 : read_matrix (file_search ("wind.data"))$
          (%i7) noncentral_moment (s2, 5);
          (%o7) [319793.8724761506, 320532.1923892463, 391249.5621381556,
                                      2502278.205988911, 1691881.797742255]

     Veja também a função 'central_moment'.

 -- Função: central_moment (<lista>, <k>)
 -- Função: central_moment (<matriz>, <k>)
     O momento central de ordem k, definido como
                              n
                            ====
                        1   \          _ k
                        -    >    (x - x)
                        n   /       i
                            ====
                            i = 1

     Exemplo:

          (%i1) load (descriptive)$
          (%i2) load (numericalio)$
          (%i3) s1 : read_list (file_search ("pidigits.data"))$
          (%i4) central_moment (s1, 2), numer; /* a variância */
          (%o4)                   8.425899999999999
          (%i6) s2 : read_matrix (file_search ("wind.data"))$
          (%i7) central_moment (s2, 3);
          (%o7) [11.29584771375004, 16.97988248298583, 5.626661952750102,
                                       37.5986572057918, 25.85981904394192]

     Veja também as funções 'central_moment' e 'mean'.

 -- Função: cv (<lista>)
 -- Função: cv (<matriz>)
     O coeficiente de variação é o quociente entre o desvio padrão da
     amostra ('std') e a média 'mean',

          (%i1) load (descriptive)$
          (%i2) load (numericalio)$
          (%i3) s1 : read_list (file_search ("pidigits.data"))$
          (%i4) cv (s1), numer;
          (%o4)                   .6193977819764815
          (%i5) s2 : read_matrix (file_search ("wind.data"))$
          (%i6) cv (s2);
          (%o6) [.4192426091090204, .3829365309260502, 0.363779605385983,
                                      .3627381836021478, .3346021393989506]

     Veja também as funções 'std' e 'mean'.

 -- Função: mini (<lista>)
 -- Função: mini (<matriz>)
     É o valor mínimo da amostra <lista>,

          (%i1) load (descriptive)$
          (%i2) load (numericalio)$
          (%i3) s1 : read_list (file_search ("pidigits.data"))$
          (%i4) mini (s1);
          (%o4)                           0
          (%i5) s2 : read_matrix (file_search ("wind.data"))$
          (%i6) mini (s2);
          (%o6)             [0.58, 0.5, 2.67, 5.25, 5.17]

     Veja também função 'maxi'.

 -- Função: maxi (<lista>)
 -- Função: maxi (<matriz>)
     É o valor máximo da amostra <lista>,

          (%i1) load (descriptive)$
          (%i2) load (numericalio)$
          (%i3) s1 : read_list (file_search ("pidigits.data"))$
          (%i4) maxi (s1);
          (%o4)                           9
          (%i5) s2 : read_matrix (file_search ("wind.data"))$
          (%i6) maxi (s2);
          (%o6)          [20.25, 21.46, 20.04, 29.63, 27.63]

     Veja também a função 'mini'.

 -- Função: range (<lista>)
 -- Função: range (<matriz>)
     A amplitude é a diferença entre os valores de maximo e de mínimo.

     Exemplo:

          (%i1) load (descriptive)$
          (%i2) load (numericalio)$
          (%i3) s1 : read_list (file_search ("pidigits.data"))$
          (%i4) range (s1);
          (%o4)                           9
          (%i5) s2 : read_matrix (file_search ("wind.data"))$
          (%i6) range (s2);
          (%o6)          [19.67, 20.96, 17.37, 24.38, 22.46]

 -- Função: quantile (<lista>, <p>)
 -- Função: quantile (<matriz>, <p>)
     É o <p>-'quantile' (quantil de ordem <p>), com <p> sendo um número
     em [0, 1] (intervalo fechado), da amostra <lista>.  Embora exista
     muitas definições para quantil de uma amostra (Hyndman, R. J., Fan,
     Y. (1996) <Sample quantiles in statistical packages>.  American
     Statistician, 50, 361-365), aquela que se baseia em interpolação
     linear é a que foi implementada no pacote 'descriptive'.

     Exemplo:

          (%i1) load (descriptive)$
          (%i2) load (numericalio)$
          (%i3) s1 : read_list (file_search ("pidigits.data"))$
          (%i4) /* 1st and 3rd quartiles */ [quantile (s1, 1/4), quantile (s1, 3/4)], numer;
          (%o4)                      [2.0, 7.25]
          (%i5) s2 : read_matrix (file_search ("wind.data"))$
          (%i6) quantile (s2, 1/4);
          (%o6)    [7.2575, 7.477500000000001, 7.82, 11.28, 11.48]

 -- Função: median (<lista>)
 -- Função: median (<matriz>)
     Uma vez que a amostra está ordenada, se o tamanho da amostra for
     ímpar a mediana é o valor central, de outra forma a mediana será a
     média dos dois valores centrais.

     Exemplo:

          (%i1) load (descriptive)$
          (%i2) load (numericalio)$
          (%i3) s1 : read_list (file_search ("pidigits.data"))$
          (%i4) median (s1);
                                          9
          (%o4)                           -
                                          2
          (%i5) s2 : read_matrix (file_search ("wind.data"))$
          (%i6) median (s2);
          (%o6)         [10.06, 9.855, 10.73, 15.48, 14.105]

     A mediana é o 1/2-'quantil'.

     Veja também function 'quantile'.

 -- Função: qrange (<lista>)
 -- Função: qrange (<matriz>)
     A amplitude do interquartil é a diferença entre o terceiro e o
     primeiro quartil, 'quantile(<lista>,3/4) - quantile(<lista>,1/4)',

          (%i1) load (descriptive)$
          (%i2) load (numericalio)$
          (%i3) s1 : read_list (file_search ("pidigits.data"))$
          (%i4) qrange (s1);
                                         21
          (%o4)                          --
                                         4
          (%i5) s2 : read_matrix (file_search ("wind.data"))$
          (%i6) qrange (s2);
          (%o6) [5.385, 5.572499999999998, 6.0225, 8.729999999999999,
                                                         6.650000000000002]

     Veja também a função 'quantile'.

 -- Função: mean_deviation (<lista>)
 -- Função: mean_deviation (<matriz>)
     O desvio médio, definido como
                               n
                             ====
                         1   \          _
                         -    >    |x - x|
                         n   /       i
                             ====
                             i = 1

     Exemplo:

          (%i1) load (descriptive)$
          (%i2) load (numericalio)$
          (%i3) s1 : read_list (file_search ("pidigits.data"))$
          (%i4) mean_deviation (s1);
                                         51
          (%o4)                          --
                                         20
          (%i5) s2 : read_matrix (file_search ("wind.data"))$
          (%i6) mean_deviation (s2);
          (%o6) [3.287959999999999, 3.075342, 3.23907, 4.715664000000001,
                                                         4.028546000000002]

     Veja também a função 'mean'.

 -- Função: median_deviation (<lista>)
 -- Função: median_deviation (<matriz>)
     O desvio da mediana, definido como
                           n
                         ====
                     1   \
                     -    >    |x - med|
                     n   /       i
                         ====
                         i = 1
     onde 'med' é a mediana da <lista>.

     Exemplo:

          (%i1) load (descriptive)$
          (%i2) load (numericalio)$
          (%i3) s1 : read_list (file_search ("pidigits.data"))$
          (%i4) median_deviation (s1);
                                          5
          (%o4)                           -
                                          2
          (%i5) s2 : read_matrix (file_search ("wind.data"))$
          (%i6) median_deviation (s2);
          (%o6)           [2.75, 2.755, 3.08, 4.315, 3.31]

     Veja também a função 'mean'.

 -- Função: harmonic_mean (<lista>)
 -- Função: harmonic_mean (<matriz>)
     A média harmônica, definida como
                            n
                         --------
                          n
                         ====
                         \     1
                          >    --
                         /     x
                         ====   i
                         i = 1

     Exemplo:

          (%i1) load (descriptive)$
          (%i2) load (numericalio)$
          (%i3) y : [5, 7, 2, 5, 9, 5, 6, 4, 9, 2, 4, 2, 5]$
          (%i4) harmonic_mean (y), numer;
          (%o4)                   3.901858027632205
          (%i5) s2 : read_matrix (file_search ("wind.data"))$
          (%i6) harmonic_mean (s2);
          (%o6) [6.948015590052786, 7.391967752360356, 9.055658197151745,
                                      13.44199028193692, 13.01439145898509]

     Veja também as funções 'mean' e 'geometric_mean'.

 -- Função: geometric_mean (<lista>)
 -- Função: geometric_mean (<matriz>)
     A média geométrica, definida como
                           /  n      \ 1/n
                           | /===\   |
                           |  ! !    |
                           |  ! !  x |
                           |  ! !   i|
                           | i = 1   |
                           \         /

     Exemplo:

          (%i1) load (descriptive)$
          (%i2) load (numericalio)$
          (%i3) y : [5, 7, 2, 5, 9, 5, 6, 4, 9, 2, 4, 2, 5]$
          (%i4) geometric_mean (y), numer;
          (%o4)                   4.454845412337012
          (%i5) s2 : read_matrix (file_search ("wind.data"))$
          (%i6) geometric_mean (s2);
          (%o6) [8.82476274347979, 9.22652604739361, 10.0442675714889,
                                      14.61274126349021, 13.96184163444275]

     Veja também as funções 'mean' e 'harmonic_mean'.

 -- Função: kurtosis (<lista>)
 -- Função: kurtosis (<matriz>)
     O coeficiente de curtose, definido como
                              n
                            ====
                      1     \          _ 4
                     ----    >    (x - x)  - 3
                        4   /       i
                     n s    ====
                            i = 1

     Exemplo:

          (%i1) load (descriptive)$
          (%i2) load (numericalio)$
          (%i3) s1 : read_list (file_search ("pidigits.data"))$
          (%i4) kurtosis (s1), numer;
          (%o4)                  - 1.273247946514421
          (%i5) s2 : read_matrix (file_search ("wind.data"))$
          (%i6) kurtosis (s2);
          (%o6) [- .2715445622195385, 0.119998784429451,
             - .4275233490482866, - .6405361979019522, - .4952382132352935]

     Veja também as funções 'mean', 'var' e 'skewness'.

 -- Função: skewness (<lista>)
 -- Função: skewness (<matriz>)
     O coeficiente de assimetria, definido como
                              n
                            ====
                      1     \          _ 3
                     ----    >    (x - x)
                        3   /       i
                     n s    ====
                            i = 1

     Exemplo:

          (%i1) load (descriptive)$
          (%i2) load (numericalio)$
          (%i3) s1 : read_list (file_search ("pidigits.data"))$
          (%i4) skewness (s1), numer;
          (%o4)                  .009196180476450306
          (%i5) s2 : read_matrix (file_search ("wind.data"))$
          (%i6) skewness (s2);
          (%o6) [.1580509020000979, .2926379232061854, .09242174416107717,
                                      .2059984348148687, .2142520248890832]

     Veja também as funções 'mean', 'var' e 'kurtosis'.

 -- Função: pearson_skewness (<lista>)
 -- Função: pearson_skewness (<matriz>)
     O coeficiente de assimetria de pearson, definido como
                          _
                       3 (x - med)
                       -----------
                            s
     onde <med> é a mediana de <lista>.

     Exemplo:

          (%i1) load (descriptive)$
          (%i2) load (numericalio)$
          (%i3) s1 : read_list (file_search ("pidigits.data"))$
          (%i4) pearson_skewness (s1), numer;
          (%o4)                   .2159484029093895
          (%i5) s2 : read_matrix (file_search ("wind.data"))$
          (%i6) pearson_skewness (s2);
          (%o6) [- .08019976629211892, .2357036272952649,
                   .1050904062491204, .1245042340592368, .4464181795804519]

     Veja também as funções 'mean', 'var' e 'median'.

 -- Função: quartile_skewness (<lista>)
 -- Função: quartile_skewness (<matriz>)
     O coeficiented de assimetria do quartil, definido como
                         c    - 2 c    + c
                          3/4      1/2    1/4
                         --------------------
                             c    - c
                              3/4    1/4
     onde c_p é o quartil de ordem <p> da amostra <lista>.

     Exemplo:

          (%i1) load (descriptive)$
          (%i2) load (numericalio)$
          (%i3) s1 : read_list (file_search ("pidigits.data"))$
          (%i4) quartile_skewness (s1), numer;
          (%o4)                  .04761904761904762
          (%i5) s2 : read_matrix (file_search ("wind.data"))$
          (%i6) quartile_skewness (s2);
          (%o6) [- 0.0408542246982353, .1467025572005382,
                 0.0336239103362392, .03780068728522298, 0.210526315789474]

     Veja também a função 'quantile'.


File: maxima.info,  Node: Funções e Variáveis Definidas específicas para estatística descritiva de várias variáveis,  Next: Funções e Variáveis Definidas para gráficos estatísticos,  Prev: Funções e Variáveis Definidas para estatística descritiva,  Up: descriptive

45.4 Funções e Variáveis Definidas específicas para estatística descritiva de várias variáveis
==============================================================================================

 -- Função: cov (<matriz>)
     A matriz de covariância da amostra de várias variáveis, definida
     como
                        n
                       ====
                    1  \           _        _
                S = -   >    (X  - X) (X  - X)'
                    n  /       j        j
                       ====
                       j = 1
     onde X_j é a j-ésima linha da matriz de amostra.

     Exemplo:

          (%i1) load (descriptive)$
          (%i2) load (numericalio)$
          (%i3) s2 : read_matrix (file_search ("wind.data"))$
          (%i4) fpprintprec : 7$  /* modifique a precisão para obter uma saída melhor */
          (%i5) cov (s2);
                [ 17.22191  13.61811  14.37217  19.39624  15.42162 ]
                [                                                  ]
                [ 13.61811  14.98774  13.30448  15.15834  14.9711  ]
                [                                                  ]
          (%o5) [ 14.37217  13.30448  15.47573  17.32544  16.18171 ]
                [                                                  ]
                [ 19.39624  15.15834  17.32544  32.17651  20.44685 ]
                [                                                  ]
                [ 15.42162  14.9711   16.18171  20.44685  24.42308 ]

     Veja também a função 'cov1'.

 -- Função: cov1 (<matriz>)
     A matriz de covariância da amostra de várias variáveis, definida
     como
                        n
                       ====
                   1   \           _        _
             S  = ---   >    (X  - X) (X  - X)'
              1   n-1  /       j        j
                       ====
                       j = 1
     where X_j is the j-th row of the sample matrix.

     Exemplo:

          (%i1) load (descriptive)$
          (%i2) load (numericalio)$
          (%i3) s2 : read_matrix (file_search ("wind.data"))$
          (%i4) fpprintprec : 7$ /* modifique a precisão para obter uma saída melhor */
          (%i5) cov1 (s2);
                [ 17.39587  13.75567  14.51734  19.59216  15.5774  ]
                [                                                  ]
                [ 13.75567  15.13913  13.43887  15.31145  15.12232 ]
                [                                                  ]
          (%o5) [ 14.51734  13.43887  15.63205  17.50044  16.34516 ]
                [                                                  ]
                [ 19.59216  15.31145  17.50044  32.50153  20.65338 ]
                [                                                  ]
                [ 15.5774   15.12232  16.34516  20.65338  24.66977 ]

     Veja também a função 'cov'.

 -- Função: global_variances (<matriz>)
 -- Função: global_variances (<matriz>, <valor_lógico>)
     A função 'global_variances' retorna uma lista de medidas de
     variância global:

        * <variância total>: 'trace(S_1)',
        * <variância média>: 'trace(S_1)/p',
        * <variância generalizada>: 'determinant(S_1)',
        * <desvio padrão generalizado>: 'sqrt(determinant(S_1))',
        * <variância efetiva> 'determinant(S_1)^(1/p)', (defined in:
          Peña, D. (2002) <Análisis de datos multivariantes>;
          McGraw-Hill, Madrid.)
        * <desvio padrão efetivo>: 'determinant(S_1)^(1/(2*p))'.
     onde <p> é a dimensão das várias variáveis aleatórias e S_1 a
     matriz de covariância retornada por 'cov1'.

     Exemplo:

          (%i1) load (descriptive)$
          (%i2) load (numericalio)$
          (%i3) s2 : read_matrix (file_search ("wind.data"))$
          (%i4) global_variances (s2);
          (%o4) [105.338342060606, 21.06766841212119, 12874.34690469686,
                   113.4651792608502, 6.636590811800794, 2.576158149609762]

     A função 'global_variances' tem um argumento lógico opcional:
     'global_variances(x,true)' diz ao Maxima que 'x' é a matriz de
     dados, fazendo o mesmo que 'global_variances(x)'.  Por outro lado,
     'global_variances(x,false)' significa que 'x' não é a matriz de
     dados, mas a matriz de covariância, evitando a repetição seu
     cálculo,

          (%i1) load (descriptive)$
          (%i2) load (numericalio)$
          (%i3) s2 : read_matrix (file_search ("wind.data"))$
          (%i4) s : cov1 (s2)$
          (%i5) global_variances (s, false);
          (%o5) [105.338342060606, 21.06766841212119, 12874.34690469686,
                   113.4651792608502, 6.636590811800794, 2.576158149609762]

     Veja também 'cov' e 'cov1'.

 -- Função: cor (<matriz>)
 -- Função: cor (<matriz>, <valor_lógico>)
     A matriz de correlação da maostra de várias variáveis.

     Exemplo:

          (%i1) load (descriptive)$
          (%i2) load (numericalio)$
          (%i3) fpprintprec:7$
          (%i4) s2 : read_matrix (file_search ("wind.data"))$
          (%i5) cor (s2);
                [   1.0     .8476339  .8803515  .8239624  .7519506 ]
                [                                                  ]
                [ .8476339    1.0     .8735834  .6902622  0.782502 ]
                [                                                  ]
          (%o5) [ .8803515  .8735834    1.0     .7764065  .8323358 ]
                [                                                  ]
                [ .8239624  .6902622  .7764065    1.0     .7293848 ]
                [                                                  ]
                [ .7519506  0.782502  .8323358  .7293848    1.0    ]

     A função 'cor' tem um argumento lógico opcional: 'cor(x,true)' diz
     ao Maxima que 'x' é a matriz de dados, fazendo o mesmo que
     'cor(x)'.  Por outro lado, 'cor(x,false)' significa que 'x' não é a
     matriz de dados, mas a matriz de covariância, evitando a repetição
     de seu cálculo,

          (%i1) load (descriptive)$
          (%i2) load (numericalio)$
          (%i3) fpprintprec:7$
          (%i4) s2 : read_matrix (file_search ("wind.data"))$
          (%i5) s : cov1 (s2)$
          (%i6) cor (s, false); /* this is faster */
                [   1.0     .8476339  .8803515  .8239624  .7519506 ]
                [                                                  ]
                [ .8476339    1.0     .8735834  .6902622  0.782502 ]
                [                                                  ]
          (%o6) [ .8803515  .8735834    1.0     .7764065  .8323358 ]
                [                                                  ]
                [ .8239624  .6902622  .7764065    1.0     .7293848 ]
                [                                                  ]
                [ .7519506  0.782502  .8323358  .7293848    1.0    ]

     Veja também 'cov' e 'cov1'.

 -- Função: list_correlations (<matriz>)
 -- Função: list_correlations (<matriz>, <valor_lógico>)
     A função 'list_correlations' retorna uma lista de medidas de
     correlação:

        * <matriz de precisão>: o inverso da matriz de covariância S_1,
                      -1     ij
                     S   = (s  )
                      1         i,j = 1,2,...,p

        * <vetor de correlação multipla>: (R_1^2, R_2^2, ..., R_p^2),
          com
                      2          1
                     R  = 1 - -------
                      i        ii
                              s   s
                                   ii
          sendo um indicador do melhor do ajuste do modelo de regressão
          linear de várias variáveis dobre X_i quando o resto das
          variáveis são usados como regressores.

        * <matriz de correlação parcial>: como elemento (i, j) sendo
                                        ij
                                       s
                     r        = - ------------
                      ij.rest     / ii  jj\ 1/2
                                  |s   s  |
                                  \       /

     Exemplo:

          (%i1) load (descriptive)$
          (%i2) load (numericalio)$
          (%i3) s2 : read_matrix (file_search ("wind.data"))$
          (%i4) z : list_correlations (s2)$
          (%i5) fpprintprec : 5$ /* for pretty output */
          (%i6) z[1];  /* precision matrix */
                [  .38486   - .13856   - .15626   - .10239    .031179  ]
                [                                                      ]
                [ - .13856   .34107    - .15233    .038447   - .052842 ]
                [                                                      ]
          (%o6) [ - .15626  - .15233    .47296    - .024816  - .10054  ]
                [                                                      ]
                [ - .10239   .038447   - .024816   .10937    - .034033 ]
                [                                                      ]
                [ .031179   - .052842  - .10054   - .034033   .14834   ]
          (%i7) z[2];  /* multiple correlation vector */
          (%o7)       [.85063, .80634, .86474, .71867, .72675]
          (%i8) z[3];  /* partial correlation matrix */
                 [  - 1.0     .38244   .36627   .49908   - .13049 ]
                 [                                                ]
                 [  .38244    - 1.0    .37927  - .19907   .23492  ]
                 [                                                ]
          (%o8)  [  .36627    .37927   - 1.0    .10911    .37956  ]
                 [                                                ]
                 [  .49908   - .19907  .10911   - 1.0     .26719  ]
                 [                                                ]
                 [ - .13049   .23492   .37956   .26719    - 1.0   ]

     A função 'list_correlations' também tem um argumento lógico
     opcional: 'list_correlations(x,true)' diz ao Maxima que 'x' é a
     matriz de dados, fazendo o mesmo que 'list_correlations(x)'.  Por
     outro lado, 'list_correlations(x,false)' significa que 'x' não é a
     matriz de correlação, mas a matriz de covariancia, evitando a
     repetição de seu cálculo.

     Veja também 'cov' e 'cov1'.


File: maxima.info,  Node: Funções e Variáveis Definidas para gráficos estatísticos,  Prev: Funções e Variáveis Definidas específicas para estatística descritiva de várias variáveis,  Up: descriptive

45.5 Funções e Variáveis Definidas para gráficos estatísticos
=============================================================

 -- Função: dataplot (<lista>)
 -- Função: dataplot (<lista>, <opção_1>, <opção_2>, ...)
 -- Função: dataplot (<matriz>)
 -- Função: dataplot (<matriz>, <opção_1>, <opção_2>, ...)
     A função 'dataplot' permite visualização direta de dados de
     amostra, ambas d uma única variável (<lista>) e de várias variáveis
     (<matriz>).  Fornecendo valores para as seguintes <opções> que são
     alguns aspéctos de impressão que podem ser controlados:

        * ''outputdev', o valor padrão é '"x"', indica o formato de
          dispositivo/arquivo da figura de saída; valores corretos são
          '"x"', '"eps"' e '"png"', para a tela, formato de arquivo
          postscript e formato de arquivo png, respectivamente.

        * ''maintitle', o valor padrão é '""', é o título principal
          entre aspas duplas.

        * ''axisnames', o valor padrão é '["x","y","z"]', é uma lista de
          nomes dos eixos 'x', 'y' e 'z'.

        * ''joined', o valor padrão é 'false', um valor lógico para
          selecionar pontos em 2D para serem unidos ou isolados.

        * ''picturescales', o valor padrão é '[1.0, 1.0]', fator de
          proporcionalidade para o tamanho do gráfico.

        * ''threedim', o valor padrão é 'true', diz ao Maxima se ou
          monta-se o gráfico de uma matriz de três colunas como um
          diagrama 3D ou se monta-se o gráfico como um diagrama de
          dispersão de várias variáveis.  Veja exemplos abaixo.

        * ''axisrot', o valor padrão é '[60, 30]', modifica o ponto de
          visualização quando ''threedim' for escolhido para 'true'
          dados forem armazenados em uma matriz de três colunas.  O
          primeiro número é o ângulo de rotação do eixo <x>, e o segundo
          número é o angulo de rotação do eixo <z>-axis, ambas as
          medidas em graus.

        * ''nclasses', o valor padrão é '10', é o número de classes para
          histogramas na diagonal de gráficos de dispersão de várias
          variáveis.

        * ''pointstyle', o valor padrão é '1', é um inteiro que indica
          como mostrar pontos de amostra.

     Por exemplo, com a seguite entrada um gráfico simples dos primeiros
     vinte dígitos de '%pi' é requisitado e a saída é armazenada em um
     arquivo no formato eps.

          (%i1) load (descriptive)$
          (%i2) load (numericalio)$
          (%i3) s1 : read_list (file_search ("pidigits.data"))$
          (%i4) dataplot (makelist (s1[k], k, 1, 20), 'pointstyle = 3)$

     Note que dados unidimensionais são colocados no gráfico como uma
     série de tempo.  No caso seguinte, ocorre a mesma coisa só que com
     mais dados e com mais configurações,

          (%i1) load (descriptive)$
          (%i2) load (numericalio)$
          (%i3) s1 : read_list (file_search ("pidigits.data"))$
          (%i4) dataplot (makelist (s1[k], k, 1, 50), 'maintitle = "Primeiros dígitos de pi",
           'axisnames = ["ordem do dígito", "valor do dígito"], 'pointstyle = 2,
           'joined = true)$

     A função 'dataplot' pode ser usada para montar gráficos de pontos
     no plano.  O exemplo seguinte é gráfico de dispersão de pares de
     pontos de velocidades de vento para o primeira e para o quinta
     estação meteorológica,

          (%i1) load (descriptive)$
          (%i2) load (numericalio)$
          (%i3) s2 : read_matrix (file_search ("wind.data"))$
          (%i4) dataplot (submatrix (s2, 2, 3, 4), 'pointstyle = 2,
           'maintitle = "Pares de medidas de velocidade do vento em nós",
           'axisnames = ["Velocidade do vento em A", "Velocidade do vento em E"])$

     Se pontos forem armazenados em uma matriz de duas colunas,
     'dataplot' pode montar o gráfico desses pontos diretamente, mas se
     eles forem formatados em uma lista de pares, essa lista deve ser
     transformada em uma matriz como no seguinte exemplo.

          (%i1) load (descriptive)$
          (%i2) x : [[-1, 2], [5, 7], [5, -3], [-6, -9], [-4, 6]]$
          (%i3) dataplot (apply ('matrix, x), 'maintitle = "Pontos",
           'joined = true, 'axisnames = ["", ""], 'picturescales = [0.5, 1.0])$

     Pontos no espaço tridimensional podem ser vistos como uma projeção
     no plano.  Nesse exemplo, o gráfico de velocidades do vento
     correspondendo a três estações meteorológicas são requisitados,
     primeiramente em um gráfico em 3D e a seguir em um gráfico de
     dispers@~ao de várias variáveis.

          (%i1) load (descriptive)$
          (%i2) load (numericalio)$
          (%i3) s2 : read_matrix (file_search ("wind.data"))$
          (%i4) /* 3D plot */ dataplot (submatrix (s2, 4, 5), 'pointstyle = 2,
           'maintitle = "Pares de medidas de velocidades do vento em nós",
           'axisnames = ["Estação A", "Estação B", "Estação C"])$
          (%i5) /* Gráfico de dispersão de várias variáveis */ dataplot (submatrix (s2, 4, 5),
           'nclasses = 6, 'threedim = false)$
     Note que no último exemplo, o número de classes no histogramas da
     diagonal é escolhido para 6, e aquela opção ''threedim' for
     escolhida para 'false'.

     Para mais que três dimensões somente gráficos de dispersão de
     várias variáveis são possível, como em

          (%i1) load (descriptive)$
          (%i2) load (numericalio)$
          (%i3) s2 : read_matrix (file_search ("wind.data"))$
          (%i4) dataplot (s2)$

 -- Função: histogram (<lista>)
 -- Função: histogram (<lista>, <opção_1>, <opção_2>, ...)
 -- Função: histogram (<one_column_matrix>)
 -- Função: histogram (<one_column_matrix>, <opção_1>, <opção_2>, ...)
     Essa função monta um gráfico de um histograma.  Dados de amostras
     devem ser armazenados em uma lista de números ou em uma matriz de
     uma coluna.  Fornecendo valores para as seguintes <opções> alguns
     aspéctos do gráfico podem ser controlados:

        * ''outputdev', o valor padrão é '"x"', indica o formato de
          arquivo da figura de saída; valores corretos são '"x"',
          '"eps"' e '"png"', para a tela, formato de arquivo postscript
          e formato de arquivo png, respectivamente.

        * ''maintitle', o valor padrão é '""', é o título principal
          entre aspas duplas.

        * ''axisnames', o valor padrão é '["x", "Fr."]', é uma lista de
          nomes dos eixos 'x' e 'y'.

        * ''picturescales', o valor padrão é '[1.0, 1.0]', fator de
          proporcionalidade para o tamanho do gráfico.

        * ''nclasses', o valor padrão é '10', é o número de classes ou o
          número de barras.

        * ''relbarwidth', o valor padrão é '0.9', um número decimao
          entre 0 e 1 para controlar a largura das barras.

        * ''barcolor', o valor padrão é '1', um inteiro para indicar a
          cor das barras.

        * ''colorintensity', o valor padrão é '1', um número decimal
          entre 0 e 1 para estabelecer a intensidade da cor.

     Nos próximos dois exemplos, histogramas são requisitados para os
     primeiros 100 dígitos do número '%pi' e para velocidades do vento
     na terceira estação meteorológica.

          (%i1) load (descriptive)$
          (%i2) load (numericalio)$
          (%i3) s1 : read_list (file_search ("pidigits.data"))$
          (%i4) histogram (s1, 'maintitle = "dígitos de pi", 'axisnames = ["", "Freqüência absoluta"],
           'relbarwidth = 0.2, 'barcolor = 3, 'colorintensity = 0.6)$
          (%i5) s2 : read_matrix (file_search ("wind.data"))$
          (%i6) histogram (col (s2, 3), 'colorintensity = 0.3)$
     Note tque no primeiro caso, 's1' é uma lista e o segundo exemplo,
     'col(s2,3)' é uma matriz.

     Veja também a função 'barsplot'.

 -- Função: barsplot (<lista>)
 -- Função: barsplot (<lista>, <opção_1>, <opção_2>, ...)
 -- Função: barsplot (<one_column_matrix>)
 -- Função: barsplot (<one_column_matrix>, <opção_1>, <opção_2>, ...)
     Similar a 'histogram' mas para variáveis estatísticas, numéricas ou
     divididas em categorias.  As opções estão abaixo,

        * ''outputdev', o valor padrão é '"x"', indica o formato de
          arquivo da figura de saída; valores corretos são '"x"',
          '"eps"' e '"png"', para a tela, formato de arquivo postscript
          e formato de arquivo png, respectivamente.

        * ''maintitle', o valor padrão é '""', é o título principal
          entre aspas duplas.

        * ''axisnames', o valor padrão é '["x", "Fr."]', é uma lista de
          nomes dos eixos 'x' e 'y'.

        * ''picturescales', o valor padrão é '[1.0, 1.0]', fator de
          proporcionalidade para o tamanho do gráfico.

        * ''relbarwidth', o valor padrão é '0.9', um número decimao
          entre 0 e 1 para controlar a largura das barras.

        * ''barcolor', o valor padrão é '1', um inteiro para indicar a
          cor das barras.

        * ''colorintensity', o valor padrão é '1', um número decimal
          entre 0 e 1 para estabelecer a intensidade da cor.

     Esse exemplo monta um gráfico de barras para os grupos 'A' e 'B' de
     pacientes na amostra 's3',

          (%i1) load (descriptive)$
          (%i2) load (numericalio)$
          (%i3) s3 : read_matrix (file_search ("biomed.data"))$
          (%i4) barsplot (col (s3, 1), 'maintitle = "Grupos de pacientes",
           'axisnames = ["Grupo", "# de indivíduos"], 'colorintensity = 0.2)$
     A primeira coluna na amostra 's3' armazena os valores das
     categorias 'A' e 'B', também conhecidos algumas vezes como fatores.
     Por outro lado, os números inteiros positivos na segunda coluna sào
     idades, em anos, que se comportam como variável discreta, então
     podemos montar um gráfico as freqüências absolutas para esses
     valores,

          (%i1) load (descriptive)$
          (%i2) load (numericalio)$
          (%i3) s3 : read_matrix (file_search ("biomed.data"))$
          (%i4) barsplot (col (s3, 2), 'maintitle = "Idades",
           'axisnames = ["Anos", "# dos indivíduos"], 'colorintensity = 0.2,
           'relbarwidth = 0.6)$

     Veja também a função 'histogram'.

 -- Função: boxplot (<data>)
 -- Função: boxplot (<data>, <opção_1>, <opção_2>, ...)
     Essa função monta diagramas em caixas.  O argumento <data> pode ser
     uma lista, que não é de grande interesse, uma vez que esses
     diagramas são principalmente usados para comparação entre
     diferentes amostras, ou uma matriz, eentão é possível comparar dois
     ou mais componentes de uma variável estatística de várias
     variáveis.  Mas é também permitido <data> se uma lista de amostras
     com tamanhos diferentes de amostra, de fato essa é aa única função
     no pacote 'descriptive' que admite esse tipo de estrutura de dados.
     Veja o exemplo abaixo.  Abaixo etão as opções,

        * ''outputdev', o valor padrão é '"x"', indica o formato de
          arquivo da figura de saída; valores corretos são '"x"',
          '"eps"' e '"png"', para a tela, formato de arquivo postscript
          e formato de arquivo png, respectivamente.

        * ''maintitle', o valor padrão é '""', é o título principal
          entre aspas duplas.

        * ''axisnames', o valor padrão é '["sample", "y"]', é uma lista
          de nomes dos eixos 'x' e 'y'.

        * ''picturescales', o valor padrão é '[1.0, 1.0]', fator de
          proporcionalidade para o tamanho do gráfico.

     Examples:

          (%i1) load (descriptive)$
          (%i2) load (numericalio)$
          (%i3) s2 : read_matrix (file_search ("wind.data"))$
          (%i4) boxplot (s2, 'maintitle = "Velocidade do vento em nós",
           'axisnames = ["Estação do ano", ""])$
          (%i5) A :
           [[6, 4, 6, 2, 4, 8, 6, 4, 6, 4, 3, 2],
            [8, 10, 7, 9, 12, 8, 10],
            [16, 13, 17, 12, 11, 18, 13, 18, 14, 12]]$
          (%i6) boxplot (A)$


File: maxima.info,  Node: diag,  Next: distrib,  Prev: descriptive,  Up: Top

46 diag
*******

* Menu:

* Funções e Variáveis Definidas para diag::


File: maxima.info,  Node: Funções e Variáveis Definidas para diag,  Prev: diag,  Up: diag

46.1 Funções e Variáveis Definidas para diag
============================================

 -- Função: diag (<lm>)
     Constrói a matriz quadrada com as matrizes de <lm> na diagonal.
     <lm> é uma lista de matrizes ou escalares.

     Exemplo:
          (%i1) load("diag")$

          (%i2) a1:matrix([1,2,3],[0,4,5],[0,0,6])$

          (%i3) a2:matrix([1,1],[1,0])$

          (%i4) diag([a1,x,a2]);
                             [ 1  2  3  0  0  0 ]
                             [                  ]
                             [ 0  4  5  0  0  0 ]
                             [                  ]
                             [ 0  0  6  0  0  0 ]
          (%o4)              [                  ]
                             [ 0  0  0  x  0  0 ]
                             [                  ]
                             [ 0  0  0  0  1  1 ]
                             [                  ]
                             [ 0  0  0  0  1  0 ]

     Para usar essa função escreva primeiramente 'load("diag")'.

 -- Função: JF (<lambda>,<n>)
     Retorna a célula de Jordan de ordem <n> com autovalor <lambda>.

     Exemplo:
          (%i1) load("diag")$

          (%i2) JF(2,5);
                              [ 2  1  0  0  0 ]
                              [               ]
                              [ 0  2  1  0  0 ]
                              [               ]
          (%o2)               [ 0  0  2  1  0 ]
                              [               ]
                              [ 0  0  0  2  1 ]
                              [               ]
                              [ 0  0  0  0  2 ]
          (%i3) JF(3,2);
                                   [ 3  1 ]
          (%o3)                    [      ]
                                   [ 0  3 ]

     Para usar essa função escreva primeiramente 'load("diag")'.

 -- Função: jordan (<mat>)
     Retorna a forma de Jordan da matriz <mat>, mas codificada em uma
     lista do Maxima.  Para pegar a matriz correspondente à codificação,
     chame a função 'dispJordan' sando como argumento a saída de 'JF'.

     Exemplo:
          (%i1) load("diag")$

          (%i3) a:matrix([2,0,0,0,0,0,0,0],
                         [1,2,0,0,0,0,0,0],
                         [-4,1,2,0,0,0,0,0],
                         [2,0,0,2,0,0,0,0],
                         [-7,2,0,0,2,0,0,0],
                         [9,0,-2,0,1,2,0,0],
                         [-34,7,1,-2,-1,1,2,0],
                         [145,-17,-16,3,9,-2,0,3])$

          (%i34) jordan(a);
          (%o4)             [[2, 3, 3, 1], [3, 1]]
          (%i5) dispJordan(%);
                          [ 2  1  0  0  0  0  0  0 ]
                          [                        ]
                          [ 0  2  1  0  0  0  0  0 ]
                          [                        ]
                          [ 0  0  2  0  0  0  0  0 ]
                          [                        ]
                          [ 0  0  0  2  1  0  0  0 ]
          (%o5)           [                        ]
                          [ 0  0  0  0  2  1  0  0 ]
                          [                        ]
                          [ 0  0  0  0  0  2  0  0 ]
                          [                        ]
                          [ 0  0  0  0  0  0  2  0 ]
                          [                        ]
                          [ 0  0  0  0  0  0  0  3 ]

     Para usar essa função escreva primeiramente 'load("diag")'.  Veja
     também 'dispJordan' e 'minimalPoly'.

 -- Função: dispJordan (<l>)
     Retorna a matriz de Jordan associada à codificação fornecida pela
     lista do Maxima <l>, que é a saída fornecida pela função 'jordan'.

     Exemplo:
          (%i1) load("diag")$

          (%i2) b1:matrix([0,0,1,1,1],
                          [0,0,0,1,1],
                          [0,0,0,0,1],
                          [0,0,0,0,0],
                          [0,0,0,0,0])$

          (%i3) jordan(b1);
          (%o3)                  [[0, 3, 2]]
          (%i4) dispJordan(%);
                              [ 0  1  0  0  0 ]
                              [               ]
                              [ 0  0  1  0  0 ]
                              [               ]
          (%o4)               [ 0  0  0  0  0 ]
                              [               ]
                              [ 0  0  0  0  1 ]
                              [               ]
                              [ 0  0  0  0  0 ]

     Para usar essa função escreva primeiramente 'load("diag")'.  Veja
     também 'jordan' e 'minimalPoly'.

 -- Função: minimalPoly (<l>)
     Retorna o menor polinômio associado à codificação fornecida pela
     lista do Maxima <l>, que é a saída fornecida pela função 'jordan'.

     Exemplo:
          (%i1) load("diag")$

          (%i2) a:matrix([2,1,2,0],
                         [-2,2,1,2],
                         [-2,-1,-1,1],
                         [3,1,2,-1])$

          (%i3) jordan(a);
          (%o3)               [[- 1, 1], [1, 3]]
          (%i4) minimalPoly(%);
                                      3
          (%o4)                (x - 1)  (x + 1)

     Para usar essa função escreva primeiramente 'load("diag")'.  Veja
     também 'jordan' e 'dispJordan'.

 -- Função: ModeMatrix (<A>,<l>)
     Retorna a matriz <M> tal que (M^^-1).A.M=J, onde <J> é a forma de
     Jordan de <A>.  A lista do Maxima <l> é a codificação da forma de
     Jordan como retornado pela função 'jordan'.

     Exemplo:
          (%i1) load("diag")$

          (%i2) a:matrix([2,1,2,0],
                    [-2,2,1,2],
                    [-2,-1,-1,1],
                    [3,1,2,-1])$

          (%i3) jordan(a);
          (%o3)               [[- 1, 1], [1, 3]]
          (%i4) M: ModeMatrix(a,%);
                            [  1    - 1   1   1 ]
                            [                   ]
                            [   1               ]
                            [ - -   - 1   0   0 ]
                            [   9               ]
                            [                   ]
          (%o4)             [   13              ]
                            [ - --   1   - 1  0 ]
                            [   9               ]
                            [                   ]
                            [  17               ]
                            [  --   - 1   1   1 ]
                            [  9                ]
          (%i5) is(  (M^^-1).a.M = dispJordan(%o3)  );
          (%o5)                      true
     Note que 'dispJordan(%o3)' é a forma de Jordan da matriz 'a'.

     Para usa essa função escreva primeiramente 'load("diag")'.  Veja
     também 'jordan' e 'dispJordan'.

 -- Função: mat_function (<f>,<mat>)
     Retorna f(mat), onde <f> é uma função analítica e <mat> uma matriz.
     Essa computação é baseada na fórmula da integral de Cauchy, que
     estabelece que se 'f(x)' for analítica e

          mat=diag([JF(m1,n1),...,JF(mk,nk)]),

     então

          f(mat)=ModeMatrix*diag([f(JF(m1,n1)),...,f(JF(mk,nk))])*ModeMatrix^^(-1)

     Note que existem entre 6 ou 8 outros métodos para esse cálculo.

     Segue-se alguns exemplos.

     Exemplo 1:
          (%i1) load("diag")$

          (%i2) b2:matrix([0,1,0], [0,0,1], [-1,-3,-3])$

          (%i3) mat_function(exp,t*b2);
                         2   - t
                        t  %e          - t     - t
          (%o3) matrix([-------- + t %e    + %e   ,
                           2
                  - t     - t                           - t
           2    %e      %e        - t           - t   %e
          t  (- ----- - ----- + %e   ) + t (2 %e    - -----)
                  t       2                             t
                         t
                                   - t          - t     - t
                 - t       - t   %e        2  %e      %e
           + 2 %e   , t (%e    - -----) + t  (----- - -----)
                                   t            2       t
                         2   - t            - t     - t
               - t      t  %e        2    %e      %e        - t
           + %e   ], [- --------, - t  (- ----- - ----- + %e   ),
                           2                t       2
                                                   t
                  - t     - t      2   - t
             2  %e      %e        t  %e          - t
          - t  (----- - -----)], [-------- - t %e   ,
                  2       t          2
                  - t     - t                           - t
           2    %e      %e        - t           - t   %e
          t  (- ----- - ----- + %e   ) - t (2 %e    - -----),
                  t       2                             t
                         t
                - t     - t                 - t
           2  %e      %e            - t   %e
          t  (----- - -----) - t (%e    - -----)])
                2       t                   t
          (%i4) ratsimp(%);
                         [   2              - t ]
                         [ (t  + 2 t + 2) %e    ]
                         [ -------------------- ]
                         [          2           ]
                         [                      ]
                         [         2   - t      ]
          (%o4)  Col 1 = [        t  %e         ]
                         [      - --------      ]
                         [           2          ]
                         [                      ]
                         [     2          - t   ]
                         [   (t  - 2 t) %e      ]
                         [   ----------------   ]
                         [          2           ]
                   [      2        - t    ]
                   [    (t  + t) %e       ]
                   [                      ]
           Col 2 = [     2            - t ]
                   [ - (t  - t - 1) %e    ]
                   [                      ]
                   [     2          - t   ]
                   [   (t  - 3 t) %e      ]
                   [        2   - t       ]
                   [       t  %e          ]
                   [       --------       ]
                   [          2           ]
                   [                      ]
                   [      2          - t  ]
           Col 3 = [    (t  - 2 t) %e     ]
                   [  - ----------------  ]
                   [           2          ]
                   [                      ]
                   [   2              - t ]
                   [ (t  - 4 t + 2) %e    ]
                   [ -------------------- ]
                   [          2           ]


     Exemplo 2:
          (%i5) b1:matrix([0,0,1,1,1],
                          [0,0,0,1,1],
                          [0,0,0,0,1],
                          [0,0,0,0,0],
                          [0,0,0,0,0])$

          (%i6) mat_function(exp,t*b1);
                            [              2     ]
                            [             t      ]
                            [ 1  0  t  t  -- + t ]
                            [             2      ]
                            [                    ]
          (%o6)             [ 0  1  0  t    t    ]
                            [                    ]
                            [ 0  0  1  0    t    ]
                            [                    ]
                            [ 0  0  0  1    0    ]
                            [                    ]
                            [ 0  0  0  0    1    ]
          (%i7) minimalPoly(jordan(b1));
                                       3
          (%o7)                       x
          (%i8) ident(5)+t*b1+1/2*(t^2)*b1^^2;
                            [              2     ]
                            [             t      ]
                            [ 1  0  t  t  -- + t ]
                            [             2      ]
                            [                    ]
          (%o8)             [ 0  1  0  t    t    ]
                            [                    ]
                            [ 0  0  1  0    t    ]
                            [                    ]
                            [ 0  0  0  1    0    ]
                            [                    ]
                            [ 0  0  0  0    1    ]
          (%i9) mat_function(exp,%i*t*b1);
                       [                           2 ]
                       [                          t  ]
                       [ 1  0  %i t  %i t  %i t - -- ]
                       [                          2  ]
                       [                             ]
          (%o9)        [ 0  1   0    %i t    %i t    ]
                       [                             ]
                       [ 0  0   1     0      %i t    ]
                       [                             ]
                       [ 0  0   0     1        0     ]
                       [                             ]
                       [ 0  0   0     0        1     ]
          (%i10) mat_function(cos,t*b1)+%i*mat_function(sin,t*b1);
                        [                           2 ]
                        [                          t  ]
                        [ 1  0  %i t  %i t  %i t - -- ]
                        [                          2  ]
                        [                             ]
          (%o10)        [ 0  1   0    %i t    %i t    ]
                        [                             ]
                        [ 0  0   1     0      %i t    ]
                        [                             ]
                        [ 0  0   0     1        0     ]
                        [                             ]
                        [ 0  0   0     0        1     ]

     Exemplo 3:
          (%i11) a1:matrix([2,1,0,0,0,0],
                           [-1,4,0,0,0,0],
                           [-1,1,2,1,0,0],
                           [-1,1,-1,4,0,0],
                           [-1,1,-1,1,3,0],
                           [-1,1,-1,1,1,2])$

          (%i12) fpow(x):=block([k],declare(k,integer),x^k)$

          (%i13) mat_function(fpow,a1);
                          [  k      k - 1 ]         [      k - 1    ]
                          [ 3  - k 3      ]         [   k 3         ]
                          [               ]         [               ]
                          [       k - 1   ]         [  k      k - 1 ]
                          [  - k 3        ]         [ 3  + k 3      ]
                          [               ]         [               ]
                          [       k - 1   ]         [      k - 1    ]
                          [  - k 3        ]         [   k 3         ]
          (%o13)  Col 1 = [               ] Col 2 = [               ]
                          [       k - 1   ]         [      k - 1    ]
                          [  - k 3        ]         [   k 3         ]
                          [               ]         [               ]
                          [       k - 1   ]         [      k - 1    ]
                          [  - k 3        ]         [   k 3         ]
                          [               ]         [               ]
                          [       k - 1   ]         [      k - 1    ]
                          [  - k 3        ]         [   k 3         ]
                   [       0       ]         [       0       ]
                   [               ]         [               ]
                   [       0       ]         [       0       ]
                   [               ]         [               ]
                   [  k      k - 1 ]         [      k - 1    ]
                   [ 3  - k 3      ]         [   k 3         ]
                   [               ]         [               ]
           Col 3 = [       k - 1   ] Col 4 = [  k      k - 1 ]
                   [  - k 3        ]         [ 3  + k 3      ]
                   [               ]         [               ]
                   [       k - 1   ]         [      k - 1    ]
                   [  - k 3        ]         [   k 3         ]
                   [               ]         [               ]
                   [       k - 1   ]         [      k - 1    ]
                   [  - k 3        ]         [   k 3         ]
                   [    0    ]
                   [         ]         [ 0  ]
                   [    0    ]         [    ]
                   [         ]         [ 0  ]
                   [    0    ]         [    ]
                   [         ]         [ 0  ]
           Col 5 = [    0    ] Col 6 = [    ]
                   [         ]         [ 0  ]
                   [    k    ]         [    ]
                   [   3     ]         [ 0  ]
                   [         ]         [    ]
                   [  k    k ]         [  k ]
                   [ 3  - 2  ]         [ 2  ]

     Para usar essa função escreva primeiramente 'load("diag")'.


File: maxima.info,  Node: distrib,  Next: draw,  Prev: diag,  Up: Top

47 distrib
**********

* Menu:

* Introdução a distrib::
* Funções e Variáveis Definidas para distribuições contínuas::
* Funções e Variáveis Definidas para distribuições discretas::


File: maxima.info,  Node: Introdução a distrib,  Next: Funções e Variáveis Definidas para distribuições contínuas,  Prev: distrib,  Up: distrib

47.1 Introdução a distrib
=========================

Pacote 'distrib' contém um conjunto de funções para fazer cálculos
envolvendo probabilidades de modelos de uma única variável estatística e
de ambos os tipos discreta e contínua.

   O que segue é um curto resumo de definiçoes básicas relacionadas à
teoria das probabilidades.

   Seja f(x) a <função densidade de probabilidade> absoluta de uma
variável aleatória contínua X. A <função distribuição de probabilidade>
é definida como
                            x
                           /
                           [
                    F(x) = I     f(u) du
                           ]
                           /
                            minf
   que é igual à probabilidade <Pr(X <= x)>.

   O valor <médio> é um parâmetro de localização e está definido como
                          inf
                         /
                         [
                E[X]  =  I   x f(x) dx
                         ]
                         /
                          minf

   A <variância> é uma medida de variação,
                      inf
                     /
                     [                    2
              V[X] = I     f(x) (x - E[X])  dx
                     ]
                     /
                      minf
   que é um número real positivo.  A raíz quadrada da variância é o
<desvio padrão>, D[X]=sqrt(V[X]), e esse <desvio padrão> é outra medida
de variação.

   O <coeficiente de assimetria> é uma medida de não simetria,
                      inf
                     /
                 1   [                    3
       SK[X] = ----- I     f(x) (x - E[X])  dx
                   3 ]
               D[X]  /
                      minf

   E o <coeficiente de curtose> mede o grau de achatamento de uma
distribuição,
                      inf
                     /
                 1   [                    4
       KU[X] = ----- I     f(x) (x - E[X])  dx - 3
                   4 ]
               D[X]  /
                      minf
   Se X for gaussiana, KU[X]=0.  De fato, ambos assimetria e curtose são
parâmetros de ajuste usados para medir a não gaussianidade de uma
distribuição.

   Se a variável aleatória X for discreta, a função densidade de
probabilidade, ou simplesmente <probabilidade>, f(x) toma valores
positivos dentro de certos conjuntos contáveis de números x_i, e zero em
caso contrário.  Nesse caso, a função distribuição de probabilidade é
                            ====
                            \
                     F(x) =  >    f(x )
                            /        i
                            ====
                           x <= x
                            i

   A média, variância, desvio padrão, coeficiente de assimetria e
coeficiente de curtose tomam a forma
                            ====
                            \
                     E[X] =  >  x  f(x ) ,
                            /    i    i
                            ====
                             x
                              i

                     ====
                     \                     2
             V[X] =   >    f(x ) (x - E[X])  ,
                     /        i    i
                     ====
                      x
                       i

                    D[X] = sqrt(V[X]),

                          ====
                   1      \                     3
       SK[X] =  -------    >    f(x ) (x - E[X])
                D[X]^3    /        i    i
                          ====
                           x
                            i
   and
                          ====
                   1      \                     4
       KU[X] =  -------    >    f(x ) (x - E[X])   - 3 ,
                D[X]^4    /        i    i
                          ====
                           x
                            i
   respectively.

   O Pacote 'distrib' inclui funções para simulação de variáveis
estatísticas pseudo-aleatórias.  Algumas dessas funções fazem uso de
variáveis opcionais que indicam o algorítmo a ser usado.  O método
inverso genérico (baseado no fato que se <u> for um número aleatório
uniforme no intervalo (0,1), então <F^(-1)(u)> é uma variável
estatística pseudo-aleatória com distribuição F) está implementada para
a maioria dos casos; isso é um método subótimo em termos de
cronometragem, mas útil para fazer comparações com outros algorítmos.
Nesse exemplo, a 'perandom_formance' dos algorítmos 'ahrens_cheng' e
'inverse' em simular variáveis chi-quadradas (letra grega "chi") são
comparadas por meio de seus histogramas:

     (%i1) load(distrib)$
     (%i2) load(descriptive)$
     (%i3) showtime: true$
     Evaluation took 0.00 seconds (0.00 elapsed) using 32 bytes.
     (%i4) random_chi2_algorithm: 'ahrens_cheng$ histogram(random_chi2(10,500))$
     Evaluation took 0.00 seconds (0.00 elapsed) using 40 bytes.
     Evaluation took 0.69 seconds (0.71 elapsed) using 5.694 MB.
     (%i6) random_chi2_algorithm: 'inverse$ histogram(random_chi2(10,500))$
     Evaluation took 0.00 seconds (0.00 elapsed) using 32 bytes.
     Evaluation took 10.15 seconds (10.17 elapsed) using 322.098 MB.

   Com o objetivo de fazer comparações visuais entre algorítmos para uma
variável estatística discreta, a função 'barsplot' do pacote
'descriptive' pode ser usada.

   Note que algum trabalho resta para ser realizado, uma vez que essas
funções de simulação não foram ainda verificadas pelos mais
rigorosamente melhores dos testes de ajuste.

   Por favor, consulte um manual introdutório sobre probabilidade e
estatística para maiores informações sobre todo esse material
matemático.

   Existe uma convenção de nome no pacote 'distrib'.  Todo nome de
função tem duas partes, a primeira faz referência à função ou ao
parâmetro que queremos calcular,
     Funções:
        função densidade de probabilidade            (pdf_*)
        função distribuição de probabilidade       (cdf_*)
        Quartil                    (quantile_*)
        Média                        (mean_*)
        Variância                    (var_*)
        Desvio padrão          (std_*)
        Coeficiente de assimetria        (skewness_*)
        Coeficiente de curtose        (kurtosis_*)
        Variável estatística pseudo-aleatória              (random_*)

   A segunda parte é uma referência explícita ao modelo probabilístico,
     Distribuíções contínuas:
        Normal              (*normal)
        Student             (*student_t)
        Chi^2               (*chi2)
        F                   (*f)
        Exponencial         (*exp)
        Lognormal           (*lognormal)
        Gama               (*gamma)
        Beta                (*beta)
        contínua uniforme  (*continuous_uniform)
        Logística            (*logistic)
        Pareto              (*pareto)
        Weibull             (*weibull)
        Rayleigh            (*rayleigh)
        Laplace             (*laplace)
        Cauchy              (*cauchy)
        Gumbel              (*gumbel)

     Distribuições discretas:
        Binomial             (*binomial)
        Poisson              (*poisson)
        Bernoulli            (*bernoulli)
        Geométrica            (*geometric)
        discreta uniforme     (*discrete_uniform)
        hipergeométrica       (*hypergeometric)
        Binomial Negativa    (*negative_binomial)

   Por exemplo, 'pdf_student_t(x,n)' é a função densidade de
probabilidade da distribuição de Student com <n> graus de liberdade,
'std_pareto(a,b)' é o desvio padrão da distribuição de Pareto com
parâmetros <a> e <b> e 'kurtosis_poisson(m)' é o coeficiente de curtose
da distribuição de Poisson com média <m>.

   Com o objetivo de fazer uso do pacote 'distrib' você precisa primeiro
tornar esse pacote disponível para uso escrevendo
     (%i1) load(distrib)$

   Para comentários, melhorias ou sugestões, por favor contacte o autor
em <'mario AT edu DOT xunta DOT es'>.


File: maxima.info,  Node: Funções e Variáveis Definidas para distribuições contínuas,  Next: Funções e Variáveis Definidas para distribuições discretas,  Prev: Introdução a distrib,  Up: distrib

47.2 Funções e Variáveis Definidas para distribuições contínuas
===============================================================

 -- Função: pdf_normal (<x>,<m>,<s>)
     Retorna o valor em <x> da função densidade de probabilidade de uma
     variável aleatória Normal(m,s), com s>0.  Para fazer uso dessa
     função, escreva primeiramente 'load(distrib)'.

 -- Função: cdf_normal (<x>,<m>,<s>)
     Retorna o valor em <x> da função distribuição de probabilidade de
     uma variável aleatória Normal(m,s), com s>0.  Essa função é
     definida em termos de funções de erro internas do Maxima, 'erf'.

          (%i1) load (distrib)$
          (%i2) assume(s>0)$ cdf_normal(x,m,s);
                                       x - m
                                 erf(---------)
                                     sqrt(2) s    1
          (%o3)                  -------------- + -
                                       2          2

     Veja também 'erf'.

 -- Função: quantile_normal (<q>,<m>,<s>)
     Retorna o <q>-quantil de uma variável aleatória Normal(m,s), com
     s>0; em outras palavras, isso é o inverso de 'cdf_normal'.  O
     argumento <q> deve ser um elemento de [0,1].  Para fazer uso dessa
     função, escreva primeiramente 'load(distrib)'.

 -- Função: mean_normal (<m>,<s>)
     Retorna a média de uma variável aleatória Normal(m,s), com s>0, a
     saber <m>.  Para fazer uso dessa função, escreva primeiramente
     'load(distrib)'.

 -- Função: var_normal (<m>,<s>)
     Retorna a variância de uma variável aleatória Normal(m,s), com s>0,
     a saber <s^2>.  Para fazer uso dessa função, escreva primeiramente
     'load(distrib)'.

 -- Função: std_normal (<m>,<s>)
     Retorna o desvio padrão de uma variável aleatória Normal(m,s), com
     s>0, a saber <s>.  Para fazer uso dessa função, escreva
     primeiramente 'load(distrib)'.

 -- Função: skewness_normal (<m>,<s>)
     Retorna o coeficiente de assimetria de uma variável aleatória
     Normal(m,s), com s>0, que é sempre igual a 0.  Para fazer uso dessa
     função,escreva primeiramente 'load(distrib)'.

 -- Função: kurtosis_normal (<m>,<s>)
     Retorna o coeficiente de curtose de uma variável aleatória
     Normal(m,s), com s>0, que é sempre igual a 0.  Para fazer uso dessa
     função, escreva primeiramente 'load(distrib)'.

 -- Variável de opção: random_normal_algorithm
     Valor padrão: 'box_mueller'

     Esse é o algorítmo selecionado para simular variáveis aleatórias
     normais.  O algorítmos implementados são 'box_mueller' e 'inverse':
        * 'box_mueller', Baseado no algorítmo descrito em Knuth, D.E.
          (1981) <Seminumerical Algorithms.  The Art of Computer
          Programming.> Addison-Wesley.

        * 'inverse', baseado no método inverso genérico.

     Veja também 'random_normal'.

 -- Função: random_normal (<m>,<s>)
 -- Função: random_normal (<m>,<s>,<n>)
     Retorna uma variável estatística pseudo-aleatória Normal(m,s), com
     s>0.  Chamando 'random_normal' com um terceiro argumento <n>, uma
     amostra aleatória de tamanho <n> será simulada.

     Existem dois algorítmos implementados para essa função, e o
     algorítmo a ser usado pode ser selecionado fornecendo um certo
     valor para a variável global 'random_normal_algorithm', cujo valor
     padrão é 'box_mueller'.

     Veja também 'random_normal_algorithm'.  Para fazer uso dessa
     função, escreva primeiramente 'load(distrib)'.

 -- Função: pdf_student_t (<x>,<n>)
     Retorna o valor em <x> da função densidade de probabilidade de uma
     variável aleatória de Student t(n), com n>0.  Para fazer uso dessa
     função, escreva primeiramente 'load(distrib)'.

 -- Função: cdf_student_t (<x>,<n>)
     Retorna o valor em <x> da função distribuição de probabilidade de
     uma variável aleatória de Student t(n), com n>0.  Essa função não
     tem uma forma definitiva e é calculada numericamente se a variável
     global 'numer' for igual a 'true', de outra froma 'cdf_student_t'
     retorna uma expressão nominal.

          (%i1) load (distrib)$
          (%i2) cdf_student_t(1/2, 7/3);
                                               1  7
          (%o2)                  cdf_student_t(-, -)
                                               2  3
          (%i3) %,numer;
          (%o3)                   .6698450596140417

 -- Função: quantile_student_t (<q>,<n>)
     Retorna o <q>-quantil de uma variável aleatória de Student t(n),
     com n>0; em outras palavras, 'quantile_student_t' é o inverso de
     'cdf_student_t'.  O argumento <q> deve ser um elemento de [0,1].
     Para fazer uso dessa função, escreva primeiramente 'load(distrib)'.

 -- Função: mean_student_t (<n>)
     Retorna a média de uma variável aleatória de Student t(n), com n>0,
     que é sempre igual a 0.  Para fazer uso dessa função, escreva
     primeiramente 'load(distrib)'.

 -- Função: var_student_t (<n>)
     Retorna a variância de uma variável aleatória de Student t(n), com
     n>2.

          (%i1) load (distrib)$
          (%i2) assume(n>2)$  var_student_t(n);
                                          n
          (%o3)                         -----
                                        n - 2

 -- Função: std_student_t (<n>)
     Retorna o desvio padrão de uma variável aleatória de Student t(n),
     com n>2.  Para fazer uso dessa função, escreva primeiramente
     'load(distrib)'.

 -- Função: skewness_student_t (<n>)
     Retorna o coeficiente de assimetria de uma variável aleatória de
     Student t(n), com n>3, que é sempre igual a 0.  Para fazer uso
     dessa função, escreva primeiramente 'load(distrib)'.

 -- Função: kurtosis_student_t (<n>)
     Retorna o coeficiente de curtose de uma variável aleatória de
     Student t(n), com n>4.  Para fazer uso dessa função, escreva
     primeiramente 'load(distrib)'.

 -- Variável de opção: random_student_t_algorithm
     Valor padrão: 'ratio'

     Esse é o algorítmo selecionado para simular variáveis estatísticas
     pseudo-aleatórias de Student.  Algorítmos implementados são
     'inverse' e 'ratio':
        * 'inverse', baseado no método inverso genérico.

        * 'ratio', baseado no fato que se <Z> for uma variável aleatória
          normal N(0,1) e S^2 for uma variável aleatória chi quadrada
          com <n> graus de liberdade, Chi^2(n), então
                                          Z
                                X = -------------
                                    /   2  \ 1/2
                                    |  S   |
                                    | ---  |
                                    \  n   /
          é uma variável aleatória de Student com <n> graus de
          liberdade, t(n).

     Veja também 'random_student_t'.

 -- Função: random_student_t (<n>)
 -- Função: random_student_t (<n>,<m>)
     Retorna uma variável estatística pseudo-aleatória de Student t(n),
     com n>0.  Chamando 'random_student_t' com um segundo argumento <m>,
     uma amostra aleatória de tamanho <m> será simulada.

     Existem dois algorítmos implementados para essa função, se pode
     selecionar o algorítmo a ser usado fornecendo um certo valor à
     variável global 'random_student_t_algorithm', cujo valor padrão é
     'ratio'.

     Veja também 'random_student_t_algorithm'.  Para fazer uso dessa
     função, escreva primeiramente 'load(distrib)'.

 -- Função: pdf_chi2 (<x>,<n>)
     Retorna o valor em <x> da função densidade de probabilidade de uma
     variável aleatória Chi-quadrada Chi^2(n), com n>0.

     A variável aleatória Chi^2(n) é equivalente a Gamma(n/2,2),
     portanto quando Maxima não tiver informação para pegar o resultado,
     uma forma nomial baseada na função de densidade densidade de
     probabilidade da função gama é retornada.

          (%i1) load (distrib)$
          (%i2) pdf_chi2(x,n);
                                              n
          (%o2)                  pdf_gamma(x, -, 2)
                                              2
          (%i3) assume(x>0, n>0)$  pdf_chi2(x,n);
                                   n/2 - 1   - x/2
                                  x        %e
          (%o4)                   ----------------
                                    n/2       n
                                   2    gamma(-)
                                              2

 -- Função: cdf_chi2 (<x>,<n>)
     Retorna o valor em <x> da função distribuição de probabilidade de
     uma variável aleatória Chi-quadrada Chi^2(n), com n>0.

     Essa função não possui uma forma fechada e é calculada
     numericamante se a variável global 'numer' for igual a 'true', de
     outra forma essa função retorna uma expressão nominal baseada na
     distribuição gama, uma vez que a variável aleatória Chi^2(n) é
     equivalente a é equivalente a Gamma(n/2,2).

          (%i1) load (distrib)$
          (%i2) cdf_chi2(3,4);
          (%o2)                  cdf_gamma(3, 2, 2)
          (%i3) cdf_chi2(3,4),numer;
          (%o3)                   .4421745996289249

 -- Função: quantile_chi2 (<q>,<n>)
     Retorna o <q>-quantilede uma variável aleatória Chi-quadrada
     Chi^2(n), com n>0; em outras palavras, essa função é a inversa da
     função 'cdf_chi2'.  O argumento <q> deve ser um elemento de [0,1].

     This função não possui uma forma fechada e é calculada
     numericamante se a variável global 'numer' for igual a 'true', de
     outra forma essa função retorna uma expressão nominal baseada no
     quantil da função gama, uma vez que a variável aleatória Chi^2(n) é
     equivalente a Gamma(n/2,2).

          (%i1) load (distrib)$
          (%i2) quantile_chi2(0.99,9);
          (%o2)                   21.66599433346194
          (%i3) quantile_chi2(0.99,n);
                                                  n
          (%o3)              quantile_gamma(0.99, -, 2)
                                                  2

 -- Função: mean_chi2 (<n>)
     Retorna a média de uma variável aleatória Chi-quadrada Chi^2(n),
     com n>0.

     A variável aleatória Chi^2(n) é equivalente a Gamma(n/2,2), embora
     quando Maxima não tiver informação disponível para pegar o
     resultado, uma forma nominal baseada na média da função gama é
     retornada.

          (%i1) load (distrib)$
          (%i2) mean_chi2(n);
                                             n
          (%o2)                   mean_gamma(-, 2)
                                             2
          (%i3) assume(n>0)$ mean_chi2(n);
          (%o4)                           n

 -- Função: var_chi2 (<n>)
     Retorna a variância de uma variável aleatória Chi-quadrada
     Chi^2(n), com n>0.

     A variável aleatória Chi^2(n) é equivalente a Gamma(n/2,2), embora
     quando Maxima não tiver informação disponível para pegar o
     resultado, uma forma nominal baseada na variância da função gama é
     retornada.

          (%i1) load (distrib)$
          (%i2) var_chi2(n);
                                             n
          (%o2)                    var_gamma(-, 2)
                                             2
          (%i3) assume(n>0)$ var_chi2(n);
          (%o4)                          2 n

 -- Função: std_chi2 (<n>)
     Retorna o desvio padrão de uma variável aleatória Chi-quadrada
     Chi^2(n), com n>0.

     A variável aleatória Chi^2(n) é equivalente a Gamma(n/2,2), embora
     quando Maxima não tiver informação disponível para pegar o
     resultado, uma forma nominal baseada no desvio padrão da função
     gama é retornada.

          (%i1) load (distrib)$
          (%i2) std_chi2(n);
                                             n
          (%o2)                    std_gamma(-, 2)
                                             2
          (%i3) assume(n>0)$ std_chi2(n);
          (%o4)                    sqrt(2) sqrt(n)

 -- Função: skewness_chi2 (<n>)
     Retorna o coeficiente de assimetria de uma variável aleatória
     Chi-quadrada Chi^2(n), com n>0.

     A variável aleatória Chi^2(n) é equivalente a Gamma(n/2,2), embora
     quando Maxima não tiver informação disponível para pegar o
     resultado, uma forma nominal baseada no coeficiente de assimetria
     da função gama é retornada.

          (%i1) load (distrib)$
          (%i2) skewness_chi2(n);
                                               n
          (%o2)                 skewness_gamma(-, 2)
                                               2
          (%i3) assume(n>0)$ skewness_chi2(n);
                                      2 sqrt(2)
          (%o4)                       ---------
                                       sqrt(n)

 -- Função: kurtosis_chi2 (<n>)
     Retorna o coeficiente de curtose de uma variável aleatória
     Chi-quadrada Chi^2(n), com n>0.

     A variável aleatória Chi^2(n) é equivalente a Gamma(n/2,2), embora
     quando Maxima não tiver informação disponível para pegar o
     resultado, uma forma nominal baseada no coeficiente de curtose da
     função gama é retornada.

          (%i1) load (distrib)$
          (%i2) kurtosis_chi2(n);
                                               n
          (%o2)                 kurtosis_gamma(-, 2)
                                               2
          (%i3) assume(n>0)$ kurtosis_chi2(n);
                                         12
          (%o4)                          --
                                         n

 -- Variável de opção: random_chi2_algorithm
     Valor padrão: 'ahrens_cheng'

     Esse é o algorítmo selecionado para simular variáveis estatística
     pseudo-aleatórias Chi-quadradas.  Os algorítmos implementados são
     'ahrens_cheng' e 'inverse':

        * 'ahrens_cheng', baseado na simulação aleatória de variáveis
          gama.  Veja 'random_gamma_algorithm' para mais detalhes.

        * 'inverse', baseado no método inverso genérico.

     Veja também 'random_chi2'.

 -- Função: random_chi2 (<n>)
 -- Função: random_chi2 (<n>,<m>)
     Retorna uma variável estatística pseudo-aleatória Chi-square
     Chi^2(n), com n>0.  Chamando 'random_chi2' com um segundo argumento
     <m>, uma amostra aleatória de tamanho <m> será simulada.

     Existem dois algorítmos implementados para essa função, se pode
     selecionar o algorítmo a ser usado fornecendo um certo valor à
     variável global 'random_chi2_algorithm', cujo valor padrão é
     'ahrens_cheng'.

     Veja também 'random_chi2_algorithm'.  Para fazer uso dessa função,
     escreva primeiramente 'load(distrib)'.

 -- Função: pdf_f (<x>,<m>,<n>)
     Retorna o valor em <x> da função densidade de probabilidade de uma
     variável aleatória F, F(m,n), com m,n>0.  Para fazer uso dessa
     função, escreva primeiramente 'load(distrib)'.

 -- Função: cdf_f (<x>,<m>,<n>)
     Retorna o valor em <x> da função distribuição de probabilidade de
     uma variável aleatória F, F(m,n), com m,n>0.  Essa função não
     possui uma forma definitiva e é calculada numericamente se a
     variável global 'numer' for igual a 'true', de outra forma retorna
     uma expressão nominal.

          (%i1) load (distrib)$
          (%i2) cdf_f(2,3,9/4);
                                               9
          (%o2)                    cdf_f(2, 3, -)
                                               4
          (%i3) %,numer;
          (%o3)                   0.66756728179008

 -- Função: quantile_f (<q>,<m>,<n>)
     Retorna o <q>-quantil de uma variável aleatória F, F(m,n), com
     m,n>0; em outras palavras, essa função é o inverso de 'cdf_f'.  O
     argumento <q> deve ser um elemento de [0,1].

     Essa função não possui uma forma fechada e é calculada
     numericamante se a variável global 'numer' for igual a 'true', de
     outra forma essa função retorna uma expressão nominal.

          (%i1) load (distrib)$
          (%i2) quantile_f(2/5,sqrt(3),5);
                                         2
          (%o2)               quantile_f(-, sqrt(3), 5)
                                         5
          (%i3) %,numer;
          (%o3)                   0.518947838573693

 -- Função: mean_f (<m>,<n>)
     Retorna a média de uma variável aleatória F, F(m,n), com m>0, n>2.
     Para fazer uso dessa função, escreva primeiramente 'load(distrib)'.

 -- Função: var_f (<m>,<n>)
     Retorna a variância de uma variável aleatória F, F(m,n), com m>0,
     n>4.  Para fazer uso dessa função, escreva primeiramente
     'load(distrib)'.

 -- Função: std_f (<m>,<n>)
     Retorna o desvio padrão de uma variável aleatória F, F(m,n), com
     m>0, n>4.  Para fazer uso dessa função, escreva primeiramente
     'load(distrib)'.

 -- Função: skewness_f (<m>,<n>)
     Retorna o coeficiente de assimetria de uma variável aleatória F,
     F(m,n), com m>0, n>6.  Para fazer uso dessa função, escreva
     primeiramente 'load(distrib)'.

 -- Função: kurtosis_f (<m>,<n>)
     Retorna o coeficiente de curtose de uma variável aleatória F,
     F(m,n), com m>0, n>8.  Para fazer uso dessa função, escreva
     primeiramente 'load(distrib)'.

 -- Variável de opção: random_f_algorithm
     Valor padrão: 'inverse'

     Esse é o algorítmo selecionado para simular variáveis estatísticas
     pseudo-aleatórias F. Os algorítmos implementados são 'ratio' e
     'inverse':

        * 'ratio', baseado no fato de que se <X> for uma variável
          aleatória Chi^2(m) e Y for uma variável aleatória Chi^2(n),
          então
                                       n X
                                   F = ---
                                       m Y
          é uma variável aleatória F com <m> e <n> graus de liberdade,
          F(m,n).

        * 'inverse', baseado no método inverso genérico.

     Veja também 'random_f'.

 -- Função: random_f (<m>,<n>)
 -- Função: random_f (<m>,<n>,<k>)
     Retorna uma variável estatística pseudo-aleatória F, F(m,n), com
     m,n>0.  Chamando 'random_f' com um terceiro argumento <k>, uma
     amostra aleatória de tamanho <k> será simulada.

     Existem dois algorítmos implementados para essa função, se pode
     selecionar o algorítmo a ser usado fornecendo um certo valor à
     variável global 'random_f_algorithm', cujo valor padrão é
     'inverse'.

     Veja também 'random_f_algorithm'.  Para fazer uso dessa função,
     escreva primeiramente 'load(distrib)'.

 -- Função: pdf_exp (<x>,<m>)
     Retorna o valor em <x> da função densidade de probabilidade
     variável aleatória Exponential(m), com m>0.

     A variável aleatória Exponential(m) é equivalente a Weibull(1,1/m),
     embora quando Maxima não tiver informação disponível para pegar o
     resultado, uma forma nominal baseada na função de densidade de
     probabilidade de Weibull éretornada.

          (%i1) load (distrib)$
          (%i2) pdf_exp(x,m);
                                                  1
          (%o2)                 pdf_weibull(x, 1, -)
                                                  m
          (%i3) assume(x>0,m>0)$  pdf_exp(x,m);
                                          - m x
          (%o4)                       m %e

 -- Função: cdf_exp (<x>,<m>)
     Retorna o valor em <x> da função distribuição de probabilidade
     variável aleatória Exponential(m), com m>0.

     A variável aleatória Exponential(m) é equivalente a Weibull(1,1/m),
     embora quando Maxima não tiver informação disponível para pegar o
     resultado, uma forma nominal baseada na distribuição de Weibull é
     retornada.

          (%i1) load (distrib)$
          (%i2) cdf_exp(x,m);
                                                  1
          (%o2)                 cdf_weibull(x, 1, -)
                                                  m
          (%i3) assume(x>0,m>0)$  cdf_exp(x,m);
                                           - m x
          (%o4)                      1 - %e

 -- Função: quantile_exp (<q>,<m>)
     Retorna o <q>-quantil variável aleatória Exponential(m), com m>0;
     em outras palavras, essa função é inversa da função 'cdf_exp'.  O
     argumento <q> deve ser um elemento de [0,1].

     A variável aleatória Exponential(m) é equivalente a Weibull(1,1/m),
     embora quando Maxima não tiver informação disponível para pegar o
     resultado, uma forma nominal baseada no qualtil de Weibull é
     retornada.

          (%i1) load (distrib)$
          (%i2) quantile_exp(0.56,5);
          (%o2)                   .1641961104139661
          (%i3) quantile_exp(0.56,m);
                                                      1
          (%o3)             quantile_weibull(0.56, 1, -)
                                                      m

 -- Função: mean_exp (<m>)
     Retorna a média de uma variável aleatória Exponential(m), com m>0.

     A variável aleatória Exponential(m) é equivalente a Weibull(1,1/m),
     embora quando Maxima não tiver informação disponível para pegar o
     resultado, uma forma nominal baseada na média de Weibull é
     reornada.

          (%i1) load (distrib)$
          (%i2) mean_exp(m);
                                                 1
          (%o2)                  mean_weibull(1, -)
                                                 m
          (%i3) assume(m>0)$  mean_exp(m);
                                          1
          (%o4)                           -
                                          m

 -- Função: var_exp (<m>)
     Retorna a variância de uma variável aleatória Exponential(m), com
     m>0.

     A variável aleatória Exponential(m) é equivalente a Weibull(1,1/m),
     embora quando Maxima não tiver informação disponível para pegar o
     resultado, uma forma nominal baseada na variância de Weibull é
     retornada.

          (%i1) load (distrib)$
          (%i2) var_exp(m);
                                                 1
          (%o2)                   var_weibull(1, -)
                                                 m
          (%i3) assume(m>0)$  var_exp(m);
                                         1
          (%o4)                          --
                                          2
                                         m

 -- Função: std_exp (<m>)
     Retorna o desvio padrão de uma variável aleatória Exponential(m),
     com m>0.

     A variável aleatória Exponential(m) é equivalente a Weibull(1,1/m),
     embora quando Maxima não tiver informação disponível para pegar o
     resultado, uma forma nominal baseada no desvio padrão de Weibull é
     retornada.

          (%i1) load (distrib)$
          (%i2) std_exp(m);
                                                 1
          (%o2)                   std_weibull(1, -)
                                                 m
          (%i3) assume(m>0)$  std_exp(m);
                                          1
          (%o4)                           -
                                          m

 -- Função: skewness_exp (<m>)
     Retorna o coeficiente de assimetria de uma variável aleatória
     Exponential(m), com m>0.

     A variável aleatória Exponential(m) é equivalente a Weibull(1,1/m),
     embora quando Maxima não tiver informação disponível para pegar o
     resultado, uma forma nominal baseada no coeficiente de assimetria
     de Weibull é retornada.

          (%i1) load (distrib)$
          (%i2) skewness_exp(m);
                                                   1
          (%o2)                skewness_weibull(1, -)
                                                   m
          (%i3) assume(m>0)$  skewness_exp(m);
          (%o4)                           2

 -- Função: kurtosis_exp (<m>)
     Retorna o coeficiente de curtose de uma variável aleatória
     Exponential(m), com m>0.

     A variável aleatória Exponential(m) é equivalente a Weibull(1,1/m),
     embora quando Maxima não tiver informação disponível para pegar o
     resultado, uma forma nominal baseada no coeficiente de curtose de
     Weibull é retornada.

          (%i1) load (distrib)$
          (%i2) kurtosis_exp(m);
                                                   1
          (%o2)                kurtosis_weibull(1, -)
                                                   m
          (%i3) assume(m>0)$  kurtosis_exp(m);
          (%o4)                           6

 -- Variável de opção: random_exp_algorithm
     Valor padrão: 'inverse'

     Esse é o algorítmo selecionado para simular variáveis exponenciais
     estatística pseudo-aleatórias.  Os algorítmos implementados são
     'inverse', 'ahrens_cheng' e 'ahrens_dieter'

        * 'inverse', baseado no método inverso genérico.

        * 'ahrens_cheng', baseado no fato de que a variável aleatória
          Exp(m) é equivalente a Gamma(1,1/m).  Veja
          'random_gamma_algorithm' para maiores detalhes.

        * 'ahrens_dieter', baseado no algorítmo descrito em Ahrens, J.H.
          e Dieter, U. (1972) <Computer methods for sampling from the
          exponential and normal distributions.> Comm, ACM, 15, Oct.,
          873-882.

     Veja também 'random_exp'.

 -- Função: random_exp (<m>)
 -- Função: random_exp (<m>,<k>)
     Retorna uma variável estatística pseudo-aleatória Exponential(m),
     com m>0.  Chamando 'random_exp' com um segundo argumento <k>, uma
     amostra aleatória de tamanho <k> será simulada.

     Existem três algorítmos implementados para essa função, se pode
     selecionar o algorítmo a ser usado fornecendo um certo valor à
     variável global 'random_exp_algorithm', cujo valor padrão é
     'inverse'.

     Veja também 'random_exp_algorithm'.  Para fazer uso dessa função,
     escreva primeiramente 'load(distrib)'.

 -- Função: pdf_lognormal (<x>,<m>,<s>)
     Retorna o valor em <x> da função densidade de probabilidade de uma
     variável aleatória Lognormal(m,s), com s>0.  Para fazer uso dessa
     função, escreva primeiramente 'load(distrib)'.

 -- Função: cdf_lognormal (<x>,<m>,<s>)
     Retorna o valor em <x> da função distribuição de probabilidade de
     uma variável aleatória Lognormal(m,s), com s>0.  Essa função é
     definida em termos de funções 'erf'de erro internas do Maxima.

          (%i1) load (distrib)$
          (%i2) assume(x>0, s>0)$  cdf_lognormal(x,m,s);
                                     log(x) - m
                                 erf(----------)
                                     sqrt(2) s     1
          (%o3)                  --------------- + -
                                        2          2

     Veja também 'erf'.

 -- Função: quantile_lognormal (<q>,<m>,<s>)
     Retorna o <q>-quantil de uma variável aleatória Lognormal(m,s), com
     s>0; em outras palavras, essa função é a inversa da função
     'cdf_lognormal'.  O argumento <q> deve ser um elemento de [0,1].
     Para fazer uso dessa função, escreva primeiramente 'load(distrib)'.

 -- Função: mean_lognormal (<m>,<s>)
     Retorna a média de uma variável aleatória Lognormal(m,s), com s>0.
     Para fazer uso dessa função, escreva primeiramente 'load(distrib)'.

 -- Função: var_lognormal (<m>,<s>)
     Retorna a variância de uma variável aleatória Lognormal(m,s), com
     s>0.  Para fazer uso dessa função, escreva primeiramente
     'load(distrib)'.

 -- Função: std_lognormal (<m>,<s>)
     Retorna o desvio padrão de uma variável aleatória Lognormal(m,s),
     com s>0.  Para fazer uso dessa função, escreva primeiramente
     'load(distrib)'.

 -- Função: skewness_lognormal (<m>,<s>)
     Retorna o coeficiente de assimetria de uma variável aleatória
     Lognormal(m,s), com s>0.  Para fazer uso dessa função, escreva
     primeiramente 'load(distrib)'.

 -- Função: kurtosis_lognormal (<m>,<s>)
     Retorna o coeficiente de curtose de uma variável aleatória
     Lognormal(m,s), com s>0.  Para fazer uso dessa função, escreva
     primeiramente 'load(distrib)'.

 -- Função: random_lognormal (<m>,<s>)
 -- Função: random_lognormal (<m>,<s>,<n>)
     Retorna uma variável estatística pseudo-aleatória Lognormal(m,s),
     com s>0.  Chamando 'random_lognormal' com um terceiro argumento
     <n>, uma amostra aleatória de tamanho <n> será simulada.

     Variáveis Log-normal são simuladas por meio de variáveis
     estatísticas normais pseudo-aleatórias.  Existem dois algorítmos
     implementados para essa função, se pode selecionar o algorítmo a
     ser usado fornecendo um certo valor à variável global
     'random_normal_algorithm', cujo valor padrão é 'box_mueller'.

     Veja também 'random_normal_algorithm'.  Para fazer uso dessa
     função, escreva primeiramente 'load(distrib)'.

 -- Função: pdf_gamma (<x>,<a>,<b>)
     Retorna o valor em <x> da função densidade de probabilidade de uma
     variável aleatória Gamma(a,b), com a,b>0.  Para fazer uso dessa
     função, escreva primeiramente 'load(distrib)'.

 -- Função: cdf_gamma (<x>,<a>,<b>)
     Retorna o valor em <x> da função distribuição de probabilidade de
     uma variável aleatória Gamma(a,b), com a,b>0.

     Essa função não possui uma forma fechada e é calculada
     numericamante se a variável global 'numer' for igual a 'true', de
     outra forma essa função retorna uma expressão nominal.

          (%i1) load (distrib)$
          (%i2) cdf_gamma(3,5,21);
          (%o2)                  cdf_gamma(3, 5, 21)
          (%i3) %,numer;
          (%o3)                 4.402663157135039E-7

 -- Função: quantile_gamma (<q>,<a>,<b>)
     Retorna o <q>-quantil de uma variável aleatória Gamma(a,b), com
     a,b>0; em outras palavras, essa função é a inversa da função
     'cdf_gamma'.  O argumento <q> deve ser um elemento de [0,1].  Para
     fazer uso dessa função, escreva primeiramente 'load(distrib)'.

 -- Função: mean_gamma (<a>,<b>)
     Retorna a média de uma variável aleatória Gamma(a,b), com a,b>0.
     Para fazer uso dessa função, escreva primeiramente 'load(distrib)'.

 -- Função: var_gamma (<a>,<b>)
     Retorna a variância de uma variável aleatória Gamma(a,b), com
     a,b>0.  Para fazer uso dessa função, escreva primeiramente
     'load(distrib)'.

 -- Função: std_gamma (<a>,<b>)
     Retorna o desvio padrão de uma variável aleatória Gamma(a,b), com
     a,b>0.  Para fazer uso dessa função, escreva primeiramente
     'load(distrib)'.

 -- Função: skewness_gamma (<a>,<b>)
     Retorna o coeficiente de assimetria de uma variável aleatória
     Gamma(a,b), com a,b>0.  Para fazer uso dessa função, escreva
     primeiramente 'load(distrib)'.

 -- Função: kurtosis_gamma (<a>,<b>)
     Retorna o coeficiente de curtose de uma variável aleatória
     Gamma(a,b), com a,b>0.  Para fazer uso dessa função, escreva
     primeiramente 'load(distrib)'.

 -- Variável de opção: random_gamma_algorithm
     Valor padrão: 'ahrens_cheng'

     Esse é o algorítmo selecionado para simular variáveis estatística
     gama pseudo-aleatórias.  Os algorítmos implementados são
     'ahrens_cheng' e 'inverse'

        * 'ahrens_cheng', essa é uma combinação de dois processos,
          dependendo do valor do parâmetro <a>:

          For a>=1, Cheng, R.C.H. e Feast, G.M. (1979).  <Some simple
          gamma variate generators>.  Appl.  Stat., 28, 3, 290-295.

          For 0<a<1, Ahrens, J.H. e Dieter, U. (1974).  <Computer
          methods for sampling from gamma, beta, poisson and binomial
          cdf_tributions>.  Computing, 12, 223-246.

        * 'inverse', baseado no método inverso genérico.

     Veja também 'random_gamma'.

 -- Função: random_gamma (<a>,<b>)
 -- Função: random_gamma (<a>,<b>,<n>)
     Retorna uma variável estatística pseudo-aleatória Gamma(a,b), com
     a,b>0.  Chamando 'random_gamma' com um terceiro argumento <n>, uma
     amostra aleatória de tamanho <n> será simulada.

     Existem dois algorítmos implementados para essa função, se pode
     selecionar o algorítmo a ser usado fornecendo um certo valor à
     variável global 'random_gamma_algorithm', cujo valor padrão é
     'ahrens_cheng'.

     Veja também 'random_gamma_algorithm'.  Para fazer uso dessa função,
     escreva primeiramente 'load(distrib)'.

 -- Função: pdf_beta (<x>,<a>,<b>)
     Retorna o valor em <x> da função densidade de probabilidade de uma
     variável aleatória Beta(a,b), com a,b>0.  Para fazer uso dessa
     função, escreva primeiramente 'load(distrib)'.

 -- Função: cdf_beta (<x>,<a>,<b>)
     Retorna o valor em <x> da função distribuição de probabilidade de
     uma variável aleatória Beta(a,b), com a,b>0.

     Essa função não possui uma forma fechada e é calculada
     numericamante se a variável global 'numer' for igual a 'true', de
     outra forma essa função retorna uma expressão nominal.

          (%i1) load (distrib)$
          (%i2) cdf_beta(1/3,15,2);
                                           1
          (%o2)                   cdf_beta(-, 15, 2)
                                           3
          (%i3) %,numer;
          (%o3)                 7.666089131388224E-7

 -- Função: quantile_beta (<q>,<a>,<b>)
     Retorna o <q>-quantil de uma variável aleatória Beta(a,b), com
     a,b>0; em outras palavras, essa função é a inversa da função
     'cdf_beta'.  O argumento <q> deve ser um elemento de [0,1].  Para
     fazer uso dessa função, escreva primeiramente 'load(distrib)'.

 -- Função: mean_beta (<a>,<b>)
     Retorna a média de uma variável aleatória Beta(a,b), com a,b>0.
     Para fazer uso dessa função, escreva primeiramente 'load(distrib)'.

 -- Função: var_beta (<a>,<b>)
     Retorna a variância de uma variável aleatória Beta(a,b), com a,b>0.
     Para fazer uso dessa função, escreva primeiramente 'load(distrib)'.

 -- Função: std_beta (<a>,<b>)
     Retorna o desvio padrão de uma variável aleatória Beta(a,b), com
     a,b>0.  Para fazer uso dessa função, escreva primeiramente
     'load(distrib)'.

 -- Função: skewness_beta (<a>,<b>)
     Retorna o coeficiente de assimetria de uma variável aleatória
     Beta(a,b), com a,b>0.  Para fazer uso dessa função, escreva
     primeiramente 'load(distrib)'.

 -- Função: kurtosis_beta (<a>,<b>)
     Retorna o coeficiente de curtose de uma variável aleatória
     Beta(a,b), com a,b>0.  Para fazer uso dessa função, escreva
     primeiramente 'load(distrib)'.

 -- Variável de opção: random_beta_algorithm
     Valor padrão: 'cheng'

     Esse é o algorítmo selecionado para simular variáveis estatísticas
     beta pseudo-aleatórias.  Os algorítmos implementados são 'cheng',
     'inverse' e 'ratio'

        * 'cheng', esse é o algorítmo definido em Cheng, R.C.H. (1978).
          <Generating Beta Variates with Nonintegral Shape Parameters>.
          Communications of the ACM, 21:317-322

        * 'inverse', baseado no método inverso genérico.

        * 'ratio', baseado no fato de que se <X> for uma variável
          aleatória Gamma(a,1) e <Y> for Gamma(b,1), então a razão
          X/(X+Y) está distribuída como Beta(a,b).

     Veja também 'random_beta'.

 -- Função: random_beta (<a>,<b>)
 -- Função: random_beta (<a>,<b>,<n>)
     Retorna uma variável estatística pseudo-aleatória Beta(a,b), com
     a,b>0.  Chamando 'random_beta' com um terceiro argumento <n>, uma
     amostra aleatória de tamanho <n> será simulada.

     Existem três algorítmos implementados para essa função, se pode
     selecionar o algorítmo a ser usado fornecendo um certo valor à
     variável global 'random_beta_algorithm', cujo valor padrão é
     'cheng'.

     Veja também 'random_beta_algorithm'.  Para fazer uso dessa função,
     escreva primeiramente 'load(distrib)'.

 -- Função: pdf_continuous_uniform (<x>,<a>,<b>)
     Retorna o valor em <x> da função densidade de probabilidade de uma
     variável aleatória Continuous Uniform(a,b), com a<b.  Para fazer
     uso dessa função, escreva primeiramente 'load(distrib)'.

 -- Função: cdf_continuous_uniform (<x>,<a>,<b>)
     Retorna o valor em <x> da função distribuição de probabilidade de
     uma variável aleatória Continuous Uniform(a,b), com a<b.  Para
     fazer uso dessa função, escreva primeiramente 'load(distrib)'.

 -- Função: quantile_continuous_uniform (<q>,<a>,<b>)
     Retorna o <q>-quantil de uma variável aleatória Continuous
     Uniform(a,b), com a<b; em outras palavras, essa função é a inversa
     da função 'cdf_continuous_uniform'.  O argumento <q> deve ser um
     elemento de [0,1].  Para fazer uso dessa função, escreva
     primeiramente 'load(distrib)'.

 -- Função: mean_continuous_uniform (<a>,<b>)
     Retorna a média de uma variável aleatória Continuous Uniform(a,b),
     com a<b.  Para fazer uso dessa função, escreva primeiramente
     'load(distrib)'.

 -- Função: var_continuous_uniform (<a>,<b>)
     Retorna a variância de uma variável aleatória Continuous
     Uniform(a,b), com a<b.  Para fazer uso dessa função, escreva
     primeiramente 'load(distrib)'.

 -- Função: std_continuous_uniform (<a>,<b>)
     Retorna o desvio padrão de uma variável aleatória Continuous
     Uniform(a,b), com a<b.  Para fazer uso dessa função, escreva
     primeiramente 'load(distrib)'.

 -- Função: skewness_continuous_uniform (<a>,<b>)
     Retorna o coeficiente de assimetria de uma variável aleatória
     Continuous Uniform(a,b), com a<b.  Para fazer uso dessa função,
     escreva primeiramente 'load(distrib)'.

 -- Função: kurtosis_continuous_uniform (<a>,<b>)
     Retorna o coeficiente de curtose de uma variável aleatória
     Continuous Uniform(a,b), com a<b.  Para fazer uso dessa função,
     escreva primeiramente 'load(distrib)'.

 -- Função: random_continuous_uniform (<a>,<b>)
 -- Função: random_continuous_uniform (<a>,<b>,<n>)
     Retorna uma variável estatística pseudo-aleatória Continuous
     Uniform(a,b), com a<b.  Chamando 'random_continuous_uniform' com um
     terceiro argumento <n>, uma amostra aleatória de tamanho <n> será
     simulada.

     Essa é uma aplicação direta da função 'random' interna do Maxima.

     Veja também 'random'.  Para fazer uso dessa função, escreva
     primeiramente 'load(distrib)'.

 -- Função: pdf_logistic (<x>,<a>,<b>)
     Retorna o valor em <x> da função densidade de probabilidade de uma
     variável aleatória Logistic(a,b) , com b>0.  Para fazer uso dessa
     função, escreva primeiramente 'load(distrib)'.

 -- Função: cdf_logistic (<x>,<a>,<b>)
     Retorna o valor em <x> da função distribuição de probabilidade de
     uma variável aleatória Logistic(a,b), com b>0.  Para fazer uso
     dessa função, escreva primeiramente 'load(distrib)'.

 -- Função: quantile_logistic (<q>,<a>,<b>)
     Retorna o <q>-quantil de uma variável aleatória Logistic(a,b) , com
     b>0; em outras palavras, essa função é a inversa da função
     'cdf_logistic'.  O argumento <q> deve ser um elemento de [0,1].
     Para fazer uso dessa função, escreva primeiramente 'load(distrib)'.

 -- Função: meanlog (<a>,<b>)
     Retorna a média de uma Logistic(a,b) variável aleatória , com b>0.
     Para fazer uso dessa função, escreva primeiramente 'load(distrib)'.

 -- Função: var_logistic (<a>,<b>)
     Retorna a variância de uma variável aleatória Logistic(a,b) , com
     b>0.  Para fazer uso dessa função, escreva primeiramente
     'load(distrib)'.

 -- Função: std_logistic (<a>,<b>)
     Retorna o desvio padrão de uma variável aleatória Logistic(a,b) ,
     com b>0.  Para fazer uso dessa função, escreva primeiramente
     'load(distrib)'.

 -- Função: skewness_logistic (<a>,<b>)
     Retorna o coeficiente de assimetria de uma variável aleatória
     Logistic(a,b) , com b>0.  Para fazer uso dessa função, escreva
     primeiramente 'load(distrib)'.

 -- Função: kurtosis_logistic (<a>,<b>)
     Retorna o coeficiente de curtose de uma variável aleatória
     Logistic(a,b) , com b>0.  Para fazer uso dessa função, escreva
     primeiramente 'load(distrib)'.

 -- Função: random_logistic (<a>,<b>)
 -- Função: random_logistic (<a>,<b>,<n>)
     Retorna uma variável estatística pseudo-aleatória Logistic(a,b),
     com b>0.  Chamando 'random_logistic' com um terceiro argumento <n>,
     uma amostra aleatória de tamanho <n> será simulada.

     Somente o método inverso genérico está implementado.  Para fazer
     uso dessa função, escreva primeiramente 'load(distrib)'.

 -- Função: pdf_pareto (<x>,<a>,<b>)
     Retorna o valor em <x> da função densidade de probabilidade de uma
     variável aleatória Pareto(a,b), com a,b>0.  Para fazer uso dessa
     função, escreva primeiramente 'load(distrib)'.

 -- Função: cdf_pareto (<x>,<a>,<b>)
     Retorna o valor em <x> da função distribuição de probabilidade de
     uma variável aleatória Pareto(a,b), com a,b>0.  Para fazer uso
     dessa função, escreva primeiramente 'load(distrib)'.

 -- Função: quantile_pareto (<q>,<a>,<b>)
     Retorna o <q>-quantile de uma variável aleatória Pareto(a,b), com
     a,b>0; em outras palavras, essa função é a inversa da função
     'cdf_pareto'.  O argumento <q> deve ser um elemento de [0,1].  Para
     fazer uso dessa função, escreva primeiramente 'load(distrib)'.

 -- Função: mean_pareto (<a>,<b>)
     Retorna a média de uma variável aleatória Pareto(a,b), com a>1,b>0.
     Para fazer uso dessa função, escreva primeiramente 'load(distrib)'.

 -- Função: var_pareto (<a>,<b>)
     Retorna a variância de uma variável aleatória Pareto(a,b), com
     a>2,b>0.  Para fazer uso dessa função, escreva primeiramente
     'load(distrib)'.

 -- Função: std_pareto (<a>,<b>)
     Retorna o desvio padrão de uma variável aleatória Pareto(a,b), com
     a>2,b>0.  Para fazer uso dessa função, escreva primeiramente
     'load(distrib)'.

 -- Função: skewness_pareto (<a>,<b>)
     Retorna o coeficiente de assimetria de uma variável aleatória
     Pareto(a,b), com a>3,b>0.  Para fazer uso dessa função, escreva
     primeiramente 'load(distrib)'.

 -- Função: kurtosis_pareto (<a>,<b>)
     Retorna o coeficiente de curtose de uma variável aleatória
     Pareto(a,b), com a>4,b>0.  Para fazer uso dessa função, escreva
     primeiramente 'load(distrib)'.

 -- Função: random_pareto (<a>,<b>)
 -- Função: random_pareto (<a>,<b>,<n>)
     Retorna uma variável estatística pseudo-aleatória Pareto(a,b), com
     a>0,b>0.  Chamando 'random_pareto' com um terceiro argumento <n>,
     uma amostra aleatória de tamanho <n> será simulada.

     Somente o método inverso genérico está implementado.  Para fazer
     uso dessa função, escreva primeiramente 'load(distrib)'.

 -- Função: pdf_weibull (<x>,<a>,<b>)
     Retorna o valor em <x> da função densidade de probabilidade de uma
     variável aleatória Weibull(a,b), com a,b>0.  Para fazer uso dessa
     função, escreva primeiramente 'load(distrib)'.

 -- Função: cdf_weibull (<x>,<a>,<b>)
     Retorna o valor em <x> da função distribuição de probabilidade de
     uma variável aleatória Weibull(a,b), com a,b>0.  Para fazer uso
     dessa função, escreva primeiramente 'load(distrib)'.

 -- Função: quantile_weibull (<q>,<a>,<b>)
     Retorna o <q>-quantil de uma variável aleatória Weibull(a,b), com
     a,b>0; em outras palavras, essa função é a inversa da função
     'cdf_weibull'.  O argumento <q> deve ser um elemento de [0,1].
     Para fazer uso dessa função, escreva primeiramente 'load(distrib)'.

 -- Função: mean_weibull (<a>,<b>)
     Retorna a média de uma variável aleatória Weibull(a,b), com a,b>0.
     Para fazer uso dessa função, escreva primeiramente 'load(distrib)'.

 -- Função: var_weibull (<a>,<b>)
     Retorna a variância de uma variável aleatória Weibull(a,b), com
     a,b>0.  Para fazer uso dessa função, escreva primeiramente
     'load(distrib)'.

 -- Função: std_weibull (<a>,<b>)
     Retorna o desvio padrão de uma variável aleatória Weibull(a,b), com
     a,b>0.  Para fazer uso dessa função, escreva primeiramente
     'load(distrib)'.

 -- Função: skewness_weibull (<a>,<b>)
     Retorna o coeficiente de assimetria de uma variável aleatória
     Weibull(a,b), com a,b>0.  Para fazer uso dessa função, escreva
     primeiramente 'load(distrib)'.

 -- Função: kurtosis_weibull (<a>,<b>)
     Retorna o coeficiente de curtose de uma variável aleatória
     Weibull(a,b), com a,b>0.  Para fazer uso dessa função, escreva
     primeiramente 'load(distrib)'.

 -- Função: random_weibull (<a>,<b>)
 -- Função: random_weibull (<a>,<b>,<n>)
     Retorna uma variável estatística pseudo-aleatória Weibull(a,b), com
     a,b>0.  Chamando 'random_weibull' com um terceiro argumento <n>,
     uma amostra aleatória de tamanho <n> será simulada.

     Somente o método inverso genérico está implementado.  Para fazer
     uso dessa função, escreva primeiramente 'load(distrib)'.

 -- Função: pdf_rayleigh (<x>,<b>)
     Retorna o valor em <x> da função densidade de probabilidade de uma
     variável aleatória Rayleigh(b), com b>0.

     A variável aleatória Rayleigh(b) é equivalente a Weibull(2,1/b),
     embora quando Maxima não tiver informação disponível para pegar o
     resultado, uma forma nominal baseada na função densidade de
     probabilidade de Weibull é retornada.

          (%i1) load (distrib)$
          (%i2) pdf_rayleigh(x,b);
                                                  1
          (%o2)                 pdf_weibull(x, 2, -)
                                                  b
          (%i3) assume(x>0,b>0)$ pdf_rayleigh(x,b);
                                              2  2
                                     2     - b  x
          (%o4)                   2 b  x %e

 -- Função: cdf_rayleigh (<x>,<b>)
     Retorna o valor em <x> da função distribuição de probabilidade de
     uma variável aleatória Rayleigh(b), com b>0.

     A variável aleatória Rayleigh(b) é equivalente a Weibull(2,1/b),
     embora quando Maxima não tiver informação disponível para pegar o
     resultado, uma forma nominal baseada na distribuição de Weibull é
     retornada.

          (%i1) load (distrib)$
          (%i2) cdf_rayleigh(x,b);
                                                  1
          (%o2)                 cdf_weibull(x, 2, -)
                                                  b
          (%i3) assume(x>0,b>0)$ cdf_rayleigh(x,b);
                                             2  2
                                          - b  x
          (%o4)                     1 - %e

 -- Função: quantile_rayleigh (<q>,<b>)
     Retorna o <q>-quantil de uma variável aleatória Rayleigh(b), com
     b>0; em outras palavras, essa função é a inversa da função
     'cdf_rayleigh'.  O argumento <q> deve ser um elemento de [0,1].

     A variável aleatória Rayleigh(b) é equivalente a Weibull(2,1/b),
     embora quando Maxima não tiver informação disponível para pegar o
     resultado, uma forma nominal baseada no quantil de Weibull é
     retornada.

          (%i1) load (distrib)$
          (%i2) quantile_rayleigh(0.99,b);
                                                      1
          (%o2)             quantile_weibull(0.99, 2, -)
                                                      b
          (%i3) assume(x>0,b>0)$ quantile_rayleigh(0.99,b);
                                  2.145966026289347
          (%o4)                   -----------------
                                          b

 -- Função: mean_rayleigh (<b>)
     Retorna a média de uma variável aleatória Rayleigh(b), com b>0.

     A variável aleatória Rayleigh(b) é equivalente a Weibull(2,1/b),
     embora quando Maxima não tiver informação disponível para pegar o
     resultado, uma forma nominal baseada na meia de Weibull é
     retornada.

          (%i1) load (distrib)$
          (%i2) mean_rayleigh(b);
                                                 1
          (%o2)                  mean_weibull(2, -)
                                                 b
          (%i3) assume(b>0)$ mean_rayleigh(b);
                                      sqrt(%pi)
          (%o4)                       ---------
                                         2 b

 -- Função: var_rayleigh (<b>)
     Retorna a variância de uma variável aleatória Rayleigh(b), com b>0.

     A variável aleatória Rayleigh(b) é equivalente a Weibull(2,1/b),
     embora quando Maxima não tiver informação disponível para pegar o
     resultado, uma forma nominal baseada na variância de Weibull é
     retornada.

          (%i1) load (distrib)$
          (%i2) var_rayleigh(b);
                                                 1
          (%o2)                   var_weibull(2, -)
                                                 b
          (%i3) assume(b>0)$ var_rayleigh(b);
                                           %pi
                                       1 - ---
                                            4
          (%o4)                        -------
                                          2
                                         b

 -- Função: std_rayleigh (<b>)
     Retorna o desvio padrão de uma variável aleatória Rayleigh(b), com
     b>0.

     A variável aleatória Rayleigh(b) é equivalente a Weibull(2,1/b),
     embora quando Maxima não tiver informação disponível para pegar o
     resultado, uma forma nominal baseada na Weibull desvio padrão é
     retornada.

          (%i1) load (distrib)$
          (%i2) std_rayleigh(b);
                                                 1
          (%o2)                   std_weibull(2, -)
                                                 b
          (%i3) assume(b>0)$ std_rayleigh(b);
                                             %pi
                                    sqrt(1 - ---)
                                              4
          (%o4)                     -------------
                                          b

 -- Função: skewness_rayleigh (<b>)
     Retorna o coeficiente de assimetria de uma variável aleatória
     Rayleigh(b), com b>0.

     A variável aleatória Rayleigh(b) é equivalente a Weibull(2,1/b),
     embora quando Maxima não tiver informação disponível para pegar o
     resultado, uma forma nominal baseada no coeficiente de assimetria
     de Weibull é retornada.

          (%i1) load (distrib)$
          (%i2) skewness_rayleigh(b);
                                                   1
          (%o2)                skewness_weibull(2, -)
                                                   b
          (%i3) assume(b>0)$ skewness_rayleigh(b);
                                   3/2
                                %pi      3 sqrt(%pi)
                                ------ - -----------
                                  4           4
          (%o4)                 --------------------
                                         %pi 3/2
                                    (1 - ---)
                                          4

 -- Função: kurtosis_rayleigh (<b>)
     Retorna o coeficiente de curtose de uma variável aleatória
     Rayleigh(b), com b>0.

     A variável aleatória Rayleigh(b) é equivalente a Weibull(2,1/b),
     embora quando Maxima não tiver informação disponível para pegar o
     resultado, uma forma nominal baseada no coeficiente de curtose de
     Weibull é retornada.

          (%i1) load (distrib)$
          (%i2) kurtosis_rayleigh(b);
                                                   1
          (%o2)                kurtosis_weibull(2, -)
                                                   b
          (%i3) assume(b>0)$ kurtosis_rayleigh(b);
                                            2
                                       3 %pi
                                   2 - ------
                                         16
          (%o4)                    ---------- - 3
                                        %pi 2
                                   (1 - ---)
                                         4

 -- Função: random_rayleigh (<b>)
 -- Função: random_rayleigh (<b>,<n>)
     Retorna uma variável estatística pseudo-aleatória Rayleigh(b), com
     b>0.  Chamando 'random_rayleigh' com um segundo argumento <n>, uma
     amostra aleatória de tamanho <n> será simulada.

     Somente o método inverso genérico está implementado.  Para fazer
     uso dessa função, escreva primeiramente 'load(distrib)'.

 -- Função: pdf_laplace (<x>,<a>,<b>)
     Retorna o valor em <x> da função densidade de probabilidade de uma
     variável aleatória Laplace(a,b), com b>0.  Para fazer uso dessa
     função, escreva primeiramente 'load(distrib)'.

 -- Função: cdf_laplace (<x>,<a>,<b>)
     Retorna o valor em <x> da função distribuição de probabilidade de
     uma variável aleatória Laplace(a,b), com b>0.  Para fazer uso dessa
     função, escreva primeiramente 'load(distrib)'.

 -- Função: quantile_laplace (<q>,<a>,<b>)
     Retorna o <q>-quantil de uma variável aleatória Laplace(a,b), com
     b>0; em outras palavras, essa função é a inversa da função
     'cdf_laplace'.  O argumento <q> deve ser um elemento de [0,1].
     Para fazer uso dessa função, escreva primeiramente 'load(distrib)'.

 -- Função: mean_laplace (<a>,<b>)
     Retorna a média de uma variável aleatória Laplace(a,b), com b>0.
     Para fazer uso dessa função, escreva primeiramente 'load(distrib)'.

 -- Função: var_laplace (<a>,<b>)
     Retorna a variância de uma variável aleatória Laplace(a,b), com
     b>0.  Para fazer uso dessa função, escreva primeiramente
     'load(distrib)'.

 -- Função: std_laplace (<a>,<b>)
     Retorna o desvio padrão de uma variável aleatória Laplace(a,b), com
     b>0.  Para fazer uso dessa função, escreva primeiramente
     'load(distrib)'.

 -- Função: skewness_laplace (<a>,<b>)
     Retorna o coeficiente de assimetria de uma variável aleatória
     Laplace(a,b), com b>0.  Para fazer uso dessa função, escreva
     primeiramente 'load(distrib)'.

 -- Função: kurtosis_laplace (<a>,<b>)
     Retorna o coeficiente de curtose de uma variável aleatória
     Laplace(a,b), com b>0.  Para fazer uso dessa função, escreva
     primeiramente 'load(distrib)'.

 -- Função: random_laplace (<a>,<b>)
 -- Função: random_laplace (<a>,<b>,<n>)
     Retorna uma variável estatística pseudo-aleatória Laplace(a,b), com
     b>0.  Chamando 'random_laplace' com um terceiro argumento <n>, uma
     amostra aleatória de tamanho <n> será simulada.

     Somente o método inverso genérico está implementado.  Para fazer
     uso dessa função, escreva primeiramente 'load(distrib)'.

 -- Função: pdf_cauchy (<x>,<a>,<b>)
     Retorna o valor em <x> da função densidade de probabilidade de uma
     variável aleatória Cauchy(a,b), com b>0.  Para fazer uso dessa
     função, escreva primeiramente 'load(distrib)'.

 -- Função: cdf_cauchy (<x>,<a>,<b>)
     Retorna o valor em <x> da função distribuição de probabilidade de
     uma variável aleatória Cauchy(a,b), com b>0.  Para fazer uso dessa
     função, escreva primeiramente 'load(distrib)'.

 -- Função: quantile_cauchy (<q>,<a>,<b>)
     Retorna o <q>-quantil de uma variável aleatória Cauchy(a,b), com
     b>0; em outras palavras, essa função é a inversa da função
     'cdf_cauchy'.  O argumento <q> deve ser um elemento de [0,1].  Para
     fazer uso dessa função, escreva primeiramente 'load(distrib)'.

 -- Função: random_cauchy (<a>,<b>)
 -- Função: random_cauchy (<a>,<b>,<n>)
     Retorna uma variável estatística pseudo aleatória Cauchy(a,b), com
     b>0.  Chamando 'random_cauchy' com um terceiro argumento <n>, uma
     amostra aleatória de tamanho <n> será simulada.

     Somente o método inverso genérico está implementado.  Para fazer
     uso dessa função, escreva primeiramente 'load(distrib)'.

 -- Função: pdf_gumbel (<x>,<a>,<b>)
     Retorna o valor em <x> da função densidade de probabilidade de uma
     variável aleatória Gumbel(a,b), com b>0.  Para fazer uso dessa
     função, escreva primeiramente 'load(distrib)'.

 -- Função: cdf_gumbel (<x>,<a>,<b>)
     Retorna o valor em <x> da função distribuição de probabilidade de
     uma variável aleatória Gumbel(a,b), com b>0.  Para fazer uso dessa
     função, escreva primeiramente 'load(distrib)'.

 -- Função: quantile_gumbel (<q>,<a>,<b>)
     Retorna o <q>-quantil de uma variável aleatória Gumbel(a,b), com
     b>0; em outras palavras, essa função é a inversa da função
     'cdf_gumbel'.  O argumento <q> deve ser um elemento de [0,1].  Para
     fazer uso dessa função, escreva primeiramente 'load(distrib)'.

 -- Função: mean_gumbel (<a>,<b>)
     Retorna a média de uma variável aleatória Gumbel(a,b), com b>0.

          (%i1) load (distrib)$
          (%i2) assume(b>0)$  mean_gumbel(a,b);
          (%o3)                     %gamma b + a
     onde o símbolol '%gamma' representa a constante de
     Euler-Mascheroni.  Veja também '%gamma'.

 -- Função: var_gumbel (<a>,<b>)
     Retorna a variância de uma variável aleatória Gumbel(a,b), com b>0.
     Para fazer uso dessa função, escreva primeiramente 'load(distrib)'.

 -- Função: std_gumbel (<a>,<b>)
     Retorna o desvio padrão de uma variável aleatória Gumbel(a,b), com
     b>0.  Para fazer uso dessa função, escreva primeiramente
     'load(distrib)'.

 -- Função: skewness_gumbel (<a>,<b>)
     Retorna o coeficiente de assimetria de uma variável aleatória
     Gumbel(a,b), com b>0.

          (%i1) load (distrib)$
          (%i2) assume(b>0)$ skewness_gumbel(a,b);
                                 12 sqrt(6) zeta(3)
          (%o3)                  ------------------
                                           3
                                        %pi
          (%i4) numer:true$ skewness_gumbel(a,b);
          (%o5)                   1.139547099404649
     onde 'zeta' representa a função zeta de Riemann.

 -- Função: kurtosis_gumbel (<a>,<b>)
     Retorna o coeficiente de curtose de uma variável aleatória
     Gumbel(a,b), com b>0.  Para fazer uso dessa função, escreva
     primeiramente 'load(distrib)'.

 -- Função: random_gumbel (<a>,<b>)
 -- Função: random_gumbel (<a>,<b>,<n>)
     Retorna uma variável estatística pseudo-aleatória Gumbel(a,b), com
     b>0.  Chamando 'random_gumbel' com um terceiro argumento <n>, uma
     amostra aleatória de tamanho <n> será simulada.

     Somente o método inverso genérico está implementado.  Para fazer
     uso dessa função, escreva primeiramente 'load(distrib)'.


File: maxima.info,  Node: Funções e Variáveis Definidas para distribuições discretas,  Prev: Funções e Variáveis Definidas para distribuições contínuas,  Up: distrib

47.3 Funções e Variáveis Definidas para distribuições discretas
===============================================================

 -- Função: pdf_binomial (<x>,<n>,<p>)
     Retorna o valor em <x> da função de probabilidade de uma
     Binomial(n,p) variável aleatória, com 0<p<1 e n um inteiro
     positivo.  Para fazer uso dessa função, escreva primeiramente
     'load(distrib)'.

 -- Função: cdf_binomial (<x>,<n>,<p>)
     Retorna o valor em <x> da função distribuição de probabilidade de
     uma Binomial(n,p) variável aleatória, com 0<p<1 e n um inteiro
     positivo.

     'cdf_binomial' é calculada numéricamente se a variável global
     'numer' for igual a 'true', de outra forma 'cdf_binomial' retorna
     uma expressão nominal.

          (%i1) load (distrib)$
          (%i2) cdf_binomial(5,7,1/6);
                                                   1
          (%o2)                 cdf_binomial(5, 7, -)
                                                   6
          (%i3) cdf_binomial(5,7,1/6), numer;
          (%o3)                   .9998713991769548

 -- Função: quantile_binomial (<q>,<n>,<p>)
     Retorna o <q>-quantil de uma variável aleatória Binomial(n,p), com
     0<p<1 e n um inteiro positivo; em outras palavras, essa função é a
     inversa da função 'cdf_binomial'.  O argumento <q> deve ser um
     elemento de [0,1].  Para fazer uso dessa função, escreva
     primeiramente 'load(distrib)'.

 -- Função: mean_binomial (<n>,<p>)
     Retorna a média de uma variável aleatória Binomial(n,p), com 0<p<1
     e n um inteiro positivo.  Para fazer uso dessa função, escreva
     primeiramente 'load(distrib)'.

 -- Função: var_binomial (<n>,<p>)
     Retorna a variância de uma variável aleatória Binomial(n,p), com
     0<p<1 e n um inteiro positivo.  Para fazer uso dessa função,
     escreva primeiramente 'load(distrib)'.

 -- Função: std_binomial (<n>,<p>)
     Retorna o desvio padrão de uma variável aleatória Binomial(n,p),
     com 0<p<1 e n um inteiro positivo.  Para fazer uso dessa função,
     escreva primeiramente 'load(distrib)'.

 -- Função: skewness_binomial (<n>,<p>)
     Retorna o coeficiente de assimetria de uma variável aleatória
     Binomial(n,p), com 0<p<1 e n um inteiro positivo.  Para fazer uso
     dessa função, escreva primeiramente 'load(distrib)'.

 -- Função: kurtosis_binomial (<n>,<p>)
     Retorna o coeficiente de curtose de uma variável aleatória
     Binomial(n,p), com 0<p<1 e n um inteiro positivo.  Para fazer uso
     dessa função, escreva primeiramente 'load(distrib)'.

 -- Variável de opção: random_binomial_algorithm
     Valor padrão: 'kachit'

     Esse é o algorítmo selecionado para simular rvariáveis estatísticas
     pseudo-aleatórias binomiais.  Os algorítmos implementados são
     'kachit', 'bernoulli' e 'inverse':

        * 'kachit', baseado no algorítmo descrito em Kachitvichyanukul,
          V. and Schmeiser, B.W. (1988) <Binomial Random Variate
          Generation>.  Communications of the ACM, 31, Feb., 216.

        * 'bernoulli', baseado na simulação testes de Bernoulli.

        * 'inverse', baseado no método inverso genérico.

     Veja também 'random_binomial'.

 -- Função: random_binomial (<n>,<p>)
 -- Função: random_binomial (<n>,<p>,<m>)
     Retorna uma variável estatística pseudo-aleatória Binomial(n,p),
     com 0<p<1 e n um inteiro positivo.  Chamando 'random_binomial' com
     um terceiro argumento <m>, uma amostra aleatória de tamanho <m>
     será simulada.

     Existem três algorítmos implementado para essa função, se pode
     selecionar o algorítmo a ser usado fornecendo um certo valor à
     variável global 'random_binomial_algorithm', cujo valor padrão é
     'kachit'.

     Veja também 'random_binomial_algorithm'.  Para fazer uso dessa
     função, escreva primeiramente 'load(distrib)'.

 -- Função: pdf_poisson (<x>,<m>)
     Retorna o valor em <x> da função de probabilidade de uma variável
     aleatória Poisson(m), com m>0.  Para fazer uso dessa função,
     escreva primeiramente 'load(distrib)'.

 -- Função: cdf_poisson (<x>,<m>)
     Retorna o valor em <x> da função distribuição de probabilidade de
     uma variável aleatória Poisson(m), com m>0.

     Essa função é calculada numéricamente se a variável global 'numer'
     for igual a 'true', de outra forma essa função retorna uma
     expressão nominal.

          (%i1) load (distrib)$
          (%i2) cdf_poisson(3,5);
          (%o2)                   cdf_poisson(3, 5)
          (%i3) cdf_poisson(3,5), numer;
          (%o3)                   .2650259152973617

 -- Função: quantile_poisson (<q>,<m>)
     Retorna o <q>-quantil de uma variável aleatória Poisson(m), com
     m>0; em outras palavras, essa função é a inversa da função
     'cdf_poisson'.  O argumento <q> deve ser um elemento de [0,1].
     Para fazer uso dessa função, escreva primeiramente 'load(distrib)'.

 -- Função: mean_poisson (<m>)
     Retorna a média de uma variável aleatória Poisson(m), com m>0.
     Para fazer uso dessa função, escreva primeiramente 'load(distrib)'.

 -- Função: var_poisson (<m>)
     Retorna a variância de uma variável aleatória Poisson(m), com m>0.
     Para fazer uso dessa função, escreva primeiramente 'load(distrib)'.

 -- Função: std_poisson (<m>)
     Retorna o desvio padrão de uma variável aleatória Poisson(m), com
     m>0.  Para fazer uso dessa função, escreva primeiramente
     'load(distrib)'.

 -- Função: skewness_poisson (<m>)
     Retorna o coeficiente de assimetria de uma variável aleatória
     Poisson(m), com m>0.  Para fazer uso dessa função, escreva
     primeiramente 'load(distrib)'.

 -- Função: kurtosis_poisson (<m>)
     Retorna o coeficiente de curtose de uma Poisson variável aleatória
     Poi(m), com m>0.  Para fazer uso dessa função, escreva
     primeiramente 'load(distrib)'.

 -- Variável de opção: random_poisson_algorithm
     Valor padrão: 'ahrens_dieter'

     Esse é o algorítmo selecionado para simular variáveis estatísticas
     pseudo-aleatórias de Poisson.Os algorítmos implementados são
     'ahrens_dieter' e 'inverse':

        * 'ahrens_dieter', baseado no algorítmo descrito em Ahrens, J.H.
          and Dieter, U. (1982) <Computer Generation of Poisson Deviates
          From Modified Normal Distributions>.  ACM Trans.  Math.
          Software, 8, 2, June,163-179.

        * 'inverse', baseado no método inverso genérico.

     Veja também 'random_poisson'.

 -- Função: random_poisson (<m>)
 -- Função: random_poisson (<m>,<n>)
     Retorna uma variável estatística pseudo-aleatória Poisson(m), com
     m>0.  Chamando 'random_poisson' com um segundo argumento <n>, uma
     amostra aleatória de tamanho <n> será simulada.

     Existem dois algorítmos implementado para essa função, se pode
     selecionar o algorítmo a ser usado fornecendo um certo valor à
     variável global 'random_poisson_algorithm', cujo valor padrão é
     'ahrens_dieter'.

     Veja também 'random_poisson_algorithm'.  Para fazer uso dessa
     função, escreva primeiramente 'load(distrib)'.

 -- Função: pdf_bernoulli (<x>,<p>)
     Retorna o valor em <x> da função de probabilidade de uma variável
     aleatória Bernoulli(p), com 0<p<1.

     A variável aleatória Bernoulli(p) é equivalente a Binomial(1,p),
     embora quando Maxima não tiver informação disponível para pegar o
     resultado, uma forma nominal baseada na função binomial de
     probabilidade é retornada.

          (%i1) load (distrib)$
          (%i2) pdf_bernoulli(1,p);
          (%o2)                 pdf_binomial(1, 1, p)
          (%i3) assume(0<p,p<1)$ pdf_bernoulli(1,p);
          (%o4)                           p

 -- Função: cdf_bernoulli (<x>,<p>)
     Retorna o valor em <x> da função distribuição de probabilidade de
     uma variável aleatória Bernoulli(p), com 0<p<1.  Para fazer uso
     dessa função, escreva primeiramente 'load(distrib)'.

 -- Função: quantile_bernoulli (<q>,<p>)
     Retorna o <q>-quantil de uma variável aleatória Bernoulli(p), com
     0<p<1; em outras palavras, essa função é a inversa da função
     'cdf_bernoulli'.  O argumento <q> deve ser um elemento de [0,1].
     Para fazer uso dessa função, escreva primeiramente 'load(distrib)'.

 -- Função: mean_bernoulli (<p>)
     Retorna a média de uma variável aleatória Bernoulli(p), com 0<p<1.

     A variável aleatória Bernoulli(p) é equivalente a Binomial(1,p),
     embora quando Maxima não tiver informação disponível para pegar o
     resultado, uma forma nominal baseada na média binomial é retornada.

          (%i1) load (distrib)$
          (%i2) mean_bernoulli(p);
          (%o2)                  mean_binomial(1, p)
          (%i3) assume(0<p,p<1)$ mean_bernoulli(p);
          (%o4)                           p

 -- Função: var_bernoulli (<p>)
     Retorna a variância de uma variável aleatória Bernoulli(p), com
     0<p<1.

     A variável aleatória Bernoulli(p) é equivalente a Binomial(1,p),
     embora quando Maxima não tiver informação disponível para pegar o
     resultado, uma forma nominal baseada na variância binomial é
     retornada.

          (%i1) load (distrib)$
          (%i2) var_bernoulli(p);
          (%o2)                  var_binomial(1, p)
          (%i3) assume(0<p,p<1)$ var_bernoulli(p);
          (%o4)                       (1 - p) p

 -- Função: std_bernoulli (<p>)
     Retorna o desvio padrão de uma variável aleatória Bernoulli(p), com
     0<p<1.

     A variável aleatória Bernoulli(p) é equivalente a Binomial(1,p),
     embora quando Maxima não tiver informação disponível para pegar o
     resultado, uma forma nominal baseada no desvio padrão binomial é
     retornada.

          (%i1) load (distrib)$
          (%i2) std_bernoulli(p);
          (%o2)                  std_binomial(1, p)
          (%i3) assume(0<p,p<1)$ std_bernoulli(p);
          (%o4)                  sqrt(1 - p) sqrt(p)

 -- Função: skewness_bernoulli (<p>)
     Retorna o coeficiente de assimetria de uma variável aleatória
     Bernoulli(p), com 0<p<1.

     A variável aleatória Bernoulli(p) é equivalente a Binomial(1,p),
     embora quando Maxima não tiver informação disponível para pegar o
     resultado, uma forma nominal baseada no coeficiente de assimetria
     binomial é retornada.

          (%i1) load (distrib)$
          (%i2) skewness_bernoulli(p);
          (%o2)                skewness_binomial(1, p)
          (%i3) assume(0<p,p<1)$ skewness_bernoulli(p);
                                       1 - 2 p
          (%o4)                  -------------------
                                 sqrt(1 - p) sqrt(p)

 -- Função: kurtosis_bernoulli (<p>)
     Retorna o coeficiente de curtose de uma variável aleatória
     Bernoulli(p), com 0<p<1.

     A variável aleatória Bernoulli(p) é equivalente a Binomial(1,p),
     embora quando Maxima não tiver informação disponível para pegar o
     resultado, uma forma nominal baseada no coeficiente de curtose
     binomial é retornada.

          (%i1) load (distrib)$
          (%i2) kurtosis_bernoulli(p);
          (%o2)                kurtosis_binomial(1, p)
          (%i3) assume(0<p,p<1)$ kurtosis_bernoulli(p);
                                   1 - 6 (1 - p) p
          (%o4)                    ---------------
                                      (1 - p) p

 -- Função: random_bernoulli (<p>)
 -- Função: random_bernoulli (<p>,<n>)
     Retorna uma variável estatística pseudo-aleatória Bernoulli(p), com
     0<p<1.  Chamando 'random_bernoulli' com um segundo argumento <n>,
     uma amostra aleatória de tamanho <n> será simulada.

     Essa é uma aplicação direta da função 'random' built-in função do
     Maxima.

     Veja também 'random'.  Para fazer uso dessa função, escreva
     primeiramente 'load(distrib)'.

 -- Função: pdf_geometric (<x>,<p>)
     Retorna o valor em <x> da função de probabilidade de uma variável
     aleatória Geometric(p), com 0<p<1.  Para fazer uso dessa função,
     escreva primeiramente 'load(distrib)'.

 -- Função: cdf_geometric (<x>,<p>)
     Retorna o valor em <x> da função distribuição de probabilidade de
     uma variável aleatória Geometric(p), com 0<p<1.  Para fazer uso
     dessa função, escreva primeiramente 'load(distrib)'.

 -- Função: quantile_geometric (<q>,<p>)
     Retorna o <q>-quantil de uma variável aleatória Geometric(p), com
     0<p<1; em outras palavras, essa função é a inversa da função
     'cdf_geometric'.  O argumento <q> deve ser um elemento de [0,1].
     Para fazer uso dessa função, escreva primeiramente 'load(distrib)'.

 -- Função: mean_geometric (<p>)
     Retorna a média de uma variável aleatória Geometric(p), com 0<p<1.
     Para fazer uso dessa função, escreva primeiramente 'load(distrib)'.

 -- Função: var_geometric (<p>)
     Retorna a variância de uma variável aleatória Geometric(p), com
     0<p<1.  Para fazer uso dessa função, escreva primeiramente
     'load(distrib)'.

 -- Função: std_geometric (<p>)
     Retorna o desvio padrão de uma variável aleatória Geometric(p), com
     0<p<1.  Para fazer uso dessa função, escreva primeiramente
     'load(distrib)'.

 -- Função: skewness_geometric (<p>)
     Retorna o coeficiente de assimetria de uma variável aleatória
     Geometric(p), com 0<p<1.  Para fazer uso dessa função, escreva
     primeiramente 'load(distrib)'.

 -- Função: kurtosis_geometric (<p>)
     Retorna o coeficiente de curtose de uma geometric variável
     aleatória Geo(p), com 0<p<1.  Para fazer uso dessa função, escreva
     primeiramente 'load(distrib)'.

 -- Variável de opção: random_geometric_algorithm
     Valor padrão: 'bernoulli'

     Esse é o algorítmo selecionado para simular variáveis estatísticas
     pseudo-aleatórias geométricas.  Algorítmos implementados são
     'bernoulli', 'devroye' e 'inverse':

        * 'bernoulli', baseado na simulação de testes de Bernoulli.

        * 'devroye', baseado no algorítmo descrito em Devroye, L. (1986)
          <Non-Uniform Random Variate Generation.> Springer Verlag, p.
          480.

        * 'inverse', baseado no método inverso genérico.

     Veja também 'random_geometric'.

 -- Função: random_geometric (<p>)
 -- Função: random_geometric (<p>,<n>)
     Retorna um Geometric(p) variável estatística pseudo-aleatória, com
     0<p<1.  Chamando 'random_geometric' com um segundo argumento <n>,
     uma amostra aleatória de tamanho <n> será simulada.

     Existem três algorítmos implementados para essa função, se pode
     selecionar o algorítmo a ser usado fornecendo um certo valor à
     variável global 'random_geometric_algorithm', cujo valor padrão é
     'bernoulli'.

     Veja também 'random_geometric_algorithm'.  Para fazer uso dessa
     função, escreva primeiramente 'load(distrib)'.

 -- Função: pdf_discrete_uniform (<x>,<n>)
     Retorna o valor em <x> da função de probabilidade de uma variável
     aleatória Discrete Uniform(n), com n a strictly positive integer.
     Para fazer uso dessa função, escreva primeiramente 'load(distrib)'.

 -- Função: cdf_discrete_uniform (<x>,<n>)
     Retorna o valor em <x> da função distribuição de probabilidade de
     uma variável aleatória Discrete Uniform(n), com n inteiro
     estritamente positivo.  Para fazer uso dessa função, escreva
     primeiramente 'load(distrib)'.

 -- Função: quantile_discrete_uniform (<q>,<n>)
     Retorna o <q>-quantil de uma variável aleatória Discrete
     Uniform(n), com n um inteiro estritamente positivo; em outras
     palavras, essa função é a inversa da função 'cdf_discrete_uniform'.
     O argumento <q> deve ser um elemento de [0,1].  Para fazer uso
     dessa função, escreva primeiramente 'load(distrib)'.

 -- Função: mean_discrete_uniform (<n>)
     Retorna a média de uma variável aleatória Discrete Uniform(n), com
     n um inteiro estritamente positivo.  Para fazer uso dessa função,
     escreva primeiramente 'load(distrib)'.

 -- Função: var_discrete_uniform (<n>)
     Retorna a variância de uma variável aleatória Discrete Uniform(n),
     com n um inteiro estritamente positivo.  Para fazer uso dessa
     função, escreva primeiramente 'load(distrib)'.

 -- Função: std_discrete_uniform (<n>)
     Retorna o desvio padrão de uma variável aleatória Discrete
     Uniform(n), com n um inteiro estritamente positivo.  Para fazer uso
     dessa função, escreva primeiramente 'load(distrib)'.

 -- Função: skewness_discrete_uniform (<n>)
     Retorna o coeficiente de assimetria de uma variável aleatória
     Discrete Uniform(n), com n um inteiro estritamente positivo.  Para
     fazer uso dessa função, escreva primeiramente 'load(distrib)'.

 -- Função: kurtosis_discrete_uniform (<n>)
     Retorna o coeficiente de curtose de uma variável aleatória Discrete
     Uniform(n), com n um inteiro estritamente positivo.  Para fazer uso
     dessa função, escreva primeiramente 'load(distrib)'.

 -- Função: random_discrete_uniform (<n>)
 -- Função: random_discrete_uniform (<n>,<m>)
     Retorna uma variável estatística pseudo-aleatória Discrete
     Uniform(n), com n um inteiro estritamente positivo.  Chamando
     'random_discrete_uniform' com um segundo argumento <m>, uma amostra
     aleatória de tamanho <m> será simulada.

     Isso é uma aplicação direta da função 'random' built-in função do
     Maxima.

     Veja também 'random'.  Para fazer uso dessa função, escreva
     primeiramente 'load(distrib)'.

 -- Função: pdf_hypergeometric (<x>,<n1>,<n2>,<n>)
     Retorna o valor em <x> da função de probabilidade de uma variável
     aleatória Hypergeometric(n1,n2,n), com <n1>, <n2> e <n> inteiros
     não negativos e n<=n1+n2.  Para fazer uso dessa função, escreva
     primeiramente 'load(distrib)'.

 -- Função: cdf_hypergeometric (<x>,<n1>,<n2>,<n>)
     Retorna o valor em <x> da função distribuição de probabilidade de
     uma variável aleatória Hypergeometric(n1,n2,n), com <n1>, <n2> e
     <n> inteiros não negativos e n<=n1+n2.  Para fazer uso dessa
     função, escreva primeiramente 'load(distrib)'.

 -- Função: quantile_hypergeometric (<q>,<n1>,<n2>,<n>)
     Retorna o <q>-quantil de uma variável aleatória
     Hypergeometric(n1,n2,n), com <n1>, <n2> e <n> inteiros não
     negativos e n<=n1+n2; em outras palavras, essa função é a inversa
     da função 'cdf_hypergeometric'.  O argumento <q> deve ser um
     elemento de [0,1].  Para fazer uso dessa função, escreva
     primeiramente 'load(distrib)'.

 -- Função: mean_hypergeometric (<n1>,<n2>,<n>)
     Retorna a média de uma variável aleatória discreta univorme
     Hyp(n1,n2,n), com <n1>, <n2> e <n> inteiros não negativos e
     n<=n1+n2.  Para fazer uso dessa função, escreva primeiramente
     'load(distrib)'.

 -- Função: var_hypergeometric (<n1>,<n2>,<n>)
     Retorna a variância de uma variável aleatória hipergeométrica
     Hyp(n1,n2,n), com <n1>, <n2> e <n> inteiros não negativos e
     n<=n1+n2.  Para fazer uso dessa função, escreva primeiramente
     'load(distrib)'.

 -- Função: std_hypergeometric (<n1>,<n2>,<n>)
     Retorna o desvio padrão de uma variável aleatória
     Hypergeometric(n1,n2,n), com <n1>, <n2> e <n> inteiros não
     negativos e n<=n1+n2.  Para fazer uso dessa função, escreva
     primeiramente 'load(distrib)'.

 -- Função: skewness_hypergeometric (<n1>,<n2>,<n>)
     Retorna o coeficiente de assimetria de uma variável aleatória
     Hypergeometric(n1,n2,n), com <n1>, <n2> e <n> inteiros não
     negativos e n<=n1+n2.  Para fazer uso dessa função, escreva
     primeiramente 'load(distrib)'.

 -- Função: kurtosis_hypergeometric (<n1>,<n2>,<n>)
     Retorna o coeficiente de curtose de uma variável aleatória
     Hypergeometric(n1,n2,n), com <n1>, <n2> e <n> inteiros não
     negativos e n<=n1+n2.  Para fazer uso dessa função, escreva
     primeiramente 'load(distrib)'.

 -- Variável de opção: random_hypergeometric_algorithm
     Valor padrão: 'kachit'

     Esse é o algorítmo selecionado para simular variáveis estatísticas
     pseudo aleatórias hipergeométricas.Os algorítmos implementados são
     'kachit' e 'inverse':

        * 'kachit', baseado no algorítmo descrito em Kachitvichyanukul,
          V., Schmeiser, B.W. (1985) <Computer generation of
          hypergeometric variáveis estatística pseudo-aleatórias.>
          Journal of Statistical Computation and Simulation 22, 127-145.

        * 'inverse', baseado no método inverso genérico.

     Veja também 'random_hypergeometric'.

 -- Função: random_hypergeometric (<n1>,<n2>,<n>)
 -- Função: random_hypergeometric (<n1>,<n2>,<n>,<m>)
     Retorna uma variável estatística pseudo-aleatória
     Hypergeometric(n1,n2,n), com <n1>, <n2> e <n> inteiros não
     negativos e n<=n1+n2.  Chamando 'random_hypergeometric' com um
     quarto argumento <m>, uma amostra aleatória de tamanho <m> será
     simulada.

     Existem dois algorítmos implementados para essa função, se pode
     selecionar o algorítmo a ser usado fornecendo um certo valor à
     variável global 'random_hypergeometric_algorithm', cujo valor
     padrão é 'kachit'.

     Veja também 'random_hypergeometric_algorithm'.  Para fazer uso
     dessa função, escreva primeiramente 'load(distrib)'.

 -- Função: pdf_negative_binomial (<x>,<n>,<p>)
     Retorna o valor em <x> da função de probabilidade de uma variável
     aleatória Negative Binomial(n,p), com 0<p<1 e n um inteiro
     positivo.  Para fazer uso dessa função, escreva primeiramente
     'load(distrib)'.

 -- Função: cdf_negative_binomial (<x>,<n>,<p>)
     Retorna o valor em <x> da função distribuição de probabilidade de
     uma Negative Binomial(n,p) variável aleatória, com 0<p<1 e n um
     inteiro positivo.

     Essa função é calculada numéricamente se a variável global 'numer'
     for igual a 'true', de outra forma essa função retorna uma
     expressão nominal.

          (%i1) load (distrib)$
          (%i2) cdf_negative_binomial(3,4,1/8);
                                                       1
          (%o2)            cdf_negative_binomial(3, 4, -)
                                                       8
          (%i3) cdf_negative_binomial(3,4,1/8), numer;
          (%o3)                  .006238937377929698

 -- Função: quantile_negative_binomial (<q>,<n>,<p>)
     Retorna o <q>-quantil de uma variável aleatória Negative
     Binomial(n,p), com 0<p<1 e n um inteiro positivo; em outras
     palavras, essa função é a inversa da função
     'cdf_negative_binomial'.  O argumento <q> deve ser um elemento de
     [0,1].  Para fazer uso dessa função, escreva primeiramente
     'load(distrib)'.

 -- Função: mean_negative_binomial (<n>,<p>)
     Retorna a média de uma variável aleatória Negative Binomial(n,p),
     com 0<p<1 e n um inteiro positivo.  Para fazer uso dessa função,
     escreva primeiramente 'load(distrib)'.

 -- Função: var_negative_binomial (<n>,<p>)
     Retorna a variância de uma variável aleatória Negative
     Binomial(n,p), com 0<p<1 e n um inteiro positivo.  Para fazer uso
     dessa função, escreva primeiramente 'load(distrib)'.

 -- Função: std_negative_binomial (<n>,<p>)
     Retorna o desvio padrão de uma variável aleatória Negative
     Binomial(n,p), com 0<p<1 e n um inteiro positivo.  Para fazer uso
     dessa função, escreva primeiramente 'load(distrib)'.

 -- Função: skewness_negative_binomial (<n>,<p>)
     Retorna o coeficiente de assimetria de uma variável aleatória
     Negative Binomial(n,p), com 0<p<1 e n um inteiro positivo.  Para
     fazer uso dessa função, escreva primeiramente 'load(distrib)'.

 -- Função: kurtosis_negative_binomial (<n>,<p>)
     Retorna o coeficiente de curtose de uma variável aleatória Negative
     Binomial(n,p), com 0<p<1 e n um inteiro positivo.  Para fazer uso
     dessa função, escreva primeiramente 'load(distrib)'.

 -- Variável de opção: random_negative_binomial_algorithm
     Valor padrão: 'bernoulli'

     Esse é o algorítmo selecionado para simular variáveis estatísticas
     pseuso-aleatórias binomiais negativas.  Os algorítmos implementados
     são 'devroye', 'bernoulli' e 'inverse':

        * 'devroye', baseado no algorítmo descrito em Devroye, L. (1986)
          <Non-Uniform Random Variate Generation>.  Springer Verlag, p.
          480.

        * 'bernoulli', baseado na simulação de testes de Bernoulli.

        * 'inverse', baseado no método inverso genérico.

     Veja também 'random_negative_binomial'.

 -- Função: random_negative_binomial (<n>,<p>)
 -- Função: random_negative_binomial (<n>,<p>,<m>)
     Retorna uma variável estatística pseudo-aleatória Negative
     Binomial(n,p), com 0<p<1 e n um inteiro positivo.  Chamando
     'random_negative_binomial' com um terceiro argumento <m>, uma
     amostra aleatória de tamanho <m> será simulada.

     Existem três algorítmos implementados para essa função, se pode
     selecionar o algorítmo a ser usado fornecendo um certo valor à
     variável global 'random_negative_binomial_algorithm', cujo valor
     padrão é 'bernoulli'.

     Veja também 'random_negative_binomial_algorithm'.  Para fazer uso
     dessa função, escreva primeiramente 'load(distrib)'.


File: maxima.info,  Node: draw,  Next: dynamics,  Prev: distrib,  Up: Top

48 draw
*******

* Menu:

* Introdução a draw::
* Funções e Variáveis Definidas para draw::


File: maxima.info,  Node: Introdução a draw,  Next: Funções e Variáveis Definidas para draw,  Prev: draw,  Up: draw

48.1 Introdução a draw
======================

'draw' é uma interface entre o Maxima e o Gnuplot.

   Existem três funções a serem usadas n nível do Maxima: 'draw2d',
'draw3d' e 'draw'.

   Siga o link abaixo para exemplos mais elaborados deste pacote:

   <http://es.geocities.com/riotorto/maxima/gpdraw>

   Voce precisará do Gnuplot 4.2 para executar este programa.


File: maxima.info,  Node: Funções e Variáveis Definidas para draw,  Prev: Introdução a draw,  Up: draw

48.2 Funções e Variáveis Definidas para draw
============================================

 -- Opção gráfica: xrange
     Valor padrão: 'false'

     Se 'xrange' for 'false', o intevalo para a coordenada <x> é
     calculado automaticamente.

     Caso o usuário deseje um intervalo específico para <x>, esse
     intervalo deve ser fornecido como uma lista da forma definida pelo
     Maxima, como em 'xrange=[-2, 3]'.

     Uma vez que essa é uma opção gráfica global, sua posição na
     descrição do fundo não é importante.

     Exemplo:

          (%i1) load(draw)$
          (%i2) draw2d(xrange = [-3,5],
                       explicit(x^2,x,-1,1))$

     Veja também 'yrange' e 'zrange'.

 -- Opção gráfica: yrange
     Valor padrão: 'false'

     Se 'yrange' for 'false', the range for the <y> coordinate is
     computed automatically.

     Se o usuário sesejar um intervalo específico para <y>, esse
     intervalo deve ser fornecido como uma lista da forma definida pelo
     Maxima, como em 'yrange=[-2, 3]'.

     Uma vez que essa é uma opção gráfica global, sua posição na
     descrição do fundo não é importante.

     Exemplo:

          (%i1) load(draw)$
          (%i2) draw2d(yrange = [-2,3],
                       explicit(x^2,x,-1,1),
                       xrange = [-3,3])$

     Veja também 'xrange' e 'zrange'.

 -- Opção gráfica: zrange
     Valor padrão: 'false'

     Se 'zrange' for 'false', o intervalo para a coordenada <z> é
     calculado automaticamente.

     Se o usuário sesejar um intervalo específico para <z>, esse
     intervalo deve ser fornecido como uma lista da forma definida pelo
     Maxima, como em 'zrange=[-2, 3]'.

     Uma vez que essa é uma opção gráfica global, sua posição na
     descrição do fundo não é importante.

     Exemplo:

          (%i1) load(draw)$
          (%i2) draw3d(yrange = [-3,3],
                       zrange = [-2,5],
                       explicit(x^2+y^2,x,-1,1,y,-1,1),
                       xrange = [-3,3])$

     Veja também 'yrange' e 'zrange'.

 -- Opção gráfica: logx
     Valor padrão: 'false'

     Se 'logx' for 'true', o eixo <x>será desenhado em escala
     logarítmica.

     Uma vez que essa é uma opção gráfica global, sua posição na
     descrição do fundo não é importante.

     Exemplo:

          (%i1) load(draw)$
          (%i2) draw2d(explicit(log(x),x,0.01,5),
                       logx = true)$

     Veja também 'logy' e 'logz'.

 -- Opção gráfica: logy
     Valor padrão: 'false'

     Se 'logy' for 'true', o eixo <y>será desenhado em escala
     logarítmica.

     Uma vez que essa é uma opção gráfica global, sua posição na
     descrição do fundo não é importante.

     Exemplo:

          (%i1) load(draw)$
          (%i2) draw2d(logy = true,
                       explicit(exp(x),x,0,5))$

     Veja também 'logx' e 'logz'.

 -- Opção gráfica: logz
     Valor padrão: 'false'

     Se 'logz' for 'true', o eixo <z>será desenhado em escala
     logarítmica.

     Uma vez que essa é uma opção gráfica global, sua posição na
     descrição do fundo não é importante.

     Exemplo:

          (%i1) load(draw)$
          (%i2) draw3d(logz = true,
                       explicit(exp(u^2+v^2),u,-2,2,v,-2,2))$

     Veja também 'logx' e 'logy'.

 -- Opção gráfica: terminal
     Valor padrão: 'screen'

     Seleciona o terminal a ser usado pelo Gnuplot; os valores possíveis
     são: 'screen' (o valor padrão), 'png', 'jpg', 'eps', e 'eps_color'.

     Uma vez que essa é uma opção gráfica global, sua posição na
     descrição do fundo não é importante.  Pode também ser usada como um
     argumento da função 'draw'

     Exemplos:

          (%i1) load(draw)$
          (%i2) /* screen terminal (default) */
                draw2d(explicit(x^2,x,-1,1))$
          (%i3) /* png file */
                draw2d(terminal  = 'png,
                       pic_width = 300,
                       explicit(x^2,x,-1,1))$
          (%i4) /* jpg file */
                draw2d(terminal   = 'jpg,
                       pic_width  = 300,
                       pic_height = 300,
                       explicit(x^2,x,-1,1))$
          (%i5) /* eps file */
                draw2d(file_name = "myfile",
                       explicit(x^2,x,-1,1),
                       terminal  = 'eps)$

     Veja também 'file_name', 'pic_width', e 'pic_height'.

 -- Opção gráfica: grid
     Valor padrão: 'false'

     Se 'grid' for 'true', uma malha será desenhada sobre o plano <xy>.

     Uma vez que essa é uma opção gráfica global, sua posição na
     descrição do fundo não é importante.

     Exemplo:

          (%i1) load(draw)$
          (%i2) draw2d(grid = true,
                       explicit(exp(u),u,-2,2))$

 -- Opção gráfica: title
     Valor padrão: '""' (a seqüência de caracteres vazia)

     A opção 'title' armazena uma seqüência de caracteres do Maxima com
     o título principal de um fundo gráfico.  Por padrão, nenhum título
     é escrito.

     Uma vez que essa é uma opção gráfica global, sua posição na
     descrição do fundo não é importante.

     Exemplo:

          (%i1) load(draw)$
          (%i2) draw2d(explicit(exp(u),u,-2,2),
                       title = "Exponential function")$

 -- Opção gráfica: xlabel
     Valor padrão: '""' (a seqüência de caracteres vazia)

     A opção 'xlabel' armazena uma seqüência de caracteres do Maxima com
     o rótulo para o eixo <x>.  Por padrão, nenhum rótulo é escrito.

     Uma vez que essa é uma opção gráfica global, sua posição na
     descrição do fundo não é importante.

     Exemplo:

          (%i1) load(draw)$
          (%i2) draw2d(xlabel = "Time",
                       explicit(exp(u),u,-2,2),
                       ylabel = "Population")$

     Veja também 'ylabel', e 'zlabel'.

 -- Opção gráfica: ylabel
     Valor padrão: '""' (a seqüência de caracteres vazia)

     A opção 'ylabel' armazena uma seqüência de caracteres do Maxima com
     o rótulo para o eixo <y>.  Por padrão, nenhum rótulo é escrito.

     Uma vez que essa é uma opção gráfica global, sua posição na
     descrição do fundo não é importante.

     Exemplo:

          (%i1) load(draw)$
          (%i2) draw2d(xlabel = "Time",
                       ylabel = "Population",
                       explicit(exp(u),u,-2,2) )$

     Veja também 'xlabel', e 'zlabel'.

 -- Opção gráfica: zlabel
     Valor padrão: '""' (a seqüência de caracteres vazia)

     A opção 'zlabel' armazena uma seqüência de caracteres do Maxima com
     o rótulo para o eixo <z>.  Por padrão, nenhum rótulo é escrito.

     Uma vez que essa é uma opção gráfica global, sua posição na
     descrição do fundo não é importante.

     Exemplo:

          (%i1) load(draw)$
          (%i2) draw3d(zlabel = "Z variable",
                       ylabel = "Y variable",
                       explicit(sin(x^2+y^2),x,-2,2,y,-2,2),
                       xlabel = "X variable" )$

     Veja também 'xlabel', e 'ylabel'.

 -- Opção gráfica: xtics
     Valor padrão: 'true'

     Se 'xtics' for 'true', a marcação numérica será feitas sobre o eixo
     <x>.

     Uma vez que essa é uma opção gráfica global, sua posição na
     descrição do fundo não é importante.

     Exemplo:

          (%i1) load(draw)$
          (%i2) /* No tics in the x-axis */
                draw2d(xtics = false,
                       explicit(exp(u),u,-2,2))$

     Veja também 'ytics', e 'ztics'.

 -- Opção gráfica: ytics
     Valor padrão: 'true'

     Se 'ytics' for 'true', a marcação numérica será feitas sobre o eixo
     <y>.

     Uma vez que essa é uma opção gráfica global, sua posição na
     descrição do fundo não é importante.

     Exemplo:

          (%i1) load(draw)$
          (%i2) draw2d(ytics = false,
                       explicit(exp(u),u,-2,2),
                       xtics = false)$

     Veja também 'xtics', e 'ztics'.

 -- Opção gráfica: ztics
     Valor padrão: 'true'

     Se 'ztics' for 'true', a marcação numérica será feitas sobre o eixo
     <z>.

     Uma vez que essa é uma opção gráfica global, sua posição na
     descrição do fundo não é importante.

     Exemplo:

          (%i1) load(draw)$
          (%i2) /* No tics in the z-axis */
                draw3d(ztics = false,
                       explicit(sin(x^2+y^2),x,-2,2,y,-2,2) )$

     Veja também 'xtics', e 'ytics'.

 -- Opção gráfica: rot_vertical
     Valor padrão: 60

     'rot_vertical' é o ângulo (em graus) da rotação vertical (em torno
     do eixo <x>) para escolher o ponto de visualização em fundos
     gráficos tridimensionais.

     O ângulo é associado ao intervalo [0, 180].

     Uma vez que essa é uma opção gráfica global, sua posição na
     descrição do fundo não é importante.

     Exemplo:

          (%i1) load(draw)$
          (%i2) draw3d(rot_vertical = 170,
                       explicit(sin(x^2+y^2),x,-2,2,y,-2,2) )$

     Veja também 'rot_horizontal'.

 -- Opção gráfica: rot_horizontal
     Valor padrão: 30

     'rot_horizontal' é o ângulo (em graus) da rotação horizontal (em
     torno do eixo <z>) para escolher o ponto de visualização em fundos
     gráficos tridimensionais.

     O ângulo é associado ao intervalo [0, 180].

     Uma vez que essa é uma opção gráfica global, sua posição na
     descrição do fundo não é importante.

     Exemplo:

          (%i1) load(draw)$
          (%i2) draw3d(rot_vertical = 170,
                       rot_horizontal = 360,
                       explicit(sin(x^2+y^2),x,-2,2,y,-2,2) )$

     Veja também 'rot_vertical'.

 -- Opção gráfica: xy_file
     Valor padrão: '""' (a seqüência de caracteres vazia)

     'xy_file' é o nome do arquivo onde as coordenada serão armazenadas
     após um clique com o botão do mouse e pressionar a tecla 'x'.  Por
     padrão, nenhuma coordenada é armazenada.

     Uma vez que essa é uma opção gráfica global, sua posição na
     descrição do fundo não é importante.

 -- Opção gráfica: user_preamble
     Valor padrão: '""' (a seqüência de caracteres vazia)

     Usuários experientes de Gnuplot podem fazer uso dessa opção para
     ajuste fino do comportamento do Gnuplot escolhendo opções para
     serem enviadas antes do comando 'plot' ou do comando 'splot'.

     O valor dessa opção deve ser uma seqüência de caracteres ou uma
     lista de seqüência de caracteres (um por linha).

     Uma vez que essa é uma opção gráfica global, sua posição na
     descrição do fundo não é importante.

     Exemplo:

     O terminal dumb não é suportado pelo pacote 'draw', mas é possível
     escolher o terminal dumb fazendo uso da opção 'user_preamble',
          (%i1) load(draw)$
          (%i2) draw2d(explicit(exp(x)-1,x,-1,1),
                       parametric(cos(u),sin(u),u,0,2*%pi),
                       user_preamble="set terminal dumb")$

 -- Opção gráfica: file_name
     Valor padrão: '"maxima_out"'

     Esse é o nome do arquivo onde os terminais 'png', 'jpg', 'eps' e
     'eps_color' guardarão o gráfico.

     Uma vez que essa é uma opção gráfica global, sua posição na
     descrição do fundo não é importante.  Pode também ser usada como um
     argumento da função 'draw'.

     Exemplo:

          (%i1) load(draw)$
          (%i2) draw2d(file_name = "myfile",
                       explicit(x^2,x,-1,1),
                       terminal  = 'png)$

     Veja também 'terminal', 'pic_width', e 'pic_height'.

 -- Opção gráfica: pic_width
     Valor padrão: 640

     Essa é a largura do arquivo de bitmap gerado pelos terminais 'png'
     e 'jpg'.

     Uma vez que essa é uma opção gráfica global, sua posição na
     descrição do fundo não é importante.  Pode também ser usada como um
     argumento da função 'draw'.

     Exemplo:

          (%i1) load(draw)$
          (%i2) draw2d(terminal   = 'png,
                       pic_width  = 300,
                       pic_height = 300,
                       explicit(x^2,x,-1,1))$

     Veja também 'terminal', 'file_name', e 'pic_height'.

 -- Opção gráfica: pic_height
     Valor padrão: 640

     Essa é a altura do arquivo de bitmap gerado pelos terminais 'png' e
     'jpg'.

     Uma vez que essa é uma opção gráfica global, sua posição na
     descrição do fundo não é importante.  Pode também ser usada como um
     argumento da função 'draw'.

     Exemplo:

          (%i1) load(draw)$
          (%i2) draw2d(terminal   = 'png,
                       pic_width  = 300,
                       pic_height = 300,
                       explicit(x^2,x,-1,1))$

     Veja também 'terminal', 'file_name', e 'pic_width'.

 -- Opção gráfica: eps_width
     Valor padrão: 12

     Essa é a largura (medida em cm) do arquivo Postscript gerado pelos
     terminais 'eps' e 'eps_color'.

     Uma vez que essa é uma opção gráfica global, sua posição na
     descrição do fundo gráfico não é importante.  Pode também ser usada
     como um argumento da função 'draw'.

     Exemplo:

          (%i1) load(draw)$
          (%i2) draw2d(terminal   = 'eps,
                       eps_width  = 3,
                       eps_height = 3,
                       explicit(x^2,x,-1,1))$

     Veja também 'terminal', 'file_name', e 'eps_height'.

 -- Opção gráfica: eps_height
     Valor padrão: 8

     Essa é a altura (medida em cm) do arquivo Postscript gerado pelos
     terminais 'eps' e 'eps_color'.

     Uma vez que essa é uma opção gráfica global, sua posição na
     descrição do fundo gráfico não é importante.  Pode também ser usada
     como um argumento da função 'draw'.

     Exemplo:

          (%i1) load(draw)$
          (%i2) draw2d(terminal   = 'eps,
                       eps_width  = 3,
                       eps_height = 3,
                       explicit(x^2,x,-1,1))$

     Veja também 'terminal', 'file_name', e 'eps_width'.

 -- Opção gráfica: axis_bottom
     Valor padrão: 'true'

     Se 'axis_bottom' for 'true', o eixo inferior é mostrado em fundos
     gráficos bidimensionais.

     Uma vez que essa é uma opção gráfica global, sua posição na
     descrição do fundo não é importante.

     Exemplo:

          (%i1) load(draw)$
          (%i2) draw2d(axis_bottom = false,
                       explicit(x^3,x,-1,1))$

     Veja também 'axis_left', 'axis_top', 'axis_right', e 'axis_3d'.

 -- Opção gráfica: axis_left
     Valor padrão: 'true'

     Se 'axis_left' for 'true', o eixo da esquerda é mostrado em fundos
     gráficos bidimensionais.

     Uma vez que essa é uma opção gráfica global, sua posição na
     descrição do fundo não é importante.

     Exemplo:

          (%i1) load(draw)$
          (%i2) draw2d(axis_left = false,
                       explicit(x^3,x,-1,1))$

     Veja também 'axis_bottom', 'axis_top', 'axis_right', e 'axis_3d'.

 -- Opção gráfica: axis_top
     Valor padrão: 'true'

     Se 'axis_top' for 'true', o eixo superior é mostrado em fundos
     gráficos bidimensionais.

     Uma vez que essa é uma opção gráfica global, sua posição na
     descrição do fundo não é importante.

     Exemplo:

          (%i1) load(draw)$
          (%i2) draw2d(axis_top = false,
                       explicit(x^3,x,-1,1))$

     Veja também 'axis_bottom', 'axis_left', 'axis_right', e 'axis_3d'.

 -- Opção gráfica: axis_right
     Valor padrão: 'true'

     Se 'axis_right' for 'true', o eixo da direita é mostrado em fundos
     gráficos bidimensionais.

     Uma vez que essa é uma opção gráfica global, sua posição na
     descrição do fundo não é importante.

     Exemplo:

          (%i1) load(draw)$
          (%i2) draw2d(axis_right = false,
                       explicit(x^3,x,-1,1))$

     Veja também 'axis_bottom', 'axis_left', 'axis_top', e 'axis_3d'.

 -- Opção gráfica: axis_3d
     Valor padrão: 'true'

     Se 'axis_3d' for 'true', os eixos <x>, <y> e <z> são mostrados em
     fundos gráficos tridimensionais.

     Uma vez que essa é uma opção gráfica global, sua posição na
     descrição do fundo não é importante.

     Exemplo:

          (%i1) load(draw)$
          (%i2) draw3d(axis_3d = false,
                       explicit(sin(x^2+y^2),x,-2,2,y,-2,2) )$

     Veja também 'axis_bottom', 'axis_left', 'axis_top', e 'axis_right'
     para eixos em duas dimensões.

 -- Opção gráfica: palette
     Valor padrão: 'color'

     'palette' indica como mapear os valores reais de uma matriz passada
     para o objeto 'image' sobre componentes de cor.

     'palette' é um vetor comprimento três com componentes variando de
     -36 a +36; cada valor é um índice para uma fórmula mapeando os
     níveis sobre as cores vermelho, verde e blue, respectivamente:
           0: 0               1: 0.5           2: 1
           3: x               4: x^2           5: x^3
           6: x^4             7: sqrt(x)       8: sqrt(sqrt(x))
           9: sin(90x)       10: cos(90x)     11: |x-0.5|
          12: (2x-1)^2       13: sin(180x)    14: |cos(180x)|
          15: sin(360x)      16: cos(360x)    17: |sin(360x)|
          18: |cos(360x)|    19: |sin(720x)|  20: |cos(720x)|
          21: 3x             22: 3x-1         23: 3x-2
          24: |3x-1|         25: |3x-2|       26: (3x-1)/2
          27: (3x-2)/2       28: |(3x-1)/2|   29: |(3x-2)/2|
          30: x/0.32-0.78125 31: 2*x-0.84     32: 4x;1;-2x+1.84;x/0.08-11.5
          33: |2*x - 0.5|    34: 2*x          35: 2*x - 0.5
          36: 2*x - 1
     números negativos significam componentes negativos de cores.

     'palette = gray' and 'palette = color' are short cuts for 'palette
     = [3,3,3]' and 'palette = [7,5,15]', respectively.

     Uma vez que essa é uma opção gráfica global, sua posição na
     descrição do fundo do gráfico não é importante.

     Exemplos:

          (%i1) load(draw)$
          (%i2) im: apply(
                     'matrix,
                      makelist(makelist(random(200),i,1,30),i,1,30))$
          (%i3) /* palette = color, default */
                draw2d(image(im,0,0,30,30))$
          (%i4) draw2d(palette = gray, image(im,0,0,30,30))$
          (%i5) draw2d(palette = [15,20,-4],
                       colorbox=false,
                       image(im,0,0,30,30))$

     Veja também 'colorbox'.

 -- Opção gráfica: colorbox
     Valor padrão: 'true'

     If 'colorbox' is 'true', a color scale is drawn together with
     'image' objects.

     Since this is a global graphics option, its position in the scene
     description does not matter.

     Exemplo:

          (%i1) load(draw)$
          (%i2) im: apply('matrix,
                           makelist(makelist(random(200),i,1,30),i,1,30))$
          (%i3) draw2d(image(im,0,0,30,30))$
          (%i4) draw2d(colorbox=false, image(im,0,0,30,30))$

     Veja também 'palette'.

 -- Opção gráfica: enhanced3d
     Valor padrão: 'false'

     Se 'enhanced3d' for 'true', superfícies são coloridas em gráficos
     tridimensionais; em outras palavras, pode escolher o modo pm3d do
     Gnuplot.

     Veja a opção 'palette' para aprender como paletas são
     especificadas.

     Exemplo:

          (%i1) load(draw)$
          (%i2) draw3d(surface_hide = true,
                       enhanced3d   = true,
                       palette      = gray,
                       explicit(20*exp(-x^2-y^2)-10,x,-3,3,y,-3,3))$

 -- Opção gráfica: point_size
     Valor padrão: 1

     'point_size' escolhe o tamanho para os pontos do gráfico.  Esse
     valor deve ser um número não negativo.

     Essa opção afeta os seguintes objetos gráficos:
        * 'gr2d': 'points'.

        * 'gr3d': 'points'.

     Exemplo:

          (%i1) load(draw)$
          (%i2) draw2d(points(makelist([random(20),random(50)],k,1,10)),
                       point_size = 5,
                       points(makelist(k,k,1,20),makelist(random(30),k,1,20)))$

 -- Opção gráfica: point_type
     Valor padrão: 1

     'point_type' indica como pontos isolados são mostrados; o valor
     dessa opção pode ser qualquer índice inteiro maior que ou igual a
     -1, ou o nome de um estilo de ponto: '$none' (-1), 'dot' (0),
     'plus' (1), 'multiply' (2), 'asterisk' (3), 'square' (4),
     'filled_square' (5), 'circle' (6), 'filled_circle' (7),
     'up_triangle' (8), 'filled_up_triangle' (9), 'down_triangle' (10),
     'filled_down_triangle' (11), 'diamant' (12) e 'filled_diamant'
     (13).

     Essa opção afeta os seguintes objetos gráficos:
        * 'gr2d': 'points'.

        * 'gr3d': 'points'.

     Exemplo:

          (%i1) load(draw)$
          (%i2) draw2d(xrange = [0,10],
                       yrange = [0,10],
                       point_size = 3,
                       point_type = 1,
                       points([[1,1],[5,1],[9,1]]),
                       point_type = 2,
                       points([[1,2],[5,2],[9,2]]),
                       point_type = asterisk,
                       points([[1,3],[5,3],[9,3]]),
                       point_type = 4,
                       points([[1,4],[5,4],[9,4]]),
                       point_type = 5,
                       points([[1,5],[5,5],[9,5]]),
                       point_type = 6,
                       points([[1,6],[5,6],[9,6]]),
                       point_type = filled_circle,
                       points([[1,7],[5,7],[9,7]]),
                       point_type = 8,
                       points([[1,8],[5,8],[9,8]]),
                       point_type = filled_diamant,
                       points([[1,9],[5,9],[9,9]]) )$

 -- Opção gráfica: points_joined
     Valor padrão: 'false'

     Se 'points_joined' for 'true', pontos são unidos por linhas retas.

     Essa opção afeta os seguintes objetos gráficos:
        * 'gr2d': 'points'.

        * 'gr3d': 'points'.

     Exemplo:

          (%i1) load(draw)$
          (%i2) draw2d(xrange        = [0,10],
                       yrange        = [0,4],
                       point_size    = 3,
                       point_type    = 1,
                       line_type     = 3,
                       points([[1,1],[5,1],[9,1]]),
                       points_joined = true,
                       point_type    = 3,
                       line_type     = 5,
                       points([[1,2],[5,2],[9,2]]),
                       point_type    = 5,
                       line_type     = 8,
                       line_width    = 7,
                       points([[1,3],[5,3],[9,3]]) )$

 -- Opção gráfica: filled_func
     Valor padrão: 'false'

     'filled_func' indica se uma função é preenchida ('true') ou não
     ('false').

     Essa opção afeta somente objetos gráfico bidimensional 'explicit'.

     Exemplo:

          (%i1) load(draw)$
          (%i2) draw2d(fill_color  = red,
                       filled_func = true,
                       explicit(sin(x),x,0,10) )$

     Veja também 'fill_color'.

 -- Opção gráfica: transparent
     Valor padrão: 'false'

     Se 'transparent' for 'true', regiões internas de poligonos são
     preenchidas de acordo com 'fill_color'.

     Essa opção afeta os seguintes objetos gráficos:
        * 'gr2d': 'polygon', 'rectangle', e 'ellipse'.

     Exemplo:

          (%i1) load(draw)$
          (%i2) draw2d(polygon([[3,2],[7,2],[5,5]]),
                       transparent = true,
                       color       = blue,
                       polygon([[5,2],[9,2],[7,5]]) )$

 -- Opção gráfica: border
     Valor padrão: 'true'

     Se 'border' for 'true', bordas de polígonos são colorizadas de
     acordo com 'line_type' e 'line_width'.

     Essa opção afeta os seguintes objetos gráficos:
        * 'gr2d': 'polygon', 'rectangle', e 'ellipse'.

     Exemplo:

          (%i1) load(draw)$
          (%i2) draw2d(color       = brown,
                       line_width  = 8,
                       polygon([[3,2],[7,2],[5,5]]),
                       border      = false,
                       fill_color  = blue,
                       polygon([[5,2],[9,2],[7,5]]) )$

 -- Opção gráfica: head_both
     Valor padrão: 'false'

     Se 'head_both' for 'true', vetores são mostrados com seta dupla na
     ponta.  Se 'false', somente uma seta é mostrada.

     Essa opção somente é relevante para objetos do tipo 'vector'.

     Exemplo:

          (%i1) load(draw)$
          (%i2) draw2d(xrange      = [0,8],
                       yrange      = [0,8],
                       head_length = 0.7,
                       vector([1,1],[6,0]),
                       head_both   = true,
                       vector([1,7],[6,0]) )$

     Veja também 'head_length', 'head_angle', e 'head_type'.

 -- Opção gráfica: head_length
     Valor padrão: 2

     'head_length' indica, em unidades do eixo <x>, o comprimento da
     ponta da seta do vetor.

     Essa opção é relevante somente para objetos do tipo 'vector'.

     Exemplo:

          (%i1) load(draw)$
          (%i2) draw2d(xrange      = [0,12],
                       yrange      = [0,8],
                       vector([0,1],[5,5]),
                       head_length = 1,
                       vector([2,1],[5,5]),
                       head_length = 0.5,
                       vector([4,1],[5,5]),
                       head_length = 0.25,
                       vector([6,1],[5,5]))$

     Veja também 'head_both', 'head_angle', e 'head_type'.

 -- Opção gráfica: head_angle
     Valor padrão: 45

     'head_angle' indica o ângulo, em graus, entre a ponta da seta do
     vetor e o segmento que forma o corpo do vetor.

     Essa opção é relevante somente para objetos do tipo 'vector'.

     Exemplo:

          (%i1) load(draw)$
          (%i2) draw2d(xrange      = [0,10],
                       yrange      = [0,9],
                       head_length = 0.7,
                       head_angle  = 10,
                       vector([1,1],[0,6]),
                       head_angle  = 20,
                       vector([2,1],[0,6]),
                       head_angle  = 30,
                       vector([3,1],[0,6]),
                       head_angle  = 40,
                       vector([4,1],[0,6]),
                       head_angle  = 60,
                       vector([5,1],[0,6]),
                       head_angle  = 90,
                       vector([6,1],[0,6]),
                       head_angle  = 120,
                       vector([7,1],[0,6]),
                       head_angle  = 160,
                       vector([8,1],[0,6]),
                       head_angle  = 180,
                       vector([9,1],[0,6]) )$

     Veja também 'head_both', 'head_length', e 'head_type'.

 -- Opção gráfica: head_type
     Valor padrão: 'filled'

     'head_type' é usada para especificar como a ponta é mostrada.
     Valores possíveis são: 'filled' (ponta fechada e preenchida),
     'empty' (ponta fechada mas não preenchida), e 'nofilled' (ponta
     aberta).

     Essa opção é relevante somente para objetos do tipo 'vector'.

     Exemplo:

          (%i1) load(draw)$
          (%i2) draw2d(xrange      = [0,12],
                       yrange      = [0,10],
                       head_length = 1,
                       vector([0,1],[5,5]), /* default type */
                       head_type = 'empty,
                       vector([3,1],[5,5]),
                       head_type = 'nofilled,
                       vector([6,1],[5,5]))$

     Veja também 'head_both', 'head_angle', e 'head_length'.

 -- Opção gráfica: label_alignment
     Valor padrão: 'center'

     'label_alignment' é usado para especificar onde escrever rótulos
     com relação às coordenadas fornecidas.  Valores possíveis são:
     'center', 'left', e 'right'.

     Essa opção é relevante somente para objetos do tipo 'label'.

     Exemplo:

          (%i1) load(draw)$
          (%i2) draw2d(xrange          = [0,10],
                       yrange          = [0,10],
                       points_joined   = true,
                       points([[5,0],[5,10]]),
                       color           = blue,
                       label("Centered alignment (default)",5,2),
                       label_alignment = 'left,
                       label("Left alignment",5,5),
                       label_alignment = 'right,
                       label("Right alignment",5,8))$

     Veja também 'label_orientation', e 'color'.

 -- Opção gráfica: label_orientation
     Valor padrão: 'horizontal'

     'label_orientation' é usada para especificar a orientação dos
     rótulos.  Valores possíveis são: 'horizontal', e 'vertical'.

     Essa opção é relevante somente para objetos do tipo 'label'.

     Exemplo:

     Nesse exemplo, um ponto fictício é adicionado para firmar uma
     imagem.  o pacote 'draw' precisa sempre de dados para montar um
     fundo.
          (%i1) load(draw)$
          (%i2) draw2d(xrange     = [0,10],
                       yrange     = [0,10],
                       point_size = 0,
                       points([[5,5]]),
                       color      = navy,
                       label("Horizontal orientation (default)",5,2),
                       label_orientation = 'vertical,
                       color             = "#654321",
                       label("Vertical orientation",1,5))$

     Veja também 'label_alignment', e 'color'.

 -- Opção gráfica: color
     Valor padrão: '"black"'

     'color' especifica a cor para o desenho de linhas, pontos, bordas
     de polígonos e rótulos.

     Cores podem ser fornecidas como nomes ou em código hexadecimal rgb.

     Nomes de cores disponíveis atualmente são: '"white"', '"black"',
     '"gray0"', '"grey0"', '"gray10"', '"grey10"', '"gray20"',
     '"grey20"', '"gray30"', '"grey30"', '"gray40"', '"grey40"',
     '"gray50"', '"grey50"', '"gray60"', '"grey60"', '"gray70"',
     '"grey70"', '"gray80"', '"grey80"', '"gray90"', '"grey90"',
     '"gray100"', '"grey100"', '"gray"', '"grey"', '"light-gray"',
     '"light-grey"', '"dark-gray"', '"dark-grey"', '"red"',
     '"light-red"', '"dark-red"', '"yellow"', '"light-yellow"',
     '"dark-yellow"', '"green"', '"light-green"', '"dark-green"',
     '"spring-green"', '"forest-green"', '"sea-green"', '"blue"',
     '"light-blue"', '"dark-blue"', '"midnight-blue"', '"navy"',
     '"medium-blue"', '"royalblue"', '"skyblue"', '"cyan"',
     '"light-cyan"', '"dark-cyan"', '"magenta"', '"light-magenta"',
     '"dark-magenta"', '"turquoise"', '"light-turquoise"',
     '"dark-turquoise"', '"pink"', '"light-pink"', '"dark-pink"',
     '"coral"', '"light-coral"', '"orange-red"', '"salmon"',
     '"light-salmon"', '"dark-salmon"', '"aquamarine"', '"khaki"',
     '"dark-khaki"', '"goldenrod"', '"light-goldenrod"',
     '"dark-goldenrod"', '"gold"', '"beige"', '"brown"', '"orange"',
     '"dark-orange"', '"violet"', '"dark-violet"', '"plum"' and
     '"purple"'.

     Componentes cromáticos em código hexadecimal são introduzidos na
     forma '"#rrggbb"'.

     Exemplo:

          (%i1) load(draw)$
          (%i2) draw2d(explicit(x^2,x,-1,1), /* default is black */
                       color = "red",
                       explicit(0.5 + x^2,x,-1,1),
                       color = blue,
                       explicit(1 + x^2,x,-1,1),
                       color = "light-blue", /* double quotes if - is used */
                       explicit(1.5 + x^2,x,-1,1),
                       color = "#23ab0f",
                       label("Esse é um rótulo",0,1.2)  )$

     Veja também 'fill_color'.

 -- Opção gráfica: fill_color
     Valor padrão: '"red"'

     'fill_color' especifica a cor para preenchimento de polígonos e
     funções explicitamente bidimensionais.

     Veja 'color' para aprender como cores são especificadas.

 -- Opção gráfica: line_width
     Valor padrão: 1

     'line_width' é a lagura das linhas do gráfico.  Seu valor deve ser
     um número positivo.

     Essa opção afeta os seguintes objetos gráficos:
        * 'gr2d': 'points', 'polygon', 'rectangle', 'ellipse', 'vector',
          'explicit', 'implicit', 'parametric' e 'polar'.

        * 'gr3d': 'points' e 'parametric'.

     Exemplo:

          (%i1) load(draw)$
          (%i2) draw2d(explicit(x^2,x,-1,1), /* default width */
                       line_width = 5.5,
                       explicit(1 + x^2,x,-1,1),
                       line_width = 10,
                       explicit(2 + x^2,x,-1,1))$

     Veja também 'line_type'.

 -- Opção gráfica: line_type
     Valor padrão: 'solid'

     'line_type' indica como linhas são mostradas; valores possíveis são
     'solid' e 'dots'.

     Essa opção afeta os seguintes objetos gráficos:
        * 'gr2d': 'points', 'polygon', 'rectangle', 'ellipse', 'vector',
          'explicit', 'implicit', 'parametric' e 'polar'.

        * 'gr3d': 'points', 'explicit', 'parametric' e
          'parametric_surface'.

     Exemplo:

          (%i1) load(draw)$
          (%i2) draw2d(line_type = dots,
                       explicit(1 + x^2,x,-1,1),
                       line_type = solid, /* default */
                       explicit(2 + x^2,x,-1,1))$

     Veja também 'line_width'.

 -- Opção gráfica: nticks
     Valor padrão: 30

     'nticks' é o número de amostra de pontos usado pelas rotinas de
     montagem de gráfico.

     Essa opção afeta os seguintes objetos gráficos:
        * 'gr2d': 'ellipse', 'explicit', 'parametric' e 'polar'.

        * 'gr3d': 'parametric'.

     Exemplo:

          (%i1) load(draw)$
          (%i2) draw2d(transparent = true,
                       ellipse(0,0,4,2,0,180),
                       nticks = 5,
                       ellipse(0,0,4,2,180,180) )$

 -- Opção gráfica: adapt_depth
     Valor padrão: 10

     'adapt_depth' é o número máximo de quebras usado pelas rotinas
     adaptativos de impressão.

     Essa opção é relevante somente para funções 2d 'explicitas'.

 -- Opção gráfica: key
     Valor padrão: '""' (a seqüência de caracteres vazia)

     'key' é o nome de uma função na legenda.  Se 'key' é uma seqüência
     de caracteres vazia, nenhuma chave é atribuída à função.

     Essa opção afeta os seguintes objetos gráficos:
        * 'gr2d': 'points', 'polygon', 'rectangle', 'ellipse', 'vector',
          'explicit', 'implicit', 'parametric', e 'polar'.

        * 'gr3d': 'points', 'explicit', 'parametric', e
          'parametric_surface'.

     Exemplo:

          (%i1) load(draw)$
          (%i2) draw2d(key = "Seno",
                       explicit(sin(x),x,0,10),
                       key = "Cosseno",
                       line_type = 3,
                       explicit(cos(x),x,0,10) )$

 -- Opção gráfica: xu_grid
     Valor padrão: 30

     'xu_grid' é o número de coordenadas da primeira variável ('x' na
     forma explícita e o número de coordenadas de 'u' em superfícies
     tridimensionais na forma paramétrica) para contruir a grade dos
     pontos de amostra.

     Essa opção afeta os seguintes objetos gráficos:
        * 'gr3d': 'explicit' e 'parametric_surface'.

     Exemplo:

          (%i1) load(draw)$
          (%i2) draw3d(xu_grid = 10,
                       yv_grid = 50,
                       explicit(x^2+y^2,x,-3,3,y,-3,3) )$

     Veja também 'yv_grid'.

 -- Opção gráfica: yv_grid
     Valor padrão: 30

     'yv_grid' é o número de coordenadas da segunda variável ('y' na
     forma explícita e o número de coordenadas de 'v' em superfícies
     tridimensionais na forma paramétrica) para construir a grade dos
     pontos de amostra.

     Essa opção afeta os seguintes objetos gráficos:
        * 'gr3d': 'explicit' e 'parametric_surface'.

     Exemplo:

          (%i1) load(draw)$
          (%i2) draw3d(xu_grid = 10,
                       yv_grid = 50,
                       explicit(x^2+y^2,x,-3,3,y,-3,3) )$

     Veja também 'xu_grid'.

 -- Opção gráfica: surface_hide
     Valor padrão: 'false'

     Se 'surface_hide' for 'true', partes escondidas não são mostradas
     no gráfico em superfícies tridimensioais.

     Uma vez que essa é uma opção gráfica global, sua posição na
     descrição do fundo não é importante.

     Exemplo:

          (%i1) load(draw)$
          (%i2) draw(columns=2,
                     gr3d(explicit(exp(sin(x)+cos(x^2)),x,-3,3,y,-3,3)),
                     gr3d(surface_hide = true,
                          explicit(exp(sin(x)+cos(x^2)),x,-3,3,y,-3,3)) )$

 -- Opção gráfica: contour
     Valor padrão: 'none'

     Option 'contour' torna o usuário capaz de selecionar onde imprimir
     linhas de contorno.  Valores possíveis são:

        * 'none': nenhuma linha de contorno é mostrada.

        * 'base': linhas de contorno são projetadas no plano xy.

        * 'surface': linhas de contorno são mostradas sobre a
          superfície.

        * 'both': duas linhas de contorno são mostradas: no plano xy e
          sobre a superfície.

        * 'map': linhas de contorno são projetadas sobre o plano xy, e o
          ponto de boservação é escolhido na vertical.

     Uma vez que essa é uma opção gráfica global, sua posição na
     descrição do fundo não é importante.

     Exemplo:

          (%i1) load(draw)$
          (%i2) draw3d(explicit(20*exp(-x^2-y^2)-10,x,0,2,y,-3,3),
                       contour_levels = 15,
                       contour        = both,
                       surface_hide   = true) $

 -- Opção gráfica: contour_levels
     Valor padrão: 5

     'contour_levels' é o número de níveis em gráficos de contorno.

     Uma vez que essa é uma opção gráfica global, sua posição na
     descrição do fundo não é importante.

     Exemplo:

          (%i1) load(draw)$
          (%i2) draw3d(explicit(20*exp(-x^2-y^2)-10,x,0,2,y,-3,3),
                       contour_levels = 15,
                       contour        = both,
                       surface_hide   = true) $

 -- Opção gráfica: columns
     Valor padrão: 1

     'columns' é o número de colunas em gráficos multiplos.

     Uma vez que essa é uma opção gráfica global, sua posição na
     descrição do fundo do gráfico não é importante.  Pode também ser
     usado como um argumento da função 'draw'.

     Exemplo:

          (%i1) load(draw)$
          (%i2) scene1: gr2d(title="Elipse",
                             nticks=30,
                             parametric(2*cos(t),5*sin(t),t,0,2*%pi))$
          (%i3) scene2: gr2d(title="Triângulo",
                             polygon([4,5,7],[6,4,2]))$
          (%i4) draw(scene1, scene2, columns = 2)$

 -- Opção gráfica: ip_grid
     Valor padrão: '[50, 50]'

     'ip_grid' escolhe a grade para a primeira amostragem em gráficos
     implícitos.

     Essa opção é relevante somente para 'implicit' objects.

 -- Opção gráfica: ip_grid_in
     Valor padrão: '[5, 5]'

     'ip_grid_in' escolhe a grade para a segunda amostragem em gráficos
     implícitos.

     Essa opção é relevante somente para 'implicit' objects.

 -- Construtor de fundo gráfico: gr2d (<opção gráfica>, ..., <objeto
          gráfico>, ...)

     A função 'gr2d' constrói um objeto descrevendo um fundo gráfico em
     duas dimensões.  Arguments are opções gráficas e objetos gráficos.
     Esse fundo gráfico é interpretado seqüêncialmente: opções gráficas
     afetam aqueles objetos gráficos colocados imediatamente à sua
     direita.

     Para fazer uso dessa função escreva primeiramente 'load(draw)'.

     Adiante encontra-se uma lista de objetos gráficos disponívies para
     fundos gráficos em duas dimensões:

        * 'points([[x1,y1], [x2,y2], [x3,y3],...])' ou
          'points([x1,x2,x3,...], [y1,y2,y3,...])': posiciona os pontos
          '[x1,y1]', '[x2,y2]', '[x2,y2]', ...  no gráfico.

          Esse objeto é efetado pelas seguintes opções gráficas:
          'point_size', 'point_type', 'points_joined', 'line_width',
          'key', 'line_type' e 'color'.

          Exemplo:

               (%i1) load(draw)$
               (%i2) draw2d(key           = "Small points",
                            points(makelist([random(20),random(50)],k,1,10)),
                            point_type    = 6,
                            point_size    = 3,
                            points_joined = true,
                            key           = "Great points",
                            points(makelist(k,k,1,20),makelist(random(30),k,1,20)))$

        * 'polygon([[x1,y1], [x2,y2], [x3,y3],...])' ou
          'polygon([x1,x2,x3,...], [y1,y2,y3,...])': desenha um polígono
          com vértices '[x1,y1]', '[x2,y2]', '[x2,y2]', ...  no plano.

          Esse objeto é afetado pelas seguintes opçs gráficas:
          'transparent', 'fill_color', 'border', 'line_width', 'key',
          'line_type' 'color'.

          Exemplo:

               (%i1) load(draw)$
               (%i2) draw2d(color      = "#e245f0",
                            line_width = 8,
                            polygon([[3,2],[7,2],[5,5]]),
                            border      = false,
                            fill_color  = yellow,
                            polygon([[5,2],[9,2],[7,5]]) )$

        * 'rectangle([x1,y1], [x2,y2])': desenha um retângulo partindo
          do vértice '[x1,y1]' e terminando no vértice '[x2,y2]' oposto
          ao primeiro.

          Esse objeto é afetado pelas seguintes opções gráficas:
          'transparent', 'fill_color', 'border', 'line_width', 'key',
          'line_type' e 'color'.

          Exemplo:

               (%i1) load(draw)$
               (%i2) draw2d(fill_color  = red,
                            line_width  = 6,
                            line_type   = dots,
                            transparent = false,
                            fill_color   = blue,
                            rectangle([-2,-2],[8,-1]),   /* opposite vertices */
                            transparent = true,
                            line_type   = solid,
                            line_width  = 1,
                            rectangle([9,4],[2,-1.5]),
                            xrange      = [-3,10],
                            yrange      = [-3,4.5] )$

        * 'ellipse(xc, yc, a, b, ang1, ang2)': desenha uma elipse com
          centro em '[xc, yc]' com semi-eixo maior 'a' e semi-eixo menor
          'b' traçando um arco de elipse que se inicia no ângulo 'ang1'
          e que vai até o ângulo 'ang2'.  semi axis 'a' e 'b',
          respectively, from angle 'ang1' to angle 'ang2'.

          Esse objeto é afetado pelas seguintes opções gráficas:
          'nticks', 'transparent', 'fill_color', 'border', 'line_width',
          'line_type', 'key' e 'color'.

          Exemplo:

               (%i1) load(draw)$
               (%i2) draw2d(transparent = false,
                            fill_color  = 8,
                            color       = gray30,
                            transparent = false,
                            line_width  = 5,
                            ellipse(0,6,3,2,270,-270),  /* center (x,y), a, b, start & end in degrees */
                            transparent = true,
                            color       = blue,
                            line_width  = 3,
                            ellipse(2.5,6,2,3,30,-90),
                            xrange      = [-3,6],
                            yrange      = [2,9] )$

        * 'label(rótulo,x,y)': escreve o 'rótulo' no ponto '[x,y]'.

          Esse objeto é afetado pelas seguintes opções gráficas:
          'label_alignment', 'label_orientation' e 'color'.

          Exemplo:

          Nesse exemplo, um ponto imaginário é adicionado para firmar a
          imagem.  O pacote 'draw' precisa sempre da dados para desenhar
          um fundo.  Essas cores podem mudar em diferentes terminais.
               (%i1) load(draw)$
               (%i2) draw2d(explicit(x^2,x,-1,1),
                            color = "red",
                            label("Label in red",0,0.3),
                            color = "#0000ff",
                            label("Label in blue",0,0.6),
                            color = "light-blue", /* double quotes if - is used */
                            label("Rótulo em light-blue",0,0.9)  )$

        * 'vector([x,y], [dx,dy])': desenha um vetor de componentes
          ortogonais '[dx,dy]' com orígem eno ponto '[x,y]'.

          Esse objeto é afetado pelas seguintes opções gráficas:
          'head_both', 'head_length', 'head_angle', 'head_type',
          'line_width', 'line_type' e 'key'.

          Exemplo:

               (%i1) load(draw)$
               (%i2) draw2d(xrange      = [0,12],
                            yrange      = [0,10],
                            head_length = 1,
                            vector([0,1],[5,5]), /* default type */
                            head_type = 'empty,
                            vector([3,1],[5,5]),
                            head_both = true,
                            head_type = 'nofilled,
                            line_type = dots,
                            vector([6,1],[5,5]))$

        * 'explicit(fcn,var,minval,maxval)': monta o gráfico da função
          explícita 'fcn', com variável 'var' assumindo valores de
          'minval' a 'maxval'.

          Esse objeto é afetado pelas seguintes opções gráficas:
          'nticks', 'adapt_depth', 'line_width', 'line_type', 'key',
          'filled_func', 'fill_color' e 'color'.

          Exemplo:

               (%i1) load(draw)$
               (%i2) draw2d(line_width = 3,
                            color      = blue,
                            explicit(x^2,x,-3,3) )$
               (%i3) draw2d(fill_color  = brown,
                            filled_func = true,
                            explicit(x^2,x,-3,3) )$

        * 
          'implicit(fcn,x-var,x-minval,x-maxval,y-var,y-minval,y-maxval)':
          monta o gráfico da função implícita definida por 'fcn', com
          variável 'x-var' assumindo de 'x-minval' a 'x-maxval', e
          variável 'y-var' assumindo valores de 'y-minval' a 'y-maxval'.

          Esse objeto é afetado pelas seguintes opções gráficas:
          'ip_grid', 'ip_grid_in', 'line_width', 'line_type', 'key' e
          'color'.

          Exemplo:

               (%i1) load(draw)$
               (%i2) draw2d(terminal  = eps,
                            grid      = true,
                            line_type = solid,
                            key       = "y^2=x^3-2*x+1",
                            implicit(y^2=x^3-2*x+1, x, -4,4, y, -4,4),
                            line_type = dots,
                            key       = "x^3+y^3 = 3*x*y^2-x-1",
                            implicit(x^3+y^3 = 3*x*y^2-x-1, x, -4,4, y, -4,4),
                            title     = "Duas funções implícitas" )$

        * 'polar(radius,ang,minang,maxang)': plots function
          'radius(ang)' defined in polar coordinates, com a variável
          'ang' assumindo valores de 'minang' a 'maxang'.

          Esse objeto é afetado pelas seguintes opções gráficas:
          'nticks', 'line_width', 'line_type', 'key' e 'color'.

          Exemplo:

               (%i1) load(draw)$
               (%i2) draw2d(user_preamble = "set grid polar",
                            nticks        = 200,
                            xrange        = [-5,5],
                            yrange        = [-5,5],
                            line_type     = 6,
                            line_width    = 3,
                            title         = "Hyperbolic Spiral",
                            polar(10/theta,theta,1,10*%pi) )$

        * 'parametric(xfun,yfun,par,parmin,parmax)': monta o gráfico da
          função paramétrica '[xfun,yfun]', com parâmetro 'par'
          assumindo valores de 'parmin' a 'parmax'.

          Esse objeto é afetado pelas seguintes opções gráficas:
          'nticks', 'line_width', 'line_type', 'key' e 'color'.

          Exemplo:

               (%i1) load(draw)$
               (%i2) draw2d(explicit(exp(x),x,-1,3),
                            color = red,
                            key   = "Esse é a unidade paramétrica!!",
                            parametric(2*cos(rrr),rrr^2,rrr,0,2*%pi))$

        * 'image(im,x0,y0,width,height)': monta o gráfico da imágem 'im'
          em uma região retangular do vértice '(x0,y0)' ao vértice
          '(x0+width,y0+height)' no plano real.  O argumeto 'im' deve
          ser uma matriz de números reais, ou uma matriz de vetores de
          comprimento três.

          Se 'im' for uma matriz de números reais, valores de pixel são
          interpretados conforme a opção gráfica 'palette', que é um
          vetor de comprimento três com componentes numéricas variando
          de -36 a +36; cada valor é um índice para uma fórmula mapeando
          os níveis sobre as cores vermelha, verde e azul,
          respectivamente:
                0: 0               1: 0.5           2: 1
                3: x               4: x^2           5: x^3
                6: x^4             7: sqrt(x)       8: sqrt(sqrt(x))
                9: sin(90x)       10: cos(90x)     11: |x-0.5|
               12: (2x-1)^2       13: sin(180x)    14: |cos(180x)|
               15: sin(360x)      16: cos(360x)    17: |sin(360x)|
               18: |cos(360x)|    19: |sin(720x)|  20: |cos(720x)|
               21: 3x             22: 3x-1         23: 3x-2
               24: |3x-1|         25: |3x-2|       26: (3x-1)/2
               27: (3x-2)/2       28: |(3x-1)/2|   29: |(3x-2)/2|
               30: x/0.32-0.78125 31: 2*x-0.84     32: 4x;1;-2x+1.84;x/0.08-11.5
               33: |2*x - 0.5|    34: 2*x          35: 2*x - 0.5
               36: 2*x - 1
          números negativos significam componente de cor negativa.

          'palette = gray' e 'palette = color' são atalhos para 'palette
          = [3,3,3]' e 'palette = [7,5,15]', respectivamente.

          Se 'im' for uma matriz de vetores de comprimento três, eles
          são interpretados como componenetes das cores vermelho, verde
          e azul.

          Exemplos:

          se 'im' for uma matriz de números reais, valores de pixel são
          interpretados conforme a opção gráfica 'palette'.
               (%i1) load(draw)$
               (%i2) im: apply(
                          'matrix,
                           makelist(makelist(random(200),i,1,30),i,1,30))$
               (%i3) /* palette = color, default */
                     draw2d(image(im,0,0,30,30))$
               (%i4) draw2d(palette = gray, image(im,0,0,30,30))$
               (%i5) draw2d(palette = [15,20,-4],
                            colorbox=false,
                            image(im,0,0,30,30))$

          Veja também 'colorbox'.

          Se 'im' for uma matriz de vetores de comprimento três, eles
          são interpretados como componentes da cores vermelho, verde e
          azul.
               (%i1) load(draw)$
               (%i2) im: apply(
                           'matrix,
                            makelist(
                              makelist([random(300),
                                        random(300),
                                        random(300)],i,1,30),i,1,30))$
               (%i3) draw2d(image(im,0,0,30,30))$

     Veja também as seguintes opções gráficas: 'xrange', 'yrange',
     'logx', 'logy', 'terminal', 'grid', 'title', 'xlabel', 'ylabel',
     'xtics', 'ytics', 'xy_file', 'file_name', 'pic_width',
     'pic_height', 'eps_width', 'eps_height', 'user_preamble',
     'axis_bottom', 'axis_left', 'axis_top', e 'axis_right'.

 -- Scene constructor: gr3d (<opção gráfica>, ..., <objeto gráfico>,
          ...)

     A função 'gr3d' constrói um objeto descrevendo um fundo gráfico
     tridimensional.  Argumentos são opções gráficas e objetos gráficos.
     Esse fundo gráfico é interpretado seqüêncialmente: opções gráficas
     afetam aqueles objetos gráficos colocados imediatamente à sua
     direita.

     Para fazer uso dessa função escreva primeiramente 'load(draw)'.

     Essa é a lista dos objetos gráficos disponíveis para fundos
     gráficos tridimensionais:

        * 'points([[x1,y1,z1], [x2,y2,z2], [x3,y3,z3],...])' ou
          'points([x1,x2,x3,...], [y1,y2,y3,...], [z1,z2,z3,...])':
          posiciona os pontos '[x1,y1,z1]', '[x2,y2,z2]', '[x2,y2,z3]',
          ...  no gráfico.

          Esse objeto é afetado pelas seguintes opções gráficas:
          'point_size', 'point_type', 'points_joined', 'line_width',
          'key', 'line_type' e 'color'.

          Exemplos:

          Uma amostra tridimensional,
               (%i1) load(draw)$
               (%i2) load (numericalio)$
               (%i3) s2 : read_matrix (file_search ("wind.data"))$
               (%i4) draw3d(title      = "Velocidades diárias de ventos disponíveis",
                            point_size = 2,
                            points(args(submatrix (s2, 4, 5))) )$

          Duas amostras tridimensionais,
               (%i1) load(draw)$
               (%i2) load (numericalio)$
               (%i3) s2 : read_matrix (file_search ("wind.data"))$
               (%i4) draw3d(title      = "Velocidades diárias de ventos disponíveis. Dois conjuntos de dados",
                            point_size = 2,
                            key        = "Amostras das estações 1, 2 e 3",
                            points(args(submatrix (s2, 4, 5))),
                            point_type = 4,
                            key        = "Amostras das estações 1, 4 e 5",
                            points(args(submatrix (s2, 2, 3))) )$

        * 'label(rótulo,x,y,z)': escreve 'rótulo' no ponto '[x,y,z]'.

          Esse objeto é afetado pelas seguintes opções gráficas:
          'label_alignment', 'label_orientation' e 'color'.

          Exemplo:

               (%i1) load(draw)$
               (%i2) draw3d(explicit(exp(sin(x)+cos(x^2)),x,-3,3,y,-3,3),
                            color = red,
                            label("SUBINDO",-2,0,3),
                            color = blue,
                            label("DESCENDO",2,0,-3) )$

        * 'vector([x,y,z], [dx,dy,dz])': monta o gráfico do vetor
          '[dx,dy,dz]' com orígem em '[x,y,z]'.

          Esse objeto é afetado pelas seguintes opções gráficas:
          'head_both', 'head_type', 'line_width', 'line_type', 'key' e
          'color'.

          Exemplo:

               (%i1) load(draw)$
               (%i2) draw3d(color = cyan,
                            vector([0,0,0],[1,1,1]/sqrt(3)),
                            vector([0,0,0],[1,-1,0]/sqrt(2)),
                            vector([0,0,0],[1,1,-2]/sqrt(6)) )$

        * 'explicit(fcn,var1,minval1,maxval1,var2,minval2,maxval2)':
          monta o gráfico da função explícita 'fcn', com a variável
          'var1' assumindo valores de 'minval1' a 'maxval1' e variável
          'var2' assumindo valores de 'minval2' a 'maxval2'.

          Esse objeto é afetado pelas seguintes opções gráficas:
          'xu_grid', 'yv_grid', 'line_type', 'key' e 'color'.

          Exemplo:

               (%i1) load(draw)$
               (%i2) draw3d(key   = "Gauss",
                            color = "#a02c00",
                            explicit(20*exp(-x^2-y^2)-10,x,-3,3,y,-3,3),
                            color = blue,
                            key   = "Plane",
                            explicit(x+y,x,-5,5,y,-5,5),
                            surface_hide = true)$

        * 'parametric(xfun,yfun,zfun,par,parmin,parmax)': monta o
          gráfico da curva paramétrica '[xfun,yfun,zfun]', com parâmetro
          'par' assumindo valores de 'parmin' a 'parmax'.

          Esse objeto é afetado pelas seguintes opções gráficas:
          'nticks', 'line_width', 'line_type', 'key' e 'color'.

          Exemplo:

               (%i1) load(draw)$
               (%i2) draw3d(explicit(exp(sin(x)+cos(x^2)),x,-3,3,y,-3,3),
                            color = royalblue,
                            parametric(cos(5*u)^2,sin(7*u),u-2,u,0,2),
                            color      = turquoise,
                            line_width = 2,
                            parametric(t^2,sin(t),2+t,t,0,2),
                            surface_hide = true,
                            title = "Surface & curves" )$

        * 
          'parametric_surface(xfun,yfun,zfun,par1,par1min,par1max,par2,par2min,par2max)':
          monta o gráfico da superfície paramétrica '[xfun,yfun,zfun]',
          com parâmetro 'par1' assumindo valores de 'par1min' a
          'par1max' e o parâmetro 'par2' assumindo valores de 'par2min'
          a 'par2max'.

          Esse objeto é afetado pelas seguintes opções gráficas:
          'xu_grid', 'yv_grid', 'line_type', 'key' e 'color'.

          Exemplo:

               (%i1) load(draw)$
               (%i2) draw3d(title          = "Concha do mar",
                            xu_grid        = 100,
                            yv_grid        = 25,
                            rot_vertical   = 100,
                            rot_horizontal = 20,
                            surface_hide   = true,
                            parametric_surface(0.5*u*cos(u)*(cos(v)+1),
                                               0.5*u*sin(u)*(cos(v)+1),
                                               u*sin(v) - ((u+3)/8*%pi)^2 - 20,
                                               u, 0, 13*%pi, v, -%pi, %pi) )$

     Veja também as seguintes opções gráficas: 'xrange', 'yrange',
     'zrange', 'logx', 'logy', 'logz', 'terminal', 'grid', 'title',
     'xlabel', 'ylabel', 'zlabel', 'xtics', 'ytics', 'ztics', 'xy_file',
     'user_preamble', 'axis_bottom', 'axis_left', 'axis_top',
     'file_name', 'pic_width', 'pic_height', 'eps_width', 'eps_height',
     'axis_right', 'rot_vertical', 'rot_horizontal', 'axis_3d',
     'xu_grid', 'yv_grid', 'surface_hide', 'contour', 'contour_levels',
     'palette', 'colorbox' e 'enhanced3d'.

 -- Function: draw (<gr2d>, ..., <gr3d>, ..., <opções>, ...)

     Monta o fundo de uma série de gráficos; seus argumentos são objetos
     'gr2d' e 'gr3d', juntamente com algumas opções.  Por padrão, o
     fundos gráficos são colocados juntos em uma coluna.

     A função 'draw' aceita duas opções possíveis: 'terminal' e
     'columns'.

     As funções 'draw2d' e 'draw3d' são atalhos para serem usados quando
     somente um fundo gráfico é requerido, em duas ou três dimensões,
     respectivamente.

     Para fazer uso dessa função escreva primeiramente 'load(draw)'.

     Exemplo:

          (%i1) load(draw)$
          (%i2) scene1: gr2d(title="Ellipse",
                             nticks=30,
                             parametric(2*cos(t),5*sin(t),t,0,2*%pi))$
          (%i3) scene2: gr2d(title="Triangle",
                             polygon([4,5,7],[6,4,2]))$
          (%i4) draw(scene1, scene2, columns = 2)$

 -- Função: draw2d (<opção>, <objeto gráfico>, ...)

     Essa função é um atalho para 'draw2d(gr2d(<opções>, ..., <objeto
     gráfico>, ...))'.

     Pode ser usada para montar gráfico de um único fundo bidimensional.

     Para fazer uso dessa função escreva primeiramente 'load(draw)'.

 -- Função: draw3d (<opção>, <graphic object>, ...)

     Essa função é um atalho para 'draw3d(gr3d(<opções>, ..., <objeto
     gráfico>, ...))'.

     Pode ser usada para montar o fundo gráfico único tridmensional.

     Para fazer uso dessa função escreva primeiramente 'load(draw)'.

 -- Variável: draw_pipes
     Valor padrão: 'true'

     Quando 'draw_pipes' for 'true', Maxima comunica-se com Gnuplot
     diretamente (via pipes).  Se 'draw_pipes' for 'false', Maxima
     comunica-se com Gnuplot via arquivos.  Essa opção não está
     disponível para usuários windows.


File: maxima.info,  Node: dynamics,  Next: eval_string,  Prev: draw,  Up: Top

49 dynamics
***********

* Menu:

* Introdução a dynamics::
* Funções e Variáveis Definidas para dynamics::


File: maxima.info,  Node: Introdução a dynamics,  Next: Funções e Variáveis Definidas para dynamics,  Prev: dynamics,  Up: dynamics

49.1 Introdução a dynamics
==========================

O pacote adicional 'dynamics' inclui muitas funções para criar várias
representações gráficas de sistemas dinâmicos discretos e fractais, e
uma implementação deo método numérico de Runge-Kutta de quarta ordem
para a resolução de sistemas de equações diferenciais.

   Para usar as funções nesse pacote você deve primeiramente torná-lo
disponível para uso com 'load("dynamics")'.

   Modificações introduzidas no Maxima 5.12

   Iniciando no Maxima 5.12, o pacote dynamics agora utiliza a função
'plot2d' para monar os gráficos.  Os comandos que produzem gráficos (com
exceção de 'julia' e de 'mandelbrot') agora aceitam qualquer opção de
'plot2d', incluindo a opção que modificam o montante das várias
interfaces gráficas, usando diferentes estilos de montagem de gráfico e
cores, e representando um ou ambos os eixos em uma escala logarítmica.
As antigas opções <domain>, <pointsize>, <xcenter>, <xradius>,
<ycenter>, <yradius>, <xaxislabel> e <yaxislabel> não são aceitas nessa
nova versão.

   Todos os programas irão agora aceitar quaisquer nomes de variáveis, e
não apenas <x> e <y> como nas antigas versões.  Dois parâmetros
requeridos tiveram modificações em dois desses programas: 'evolution2d'
agora requer uma lista nomeando explicitamente as duas variáveis
independentes, e o intervalo horizontal para 'orbits' não mais requer um
tamanho de passo; o intervalo pode somente espcificar o nome da
variável, e o menor e o maior valores; o número de passos pode agora ser
modificado com a opção <nticks>.


File: maxima.info,  Node: Funções e Variáveis Definidas para dynamics,  Prev: Introdução a dynamics,  Up: dynamics

49.2 Funções e Variáveis Definidas para dynamics
================================================

 -- Função: chaosgame ('[['<x1>, <y1>']'...'['<xm>, <ym>']]', '['<x0>,
          <y0>']', <b>, <n>, ...opções...);

     Implementa o então chamado jogo do caos: o ponto inicial (<x0>,
     <y0>) é colocado no gráfico e então um dos <m> pontos '['<x1>,
     <y1>']'...'['<xm>, <ym>']' será selecionado de forma aleatória.  O
     próximo ponto colocado no gráfico será sobre o segmento que vai do
     ponto anteriormente colocado no gráfico ao ponto escolhido
     aleatóriamente, à distância do ponto aleatório que será <b> vezes o
     comprimento daquele segmento.  o procedimento é repetido <n> vezes.

 -- Função: evolution (<F>, <y0>, <n>, ..., opções, ...);

     Desenha <n+1> pontos em gráfico bidimensional, onde as coordenadas
     horizontais dos pontos são os inteiros 0, 1, 2, ..., <n>, e as
     coordenadas verticais são os valores correspondentes <y(n)> da
     seqüência definida pela relação de recorrência
                  y(n+1) = F(y(n))

     com valor inicial <y(0)> igual a <y0>.  <F> deve ser uma expressão
     que depende somente de uma variável (no exemplo, essa variável
     dependente de <y>, mas qualquer outra variável pode ser usada em
     lugar de <y>), <y0> deve ser um número real e <n> deve ser um
     inteiro positivo.

 -- Função: evolution2d ('['<F>, <G>']', '['<u>, <v>']', '['<u0>,
          <y0>']', <n>, ..., opções, ...);

     Mostra, em um gráfico bidimensional, os primeiros <n+1> pontos na
     seqüência de pontos definida por meio do sistema dinâmico discreto
     bidimensional com relações de recorrência
                  u(n+1) = F(u(n), v(n))    v(n+1) = G(u(n), v(n))

     Com valores iniciais <u0> e <v0>.  <F> e <G> devem ser duas
     expressões que dependem somente de duas variáveis <u> e <v>, que
     devem ser nomeadas explicitamente em uma lista.

 -- Função: ifs ('['<r1>, ..., <rm>']', '['<A1>, ..., <Am>']', '[['<x1>,
          <y1>']', ..., '['<xm>, <ym>']]', '['<x0>, <y0>']', <n>, ...,
          opções, ...);

     Implemanta o método de Sistemas de Funções iteradas.  Esse método é
     similar ao método descrito na função 'chaosgame', mas em lugar de
     encolher o segmento do ponto corrente ao ponto escolhido
     aleatóriamente, as duas componentes daquele segmento irão ser
     multiplicadas pela matrix 2 por 2 <Ai> que corresponde ao ponto
     escolhido aleatóriamente.

     A escolha aleatória de um dos <m> pontos de atração pode ser feita
     com uma distribuição de probabilidade não uniforme definida por
     meio dos pesos <r1>,...,<rm>.  Esses pesos são fornecidos de forma
     cumulativa; por exemplo se existem 3 pontos com probabilidades 0.2,
     0.5 e 0.3, os pesos <r1>, <r2> e <r3> podem ser 2, 7 e 10.

 -- Função: rk (EDO, var, inicio, domain)
 -- Função: rk ([EDO1,...,EDOm], [v1,...,vm], [inic1,...,inicm], domain)

     A primeira forma resolve numericamente uma equação diferencial de
     primeira ordem, e a segunda formaresolve um sistema de m dessas
     equações, usando o método de Runge-Kutta de quarta ordem.  'var'
     representa a variável dependente.  EDO deve ser uma expressão que
     dependa somente da variável independente e da variável dependente e
     defina a derivada da variável dependente com relação à variável
     independente.

     A variável independente é especificada com 'domain', que deve ser
     uma lista dde quatro elementos como, por exemplo:
          [t, 0, 10, 0.1]
     O primeiro elemento da lista identifica a variável independente, o
     segundo e o terceiro elementos são os valores inicial e final para
     para aquela variável, e o último elemento escolhe o incremento que
     pode ser usado dentro daquele intervalo.

     Se <m> equações estão sendo resolvidas, podem existir <m> variáveis
     dependentes <v1>, <v2>, ..., <vm>.  Os valores iniciais para
     aquelas variáveis serão <inic1>, <inic2>, ..., <inicm>.  Ainda pode
     ser apenas uma variável independente definida por 'domain', como no
     caso anterior.  <EDO1>, ..., <EDOm> são as expressões que definem
     as derivadas de cada variável dependente em termos da variável
     independente.  As variáveis que podem aparecer naquelas expressões
     são a variável independente e quaisquer outras variáveis
     dependentes.  É importante fornecer as derivadas <EDO1>, ...,
     <EDOm> na lista exatamente na mesma ordem usada para variáveis
     dependentes; por exemplo, o terceiro elemento na lista irá ser
     interpretado com a derivada da terceira variável dependente.

     O programa tentará integrar as equações a partir do valor inicial
     da variável independente até seu último valor, usando incrementos
     constantes.  Se em algum passo uma das variáveis dependentes recebe
     um valor absoluto muito grande, a integração será interrompida
     naquele ponto.  O resultado será uma lista com tamtos elementos
     quantos forem o número de iterações feitas.  Cada elemento na lista
     de resultado é em si mesmo outra lista comh <m>+1 elementos: o
     valor da variável independente, seguido pelos valores das variáveis
     dependentes correspondentes àquele ponto.

 -- Função: staircase (<F>, <y0>, <n>, ...opções...);

     Desenha um diagrama em escada para a seqüência definida pela
     relação de recorrência
                  y(n+1) = F(y(n))

     A interpretação e os valores permitidos dos parâmetros de entrada
     são os mesmos que para a função 'evolution'.  Um diagrama em escada
     consiste de um gráfico da função <F(y)>, juntamente com a linha
     <G(y)> '=' <y>.  Um segmento vertical é desenhado a partir das
     point (<y0>, <y0>) on that line until the point where it
     intersecções com a função <F>.  A partir daquele ponto um segmento
     horizontal é desenhado até encontrar o ponto (<y1>, <y1>) sobre a
     linha, e o procedimento é repetido <n> vezes até que o ponto (<yn>,
     <yn>) é encontrado.

   opções

   Cada opção é uma lista de dois ou mais itens.  O primeiro item é o
nome da opção, e os restantes compreendem os argumentos para a opção.

   As opções aceitas pelas funções 'evolution', 'evolution2d',
'staircase', 'orbits', 'ifs' e 'chaosgame' são as mesmas opções para
'plot2d'.  Adicionalmente para aquelas opções, 'orbits' aceita a opção
extra <pixels> que escolhe o número máximo de pontos diferentes que irão
ser representados na direção vertical.

   Exemplos

   Representação gráfica e diagrama em escada para a seqüência: 2,
cos(2), cos(cos(2)),...

     (%i1) load("dynamics")$

     (%i2) evolution(cos(y), 2, 11);

     (%i3) staircase(cos(y), 1, 11, [y, 0, 1.2]);

   Se seu sistema for lento, você deverá reduzir o número de iterações
nos seguintes exemplos.  E se os pontos parecerem muito pequenos no seu
monitor, você pode querer tentar um estilo diferente, tal como
'['<style>,'['<points>,0.8']]'.

   Diagrama de órbitas para o mapa quadrático, com um parâmetro <a>.
             x(n+1) = a + x(n)^2

     (%i4) orbits(x^2+a, 0, 50, 200, [a, -2, 0.25], [style, dots]);

   Para ampliar a região em torno da bifurcação menor perto de x '='
-1.25 use:
     (%i5) orbits(x+y^2, 0, 100, 400, [a,-1,-1.53], [x,-1.6,-0.8],
                  [nticks, 400], [style,dots]);

   Evolução de um sistemma bidimensional que leva a um fractal:

     (%i6) f: 0.6*x*(1+2*x)+0.8*y*(x-1)-y^2-0.9$

     (%i7) g: 0.1*x*(1-6*x+4*y)+0.1*y*(1+9*y)-0.4$

     (%i8) evolution2d([f,g], [x,y], [-0.5,0], 50000, [style,dots]);

   E uma ampliação de uma pequena regial naquele fractal:

     (%i9) evolution2d([f,g], [x,y], [-0.5,0], 300000, [x,-0.8,-0.6],
                       [y,-0.4,-0.2], [style, dots]);

   Um gráfico do triângulo de Sierpinsky, obtido com o jogo do caos:

     (%i9) chaosgame([[0, 0], [1, 0], [0.5, sqrt(3)/2]], [0.1, 0.1], 1/2,
                      30000, [style, dots]);

   A samambaia de Barnsley, obtida com um Sistema de Funções Iteradas:

     (%i10) a1: matrix([0.85,0.04],[-0.04,0.85])$

     (%i11) a2: matrix([0.2,-0.26],[0.23,0.22])$

     (%i12) a3: matrix([-0.15,0.28],[0.26,0.24])$

     (%i13) a4: matrix([0,0],[0,0.16])$

     (%i14) p1: [0,1.6]$

     (%i15) p2: [0,1.6]$

     (%i16) p3: [0,0.44]$

     (%i17) p4: [0,0]$

     (%i18) w: [85,92,99,100]$

     (%i19) ifs(w, [a1,a2,a3,a4], [p1,p2,p3,p4], [5,0], 50000, [style,dots]);

   Para resolver numericamente a equação diferencial

               dx/dt = t - x^2

   Com valor inicial x(t=0) = 1, no intervalo de 't' de 0 a 8 e com
incrementos de 0.1 para 't', use:

     (%i20) results: rk(t-x^2,x,1,[t,0,8,0.1])$

   os resultados serão salvos na lista de resultados.

   Para resolver numericamente o sistema:

             dx/dt = 4-x^2-4*y^2     dy/dt = y^2-x^2+1

   para 't' entre 0 e 4, e com valores de -1.25 e 0.75 para x e y em
t=0:

     (%i21) sol: rk([4-x^2-4*y^2,y^2-x^2+1],[x,y],[-1.25,0.75],[t,0,4,0.02])$


File: maxima.info,  Node: eval_string,  Next: f90,  Prev: dynamics,  Up: Top

50 eval_string
**************

* Menu:

* Funções e Variáveis Definidas para eval_string::


File: maxima.info,  Node: Funções e Variáveis Definidas para eval_string,  Prev: eval_string,  Up: eval_string

50.1 Funções e Variáveis Definidas para eval_string
===================================================

 -- Função: eval_string (<str>)
     Entrega a seqüência de caracteres do Maxima <str> como uma
     expressão do Maxima e a avalia.  <str> é uma seqüência de
     caracteres do Maxima.  Essa seqüência pode ou não ter um marcador
     de final (sinal de dólar '$' ou ponto e vírgula ';').  Somente a
     primeira expressão é entregue e avaliada, se ouver mais de uma.

     Reclama se <str> não for uma seqüência de caracteres do Maxima.

     Exemplos:
          (%i1) eval_string ("foo: 42; bar: foo^2 + baz");
          (%o1)                       42
          (%i2) eval_string ("(foo: 42, bar: foo^2 + baz)");
          (%o2)                   baz + 1764

     Veja também 'parse_string'.

 -- Função: parse_string (<str>)
     Entrega a seqüência de caracteres do Maxima <str> como uma
     expressão do Maxima (sem fazer nenhuma avaliação dessa expressão).
     <str> é uma seqüência de caracteres do Maxima.  Essa seqüência pode
     ou não ter um marcador de final (sinal de dólar '$' ou ponto e
     vírgula ';').  Somente a primeira expressão é entregue e avaliada,
     se ouver mais de uma.

     Reclama se <str> não for uma seqüência de caracteres do Maxima.

     Exemplos:
          (%i1) parse_string ("foo: 42; bar: foo^2 + baz");
          (%o1)                    foo : 42
          (%i2) parse_string ("(foo: 42, bar: foo^2 + baz)");
                                              2
          (%o2)          (foo : 42, bar : foo  + baz)

     Veja também a função 'eval_string'.


File: maxima.info,  Node: f90,  Next: ggf,  Prev: eval_string,  Up: Top

51 f90
******

* Menu:

* Funções e Variáveis Definidas para f90::


File: maxima.info,  Node: Funções e Variáveis Definidas para f90,  Prev: f90,  Up: f90

51.1 Funções e Variáveis Definidas para f90
===========================================

 -- Função: f90 (<expr>)
     O comando f90 é uma atualização para o comando 'fortran' original
     do maxima.  A diferença primária é o caminho através do qual linhas
     longas são quebradas.

     No exemplo seguinte, observe como o comando 'fortran' para linhas
     dentro de símbolos.  O comando 'f90' jamais para linha dentro de um
     símbolo.

          (%i1) load("f90")$

          (%i2) expr:expand((xxx+yyy+7)^4);
                   4            3         3        2    2
          (%o2) yyy  + 4 xxx yyy  + 28 yyy  + 6 xxx  yyy
                       2          2        3             2
           + 84 xxx yyy  + 294 yyy  + 4 xxx  yyy + 84 xxx  yyy
                                         4         3          2
           + 588 xxx yyy + 1372 yyy + xxx  + 28 xxx  + 294 xxx
           + 1372 xxx + 2401
          (%i3) fortran(expr);
                yyy**4+4*xxx*yyy**3+28*yyy**3+6*xxx**2*yyy**2+84*xxx*yyy**2+294*yy
               1   y**2+4*xxx**3*yyy+84*xxx**2*yyy+588*xxx*yyy+1372*yyy+xxx**4+28*
               2   xxx**3+294*xxx**2+1372*xxx+2401
          (%o3)                       done
          (%i4) f90(expr);
          yyy**4+4*xxx*yyy**3+28*yyy**3+6*xxx**2*yyy**2+84*xxx*yyy**2+294* &
               yyy**2+4*xxx**3*yyy+84*xxx**2*yyy+588*xxx*yyy+1372*yyy+xxx** &
               4+28*xxx**3+294*xxx**2+1372*xxx+2401
          (%o4)                       done

     A implementação 'f90' termina como um rápido reparo em 'fortran'.
     Não é necessáriamente um bom exemplo sobre o qual se deva basear
     outros tradutores do Maxima para outras linguagens de programação.

     Para usar essa função escreva primeiro 'load("f90")'.


File: maxima.info,  Node: ggf,  Next: grobner,  Prev: f90,  Up: Top

52 ggf
******

* Menu:

* Funções e Variáveis Definidas para ggf::


File: maxima.info,  Node: Funções e Variáveis Definidas para ggf,  Prev: ggf,  Up: ggf

52.1 Funções e Variáveis Definidas para ggf
===========================================

 -- Variável de Opção: GGFINFINITY
     Valor padrão: 3

     Essa é uma variável de opção para a função 'ggf'.

     Quando calculando a fração contínua da função geradora, um
     quociente parcial tendo um grau (estritamente) maior que
     <GGFINFINITY> será descartado e o convergente atual será
     considerado como o valor exato da função geradora; na grande mioria
     dos casos o grau de todos os quocientes parciais será ou 0 ou 1; se
     você usar um valor muito grande, então você poderá fornecer termos
     suficientes com o objetivo de fazer o cálculo preciso o bastante.

     Veja também 'ggf'.

 -- Variável de opção: GGFCFMAX
     Valor padrão: 3

     Essa é uma variável de opção para a função 'ggf'.

     Quando calculando a fração contínua da função geradora, se nenhum
     bom resultado for encontrado (veja o sinalizador <GGFINFINITY>)
     após se ter calculado uma quantidade de <GGFCFMAX> quocientes
     parciais, a função geradora será considerada como não sendo uma
     fração de dois polinômios e a função irá terminar.  Coloque
     livemente um valor muito grande para funções geradoras mais
     complicadas.

     Veja também 'ggf'.

 -- Função: ggf (<l>)
     Calcula a função geradora (se for uma fração de dois polinômios) de
     uma seqüência, sendo dados seus primeiros termos.  <l> é uma lista
     de números.

     A solução é retornada como uma fração de dois polinômios.  Se
     nenhuma solução tiver sido encontrada, é retornado 'done'.

     Essa função é controlada attravés das variáveis globais
     <GGFINFINITY> e <GGFCFMAX>.  Veja também <GGFINFINITY> e
     <GGFCFMAX>.

     Para usar essa função primeiro escreva 'load("ggf")'.


File: maxima.info,  Node: grobner,  Next: impdiff,  Prev: ggf,  Up: Top

53 grobner
**********

/grobner.texi/1.3/Sat Jun 2 00:13:21 2007//
* Menu:

* Introdução a grobner::
* Funções e Variáveis Definidas para grobner::


File: maxima.info,  Node: Introdução a grobner,  Next: Funções e Variáveis Definidas para grobner,  Prev: Top,  Up: Top

53.1 Introdução a grobner
=========================

'grobner' é um pacote para trabalhos com bases de Groebner no Maxima.

Um tutorial sobre _Bases de Groebner_ pode ser encontrado em

<http://www.geocities.com/CapeCanaveral/Hall/3131/>

Para usar as seguintes funções você deve primeiramente tornar o pacote
'grobner.lisp' disponível para uso:

     load(grobner);

Uma demonstração de uso pode ser iniciada com
     demo("grobner.demo");

ou com
     batch("grobner.demo")

Alguns dos cálculos no arquivo de demonstração irão tomar um pouco de
tempo portanto a saída 'grobner-demo.output' do arquivo de demonstração
pode ser encontrada no mesmo diretório que o arquivo de demonstração.

53.1.1 Notas sobre o pacote grobner
-----------------------------------

O pacote foi escrito por

Marek Rychlik

<http://alamos.math.arizona.edu>

e foi liberado em 24/05/2002 nos termos da Licença Pública Geral
(GPL/GNU/FSF) (veja o arquivo 'grobner.lisp'.  Essa documentação foi
extraída dos arquivos
'README', 'grobner.lisp', 'grobner.demo', 'grobner-demo.output'

por Günter Nowak.  Sugestões de melhorias da documentação podem ser
discutidas em _maxima_-mailing-list <maxima@math.utexas.edu>.  O código
está um pouco desatualizado atualmente.  Implementações modernas
utilizam o algorítmo rápido _F4_ descrito em
A new efficient algorithm for computing Gröbner bases (F4)
Jean-Charles Faugère
LIP6/CNRS Université Paris VI
January 20, 1999

53.1.2 Implementações de ordem monomial admissível em grobner
-------------------------------------------------------------

   * 'lex'

     puramente lexicográfica, ordenação padrão para comparações
     monomiais
   * 'grlex'

     ordenação total de grau, quando houver empate é quebrada pela ordem
     lexicográfica

   * 'grevlex'

     grau total, quando houver empate é quebrada pela ordem
     lexicográfica reversa

   * 'invlex'

     ordenação lexicográfica reversa


File: maxima.info,  Node: Funções e Variáveis Definidas para grobner,  Prev: Introdução a grobner,  Up: Top

53.2 Funções e Variáveis Definidas para grobner
===============================================

53.2.1 Comutadores globais para grobner
---------------------------------------

 -- Variável de opção: poly_monomial_order
     Valor padrão: 'lex'

     Esse comutador globalcontrola qual a ordenação monomial é usada em
     polinomio e em cálculos com Bases de Groebner.  Se não for
     escolhidat, 'lex' será usada.

 -- Variável de opção: poly_coefficient_ring
     Valor padrão: 'expression_ring'

     Esse comutador indica o anel de coeficiente dos polinômios que irá
     ser usado em cálculos de grobner.  Se não for escolhido, o anel de
     expressão geral do _maxima's_ irá ser usado.  Essa variável pode
     ser escolhida para 'ring_of_integers' se for desejado.

 -- Variável de opção: poly_primary_elimination_order
     Valor padrão: 'false'

     Nome da ordem padrão de eliminação de variáveis em funções de
     eliminação.  Se não for escolhida, 'lex' irá ser usada.

 -- Variável de opção: poly_secondary_elimination_order
     Valor padrão: 'false'

     Nome da ordem padrão para manter variáveis em funções de
     eliminação.  Se não for escolhida, 'lex' irá ser usada.

 -- Variável de opção: poly_elimination_order
     Valor padrão: 'false'

     Nome da ordem padrão de funções de eliminação.  Se escolhida, irá
     sobrescrever as escolhas nas variáveis
     'poly_primary_elimination_order' e
     'poly_secondary_elimination_order'.  O usuário deve garantir que
     essa é uma ordem de eliminação verdadeira válida para o número de
     variáveis eliminadas.

 -- Variável de opção: poly_return_term_list
     Valor padrão: 'false'

     Se escolhida para 'true', todas as funções no pacote 'grobner' irão
     retornar cada polinômio como uma lista de termos na ordem monomial
     corrente em lugar de retornar uma expressão geral do _maxima_.

 -- Variável de opção: poly_grobner_debug
     Valor padrão: 'false'

     Se escolhida para 'true', produz saída de depuração e rastros.

 -- Variável de opção: poly_grobner_algorithm
     Valor padrão: 'buchberger'

     Valores possíveis:
        * 'buchberger'
        * 'parallel_buchberger'
        * 'gebauer_moeller'

     O nome do algorítmo usado para encontrar as bases de Groebner.

 -- Variável de opção: poly_top_reduction_only
     Valor padrão: 'false'

     Se não for 'false', usa redução de topo somente se for possível.
     Redução de topo significa que o algorítmo de divisão para após a
     primeira redução.

53.2.2 Operadores simples em grobner
------------------------------------

'poly_add', 'poly_subtract', 'poly_multiply' e 'poly_expt' são as
operações aritméticas sobre polinômios.  Elas são executadas usando
representação interna, mas os resultados são convertidos de volta à
forma geral do _maxima_.

 -- Função: poly_add (<poli1>, <poli2>, <varlist>)
     Adiciona dois polinômios <poli1> e <poli2>.

          (%i1) poly_add(z+x^2*y,x-z,[x,y,z]);
                                              2
          (%o1)                              x  y + x

 -- Função: poly_subtract (<poli1>, <poli2>, <varlist>)
     Subtrai o polinômio <poli2> do polinômio <poli1>.

          (%i1) poly_subtract(z+x^2*y,x-z,[x,y,z]);
                                                2
          (%o1)                          2 z + x  y - x

 -- Função: poly_multiply (<poli1>, <poli2>, <varlist>)
     Retorna o produto dos polinômios <poli1> e <poli2>.

          (%i2) poly_multiply(z+x^2*y,x-z,[x,y,z])-(z+x^2*y)*(x-z),expand;
          (%o1)                                  0

 -- Função: poly_s_polynomial (<poli1>, <poli2>, <varlist>)
     Retorna o _polinômio syzygy_ (_S-polinomial_) de dois polinômios
     <poli1> e <poli2>.

 -- Função: poly_primitive_part (<poli1>, <varlist>)
     Retorna o polinômio <poli> dividido pelo MDC entre seus
     coeficientes.

          (%i1) poly_primitive_part(35*y+21*x,[x,y]);
          (%o1)                              5 y + 3 x

 -- Função: poly_normalize (<poli>, <varlist>)
     Retorna o polinômio <poli> dividido pelo coeficiente lider.
     'poly_normalize' assume que a divisão é possível, o que nem sempre
     ocorre em anéis que não são corpos (fields).

53.2.3 Outras funções em grobner
--------------------------------

 -- Função: poly_expand (<poli>, <varlist>)
     Essa função transforma polinômios para a forma interna e da forma
     interna para a forma geral.  'poly_expand' é equivalente a
     'expand(poly)' se <poli> passa corretamente para um polinômio.  Se
     a representação não for compatível com um polinômio nas variáveis
     <varlist>, o resultado é um erro.  Esse resultado em erro pode ser
     usado para testar se uma expressão transforma-se corretamente para
     a representação interna.  Os seguintes exemplos ilustra que
     variáveis de funções indexadas e transcendentes são permitidas.

          (%i1) poly_expand((x-y)*(y+x),[x,y]);
                                               2    2
          (%o1)                               x  - y
          (%i2) poly_expand((y+x)^2,[x,y]);
                                          2            2
          (%o2)                          y  + 2 x y + x
          (%i3) poly_expand((y+x)^5,[x,y]);
                            5      4         2  3       3  2      4      5
          (%o3)            y  + 5 x y  + 10 x  y  + 10 x  y  + 5 x  y + x
          (%i4) poly_expand(-1-x*exp(y)+x^2/sqrt(y),[x]);
                                                    2
                                            y      x
          (%o4)                       - x %e  + ------- - 1
                                                 sqrt(y)

          (%i5) poly_expand(-1-sin(x)^2+sin(x),[sin(x)]);
                                          2
          (%o5)                      - sin (x) + sin(x) - 1


 -- Função: poly_expt (<poli>, <número>, <varlist>)
     eleva <poli> a um inteiro positivo <número>.  If <número> não for
     um inteiro positivo um erro irá ser mostrado.

          (%i1) poly_expt(x-y,3,[x,y])-(x-y)^3,expand;
          (%o1)                                  0

 -- Função: poly_content (<poli>. <varlist>)
     'poly_content' extrai o MDC entre seus coeficientes

          (%i1) poly_content(35*y+21*x,[x,y]);
          (%o1)                                  7

 -- Função: poly_pseudo_divide (<poli>, <polilist>, <varlist>)
     Realiza a divisão falsa do polinômio <poli> pela lista de n
     polinômios <polilist>.  Retorna multiplos valores.  O primeiro
     valor é uma lista de quocientes a.  O segundo valor é o resto r.  O
     terceiro argumento é um coeficiente escalar c, tal que c*poli pode
     ser dividido por<polilist> dentro do anel dos coeficientes, que não
     é necessáriamente corpo.  Finalmente, o quarto valor é um contador
     inteiro do número de reduções realizadas.  O objetos resultantes
     satisfazem à equação:

     c*poly=sum(a[i]*polylist[i],i=1...n)+r.

 -- Função: poly_exact_divide (<poli1>, <poli2>, <varlist>)
     Divide um polinômio <poli1> por outro polinômio <poli2>.  Assume
     que a divisão exata (sem resto) é possível.  Retorna o quociente.

 -- Função: poly_normal_form (<poli>, <polilist>, <varlist>)
     'poly_normal_form' encontra a forma normal de um polinômio <poli>
     com relação a um conjunto de polinômios <polilist>.

 -- Função: poly_buchberger_criterion (<polilist>, <varlist>)
     Returns 'true' if <polilist> is a Groebner basis with respect to
     the current term order, by using the Buchberger criterion: for
     every two polynomials h1 and h2 in <polilist> the S-polynomial
     S(h1,h2) reduces to 0 modulo <polilist>.

 -- Função: poly_buchberger (<polilist_fl> <varlist>)
     'poly_buchberger' realiza o algorítmo de Buchberger sobre uma lista
     de polinômios e retorna a base de Grobner resultante.

53.2.4 Pósprocessamento padão de bases de Groebner
--------------------------------------------------

O _k-ésimo ideal de eliminação_ I_k de uma Ideal I sobre K[
x[1],...,x[n] ] é o ideal intersecção(I, K[ x[k+1],...,x[n] ]).
O _ideal quociente_ I:J é o ideal {h|for all w em J: w*h em I}.
O ideal I:p^inf é o ideal {h| existe um n em N: p^n*h em I}.
O ideal I:J^inf é o ideal {h| existe um n em N \and a p em J: p^n*h em
I}.
O _ideal radical_ sqrt(I) é o ideal {h| existe um n em N : h^n em I }.

 -- Função: poly_reduction (<polilist>, <varlist>)
     'poly_reduction' reduz uma lista de polinômios <polilist>, de forma
     que cada poinômio é completametne reduzido com relação a outros
     polinômios.

 -- Função: poly_minimization (<polilist>, <varlist>)
     Retorna uma sublista da lista de polinômios <polilist> gerando o
     mesmo ideal de monômio que <polilist> mas minimo, i.e.  nenhum
     monômio líder de um polinômio na sublista divide o monômio líder de
     outro polinômio.

 -- Função: poly_normalize_list (<polilist>, <varlist>)
     'poly_normalize_list' aplica 'poly_normalize' a cada polinômio na
     lista.  Que significa que 'poly_normalize_list' divide todo
     polinômio em uma lista <polilist> por seu coeficiente líder.

 -- Função: poly_grobner (<polilist>, <varlist>)
     Retorna uma base de Groebner do ideal gerado pelos polinômios
     <polilist>.  Afetado pelos sinalizadores globais.

 -- Função: poly_reduced_grobner (<polilist>, <varlist>)
     Retorna uma base de Groebner reduzida do ideal gerado pelos
     polinômios <polilist>.  Afetado pelos sinalizadores globais.

 -- Função: poly_depends_p (<poli>, <var>, <varlist>)
     'poly_depends' testa se um polinômio depende da variável <var>.

 -- Função: poly_elimination_ideal (<polilist>, <num>, <varlist>)

     'poly_elimination_ideal' retorna a base de grobner do num-ésimo
     ideal de eliminação de um ideal especificado como uma lista de
     polinômios geradores (não necessáriamente base de Groebner)

 -- Função: poly_colon_ideal (<polilist1>, <polilist2>, <varlist>)

     Retorna a base reduzida de Groebner do ideal quociente

     I(polilist1):I(polilist2)

     onde polilist1 e polilist2 são duas listas de polinômios.

 -- Função: poly_ideal_intersection (<polilist1>, <polilist2>,
          <varlist>)

     'poly_ideal_intersection' retorna a intersecção entre dois ideais.

 -- Função: poly_lcm (<poli1>, <poli2>, <varlist>)
     Retorna o mínimo múltiplo comum entre <poli1> e <poli2>.

 -- Função: poly_gcd (<poli1>, <poli2>, <varlist>)
     Retorna máximo divisor comum de <poli1> e <poli2>.

 -- Função: poly_grobner_equal (<polilist1>, <polilist2>, <varlist>)
     'poly_grobner_equal' testa se duas bases de Groebner geram o mesmo
     ideal.  Retorna 'true' se as duas listas de polinômios <polilist1>
     e <polilist2>, assumidas serem bases de Groebner, geram o mesmo
     ideal, e 'false' de outra forma.  Isso é equivalente a verificar
     que todo polinômio da primeira base é reduzido a 0 módulo a segunda
     base e vice-versa.  Note que no exemplo abaixo a primeira lista não
     é uma base de Groebner, e dessa forma o resultado é 'false'.

          (%i1) poly_grobner_equal([y+x,x-y],[x,y],[x,y]);
          (%o1)                         false

 -- Função: poly_grobner_subsetp (<polilist1>, <polilist2>, <varlist>)

     'poly_grobner_subsetp' testa se um ideal gerado pela <polilist1>
     está contido em um ideal gerado pela <polilist2>.  Para esse teste
     sempre tenha sucesso, <polilist2> deve ser uma base de Groebner.

 -- Função: poly_grobner_member (<poli>, <polilist>, <varlist>)

     Retorna 'true' se um polinômio <poli> pertence ao ideal gerado pela
     lista polinomial <polilist>, que é assumida como sendouma base de
     Groebner.  Retorna 'false' de outra forma.

     'poly_grobner_member' testa se um polinômio pertence a um ideal
     gerado por uma lista de polinômios, que é assumida ser uma base de
     Groebner.  Equivale a 'normal_form' sendo 0.

 -- Função: poly_ideal_saturation1 (<polilist>, <poli>, <varlist>)
     Retorna abase de Groebner reduzida da saturação do ideal

     I(polylist):poly^inf

     Geometricamente, sobre um corpo algebricamente fechado, esse é um
     conjunto de polinmios no ideal gerado por <polilist> que não tende
     identicamente a zero sobre a variação de <poli>.

 -- Função: poly_ideal_saturation (<polilist1>, <polilist2>, <varlist>)
     Retorna a base de Groebner reduzida da saturação do ideal

     I(polylist1):I(polylist2)^inf

     Geometricamente, sobre um corpo algebricamente fechado, esse é um
     conjunto de polinmios no ideal gerado por <polilist1> que não tende
     identicamente a zero sobre a variação de <polilist2>.

 -- Função: poly_ideal_polysaturation1 (<polilist1>, <polilist2>,
          <varlist>)
     <polilist2> ist a list of n polynomials '[poly1,...,polyn]'.
     Retorna a base de Groebner reduzida do ideal

     I(polylist):poly1^inf:...:polyn^inf

     obtido por uma seqüência de sucessivas saturações nos polinômios da
     lista polinômial <polilist2> do ideal gerado pela lista polinomial
     <polilist1>.

 -- Função: poly_ideal_polysaturation (<polilist>, <polilistlist>,
          <varlist>)
     <polilistlist> is a list of n list of polynomials
     '[polylist1,...,polylistn]'.  Retorna a base reduzida de Groebner
     da saturação do ideal

     I(polylist):I(polylist_1)^inf:...:I(polylist_n)^inf

 -- Função: poly_saturation_extension (<poli>, <polilist>, <varlist1>,
          <varlist2>)

     'poly_saturation_extension' implementa o famoso artifício de
     Rabinowitz.


File: maxima.info,  Node: impdiff,  Next: implicit_plot,  Prev: grobner,  Up: Top

54 impdiff
**********

* Menu:

* Funções e Variáveis Definidas para impdiff::


File: maxima.info,  Node: Funções e Variáveis Definidas para impdiff,  Prev: impdiff,  Up: impdiff

54.1 Funções e Variáveis Definidas para impdiff
===============================================

 -- Função: implicit_derivative (<f>,<indvarlist>,<orderlist>,<depvar>)
     Essa subrotina calcula derivadas implícitas de funções de várias
     variáveis.  <f> é uma função do tipo array, os índices são o grau
     da derivada na ordem <indvarlist>; <indvarlist> é a lista de
     variáveis independentes; <orderlist> é a ordem desejada; e <depvar>
     é a variável dependente.

     Para usar essa função escreva primeiro 'load("impdiff")'.


File: maxima.info,  Node: implicit_plot,  Next: interpol,  Prev: impdiff,  Up: Top

55 implicit_plot
****************

* Menu:

* Funções e Variáveis Definidas para implicit_plot::


File: maxima.info,  Node: Funções e Variáveis Definidas para implicit_plot,  Prev: implicit_plot,  Up: implicit_plot

55.1 Funções e Variáveis Definidas para implicit_plot
=====================================================

 -- Função: implicit_plot (<expr>, <x_range>, <y_range>)
 -- Função: implicit_plot ([<expr_1>, ..., <expr_n>], <x_range>,
          <y_range>)

     Mostra na tela um gráfico de uma ou mais expressões na forma
     implícita.  <expr> é a expressão a ser montado o gráfico, <x_range>
     o intervalo do eixo do eixo horizontal e <y_range> o intervalo do
     eixo vertical.  'implicit_plot' somente trabalha com o driver do
     gnuplot.  'implicit_plot' respeita as escolhas globais para o
     driver do gnuplot escolhidas por meio da função <set_plot_option>.
     Opções podem tamb;em serem passadas para a função 'implicit_plot'
     como argumentos opcionais.

     'implicit_plot' trabalha por meio de mudanças de sinal de trilha
     sobre a área fornecida através de <x_range> e <y_range> e pode
     falhar em expressões complicadas.

     'load(implicit_plot)' torna essa função disponível para uso.

     Exemplo:
          (%i1) load(implicit_plot)$
          (%i2) implicit_plot (x^2 = y^3 - 3*y + 1, [x, -4, 4], [y, -4, 4])$


File: maxima.info,  Node: interpol,  Next: lbfgs,  Prev: implicit_plot,  Up: Top

56 interpol
***********

* Menu:

* Introdução a interpol::
* Funções e Variáveis Definidas para interpol::


File: maxima.info,  Node: Introdução a interpol,  Next: Funções e Variáveis Definidas para interpol,  Prev: interpol,  Up: interpol

56.1 Introdução a interpol
==========================

Pacote 'interpol' define os métodos Lagrangiano, linear e o de splines
cúbicos para interpolação polinomial.

   Comentários, correções e sugestões, por favor contacte-me em <'mario
AT edu DOT xunta DOT es'>.


File: maxima.info,  Node: Funções e Variáveis Definidas para interpol,  Prev: Introdução a interpol,  Up: interpol

56.2 Funções e Variáveis Definidas para interpol
================================================

 -- Função: lagrange (<pontos>)
 -- Função: lagrange (<pontos>, <opção>)
     Calcula a interpolação polinomial através do método Lagrangiano.  O
     argumento <pontos> deve ser um dos seguintes:

        * uma matriz de duas colunas, 'p:matrix([2,4],[5,6],[9,3])',
        * uma lista de pares, 'p: [[2,4],[5,6],[9,3]]',
        * uma lista de números, 'p: [4,6,3]', e nesse caso as abcissas
          irão ser atribuídas automaticamente aos valores 1, 2, 3, etc.

     Nos dois primeiros casos os pares são ordenados em relação à
     primeira coordenada antes de fazer os cálculos.

     Com o argumento <opção> é possível escolher o nome da variável
     independente, o qual é ''x' por padrão; para definir qualquer
     outra, z por exemplo, escreva 'varname='z'.

     Exemplos:

          (%i1) load("interpol")$
          (%i2) p:[[7,2],[8,2],[1,5],[3,2],[6,7]]$
          (%i3) lagrange(p);
                           4        3         2
                       73 x    701 x    8957 x    5288 x   186
          (%o3)        ----- - ------ + ------- - ------ + ---
                        420     210       420      105      5
          (%i4) f(x):=''%;
                               4        3         2
                           73 x    701 x    8957 x    5288 x   186
          (%o4)    f(x) := ----- - ------ + ------- - ------ + ---
                            420     210       420      105      5
          (%i5) /* Evaluate the polynomial at some points */
                map(f,[2.3,5/7,%pi]);
                                       919062
          (%o5)  [- 1.567534999999992, ------,
                                       84035
                                   4          3           2
                             73 %pi    701 %pi    8957 %pi    5288 %pi   186
                             ------- - -------- + --------- - -------- + ---]
                               420       210         420        105       5
          (%i6) %,numer;
          (%o6) [- 1.567534999999992, 10.9366573451538, 2.89319655125692]
          (%i7) /* Plot the polynomial together with points */
                plot2d([f(x),[discrete,p]],[x,0,10],
                     [gnuplot_curve_styles,
                           ["with lines","with points pointsize 3"]])$
          (%i8) /* Change variable name */
                lagrange(p, varname=w);
                           4        3         2
                       73 w    701 w    8957 w    5288 w   186
          (%o8)        ----- - ------ + ------- - ------ + ---
                        420     210       420      105      5

 -- Função: charfun2 (<x>, <a>, <b>)
     Retorna 'true', i.  e., verdadeiro se o número <x> pertence ao
     intervalo [a, b), e 'false', i.  e., falsono caso contrário.

 -- Função: linearinterpol (<pontos>)
 -- Função: linearinterpol (<pontos>, <opção>)
     Calcula a interpolação polinomial através do método linear.  O
     argumento <pontos> deve ser um dos seguintes:

        * uma matriz de duas colunas, 'p:matrix([2,4],[5,6],[9,3])',
        * uma lista de pares, 'p: [[2,4],[5,6],[9,3]]',
        * uma lista de números, 'p: [4,6,3]', e nesse caso as abcissas
          irão ser atribuídas automaticamente aos valores 1, 2, 3, etc.

     Nos dois primeiros casos os pares são ordenados em relação à
     primeira coordenada antes de fazer os cálculos.

     Com o argumento <opção> é possível escolher o nome da variável
     independente, o qual é ''x' por padrão; para definir qualquer
     outra, z por exemplo, escreva 'varname='z'.

     Examples:
          (%i1) load("interpol")$
          (%i2) p: matrix([7,2],[8,3],[1,5],[3,2],[6,7])$
          (%i3) linearinterpol(p);
                  13   3 x
          (%o3)  (-- - ---) charfun2(x, minf, 3)
                  2     2
           + (x - 5) charfun2(x, 7, inf) + (37 - 5 x) charfun2(x, 6, 7)
              5 x
           + (--- - 3) charfun2(x, 3, 6)
               3

          (%i4) f(x):=''%;
                          13   3 x
          (%o4)  f(x) := (-- - ---) charfun2(x, minf, 3)
                          2     2
           + (x - 5) charfun2(x, 7, inf) + (37 - 5 x) charfun2(x, 6, 7)
              5 x
           + (--- - 3) charfun2(x, 3, 6)
               3
          (%i5)  /* Evaluate the polynomial at some points */
                 map(f,[7.3,25/7,%pi]);
                                      62  5 %pi
          (%o5)                 [2.3, --, ----- - 3]
                                      21    3
          (%i6) %,numer;
          (%o6)  [2.3, 2.952380952380953, 2.235987755982989]
          (%i7)  /* Plot the polynomial together with points */
                 plot2d(['(f(x)),[discrete,args(p)]],[x,-5,20],
                     [gnuplot_curve_styles,
                           ["with lines","with points pointsize 3"]])$
          (%i8)  /* Change variable name */
                 linearinterpol(p, varname='s);
                 13   3 s
          (%o8) (-- - ---) charfun2(s, minf, 3)
                 2     2
           + (s - 5) charfun2(s, 7, inf) + (37 - 5 s) charfun2(s, 6, 7)
              5 s
           + (--- - 3) charfun2(s, 3, 6)
               3

 -- Função: cspline (<pontos>)
 -- Função: cspline (<pontos>, <opção1>, <opção2>, ...)
     Calcula a interpolação polnomial pelo método de splines (
     polinômios de ordem k que interpolam os dados e têm k-1 derivadas
     contínuas em todo o intervalo ) cúbicos.  O argumento <pontos> deve
     ser um dos seguintes:

        * uma matriz de duas colunas, 'p:matrix([2,4],[5,6],[9,3])',
        * uma lista de pares, 'p: [[2,4],[5,6],[9,3]]',
        * uma lista de números, 'p: [4,6,3]', e nesse caso as abcissas
          irão ser atribuídas automaticamente aos valores 1, 2, 3, etc.

     Nos dois primeiros casos os pares são ordenados em relação à
     primeira coordenada antes de fazer os cálculos.

     Existem três opções para ajustar necessidades específicas:
        * ''d1', o padrão é ''unknown', é a primeira derivada em x_1; se
          essa primeira derivada for desconhecida, ''unknown', a segunda
          derivada em x_1 é igualada a 0 (o spline cúbico natural); se
          essa primeira derivada for igual a um número, a segunda
          derivada é calculada baseando-se nesse número.

        * ''dn', o padrão é ''unknown', é a primeira derivada em x_n; se
          essa primeira derivada for desconhecida, ''unknown', a segunda
          derivada em x_n é igualada a 0 (o spline cúbico natural); se
          essa primeira derivada for igual a um número, a segunda
          derivada é calculada baseando-se nesse número.

        * ''nome_var', o padrão é ''x', é o nome da variável
          independente.

     Exemplos:
          (%i1) load("interpol")$
          (%i2) p:[[7,2],[8,2],[1,5],[3,2],[6,7]]$
          (%i3) /* Unknown first derivatives at the extremes
                   is equivalent to natural cubic splines */
                cspline(p);
                        3         2
                  1159 x    1159 x    6091 x   8283
          (%o3)  (------- - ------- - ------ + ----) charfun2(x, minf, 3)
                   3288      1096      3288    1096
                      3         2
                2587 x    5174 x    494117 x   108928
           + (- ------- + ------- - -------- + ------) charfun2(x, 7, inf)
                 1644       137       1644      137
                    3          2
              4715 x    15209 x    579277 x   199575
           + (------- - -------- + -------- - ------) charfun2(x, 6, 7)
               1644       274        1644      274
                      3         2
                3287 x    2223 x    48275 x   9609
           + (- ------- + ------- - ------- + ----) charfun2(x, 3, 6)
                 4932       274      1644     274

          (%i4) f(x):=''%$
          (%i5) /* Some evaluations */
                map(f,[2.3,5/7,%pi]), numer;
          (%o5) [1.991460766423356, 5.823200187269903, 2.227405312429507]
          (%i6) /* Plotting interpolating function */
                plot2d(['(f(x)),[discrete,p]],[x,0,10],
                    [gnuplot_curve_styles,
                         ["with lines","with points pointsize 3"]])$
          (%i7) /* New call, but giving values at the derivatives */
                cspline(p,d1=0,dn=0);
                        3          2
                  1949 x    11437 x    17027 x   1247
          (%o7)  (------- - -------- + ------- + ----) charfun2(x, minf, 3)
                   2256       2256      2256     752
                      3          2
                1547 x    35581 x    68068 x   173546
           + (- ------- + -------- - ------- + ------) charfun2(x, 7, inf)
                  564       564        141      141
                   3          2
              607 x    35147 x    55706 x   38420
           + (------ - -------- + ------- - -----) charfun2(x, 6, 7)
               188       564        141      47
                      3         2
                3895 x    1807 x    5146 x   2148
           + (- ------- + ------- - ------ + ----) charfun2(x, 3, 6)
                 5076       188      141      47
          (%i8) /* Defining new interpolating function */
                g(x):=''%$
          (%i9) /* Plotting both functions together */
                plot2d(['(f(x)),'(g(x)),[discrete,p]],[x,0,10],
                     [gnuplot_curve_styles,
                        ["with lines","with lines","with points pointsize 3"]])$


File: maxima.info,  Node: lbfgs,  Next: lindstedt,  Prev: interpol,  Up: Top

57 lbfgs
********

* Menu:

* Introdução a lbfgs::
* Funções e Variáveis Definidas para lbfgs::


File: maxima.info,  Node: Introdução a lbfgs,  Next: Funções e Variáveis Definidas para lbfgs,  Prev: Top,  Up: Top

57.1 Introdução a lbfgs
=======================

'lbfgs' é uma implementação do algorítmo[1] L-BFGS
(Broyden-Fletcher-Goldfarb-Shanno) para resolver problemas de
minimização não limitada através de um algorítmo de memória limitada
quasi-Newton (BFGS). Esse algorítmo é chamado de método de memória
limitada porque uma aproximação de baixo ranque da inverso da matriz
Hessiana é armazenado em lugar da inversa da matriz Hessiana completa.
O programa foi escrito origináriamente em Fortran [2] por Jorge Nocedal,
incorporando algumas funções originalmente escritas por Jorge J. Moré e
David J. Thuente, e traduzidas para Lisp automaticamente através do
programa 'f2cl'.  O pacote do Maxima 'lbfgs' compreende o código
traduzido e adicionalmente uma interface de função que gerencia alguns
detallhes.

   Referências:

   [1] D. Liu and J. Nocedal.  "On the limited memory BFGS method for
large scale optimization".  Mathematical Programming B 45:503-528 (1989)

   [2] http://netlib.org/opt/lbfgs_um.shar


File: maxima.info,  Node: Funções e Variáveis Definidas para lbfgs,  Prev: Introdução a lbfgs,  Up: Top

57.2 Funções e Variáveis Definidas para lbfgs
=============================================

 -- Função: lbfgs (<FOM>, <X>, <X0>, <epsilon>, <iprint>)

     Encontra uma solução aproximada da minimização não limitada de
     número de mérito <FOM> sobre a lista de variáveis <X>, começando a
     partir da estimativa inicial <X0>, tal que norm grad FOM < epsilon
     max(1, norm X).

     O algorítmo aplicado é um algorítmo de memória limitada[1]
     quasi-Newton (BFGS). Esse algorítmo é chamado de método de memória
     limitada porque uma aproximação de baixo ranque da inverso da
     matriz Hessiana é armazenado em lugar da inversa da matriz Hessiana
     completa.  Cada iteração do algorítmo é uma busca de linha, isto é,
     uma busca ao longo de um raio em torno da variáveis <X>, com a
     direção de busca calculada a partir da Hessian inversa aproximada.
     O FOM é sempre decrementado por meio de uma busca de linha
     realizada com sucesso.  Usualmente (mas não sempre) a norma do
     gradiente de FOM também é decrementada.

     <iprint> controla as messaens de progresso mostradas através de
     'lbfgs'.

     'iprint[1]'
          '<iprint>[1]' controla a freqüência das mensagens de
          progresso.
          'iprint[1] < 0'
               Nenhuma mensagem de progresso.
          'iprint[1] = 0'
               Messagens na primeira iteração e na última iteração.
          'iprint[1] > 0'
               Mostra uma mensagem a cada '<iprint>[1]' iterações.
     'iprint[2]'
          '<iprint>[2]' controla a quantidade de informações fornecidas
          pelas mensagens de progresso (verbosidade).
          'iprint[2] = 0'
               Mostra na tela o contador de iterações, o número de
               avaliações de <FOM>, o valor de <FOM>, a norma do
               gradiente de <FOM>, e o comprimento do salto.
          'iprint[2] = 1'
               O mesmo que '<iprint>[2] = 0', adicionando <X0> e o
               gradiente de <FOM> avaliado em <X0>.
          'iprint[2] = 2'
               O mesmo que '<iprint>[2] = 1', adicionando valores de <X>
               a cada iteração.
          'iprint[2] = 3'
               O mesmo que '<iprint>[2] = 2', adicionando o gradiente de
               <FOM> a cada iteração.

     As colunas mostradas por 'lbfgs' são as seguintes.

     'I'
          número de iterações.  Esse número é incrementado a cada busca
          de linha.
     'NFN'
          Número de avaliações do número de mérito.
     'FUNC'
          Valor do nero de mérito ao final da busca de linha mais
          recente.
     'GNORM'
          Norma do gradiente do número de mérito ao final da mais
          recente busca de linha.
     'STEPLENGTH'
          Um parâmetro interno do algorítmo de busca.

     Informação adicional com relação a detalhes do algorítmo podem ser
     encontradas nos comentários do código Fortran original em [2].

     Veja também 'lbfgs_nfeval_max' e 'lbfgs_ncorrections'.

     Referências:

     [1] D. Liu e J. Nocedal.  "On the limited memory BFGS method for
     large scale optimization".  Mathematical Programming B 45:503-528
     (1989)

     [2] http://netlib.org/opt/lbfgs_um.shar

     Exemplo:

     O mesmo FOM como calculada por FGCOMPUTE no programa sdrive.f no
     pacote LBFGS de Netlib.  Note que as variáveis em questão são
     variáveis com subscritos.  O FOM tem um mínimo exato igual a zero
     em u[k] = 1 for k = 1, ..., 8.

          (%i1) load (lbfgs);
          (%o1)   /usr/share/maxima/5.10.0cvs/share/lbfgs/lbfgs.mac
          (%i2) t1[j] := 1 - u[j];
          (%o2)                     t1  := 1 - u
                                      j         j
          (%i3) t2[j] := 10*(u[j + 1] - u[j]^2);
                                                    2
          (%o3)                t2  := 10 (u      - u )
                                 j         j + 1    j
          (%i4) n : 8;
          (%o4)                           8
          (%i5) FOM : sum (t1[2*j - 1]^2 + t2[2*j - 1]^2, j, 1, n/2);
                           2 2           2              2 2           2
          (%o5) 100 (u  - u )  + (1 - u )  + 100 (u  - u )  + (1 - u )
                      8    7           7           6    5           5
                               2 2           2              2 2           2
                  + 100 (u  - u )  + (1 - u )  + 100 (u  - u )  + (1 - u )
                          4    3           3           2    1           1
          (%i6) lbfgs (FOM, '[u[1], u[2], u[3], u[4], u[5], u[6], u[7], u[8]],
                 [-1.2, 1, -1.2, 1, -1.2, 1, -1.2, 1], 1e-3, [1, 0]);
          *************************************************
            N=    8   NUMBER OF CORRECTIONS=25
                 INITIAL VALUES
           F=  9.680000000000000D+01   GNORM=  4.657353755084532D+02
          *************************************************

             I  NFN     FUNC                    GNORM                   STEPLENGTH

             1    3     1.651479526340304D+01   4.324359291335977D+00   7.926153934390631D-04
             2    4     1.650209316638371D+01   3.575788161060007D+00   1.000000000000000D+00
             3    5     1.645461701312851D+01   6.230869903601577D+00   1.000000000000000D+00
             4    6     1.636867301275588D+01   1.177589920974980D+01   1.000000000000000D+00
             5    7     1.612153014409201D+01   2.292797147151288D+01   1.000000000000000D+00
             6    8     1.569118407390628D+01   3.687447158775571D+01   1.000000000000000D+00
             7    9     1.510361958398942D+01   4.501931728123680D+01   1.000000000000000D+00
             8   10     1.391077875774294D+01   4.526061463810632D+01   1.000000000000000D+00
             9   11     1.165625686278198D+01   2.748348965356917D+01   1.000000000000000D+00
            10   12     9.859422687859137D+00   2.111494974231644D+01   1.000000000000000D+00
            11   13     7.815442521732281D+00   6.110762325766556D+00   1.000000000000000D+00
            12   15     7.346380905773160D+00   2.165281166714631D+01   1.285316401779533D-01
            13   16     6.330460634066370D+00   1.401220851762050D+01   1.000000000000000D+00
            14   17     5.238763939851439D+00   1.702473787613255D+01   1.000000000000000D+00
            15   18     3.754016790406701D+00   7.981845727704576D+00   1.000000000000000D+00
            16   20     3.001238402309352D+00   3.925482944716691D+00   2.333129631296807D-01
            17   22     2.794390709718290D+00   8.243329982546473D+00   2.503577283782332D-01
            18   23     2.563783562918759D+00   1.035413426521790D+01   1.000000000000000D+00
            19   24     2.019429976377856D+00   1.065187312346769D+01   1.000000000000000D+00
            20   25     1.428003167670903D+00   2.475962450826961D+00   1.000000000000000D+00
            21   27     1.197874264861340D+00   8.441707983493810D+00   4.303451060808756D-01
            22   28     9.023848941942773D-01   1.113189216635162D+01   1.000000000000000D+00
            23   29     5.508226405863770D-01   2.380830600326308D+00   1.000000000000000D+00
            24   31     3.902893258815567D-01   5.625595816584421D+00   4.834988416524465D-01
            25   32     3.207542206990315D-01   1.149444645416472D+01   1.000000000000000D+00
            26   33     1.874468266362791D-01   3.632482152880997D+00   1.000000000000000D+00
            27   34     9.575763380706598D-02   4.816497446154354D+00   1.000000000000000D+00
            28   35     4.085145107543406D-02   2.087009350166495D+00   1.000000000000000D+00
            29   36     1.931106001379290D-02   3.886818608498966D+00   1.000000000000000D+00
            30   37     6.894000721499670D-03   3.198505796342214D+00   1.000000000000000D+00
            31   38     1.443296033051864D-03   1.590265471025043D+00   1.000000000000000D+00
            32   39     1.571766603154336D-04   3.098257063980634D-01   1.000000000000000D+00
            33   40     1.288011776581970D-05   1.207784183577257D-02   1.000000000000000D+00
            34   41     1.806140173752971D-06   4.587890233385193D-02   1.000000000000000D+00
            35   42     1.769004645459358D-07   1.790537375052208D-02   1.000000000000000D+00
            36   43     3.312164100763217D-10   6.782068426119681D-04   1.000000000000000D+00

           THE MINIMIZATION TERMINATED WITHOUT DETECTING ERRORS.
           IFLAG = 0
          (%o6) [u  = 1.000005339815974, u  = 1.000009942839805,
                  1                       2
          u  = 1.000005339815974, u  = 1.000009942839805,
           3                       4
          u  = 1.000005339815974, u  = 1.000009942839805,
           5                       6
          u  = 1.000005339815974, u  = 1.000009942839805]
           7                       8

 -- Variãvel: lbfgs_nfeval_max
     Valor padrão: 100

     'lbfgs_nfeval_max' é o número máximo de avaliações do número de
     mérito (FOM - "figure of merit" em inglês) em 'lbfgs'.  Quando
     'lbfgs_nfeval_max' for encontrada, 'lbfgs' retorna o resultado da
     última busca de linha realizada co sucesso.

 -- Variãvel: lbfgs_ncorrections
     Valor padrão: 25

     'lbfgs_ncorrections' é o número de correções aplicadas à matriz
     Hessiana inversa aproximada que é mantida por 'lbfgs'.


File: maxima.info,  Node: lindstedt,  Next: linearalgebra,  Prev: lbfgs,  Up: Top

58 lindstedt
************

* Menu:

* Funções e Variáveis Definidas para lindstedt::


File: maxima.info,  Node: Funções e Variáveis Definidas para lindstedt,  Prev: lindstedt,  Up: lindstedt

58.1 Funções e Variáveis Definidas para lindstedt
=================================================

 -- Função: Lindstedt (<eq>,<pvar>,<torder>,<ic>)
     Esse é um primeiro passo para um código de Lindstedt.  Esse código
     pode resolver problemas com condições iniciais fornecidas, às quais
     podem ser constantes arbitrárias, (não apenas <%k1> e <%k2>) onde
     as condições iniciais sobre as equações de perturbação são z[i]=0,
     z'[i]=0 para i>0.  <ic> é a lista de condições iniciais.

     Problemas ocorrem quando condições iniciais não forem dadas, como
     as constantes nas equações de perturbação são as mesmas que a
     solução da equação de ordem zero.  Também, problemas ocorrem quando
     as condições iniciais para as equações de perturbação não são
     z[i]=0, z'[i]=0 para i>0, tais como a equação de Van der Pol.

     Exemplo:
          (%i1) load("makeOrders")$

          (%i2) load("lindstedt")$

          (%i3) Lindstedt('diff(x,t,2)+x-(e*x^3)/6,e,2,[1,0]);
                    2
                   e  (cos(5 T) - 24 cos(3 T) + 23 cos(T))
          (%o3) [[[---------------------------------------
                                    36864
             e (cos(3 T) - cos(T))
           - --------------------- + cos(T)],
                      192
                    2
                 7 e    e
          T = (- ---- - -- + 1) t]]
                 3072   16

     Para usar essa função escreva primeiro 'load("makeOrders")' e
     'load("lindstedt")'.


File: maxima.info,  Node: linearalgebra,  Next: lsquares,  Prev: lindstedt,  Up: Top

59 linearalgebra
****************

* Menu:

* Introdução a linearalgebra::
* Funções e Variáveis Definidas para linearalgebra::


File: maxima.info,  Node: Introdução a linearalgebra,  Next: Funções e Variáveis Definidas para linearalgebra,  Prev: linearalgebra,  Up: linearalgebra

59.1 Introdução a linearalgebra
===============================

'linearalgebra' é uma coleção de funções para álgebra linear.

   Exemplo:

     (%i1) M : matrix ([1, 2], [1, 2]);
                                 [ 1  2 ]
     (%o1)                       [      ]
                                 [ 1  2 ]
     (%i2) nullspace (M);
                                    [  1  ]
                                    [     ]
     (%o2)                     span([   1 ])
                                    [ - - ]
                                    [   2 ]
     (%i3) columnspace (M);
                                     [ 1 ]
     (%o3)                      span([   ])
                                     [ 1 ]
     (%i4) ptriangularize (M - z*ident(2), z);
                              [ 1   2 - z   ]
     (%o4)                    [             ]
                              [           2 ]
                              [ 0  3 z - z  ]
     (%i5) M : matrix ([1, 2, 3], [4, 5, 6], [7, 8, 9]) - z*ident(3);
                          [ 1 - z    2      3   ]
                          [                     ]
     (%o5)                [   4    5 - z    6   ]
                          [                     ]
                          [   7      8    9 - z ]
     (%i6) MM : ptriangularize (M, z);
                   [ 4  5 - z            6            ]
                   [                                  ]
                   [                2                 ]
                   [     66        z    102 z   132   ]
                   [ 0   --      - -- + ----- + ---   ]
     (%o6)         [     49        7     49     49    ]
                   [                                  ]
                   [               3        2         ]
                   [           49 z    245 z    147 z ]
                   [ 0    0    ----- - ------ - ----- ]
                   [            264      88      44   ]
     (%i7) algebraic : true;
     (%o7)                         true
     (%i8) tellrat (MM [3, 3]);
                              3       2
     (%o8)                  [z  - 15 z  - 18 z]
     (%i9) MM : ratsimp (MM);
                    [ 4  5 - z           6           ]
                    [                                ]
                    [                2               ]
     (%o9)         [     66      7 z  - 102 z - 132 ]
                    [ 0   --    - ------------------ ]
                    [     49              49         ]
                    [                                ]
                    [ 0    0             0           ]
     (%i10) nullspace (MM);
                             [        1         ]
                             [                  ]
                             [   2              ]
                             [  z  - 14 z - 16  ]
                             [  --------------  ]
     (%o10)             span([        8         ])
                             [                  ]
                             [    2             ]
                             [   z  - 18 z - 12 ]
                             [ - -------------- ]
                             [         12       ]
     (%i11) M : matrix ([1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12], [13, 14, 15, 16]);
                            [ 1   2   3   4  ]
                            [                ]
                            [ 5   6   7   8  ]
     (%o11)                 [                ]
                            [ 9   10  11  12 ]
                            [                ]
                            [ 13  14  15  16 ]
     (%i12) columnspace (M);
                                [ 1  ]  [ 2  ]
                                [    ]  [    ]
                                [ 5  ]  [ 6  ]
     (%o12)                span([    ], [    ])
                                [ 9  ]  [ 10 ]
                                [    ]  [    ]
                                [ 13 ]  [ 14 ]
     (%i13) apply ('orthogonal_complement, args (nullspace (transpose (M))));
                                [ 0 ]  [  1  ]
                                [   ]  [     ]
                                [ 1 ]  [  0  ]
     (%o13)                span([   ], [     ])
                                [ 2 ]  [ - 1 ]
                                [   ]  [     ]
                                [ 3 ]  [ - 2 ]


File: maxima.info,  Node: Funções e Variáveis Definidas para linearalgebra,  Prev: Introdução a linearalgebra,  Up: linearalgebra

59.2 Funções e Variáveis Definidas para linearalgebra
=====================================================

 -- Função: addmatrices (<f>, <M_1>, ..., <M_n>)

     Usando a função <f> como a função de adição, retorne a adição das
     matrizes <M_1>, ..., <M_n>.  A função <f> deve aceitar qualquer
     número de argumentos (uma função enária do Maxima).

     Exemplos:

          (%i1) m1 : matrix([1,2],[3,4])$
          (%i2) m2 : matrix([7,8],[9,10])$
          (%i3) addmatrices('max,m1,m2);
          (%o3) matrix([7,8],[9,10])
          (%i4) addmatrices('max,m1,m2,5*m1);
          (%o4) matrix([7,10],[15,20])

 -- Função: blockmatrixp (<M>)

     Retorna 'true' se e somente se <M> for uma matriz e toda entrada de
     <M> também for uma matriz.

 -- Função: columnop (<M>, <i>, <j>, <theta>)

     Se <M> for uma matriz, retorna a matriz que resulta de fazer a
     operação de coluna 'C_i <- C_i - <theta> * C_j'.  Se <M> não tiver
     uma linha <i> ou <j>, emite uma mensagem de erro.

 -- Função: columnswap (<M>, <i>, <j>)

     Se <M> for uma matriz, troca as colunas <i> e <j>.  Se <M> não
     tiver uma coluna <i> ou <j>, emite uma mensagem de erro.

 -- Função: columnspace (<M>)

     Se <M> for uma matriz, retorna 'span (v_1, ..., v_n)', onde o
     conjunto '{v_1, ..., v_n}' é uma base para o espaço coluna de <M>.
     A diferença entre o maior elemento e o menor elemento do conjunto
     vazio é '{0}'.  Dessa forma, quando o espaço coluna tiver somente
     um membro, retorna 'span ()'.

 -- Função: copy (<e>)

     Retorna uma cópia da expressão <e> do Maxima.  Embora <e> possa ser
     qualquer expressão do Maxima, A função 'copy' é mais útil quando
     <e> for ou uma lista ou uma matriz; considere:
          (%i1) m : [1,[2,3]]$
          (%i2) mm : m$
          (%i3) mm[2][1] : x$
          (%i4) m;
          (%o4)                      [1,[x,3]]
          (%i5) mm;
          (%o5)                      [1,[x,3]]
     Vamos tentar a mesma experiência, mas dessa vez tomemos <mm> como
     sendo uma cópia de <m>
          (%i6) m : [1,[2,3]]$
          (%i7) mm : copy(m)$
          (%i8) mm[2][1] : x$
          (%i9) m;
          (%o9)                     [1,[2,3]]
          (%i10) mm;
          (%o10)                    [1,[x,3]]
     Dessa vez, a atribuição a <mm> não muda o valor de <m>.

 -- Função: cholesky (<M>)
 -- Função: cholesky (<M>, <campo>)

     Retorna fatorização de Cholesky da matriz hermitiana (or
     autoadjunta) <M>.  O valor padrão para o segundo argumento é
     'generalring'.  Para uma descrição dos possíveis valores para
     <campo>, veja 'lu_factor'.

 -- Função: ctranspose (<M>)

     Retorna a matriz transposta conjugada complexa da matriz <M>.  A
     função 'ctranspose' usa 'matrix_element_transpose' para transpor
     cada elemento da matriz.

 -- Função: diag_matrix (<d_1>, <d_2>,...,<d_n>)

     Retorna uma matriz diagonal matriz com entradas de diagonal <d_1>,
     <d_2>,...,<d_n>.  Quando as entradas de diagonal forem matrizes, as
     entradas zero da matriz retornada serão todas matrizes de tamanho
     apropriado; por exemplo:
          (%i1) diag_matrix(diag_matrix(1,2),diag_matrix(3,4));

                                      [ [ 1  0 ]  [ 0  0 ] ]
                                      [ [      ]  [      ] ]
                                      [ [ 0  2 ]  [ 0  0 ] ]
          (%o1)                       [                    ]
                                      [ [ 0  0 ]  [ 3  0 ] ]
                                      [ [      ]  [      ] ]
                                      [ [ 0  0 ]  [ 0  4 ] ]
          (%i2) diag_matrix(p,q);

                                             [ p  0 ]
          (%o2)                              [      ]
                                             [ 0  q ]

 -- Função: dotproduct (<u>, <v>)

     Retorna o produto do ponto (produto escalar) dos vetores <u> e <v>.
     Isso é o mesmo que 'conjugate (transpose (<u>)) . <v>'.  Os
     argumentos <u> e <v> devem ser vetores coluna.

 -- Função: eigens_by_jacobi (<A>)
 -- Função: eigens_by_jacobi (<A>, <tipo_corpo>)

     Calculam os autovalores e autovetores de <A> pelo método de
     rotações de Jacobi.  <A> deve ser uma matriz simétrica (mas essa
     matriz simétrica precisa não ser nem definida positiva e nem
     semidefinida positiva).  <tipo_corpo> indica o corpo computacional,
     pode ser ou 'floatfield' ou 'bigfloatfield'.  Se <tipo_corpo> não
     for especificado, o padrão é 'floatfield'.

     Os elementos de <A> devem ser números ou expressões que avaliam
     para números via 'float' ou 'bfloat' (dependendo do valor de
     <tipo_corpo>).

     Exemplos:

          (%i1) S : matrix ([1/sqrt(2), 1/sqrt(2)], [- 1/sqrt(2), 1/sqrt(2)]);                     [     1         1    ]
                               [     1         1    ]
                               [  -------   ------- ]
                               [  sqrt(2)   sqrt(2) ]
          (%o1)                [                    ]
                               [      1        1    ]
                               [ - -------  ------- ]
                               [   sqrt(2)  sqrt(2) ]
          (%i2) L : matrix ([sqrt(3), 0], [0, sqrt(5)]);
                                [ sqrt(3)     0    ]
          (%o2)                 [                  ]
                                [    0     sqrt(5) ]
          (%i3) M : S . L . transpose (S);
                      [ sqrt(5)   sqrt(3)  sqrt(5)   sqrt(3) ]
                      [ ------- + -------  ------- - ------- ]
                      [    2         2        2         2    ]
          (%o3)       [                                      ]
                      [ sqrt(5)   sqrt(3)  sqrt(5)   sqrt(3) ]
                      [ ------- - -------  ------- + ------- ]
                      [    2         2        2         2    ]
          (%i4) eigens_by_jacobi (M);
          The largest percent change was 0.1454972243679
          The largest percent change was 0.0
          number of sweeps: 2
          number of rotations: 1
          (%o4) [[1.732050807568877, 2.23606797749979],
                                  [  0.70710678118655   0.70710678118655 ]
                                  [                                      ]]
                                  [ - 0.70710678118655  0.70710678118655 ]
          (%i5) float ([[sqrt(3), sqrt(5)], S]);
          (%o5) [[1.732050807568877, 2.23606797749979],
                                  [  0.70710678118655   0.70710678118655 ]
                                  [                                      ]]
                                  [ - 0.70710678118655  0.70710678118655 ]
          (%i6) eigens_by_jacobi (M, bigfloatfield);
          The largest percent change was 1.454972243679028b-1
          The largest percent change was 0.0b0
          number of sweeps: 2
          number of rotations: 1
          (%o6) [[1.732050807568877b0, 2.23606797749979b0],
                          [  7.071067811865475b-1   7.071067811865475b-1 ]
                          [                                              ]]
                          [ - 7.071067811865475b-1  7.071067811865475b-1 ]

 -- Função: get_lu_factors (<x>)

     Quando '<x> = lu_factor (<A>)', então 'get_lu_factors' retorna uma
     lista da forma '[P, L, U]', onde <P> é uma matriz de permutação,
     <L> é triangular baixa com a diagonal preenchida com a unidade, e
     <U> é triangular alta, e '<A> = <P> <L> <U>'.

 -- Função: hankel (<col>)
 -- Função: hankel (<col>, <lin>)

     Retorna uma matriz de Hankel <H>.  A primeira coluna de <H> é
     <col>; exceto para a primeira entrada, a última linha de <H> é
     <lin>.  O valor padrão para <lin> é o vetor nulo com o mesmo
     comprimento que <col>.

 -- Função: hessian (<f>,<vars>)

     Retorna a matriz hessiana de <f> com relação às variáveis na lista
     <vars>.  As entradas <i>,<j> da matriz hessiana são <diff(f
     vars[i],1,vars[j],1)>.

 -- Função: hilbert_matrix (<n>)

     Retorna the <n> by <n> matriz de Hilbert.  Quando <n> não for um
     inteiro positivo, emite uma mensagem de erro.

 -- Função: identfor (<M>)
 -- Função: identfor (<M>, <corpo>)

     Retorna uma matriz identidade que tem o mesmo tamanho que a matriz
     <M>.  As entradas de diagonal da matriz identidade são a identidade
     multiplicativa do corpo <corpo>; o padrão para <corpo> é
     <generalring>.

     O primeiro argumento <M> pode ser uma matriz quadrada ou um não
     matriz.  Quando <M> for uma matriz, cada entrada de <M> pode ser
     uma matriz quadrada - dessa forma <M> pode ser uma matriz de bloco
     do Maxima.  A matriz pode ser de bloco para qualquer (finita)
     quantidade de níveis.

     Veja também 'zerofor'

 -- Função: invert_by_lu (<M>, <(rng generalring)>)

     Inverte a matriz <M> através de fatorização linear alta (LU). A
     fatorização LU é concluída usando o anel <rng>.

 -- Função: kronecker_product (<A>, <B>)

     Retorna o produto de Kronecker das matrizes <A> e <B>.

 -- Função: listp (<e>, <p>)
 -- Função: listp (<e>)

     Recebendo um argumento opcional <p>, retorna 'true' se <e> for uma
     lista do Maxima e <p> avalia para 'true' para elemento da lista.
     Quando 'listp' não recebe o argumento opcional, retorna 'true' se
     <e> for uma lista do Maxima.  em todos os outros casos, retorna
     'false'.

 -- Função: locate_matrix_entry (<M>, <r_1>, <c_1>, <r_2>, <c_2>, <f>,
          <rel>)

     O primeiro argumento deve ser uma matriz; os argumentos que vão de
     <r_1> até <c_2> determinam um sub-matriz de <M> que consiste de
     linhas que vão de <r_1> até <r_2> e colunas que vão de <c_1> até
     <c_2>.

     Encontra uma entrada na sub-matriz <M> que satisfaz alguma
     propriedade.  Existem três casos:

     (1) '<rel> = 'bool' e <f> um predicado:

     Examina a sub-matriz da esquerda para a direita e de cima para
     baixo, e retorna o índice da primeria entrada que satisfizer o
     predicado <f>.  Se nenhuma entrada da matriz satisfizer o predicado
     <f>, retorna 'false'.

     (2) '<rel> = 'max' e <f> avaliar para um número real:

     Examina a sub-matriz procurando por uma entrada que maximize <f>.
     Retorna retorna o índice da entrada maximizada.

     (3) '<rel> = 'min' e <f> avaliar para um número real:

     Examina a sub-matriz procurando por uma entrada que minimize <f>.
     Retorna o índice de uma entrada minimizada.

 -- Função: lu_backsub (<M>, <b>)

     Quando '<M> = lu_factor (<A>, <corpo>)', então 'lu_backsub (<M>,
     <b>)' resolve o sistema linear '<A> <x> = <b>'.

 -- Função: lu_factor (<M>, <corpo>)

     Retorna uma lista da forma '[<LU>, <perm>, <corpo>]', ou da forma
     '[<LU>, <perm>, <cmp>, <baixo-cnd> <alto-cnd>]', onde

     (1) A matriz <LU> contéa fatorização de <M> na forma enpacotada.
     Forma empacotada significa três coisas: Primeiro, as linhas de <LU>
     são permutadas confirme a lista <perm>.  Se, por exemplo, <perm>
     for a lista list '[3,2,1]', a primeira linha atual da fatorização
     <LU> será a terceira linha da matriz <LU>.  Segundo, o fator
     triangular baixo de m é a parte triangular baixa de <LU> com as
     entradas de diagonal todas substituídas pela unidade.  Terceiro, o
     fator triangular alto de <M> é a parte triangular alta de <LU>.

     (2) Quando o corpo for ou 'floatfield' ou 'complexfield', os
     números <baixo-cnd> e <alto-cnd> serão associados baixo e alto para
     o número condicional de norma infinita de <M>.  Para todos os
     corpos (fields), o número condicional de norma infinita não pode
     ser estimado; para tais corpos, 'lu_factor' retorna uma lista com
     dois itens.  Ambos o baixo e o alto associado podem diferir de seus
     verdadeiros valores de fatores arbitráriamente grandes.  (Veja
     também 'mat_cond'.)

     O argumento <M> deve ser a matriz quadrada.

     O argumento opcional <cmp> deve ser um símbolo que determine um
     anel ou corpo.  Os corpos e anéis predefinidos são:

     (a) 'generalring' - o anel de expressões do Maxima, (b)
     'floatfield' - o corpo dos números em ponto flutuante do tipo de
     precisão dupla, (c) 'complexfield' - o corpo dos números complexos
     em ponto flutuante do tipo de precisão dupla, (d) 'crering' - o
     anel das expressões racionais canônicas (CRE) do Maxima, (e)
     'rationalfield' - o corpo dos números racionais, (f) 'runningerror'
     - rastro de todos os erros de arredondamento de números em ponto
     flutuante, (g) 'noncommutingring' - o anel de expressões do Maxima
     onde multiplicação for o operador ponto não comutativo.

     Quando o corpo for 'floatfield', 'complexfield', ou 'runningerror',
     o algorítmo usa pivotagem parcial; para todos os outros corpos,
     linhas são comutadas somente quando necessário para evitar um pivô
     nulo.

     A adição aritmética em ponto flutuante não é associativa, então o
     significado de 'corpo' difere da definição matemática.

     Um membro do corpo 'runningerror' é uma lista do Máxima de dois
     membros da forma '[x,n]',onde <x> é um número em onto flutuante e
     'n' é um inteiro.  A diferença relativa entre o valor de
     'verdadeiro' de 'x' e 'x' é aproximadamente associado pelo épsilon
     da máquina vezes 'n'.  O erro de execução associado arrasta alguns
     termos da ordem do quadrado do épsilon da máquina.

     Não existe interface de usuário definida um novo anel.  Um usuário
     que estiver familiazrizado com o Lisp Comum está apto para definir
     um novo corpo.  Para fazer isso, um usuário deve definir funções
     para as operações aritméticas e funções para conversão para a
     representação de corpo do Máxima e vice-versa.  Adicionalmente,
     para corpos ordenados (onde a pivotagem parcial será usada), um
     uduário deve definir funções para módulo e para comparar membros do
     corpo.  Após isso tudo que resta é definir uma estrutura de Lisp
     Comum 'mring'.  O arquivo 'mring' tem muitos exemplos.

     Para calcular a fatorização, a primeira tarefa é converter cada
     entrada de matriz para um elemento do corpo indicado.  Quando a
     cnversão não for possível, a fatorização encerra com uma mensagem
     de erro.  Elementos do corpo não precisam ser expressões do Maxima.
     Elementos do 'complexfield', por exemplo, são números complexos do
     Lisp Comum.  Dessa forma após calcular a fatorização, como entradas
     da matriz devem ser convertidas para expressões do Maxima.

     Veja também 'get_lu_factors'.

     Exemplos:
          (%i1) w[i,j] := random (1.0) + %i * random (1.0);
          (%o1)          w     := random(1.) + %i random(1.)
                          i, j
          (%i2) showtime : true$
          Evaluation took 0.00 seconds (0.00 elapsed)
          (%i3) M : genmatrix (w, 100, 100)$
          Evaluation took 7.40 seconds (8.23 elapsed)
          (%i4) lu_factor (M, complexfield)$
          Evaluation took 28.71 seconds (35.00 elapsed)
          (%i5) lu_factor (M, generalring)$
          Evaluation took 109.24 seconds (152.10 elapsed)
          (%i6) showtime : false$

          (%i7) M : matrix ([1 - z, 3], [3, 8 - z]);
                                  [ 1 - z    3   ]
          (%o7)                   [              ]
                                  [   3    8 - z ]
          (%i8) lu_factor (M, generalring);
                    [ 1 - z         3        ]
                    [                        ]
          (%o8)    [[   3            9       ], [1, 2], generalring]
                    [ -----  - z - ----- + 8 ]
                    [ 1 - z        1 - z     ]
          (%i9) get_lu_factors (%);
                            [   1    0 ]  [ 1 - z         3        ]
                  [ 1  0 ]  [          ]  [                        ]
          (%o9) [[      ], [   3      ], [                9       ]]
                  [ 0  1 ]  [ -----  1 ]  [   0    - z - ----- + 8 ]
                            [ 1 - z    ]  [              1 - z     ]
          (%i10) %[1] . %[2] . %[3];
                                  [ 1 - z    3   ]
          (%o10)                  [              ]
                                  [   3    8 - z ]

 -- Função: mat_cond (<M>, 1)
 -- Função: mat_cond (<M>, inf)

     Retorna o número condiciona da norma de ordem <p> da matriz <m>.
     Os valores permitidos para <p> são 1 e <inf>.  Essa função utiliza
     a fatorização linear alta para inverter a matriz <m>.  Dessa forma
     o tempode execução para 'mat_cond' é proporcional ao cubo do
     tamanho da matriz; 'lu_factor' determina as associaçãoes baixa e
     alta para o número de condição de norma infinita em tempo
     proporcional ao quadrado do tamanho da matriz.

 -- Função: mat_norm (<M>, 1)
 -- Função: mat_norm (<M>, inf)
 -- Função: mat_norm (<M>, frobenius)

     Retorna a matriz de norma <p> da matriz <M>.  Os valores permitidos
     para <p> são 1, 'inf', e 'frobenius' (a norma da matriz de
     Frobenius).  A matriz <M> pode ser uma matriz não de bloco.

 -- Função: matrixp (<e>, <p>)
 -- Função: matrixp (<e>)

     Fornecendo um argumento opcional <p>, 'matrixp' retorna 'true' se
     <e> for uma matriz e <p> avaliar para 'true' para todo elemento da
     matriz.  Quando a 'matrixp' não for fornecido umargumento opcional,
     retorna 'true' se 'e' for uma matriz.  em todos os outros casos,
     retorna 'false'.

     Veja também 'blockmatrixp'

 -- Função: matrix_size (<M>)

     Retorna uma lista com dois elementos que fornecem o número de
     linhas e colunas, respectivamente da matriz <M>.

 -- Função: mat_fullunblocker (<M>)

     Se <M> for uma matriz de bloco, expande todos os blocos da matriz
     em todos os níveis.  Se <M> for uma matriz, retorna <M>; de outra
     forma, emite uma mensagem de erro.

 -- Função: mat_trace (<M>)

     Retorna o traço da matriz <M>.  Se <M> não for uma matriz, retorna
     uma forma substantiva.  Quando <M> for uma matriz de bloco,
     'mat_trace(M)' retorna o mesmo valor retornado por
     'mat_trace(mat_unblocker(m))'.

 -- Função: mat_unblocker (<M>)

     Se <M> for uma matriz de bloco, 'mat_unbloker' desfaz o bloco de
     <M> um nível.  Se <M> for uma matriz, 'mat_unblocker (M)' retorna
     <M>; de outra forma, emite uma mensagem de erro.

     Dessa forma se cada entrada de <M> for matriz, 'mat_unblocker (M)'
     retorna uma matriz "desblocada", mas se cada entrada de <M> for uma
     matriz de bloco, 'mat_unblocker (M)' retorna uma matriz de bloco
     com um nível de bloco a menos.

     Se você usa matrizes de bloco, muito provavelmente você irá querer
     escolher 'matrix_element_mult' para '"."' e
     'matrix_element_transpose' para ''transpose'.  Veja também
     'mat_fullunblocker'.

     Exemplo:

          (%i1) A : matrix ([1, 2], [3, 4]);
                                      [ 1  2 ]
          (%o1)                       [      ]
                                      [ 3  4 ]
          (%i2) B : matrix ([7, 8], [9, 10]);
                                      [ 7  8  ]
          (%o2)                       [       ]
                                      [ 9  10 ]
          (%i3) matrix ([A, B]);
                               [ [ 1  2 ]  [ 7  8  ] ]
          (%o3)                [ [      ]  [       ] ]
                               [ [ 3  4 ]  [ 9  10 ] ]
          (%i4) mat_unblocker (%);
                                   [ 1  2  7  8  ]
          (%o4)                    [             ]
                                   [ 3  4  9  10 ]

 -- Função: nonnegintegerp (<n>)

     Retorna 'true' se e somente se '<n> >= 0' e <n> for um inteiro.

 -- Função: nullspace (<M>)

     Se <M> for uma matriz, retorna 'span (v_1, ..., v_n)', onde o
     conjunto '{v_1, ..., v_n}' é uma base para o espaço nulo de <M>.  A
     diferença entre o maior elemento e o menor elemento do conjunto
     vazio é '{0}'.  Dessa forma, quando o espaço nulo tiver somente um
     membro, retorna 'span ()'.

 -- Função: nullity (<M>)

     Se <M> for uma matriz, retorna a dimensão do espaço nulo de <M>.

 -- Função: orthogonal_complement (<v_1>, ..., <v_n>)

     Retorna 'span (u_1, ..., u_m)', onde o conjunto '{u_1, ..., u_m}' é
     uma base para o complemento ortogonal do conjunto '(v_1, ...,
     v_n)'.

     Cada vetor no intervalo de <v_1> até <v_n> deve ser um vetor
     coluna.

 -- Função: polynomialp (<p>, <L>, <coeffp>, <exponp>)
 -- Função: polynomialp (<p>, <L>, <coeffp>)
 -- Função: polynomialp (<p>, <L>)

     Retorna 'true' se <p> for um polinômio nas variáveis da lista <L>,
     O predicado <coeffp> deve avaliar para 'true' para cada
     coeficiente, e o predicado <exponp> deve avaliar para 'true' para
     todos os expoentes das variáveis na lista <L>.  Se você quiser usar
     um valor personalizado para <exponp>, você deve fornecer <coeffp>
     com um valor mesmo se você quiser o valor padrão para <coeffp>.

     'polynomialp (<p>, <L>, <coeffp>)' é equivalente a 'polynomialp
     (<p>, <L>, <coeffp>, 'nonnegintegerp)'.

     'polynomialp (<p>, <L>)' é equivalente a 'polynomialp (<p>, L<,>
     'constantp, 'nonnegintegerp)'.

     O polinômio não precisa ser expandido:

          (%i1) polynomialp ((x + 1)*(x + 2), [x]);
          (%o1)                         true
          (%i2) polynomialp ((x + 1)*(x + 2)^a, [x]);
          (%o2)                         false

     Um exemplo usando um valor personalizado para 'coeffp' e para
     'exponp':

          (%i1) polynomialp ((x + 1)*(x + 2)^(3/2), [x], numberp, numberp);
          (%o1)                         true
          (%i2) polynomialp ((x^(1/2) + 1)*(x + 2)^(3/2), [x], numberp, numberp);
          (%o2)                         true

     Polinômios com duas variáveis:

          (%i1) polynomialp (x^2 + 5*x*y + y^2, [x]);
          (%o1)                         false
          (%i2) polynomialp (x^2 + 5*x*y + y^2, [x, y]);
          (%o2)                         true

 -- Função: polytocompanion (<p>, <x>)

     Se <p> for um polinômio em <x>, retorna a atriz companheira de <p>.
     Para um polinômio mônico <p> de grau <n>, temos '<p> = (-1)^<n>
     charpoly (polytocompanion (<p>, <x>))'.

     Quando <p> não for um polinômio em <x>, emite uma mensagem de erro.

 -- Função: ptriangularize (<M>, <v>)

     Se <M> for uma matriz onde cada entrada dessa matriz for um
     polinômio em <v>, retorna a matriz <M2> tal que

     (1) <M2> é triangular alta,

     (2) '<M2> = <E_n> ... <E_1> <M>', onde os elemetnos de <E_1> a
     <E_n> são matrizes elementares cujas entrada são polinômios em <v>,

     (3) '|det (<M>)| = |det (<M2>)|',

     Nota: Essa função não verifica se toda entrada é um polinômio em
     <v>.

 -- Função: rowop (<M>, <i>, <j>, <theta>)

     Se <M> for uma matriz, retorna a matriz que resulta de se fazer a
     operação de linha 'R_i <- R_i - theta * R_j'.  Se <M> não tiver uma
     linha <i> ou <j>, emite uma mensagem de erro.

 -- Função: rank (<M>)

     Retorna o ranque daquela matriz <M>.  O rank é a dimensão do espaço
     coluna.  Exemplo:
          (%i1) rank(matrix([1,2],[2,4]));
          (%o1)                                  1
          (%i2) rank(matrix([1,b],[c,d]));
           Proviso:  {d - b c # 0}
          (%o2)                                  2

 -- Função: rowswap (<M>, <i>, <j>)

     Se <M> for uma matriz, permuta as linha <i> e <j>.  Se <M> não
     tiver uma linha <i> ou <j>, emite uma mensagem de erro.

 -- Função: toeplitz (<col>)
 -- Função: toeplitz (<col>, <lin>)

     Retorna uma matriz de Toeplitz <T>.  a primeira coluna de <T> é
     <col>; exceto para a primeira entrada, a primeira linha de <T> é
     <lin>.  O padrão para <lin> é o conjugado complexo de <col>.
     Exemplo:
          (%i1)  toeplitz([1,2,3],[x,y,z]);

                                            [ 1  y  z ]
                                            [         ]
          (%o1)                             [ 2  1  y ]
                                            [         ]
                                            [ 3  2  1 ]
          (%i2)  toeplitz([1,1+%i]);

                                        [   1     1 - %I ]
          (%o2)                         [                ]
                                        [ %I + 1    1    ]

 -- Função: vandermonde_matrix ([<x_1>, ..., <x_n>])

     Retorna uma matriz <n> por <n> cuja <i>-ésima linha é '[1, <x_i>,
     <x_i>^2, ... <x_i>^(<n>-1)]'.

 -- Função: zerofor (<M>)
 -- Função: zerofor (<M>, <fld>)

     Retorna uma matriz zero que tem o mesmo tamanho da matriz <M>.
     Toda entrada da matriz zero é a identidade aditiva do anel <fld>; o
     valor padrão para <fld> é <generalring>.

     O primeiro argumento <M> pode ser uma matriz quadrada ou uma não
     matriz.  Quando <M> for uma matriz, cada entrada de <M> pode ser
     uma matriz quadrada - dessa forma <M> pode ser uma matriz de bloco
     do Maxima.  A matriz pode ser de bloco para qualquer nível
     (finito).

     Veja também 'identfor'

 -- Função: zeromatrixp (<M>)

     Se <M> não for uma matriz de bloco, retorna 'true' se 'is (equal
     (<e>, 0))' for verdadeiro para cada elemento <e> da matriz <M>.  Se
     <M> for uma matriz de bloco, retorna 'true' se 'zeromatrixp'
     avaliar para 'true' para cada elemento de <e>.


File: maxima.info,  Node: lsquares,  Next: makeOrders,  Prev: linearalgebra,  Up: Top

60 lsquares
***********

* Menu:

* Funções e Variáveis Definidas para lsquares::


File: maxima.info,  Node: Funções e Variáveis Definidas para lsquares,  Prev: lsquares,  Up: lsquares

60.1 Funções e Variáveis Definidas para lsquares
================================================

 -- Variável global: DETCOEF

     Essa variável é usada pelas funções 'lsquares' e 'plsquares' para
     armazenar o Coeficiente de Determinação que mede o melhor do
     ajuste.  Esse intervalo de 0 (nenhuma correlação) a 1 (correlação
     exata).

     Quando 'plsquares' for chamada com uma lista de variáveis
     independentes, <DETCOEF> é escolhida para uma lista de Coeficientes
     de Determinação.  Veja 'plsquares' para detalhes.

     Veja também 'lsquares'.

 -- Função: lsquares (<Mat>,<VarList>,<equação>,<ParamList>)
 -- Função: lsquares
          (<Mat>,<VarList>,<equação>,<ParamList>,<EsperadosList>)
     Ajuste múltiplo de equações não lineares de uma tabela de dados
     pelo método dos "mínimos quadrados".  <Mat> é uma matriz contendo
     os dados, <VarList> é uma lista de nomes de variáveis (um para cada
     coluna de <Mat>), <equação> é a equação a ser ajustada (essa
     equação deve estar na forma: 'depvar=f(indepvari,..., paramj,...)',
     'g(depvar)=f(indepvari,..., paramj,...)' ou na forma 'g(depvar,
     paramk,...)=f(indepvari,..., paramj,...)'), <ParamList> é a lista
     de parâmetros para obter, e <EsperadosList> é uma lista opcional de
     aproximações iniciais para os parâmetros; quando esse último
     argumento estiver presente, 'mnewton' é usado em lugar de 'solve'
     com o objetivo de pegar os parâmetros.

     A equação pode ser completamente não linear com relação às
     variáveis independentes e à variável dependente.  Com o objetivo de
     usar 'solve()', as equações devem ser lineares ou polinomiais com
     relação aos parâmetros.  Equações como 'y=a*b^x+c' podem ser
     ajustadas para '[a,b,c]' com 'solve' se os valores de 'x' forem
     inteiros positivos pequenos e existam poucos dados (veja o exemplo
     em lsquares.dem).  'mnewton' permite ajustar uma equação não linear
     com relação aos parâmetros, mas um bom conjunto de aproximações
     iniciais deve ser fornecido.

     Se possível, a equação ajustada é retornada.  Se existir mais de
     uma solução, uma lista de equações é retornada.  O Coeficiente de
     Determinação é mostrado para informar sobre o melhor do ajuste, de
     0 (nenhuma correlação) a 1 (correlação exata).  Esse valor é também
     armazenada na vriável global <DETCOEF>.

     Exemplos usando 'solve':
          (%i1) load("lsquares")$

          (%i2) lsquares(matrix([1,2,0],[3,5,4],[4,7,9],[5,8,10]),
                         [x,y,z], z=a*x*y+b*x+c*y+d, [a,b,c,d]);
                Determination Coefficient = 1.0
                              x y + 23 y - 29 x - 19
          (%o2)           z = ----------------------
                                        6
          (%i3) lsquares(matrix([0,0],[1,0],[2,0],[3,8],[4,44]),
                         [n,p], p=a4*n^4+a3*n^3+a2*n^2+a1*n+a0,
                   [a0,a1,a2,a3,a4]);
                Determination Coefficient = 1.0
                               4       3      2
                            3 n  - 10 n  + 9 n  - 2 n
          (%o3)         p = -------------------------
                                        6
          (%i4) lsquares(matrix([1,7],[2,13],[3,25]),
                         [x,y], (y+c)^2=a*x+b, [a,b,c]);
                Determination Coefficient = 1.0
          (%o4) [y = 28 - sqrt(657 - 216 x),
                                          y = sqrt(657 - 216 x) + 28]
          (%i5) lsquares(matrix([1,7],[2,13],[3,25],[4,49]),
                         [x,y], y=a*b^x+c, [a,b,c]);
                Determination Coefficient = 1.0
                                        x
          (%o5)                  y = 3 2  + 1

     Exemplos usando 'mnewton':
          (%i6) load("lsquares")$

          (%i7) lsquares(matrix([1.1,7.1],[2.1,13.1],[3.1,25.1],[4.1,49.1]),
                         [x,y], y=a*b^x+c, [a,b,c], [5,5,5]);
                                                       x
          (%o7) y = 2.799098974610482 1.999999999999991
                                                  + 1.099999999999874
          (%i8) lsquares(matrix([1.1,4.1],[4.1,7.1],[9.1,10.1],[16.1,13.1]),
                         [x,y], y=a*x^b+c, [a,b,c], [4,1,2]);
                                       .4878659755898127
          (%o8) y = 3.177315891123101 x
                                                  + .7723843491402264
          (%i9) lsquares(matrix([0,2,4],[3,3,5],[8,6,6]),
                        [m,n,y], y=(A*m+B*n)^(1/3)+C, [A,B,C], [3,3,3]);
                                                               1/3
          (%o9) y = (3.999999999999862 n + 4.999999999999359 m)
                                                   + 2.00000000000012

     Para usar essa função escreva primeiro 'load("lsquares")'.  Veja
     também 'DETCOEF' e 'mnewton'.

 -- Função: plsquares (<Mat>,<VarList>,<depvars>)
 -- Função: plsquares (<Mat>,<VarList>,<depvars>,<maxexpon>)
 -- Função: plsquares (<Mat>,<VarList>,<depvars>,<maxexpon>,<maxdegree>)
     Ajuste de polinômios de várias variáveis de uma tabela de dados
     pelo método dos "mínimos quadrados".  <Mat> é uma matriz contendo
     os dados, <VarList> é uma lista de nomes de variáveis (um nome para
     cada coluna de Mat, mas use "-" em lugar de nomes de variáveis para
     colunas de Mat), <depvars> é o nome de uma variável dependente ou
     uma lista com um ou mais nomes de variáveis dependentes (os quais
     nomes podem estar em <VarList>), <maxexpon> é o expoente máximo
     opcional para cada variável independente (1 por padrão), e
     <maxdegree> é o argumento opcional grau máximo do polinômio
     (<maxexpon> por padrão); note que a soma dos expoentes de cada
     termo deve ser menor ou igual a <maxdegree>, e se 'maxdgree = 0'
     então nenhum limite é aplicado.

     Se <depvars> é o nome de uma variável dependente (fora de uma
     lista), 'plsquares' retorna o polinômio ajustado.  Se <depvars> for
     uma lista de uma ou mais variáveis dependentes, 'plsquares' retorna
     uma lista com o(s) polinômio(s) ajustado(s).  Os Coeficientes de
     Determinação são mostrados com o objetivo de informar sobre o
     melhor do ajuste, cujo intervalo vai de 0 (nenhuma correlação) a 1
     (correlação exata).  Esses valores são também são também
     armazenados na variável global <DETCOEF> (uma lista se <depvars>
     for também uma lista).

     Um simples exemplo de ajuste linear de várias variáveis:
          (%i1) load("plsquares")$

          (%i2) plsquares(matrix([1,2,0],[3,5,4],[4,7,9],[5,8,10]),
                          [x,y,z],z);
               Determination Coefficient for z = .9897039897039897
                                 11 y - 9 x - 14
          (%o2)              z = ---------------
                                        3

     O mesmo exemplo sem restrições de gra:
          (%i3) plsquares(matrix([1,2,0],[3,5,4],[4,7,9],[5,8,10]),
                          [x,y,z],z,1,0);
               Determination Coefficient for z = 1.0
                              x y + 23 y - 29 x - 19
          (%o3)           z = ----------------------
                                        6

     Quantas diagonais possi um polígono de N lados tem?  What
     polynomial degree should be used?
          (%i4) plsquares(matrix([3,0],[4,2],[5,5],[6,9],[7,14],[8,20]),
                          [N,diagonais],diagonais,5);
               Determination Coefficient for diagonais = 1.0
                                          2
                                         N  - 3 N
          (%o4)              diagonais = --------
                                            2
          (%i5) ev(%, N=9);   /* Testando para um polígono de 9 lados - o eneágono */
          (%o5)                 diagonals = 27

     Quantos caminhos fazemos para colocar duas raínhas sem que elas
     estejam ameaçadas em um tabuleiro de xadrez n x n ?
          (%i6) plsquares(matrix([0,0],[1,0],[2,0],[3,8],[4,44]),
                          [n,posicoes],[posicoes],4);
               Determination Coefficient for [posicoes] = [1.0]
                                   4       3      2
                                3 n  - 10 n  + 9 n  - 2 n
          (%o6)    [posicoes  = -------------------------]
                                            6
          (%i7) ev(%[1], n=8); /* Tesando para um tabuleiro de (8 x 8) */
          (%o7)                posicoes = 1288

     Em exemplo com seis variáveis dependentes:
          (%i8) mtrx:matrix([0,0,0,0,0,1,1,1],[0,1,0,1,1,1,0,0],
                            [1,0,0,1,1,1,0,0],[1,1,1,1,0,0,0,1])$
          (%i8) plsquares(mtrx,[a,b,_And,_Or,_Xor,_Nand,_Nor,_Nxor],
                               [_And,_Or,_Xor,_Nand,_Nor,_Nxor],1,0);
                Determination Coefficient for
          [_And, _Or, _Xor, _Nand, _Nor, _Nxor] =
          [1.0, 1.0, 1.0, 1.0, 1.0, 1.0]
          (%o2) [_And = a b, _Or = - a b + b + a,
          _Xor = - 2 a b + b + a, _Nand = 1 - a b,
          _Nor = a b - b - a + 1, _Nxor = 2 a b - b - a + 1]

     Para usar essa função escreva primeiramente 'load("lsquares")'.


File: maxima.info,  Node: makeOrders,  Next: mnewton,  Prev: lsquares,  Up: Top

61 makeOrders
*************

* Menu:

* Funções e Variáveis Definidas para makeOrders::


File: maxima.info,  Node: Funções e Variáveis Definidas para makeOrders,  Prev: makeOrders,  Up: makeOrders

61.1 Funções e Variáveis Definidas para makeOrders
==================================================

 -- Função: makeOrders (<indvarlist>,<orderlist>)
     Retorna uma lista de todos os expoentes para um polinômio acima de
     e incluindo os argumentos.

          (%i1) load("makeOrders")$

          (%i2) makeOrders([a,b],[2,3]);
          (%o2) [[0, 0], [0, 1], [0, 2], [0, 3], [1, 0], [1, 1],
                      [1, 2], [1, 3], [2, 0], [2, 1], [2, 2], [2, 3]]
          (%i3) expand((1+a+a^2)*(1+b+b^2+b^3));
                 2  3      3    3    2  2      2    2    2
          (%o3) a  b  + a b  + b  + a  b  + a b  + b  + a  b + a b
                                                            2
                                                     + b + a  + a + 1
     onde '[0, 1]' está associado ao termo b e '[2, 3]' está associado
     ao termo a^2 b^3.

     Para usar essa função escreva primeiro 'load("makeOrders")'.


File: maxima.info,  Node: mnewton,  Next: numericalio,  Prev: makeOrders,  Up: Top

62 mnewton
**********

* Menu:

* Funções e Variáveis Definidas para mnewton::


File: maxima.info,  Node: Funções e Variáveis Definidas para mnewton,  Prev: mnewton,  Up: mnewton

62.1 Funções e Variáveis Definidas para mnewton
===============================================

 -- Variável de opção: newtonepsilon
     Valor padrão: '10.0^(-fpprec/2)'

     Precisão para determinar quando a função 'mnewton' convergiu em
     direção à solução.

     Veja também 'mnewton'.

 -- Variável de opção: newtonmaxiter
     Valor padrão: '50'

     Número máximo de iterações que para a função 'mnewton' caso essa
     função não seja convergente ou se convergir muito lentamente.

     Veja também 'mnewton'.

 -- Função: mnewton (<FuncList>,<VarList>,<GuessList>)
     Solução de multiplas funções não lineares usando o método de
     Newton.  <FuncList> é a lista de funções a serem resolvidas,
     <VarList> é a lista dos nomes de variáveis, e <GuessList> é a lista
     de aproximações iniciais.

     A solução é retornada no mesmo formato retornado pela função
     'solve()'.  Caso a solução não seja encontrada, '[]' é retornado.

     Essa função é controlada através das variáveis globais
     'newtonepsilon' e 'newtonmaxiter'.

          (%i1) load("mnewton")$

          (%i2) mnewton([x1+3*log(x1)-x2^2, 2*x1^2-x1*x2-5*x1+1],
                        [x1, x2], [5, 5]);
          (%o2) [[x1 = 3.756834008012769, x2 = 2.779849592817897]]
          (%i3) mnewton([2*a^a-5],[a],[1]);
          (%o3)             [[a = 1.70927556786144]]
          (%i4) mnewton([2*3^u-v/u-5, u+2^v-4], [u, v], [2, 2]);
          (%o4) [[u = 1.066618389595407, v = 1.552564766841786]]

     Para usar essa função primeiro escreva 'load("mnewton")'.  Veja
     também 'newtonepsilon' e 'newtonmaxiter'.


File: maxima.info,  Node: numericalio,  Next: opsubst,  Prev: mnewton,  Up: Top

63 numericalio
**************

* Menu:

* Introdução a numericalio::
* Funções e Variáveis Definidas para numericalio::


File: maxima.info,  Node: Introdução a numericalio,  Next: Funções e Variáveis Definidas para numericalio,  Prev: numericalio,  Up: numericalio

63.1 Introdução a numericalio
=============================

'numericalio' é uma coleção de funções para ler e escrever arquivos de
dados.  O arquivo é lido completamente para construir um objeto;
leituras parciais não são suportadas.

   É assumido que cada item a ler ou escrever é atômico: um número
inteiro, número em ponto flutuante, grande número em ponto flutuante,
seqüência de caracteres, ou símbolo, e não um número racional ou um
número complexo ou qualquer outro tipo de expressão não atômica.  Essas
funções podem tentar fazer alguma coisa levemente parecida com
expressões não atômicas, mas os resultados não são especificados aqui e
são sujeitos a mudanças.

   Átomos em ambos os arquivos de entrada e saída possuem o mesmo
formato que em arquivos de lote do Maxima ou no console interativo.  Em
particular, seqüência de caracteres são contidas dentro de aspas duplas,
contrabarra '\' evita qualquer interpretação especial do caractere
seguinte, e o ponto de interrogação '?' é reconhecido no início de um
símbolo para significar um símbolo do Lisp (em oposição a um símbolo do
Maxima).  Nenhum caractere de continuação (para continuar linhas
quebradas) é reconhecido.

   <separator_flag> diz que caracteres separa elementos.
<separator_flag> é um argumento opcional para todas as funções de
leitura e escrita.

   Para entrada, os valores de <separator_flag> reconhecidos são:
'comma' para valores separados por vírgula, 'pipe' para valores
separados pelo caractere barra vertical '|', 'semicolon' para valores
separados por ponto e vírgula ';', e 'space' para valores separados
pelos caracteres de espaço e de tabulação.  Se o nome do arquivo a ser
lido/escrito termina em '.csv' e <separator_flag> não for especificado,
'comma' é assumido.  Se o nome do arquivo termina em alguma outra coisa
que não '.csv' e 'separator_flag' não for especificado, 'space' é
assumido.

   Para saída, os mesmos quatro sinalizadores são reconhecidos como na
entrada, e também 'tab', para valores separados pelo caractere de
tabulaçao.

   Em entrada, múltiplos espaços e multiplas tabulações sucessivas
contam como um separador simples.  Todavia, múltiplas vírgulas, barras
verticais, ou ponto-e-vírgulas são significativos.  Sucessivas vírgulas,
barras verticais, ou ponto-e-vírgulas (com ou sem intercalação de
espaços ou tabulações) são considerados como tendo 'false' entre os
separadores.  Por exemplo, '1234,,Foo' é tratado da mesma forma que
'1234,false,Foo'.  Em saídas, os átomos 'false' são escritos como tais;
uma lista '[1234, false, Foo]' é escrita '1234,false,Foo', e não é
tentado colapsar a saída para '1234,,Foo'.


File: maxima.info,  Node: Funções e Variáveis Definidas para numericalio,  Prev: Introdução a numericalio,  Up: numericalio

63.2 Funções e Variáveis Definidas para numericalio
===================================================

 -- Função: read_matrix (<nomearquivo>)
 -- Função: read_matrix (<nomearquivo>, <separator_flag>)
     Lê o arquivo <nomearquivo> e retorna seu conteúdo completo como uma
     matriz.  Se <separator_flag> não for especificado, o arquivo é
     assumido como delimitado por espaços em branco.

     'read_matrix' infere o tamanho da matriz dos dados de entrada.
     Cada linha do arquivo inicia uma linha da matriz.  Se algumas
     linhas possuirem diferentes comprimentos, 'read_matrix' reclama.

 -- Função: read_lisp_array (<nomearquivo>, <A>)
 -- Função: read_lisp_array (<nomearquivo>, <A>, <separator_flag>)

     'read_lisp_array' exige que o array seja declarado através de
     'make_array' antes de chamar a função de leitura.  (Isso obviamente
     é necessário para inferir a dimensão do array, que pode ser um
     problema para arrays com múltiplas dimensões.)

     'read_lisp_array' não verifica para ver se o arquivo de entrada
     está de acordo com as dimensãoes do array; a entrada é lida como
     uma lista monótona, então o array é preenchido usando 'fillarray'.

 -- Função: read_maxima_array (<nomearquivo>, <A>)
 -- Função: read_maxima_array (<nomearquivo>, <A>, <separator_flag>)

     'read_maxima_array' requer que o array seja declarado através de
     'array' antes de chamar a função de leitura.  (Isso obviamente é
     necessário para inferir a dimensão do array, que pode ser uma
     hassle para arrays com múltiplas dimensões.)

     'read_maxima_array' não verifica para ver se o arquivo de entrada
     está de acordo com as dimensãoes do array; a entrada é lida como
     uma lista monótona, então o array é preenchido usando 'fillarray'.

 -- Função: read_hashed_array (<nomearquivo>, <A>)
 -- Função: read_hashed_array (<nomearquivo>, <A>, <separator_flag>)

     'read_hashed_array' trata o primeiro item sobre uma linha como uma
     chave hash, e associa o restante da linha (como uma lista) com a
     chava.  Por exemplo, a linha '567 12 17 32 55' é equivalente a
     'A[567]: [12, 17, 32, 55]$'.  Linhas não precisam ter o mesmo
     número de elementos.

 -- Função: read_nested_list (<nomearquivo>)
 -- Função: read_nested_list (<nomearquivo>, <separator_flag>)

     'read_nested_list' retorna uma lista que tem uma sublista para cada
     linha de entrada.  Linhas não precisam ter o mesmo número de
     elementos.  Linhas vazias não são ignoradas: uma linha vazia
     retorna uma sublista vazia.

 -- Função: read_list (<nomearquivo>)
 -- Função: read_list (<nomearquivo>, <separator_flag>)

     'read_list' lê todas as entradas em uma lista monótona.
     'read_list' ignora o caractere de fim de linha.

 -- Função: write_data (<X>, <nomearquivo>)
 -- Função: write_data (<object>, <nomearquivo>, <separator_flag>)

     'write_data' escreve o objeto <X> no arquivo <nomearquivo>.

     'write_data' escreve matrizes da forma usual, com uma linha por
     fileira.

     'write_data' escreve arrays declarados do Lisp e do Maxima da forma
     usual, com um caractere de nova linha no final de todo pedaço.
     Pedaços dimensionais muito grandes são separados por meio de novas
     linhas adicionais.

     'write_data' escreve arrays desordenados com uma chave seguida por
     a lista associada sobre cada linha.

     'write_data' escreve a lista seguinte com cada sublista em uma
     linha.

     'write_data' escreve uma lista monótona toda em uma linha.

     Se 'write_data' anexa ao final ou abandona os excessos em seus
     arquivos de saída é governado através da variável global
     'file_output_append'.


File: maxima.info,  Node: opsubst,  Next: orthopoly,  Prev: numericalio,  Up: Top

64 opsubst
**********

* Menu:

* Funções e Variáveis Definidas para  opsubst::


File: maxima.info,  Node: Funções e Variáveis Definidas para opsubst,  Prev: opsubst,  Up: opsubst

64.1 Funções e Variáveis Definidas para opsubst
===============================================

 -- Função: opsubst (<f>,<g>,<e>)
 -- Função: opsubst (<g>=<f>,<e>)
 -- Função: opsubst ([<g1>=<f1>,<g2>=<f2>,..., <gn>=<fn>],<e>)
     A função 'opsubst' similar à função 'subst', exceto que 'opsubst'
     somente faz substituições para as operações em uma expressões.  Em
     geral, quando <f> for um operador em uma expressão <e>, substitui
     <g> por <f> na expressão <e>.

     Para determinar o operador, 'opsubst' escolhe 'inflag' para
     verdadeiro ( true ).  Isso significa que 'opsubst' substitui para a
     forma de operador interna, não para a mostrada, na expressão.

     Exemplos:
          (%i1) load (opsubst)$

          (%i2) opsubst(f,g,g(g(x)));
          (%o2)                     f(f(x))
          (%i3) opsubst(f,g,g(g));
          (%o3)                       f(g)
          (%i4) opsubst(f,g[x],g[x](z));
          (%o4)                       f(z)
          (%i5) opsubst(g[x],f, f(z));
          (%o5)                      g (z)
                                      x
          (%i6) opsubst(tan, sin, sin(sin));
          (%o6)                     tan(sin)
          (%i7) opsubst([f=g,g=h],f(x));
          (%o7)                       h(x)

     Internamente, Maxima não usa os operadores de negação unária,
     divisão, ou de subtração; dessa forma:
          (%i8) opsubst("+","-",a-b);
          (%o8)                     a - b
          (%i9) opsubst("f","-",-a);
          (%o9)                      - a
          (%i10) opsubst("^^","/",a/b);
                                       a
          (%o10)                       -
                                       b

     A representação interna de -a*b é *(-1,a,b); dessa forma
          (%i11) opsubst("[","*", -a*b);
          (%o11)                  [- 1, a, b]

     Quando o operador não for um símbolo Maxima, geralmente alguma
     outra função sinalizará um erro:
          (%i12) opsubst(a+b,f, f(x));

          Improper name or value in functional position:
          b + a
           -- an error.  Quitting.  To debug this try debugmode(true);

     Todavia, operadores subscritos são permitidos:
          (%i13) opsubst(g[5],f, f(x));
          (%o13)                     g (x)
                                      5

     Para usar essa função escreva primeiramente 'load("opsubst")'.


File: maxima.info,  Node: orthopoly,  Next: plotdf,  Prev: opsubst,  Up: Top

65 orthopoly
************

* Menu:

* Introdução a polinômios ortogonais::
* Funções e Variáveis Definidas para polinômios ortogonais::


File: maxima.info,  Node: Introdução a polinômios ortogonais,  Next: Funções e Variáveis Definidas para polinômios ortogonais,  Prev: orthopoly,  Up: orthopoly

65.1 Introdução a polinômios ortogonais
=======================================

'orthopoly' é um pacote para avaliação simbólica e numérica de muitos
tipos de polinômios ortogonais, incluindo polinômios de Chebyshev,
Laguerre, Hermite, Jacobi, Legendre, e ultraesférico (Gegenbauer).
Adicionalmentey, 'orthopoly' inclui suporte funções esféricas segundo o
critério de Bessel, esféricas segundo o critério de Hankel, e funções
harmônica esféricas.

   Em sua maior parte, 'orthopoly' segue as convenções de Abramowitz e
Stegun Handbook of Mathematical Functions, Chapter 22 (10th printing,
December 1972); adicionalmente, usamos Gradshteyn e Ryzhik, Table of
Integrals, Series, and Products (1980 corrected and enlarged edition), e
Eugen Merzbacher Quantum Mechanics (2nd edition, 1970).

   Barton Willis da University de Nebraska e Kearney (UNK) escreveu o
pacote 'orthopoly' e sua documetação.  O pacote é liberado segundo a
licença pública geral GNU (GPL).

65.1.1 Iniciando com orthopoly
------------------------------

'load (orthopoly)' torna o pacote 'orthopoly' disponível para uso.

   Para encontrar o polinômio de Legendre de terceira ordem,

     (%i1) legendre_p (3, x);
                           3             2
                  5 (1 - x)    15 (1 - x)
     (%o1)      - ---------- + ----------- - 6 (1 - x) + 1
                      2             2

   Para expressar esse polinômio como uma soma de potências de <x>,
aplique <ratsimp> ou <rat> para o resultado anterior.

     (%i2) [ratsimp (%), rat (%)];
                             3           3
                          5 x  - 3 x  5 x  - 3 x
     (%o2)/R/            [----------, ----------]
                              2           2

   Alternativamente, faça o segundo argumento para 'legendre_p' (sua
variável "principal") uma expressão racional canônica (CRE) usando
'rat(x)' em lugar de somente 'x'.

     (%i1) legendre_p (3, rat (x));
                                   3
                                5 x  - 3 x
     (%o1)/R/                   ----------
                                    2

   Para avaliação em ponto flutuante, 'orthopoly' usa uma análise de
erro durante a execução para estimar uma associação superior para o
erro.  Por exemplo,

     (%i1) jacobi_p (150, 2, 3, 0.2);
     (%o1) interval(- 0.062017037936715, 1.533267919277521E-11)

   intervalos possuem a forma 'interval (<c>, <r>)', onde <c> é o centro
e <r> é o raio do intervalo.  Uma vez que Maxima não suporta aritmética
sobre intervalos, em algumas situações, tais como em gráficos, você vai
querer suprimir o erro e sair somente com o centro do intervalo.  Para
fazer isso, escolha a variável de opção 'orthopoly_returns_intervals'
para 'false'.

     (%i1) orthopoly_returns_intervals : false;
     (%o1)                         false
     (%i2) jacobi_p (150, 2, 3, 0.2);
     (%o2)                  - 0.062017037936715

   Veja a seção *note Avaliação em Ponto Flutuante:: para maiores
informaçõesfor more information.

   Muitas funções em 'orthopoly' possuem uma propriedade 'gradef'; dessa
forma

     (%i1) diff (hermite (n, x), x);
     (%o1)                     2 n H     (x)
                                    n - 1
     (%i2) diff (gen_laguerre (n, a, x), x);
                   (a)               (a)
                n L   (x) - (n + a) L     (x) unit_step(n)
                   n                 n - 1
     (%o2)      ------------------------------------------
                                    x

   A função de um único passo no segundo exemplo previne um erro que
poderia de outra forma surgir através da avaliação de <n> para 0.

     (%i3) ev (%, n = 0);
     (%o3)                           0

   A propriedade 'gradef' somente aplica para a variável "principal";
dderivadas com relação a outros argumentos usualmente resultam em uma
mensagem de erro; por exemplo

     (%i1) diff (hermite (n, x), x);
     (%o1)                     2 n H     (x)
                                    n - 1
     (%i2) diff (hermite (n, x), n);

     Maxima doesn't know the derivative of hermite with respect the first argument
      -- an error.  Quitting.  To debug this try debugmode(true);

   Geralmente, funções em 'orthopoly' mapeiam sobre listas e matrizes.
Para o mapeamento para avaliação total, as variáveis de opção
'doallmxops' e 'listarith' devem ambas serem 'true' (o valor padrão).
Para ilustrar o mapeamento sobre matrizes, considere

     (%i1) hermite (2, x);
                                          2
     (%o1)                    - 2 (1 - 2 x )
     (%i2) m : matrix ([0, x], [y, 0]);
                                 [ 0  x ]
     (%o2)                       [      ]
                                 [ y  0 ]
     (%i3) hermite (2, m);
                    [                             2  ]
                    [      - 2        - 2 (1 - 2 x ) ]
     (%o3)          [                                ]
                    [             2                  ]
                    [ - 2 (1 - 2 y )       - 2       ]

   No segundo exemplo, o elemento 'i, j' do valor é 'hermite (2,
m[i,j])'; isso não é o mesmo que calcular '-2 + 4 m . m', como visto no
próximo exemplo.

     (%i4) -2 * matrix ([1, 0], [0, 1]) + 4 * m . m;
                         [ 4 x y - 2      0     ]
     (%o4)               [                      ]
                         [     0      4 x y - 2 ]

   Se você avaliar uma função em um ponto fora do seu domínio,
geralmente 'orthopoly' retorna uma função não avaliada.  Por exemplo,

     (%i1) legendre_p (2/3, x);
     (%o1)                        P   (x)
                                   2/3

   'orthopoly' suporta tradução em TeX; 'orthopoly' também faz saídas
bidimensionais em um terminal.

     (%i1) spherical_harmonic (l, m, theta, phi);
                               m
     (%o1)                    Y (theta, phi)
                               l
     (%i2) tex (%);
     $$Y_{l}^{m}\left(\vartheta,\varphi\right)$$
     (%o2)                         false
     (%i3) jacobi_p (n, a, a - b, x/2);
                               (a, a - b) x
     (%o3)                    P          (-)
                               n          2
     (%i4) tex (%);
     $$P_{n}^{\left(a,a-b\right)}\left({{x}\over{2}}\right)$$
     (%o4)                         false

65.1.2 Limitations
------------------

Quando uma expressão envolve muitos polinômios ortogonais com ordens
simbólicas, é possível que a expressão atualmente tenda para zero, e
ainda ocorre também que Maxima estar incapacitado de simplificar essa
expressão para zero.  Se você faz uma divisão por tal quantidade que
tende a zero, você pode estar em apuros.  Por exemplo, a seguinte
expressão tende para zero para inteiros <n> maiores que 1, e ainda
ocorre também que Maxima está incapacitado de simplificar essa expressão
para zero.

     (%i1) (2*n - 1) * legendre_p (n - 1, x) * x - n * legendre_p (n, x) + (1 - n) * legendre_p (n - 2, x);
     (%o1)  (2 n - 1) P     (x) x - n P (x) + (1 - n) P     (x)
                       n - 1           n               n - 2

   Para um <n> específico, podemos reduzir a expressão a zero.

     (%i2) ev (% ,n = 10, ratsimp);
     (%o2)                           0

   Geralmente, a forma polinomial de um polinômio ortogonal esteja
adequada de forma hostil para avaliaçao em ponto flutuante.  Aqui está
um exemplo.

     (%i1) p : jacobi_p (100, 2, 3, x)$

     (%i2) subst (0.2, x, p);
     (%o2)                3.4442767023833592E+35
     (%i3) jacobi_p (100, 2, 3, 0.2);
     (%o3)  interval(0.18413609135169, 6.8990300925815987E-12)
     (%i4) float(jacobi_p (100, 2, 3, 2/10));
     (%o4)                   0.18413609135169

   O verdadeiro valor está em torno de 0.184; ess calculo suporta erro
de cancelamento por extremo subtrativo.Expandindo o polinômio e então
avaliando, fornecendo um melhor resultado.
     (%i5) p : expand(p)$
     (%i6) subst (0.2, x, p);
     (%o6) 0.18413609766122982

   Essa não é uma regra geral; expandindo o polinômio não resulta sempre
em expressões que são melhores adaptadas a avaliação numérica.  Com
grande folga, o melhor caminho para fazer avaliação numérica é fazer um
ou mais argumentos da função serem números em ponto flutuante.  Em
função disso, algorítmos especializados em ponto flutuante são usados
para avaliação.

   A função 'float' do Maxima é até certo ponto indiscriminada; se você
aplicar 'float' a uma expressão envolvendo um polinômio ortogonal com um
grau simbólico ou um parâmetro de ordem, esses parâmetos (inteiros)
podem ser convertido em números em ponto flutuante; após o que, a
expressão não irá avaliar completamente.  Considere

     (%i1) assoc_legendre_p (n, 1, x);
                                    1
     (%o1)                         P (x)
                                    n
     (%i2) float (%);
                                   1.0
     (%o2)                        P   (x)
                                   n
     (%i3) ev (%, n=2, x=0.9);
                                  1.0
     (%o3)                       P   (0.9)
                                  2

   A expressão em (%o3) não irá avaliar para um número em ponto
flutuante; 'orthopoly' não reconhece valores em ponto flutuante em
lugares onde deve haver valores inteiros.  Similarmente, avaliação
numérica da função 'pochhammer' para ordens que excedam
'pochhammer_max_index' pode ser perturbador; considere

     (%i1) x :  pochhammer (1, 10), pochhammer_max_index : 5;
     (%o1)                         (1)
                                      10

   Aplicando 'float' não avalia <x> para um número em ponto flutuante

     (%i2) float (x);
     (%o2)                       (1.0)
                                      10.0

   Para avaliar <x> para um número em ponto flutuante, você irá precisar
associar 'pochhammer_max_index' a 11 ou mais e aplicar 'float' a <x>.

     (%i3) float (x), pochhammer_max_index : 11;
     (%o3)                       3628800.0

   O valor padrão de 'pochhammer_max_index' é 100; modifique esse valor
após chama 'orthopoly'.

   Finalmente, tenha consciência que os livros citados nas referências
adotam diferentes definições de polinômios ortogonais; geralmente
adotamos as convenções citadas nas convenções de Abramowitz e Stegun.

   Antes de você suspeitar de um erro no pacote 'orthopoly', verifique
alguns casos especiais para determinar se suas definições coincidem com
aquelas usadas por 'orthopoly'.  Definitions muitas vezes diferem por
uma normalização; ocasionalmente, autores utilizam versões "modificadas"
das funções que fazem a família ortogonal sobre um intervalo diferente
do intervalo (-1, 1).  Para definir, por exemplo, um polinômio de
Legendre que é ortogonal a (0, 1), defina

     (%i1) shifted_legendre_p (n, x) := legendre_p (n, 2*x - 1)$

     (%i2) shifted_legendre_p (2, rat (x));
                                 2
     (%o2)/R/                 6 x  - 6 x + 1
     (%i3) legendre_p (2, rat (x));
                                    2
                                 3 x  - 1
     (%o3)/R/                    --------
                                    2

65.1.3 Avaliação em Ponto Flutuante
-----------------------------------

Muitas funções em 'orthopoly' utilizam análise de erro durante a
execução para estimar o erro em avaliações em ponto flutuante; as
exceções são funções de Bessel esféricas e os polinômios associados de
Legendre do segundo tipo.  Para avaliações numéricas, as funções de
Bessel esféricas chamam funções da coleção de programas 'SLATEC'.
Nenhum método especializado é usado para avaliação numérica dos
polinômios associados de Legendre do segundo tipo.

   A análise de erro durante a execução ignora erros que são de segunda
ordem ou maior na máquina (também conhecida como perda de algarismos).
A análise de erro durante a execução também ignora alguns poucos outros
tipos de erro.  É possível (embora não provável) que o erro atual exceda
o estimado.

   Intervalos possuem a forma 'interval (<c>, <r>)', onde <c> é o centro
do intervalo e <r> é seu raio.  O centro de um intervalo pode sr um
número complexo, e o raio é sempre um número real positivo.

   Aqui está um exemplo.

     (%i1) fpprec : 50$

     (%i2) y0 : jacobi_p (100, 2, 3, 0.2);
     (%o2) interval(0.1841360913516871, 6.8990300925815987E-12)
     (%i3) y1 : bfloat (jacobi_p (100, 2, 3, 1/5));
     (%o3) 1.8413609135168563091370224958913493690868904463668b-1

   Vamos testar o quanto o erro atual é é menor que o erro estimado

     (%i4) is (abs (part (y0, 1) - y1) < part (y0, 2));
     (%o4)                         true

   Realmente, por esse exemplo o erro estimado é um maior que o erro
verdadeiro.

   Maxima não suporta aritmética sobre intervalos.

     (%i1) legendre_p (7, 0.1) + legendre_p (8, 0.1);
     (%o1) interval(0.18032072148437508, 3.1477135311021797E-15)
             + interval(- 0.19949294375000004, 3.3769353084291579E-15)

   Um usuário pode definir operadores aritméticos que fazem matemática
de intervalos.  Para definir adição de intervalos, podemos definir

     (%i1) infix ("@+")$

     (%i2) "@+"(x,y) := interval (part (x, 1) + part (y, 1), part (x, 2) + part (y, 2))$

     (%i3) legendre_p (7, 0.1) @+ legendre_p (8, 0.1);
     (%o3) interval(- 0.019172222265624955, 6.5246488395313372E-15)

   As rotinas eseciais em ponto flutuante são chamadas quando os
argumentos forem complexos.  Por exemplo,

     (%i1) legendre_p (10, 2 + 3.0*%i);
     (%o1) interval(- 3.876378825E+7 %i - 6.0787748E+7,
                                                1.2089173052721777E-6)

   Let's compare this to the true value.

     (%i1) float (expand (legendre_p (10, 2 + 3*%i)));
     (%o1)          - 3.876378825E+7 %i - 6.0787748E+7

   Adicionalmente, quando os argumentos forem grandes números em ponto
flutuante, as rotinas especiais de ponto flutuante são chamadas;
todavia, tos grandes números em ponto flutuante são convertidos para
números em ponto flutuante de dupla precisão e o resultado final é
número em ponto flutuante de precisão dupla.

     (%i1) ultraspherical (150, 0.5b0, 0.9b0);
     (%o1) interval(- 0.043009481257265, 3.3750051301228864E-14)

65.1.4 Gráficos e 'orthopoly'
-----------------------------

Para montar gráficos de expressões que envolvem polinômios ortogonais,
você deve azer duas coisas:
  1. Escolher a variável de opção 'orthopoly_returns_intervals' para
     'false',
  2. Colocar apóstrofo em qualquer chamada a funções do pacote
     'orthopoly'.
   Se chamadas a funções não receberem apóstrofo, Maxima irá avaliá-las
para polinômios antes de montar o gráfico; conseqüêntemente, as rotinas
especializadas em ponto flutuante não serão chamadas.  Aqui está um
exemplo de como montar o gráfico de uma expressão que envolve um
polinômio de Legendre.

     (%i1) plot2d ('(legendre_p (5, x)), [x, 0, 1]), orthopoly_returns_intervals : false;
     (%o1)

   A expressão completa 'legendre_p (5, x)' recebe apóstrofo; isso é
diferente de apenas colocar apóstrofo no nome da função usando
''legendre_p (5, <x>)'.

65.1.5 Funções Diversas
-----------------------

O pacote 'orthopoly' define o síbolo de Pochhammer e uma função de passo
de unidade.  'orthopoly' utiliza a função delta de Kronecker e a função
de passo de unidade em declarações 'gradef'.

   Para converter os símbolos Pochhammer em quocientes da funções gama,
use 'makegamma'.

     (%i1) makegamma (pochhammer (x, n));
                               gamma(x + n)
     (%o1)                     ------------
                                 gamma(x)
     (%i2) makegamma (pochhammer (1/2, 1/2));
                                     1
     (%o2)                       ---------
                                 sqrt(%pi)

   Derivadas de símbolos de Pochhammer são fornecidas em termos de 'psi'
function.

     (%i1) diff (pochhammer (x, n), x);
     (%o1)             (x)  (psi (x + n) - psi (x))
                          n     0             0
     (%i2) diff (pochhammer (x, n), n);
     (%o2)                   (x)  psi (x + n)
                                n    0

   Vocêprecisa ser cuidadoso com expressões como (%o1); a diferença das
funções 'psi' possuem polinômios quando '<x> = -1, -2, .., -<n>'.  Esses
polinômios cacelam-se com fatores em 'pochhammer (<x>, <n>)' fazendo da
derivada um polinômio de grau '<n> - 1' quando <n> for um inteiro
positivo.

   O símbolo de Pochhammer é definido de ordens negativas até sua
representação como um quociente de funções gama.  Considere

     (%i1) q : makegamma (pochhammer (x, n));
                               gamma(x + n)
     (%o1)                     ------------
                                 gamma(x)
     (%i2) sublis ([x=11/3, n= -6], q);
                                    729
     (%o2)                        - ----
                                    2240

   Alternativamente, podemos tomar ese resultado diretamente.

     (%i1) pochhammer (11/3, -6);
                                    729
     (%o1)                        - ----
                                    2240

   A função passo de unidade é contínua à esquerda; dessa forma

     (%i1) [unit_step (-1/10), unit_step (0), unit_step (1/10)];
     (%o1)                       [0, 0, 1]

   Se você precisa de uma função de unidade de passo que é ou contínua à
esquerda ou contínua à direita em zero, defina sua própria função de
unidade de passo usando 'signum'; por exemplo,

     (%i1) xunit_step (x) := (1 + signum (x))/2$

     (%i2) [xunit_step (-1/10), xunit_step (0), xunit_step (1/10)];
                                     1
     (%o2)                       [0, -, 1]
                                     2

   Não redefina a própria 'unit_step'; alguns código em 'orthopoly'
requerem que a função de passo de unidade seja contínua à esquerda.

65.1.6 Algorítmos
-----------------

Geralmente, 'orthopoly' faz avaliações simbólicas pelo uso de uma
representação hipergeométrica de polinômios ortogonais.  As funções
hipegeométricas são avaliadas usando as funções (não documetadas)
'hypergeo11' e 'hypergeo21'.  As excessões são as funções de Bessel
metade inteiras e a função de Legendre associada de segundo tipo.  As
funções de Bessel metade inteiras são avaliadas usando uma representação
explícita, e a função de Legendre associada de segundo tipo é avaliada
usando recursividade.

   Para avaliação em ponto flutuante, nós novamente convertemos muitas
fuções em uma forma hipergeométrica; nós avaliamos as funções
hipergeométricas usando recursividade para frente.  Novamente, as
excessões são as funções de Bessel metade inteiras e a função de
Legendre associada de segundo tipo.  Numericamente, as funções de Bessel
meio inteiras são avaliadas usando o código SLATEC.


File: maxima.info,  Node: Funções e Variáveis Definidas para polinômios ortogonais,  Prev: Introdução a polinômios ortogonais,  Up: orthopoly

65.2 Funções e Variáveis Definidas para polinômios ortogonais
=============================================================

 -- Função: assoc_legendre_p (<n>, <m>, <x>)
     As funções de Legendre associadas de primeiro tipo.

     Referência: Abramowitz e Stegun, equações 22.5.37, página 779,
     8.6.6 (segunda equação), página 334, e 8.2.5, página 333.

 -- Função: assoc_legendre_q (<n>, <m>, <x>)
     A função de Legendre associada de segundo tipo.

     Referência: Abramowitz e Stegun, equação 8.5.3 e 8.1.8.

 -- Função: chebyshev_t (<n>, <x>)
     A função de Chebyshev de primeiro tipo.

     Referência: Abramowitz e Stegun, equação 22.5.47,página 779.

 -- Função: chebyshev_u (<n>, <x>)
     A função de Chebyshev do segundo tipo.

     Referência: Abramowitz e Stegun, equação 22.5.48,página 779.

 -- Função: gen_laguerre (<n>, <a>, <x>)
     O poliômio generalizado de Laguerre.

     Referência: Abramowitz e Stegun, equação 22.5.54,página 780.

 -- Função: hermite (<n>, <x>)
     O polinômio de Hermite.

     Referência: Abramowitz e Stegun, equação 22.5.55,página 780.

 -- Função: intervalp (<e>)
     Retorna 'true' se a entrada for um intervalo e retorna 'false' se
     não for.

 -- Função: jacobi_p (<n>, <a>, <b>, <x>)
     o polinômio de Jacobi.

     Os polinômios de Jacobi são atualmente definidos para todo <a> e
     <b>; todavia, o peso do polinômio de Jacobi '(1 - <x>)^<a> (1 +
     <x>)^<b>' não é integrável para '<a> <= -1' ou '<b> <= -1'.

     Referência: Abramowitz e Stegun, equação 22.5.42,página 779.

 -- Função: laguerre (<n>, <x>)
     O polinômio de Laguerre.

     Referência: Abramowitz e Stegun, equatções 22.5.16 e 22.5.54,página
     780.

 -- Função: legendre_p (<n>, <x>)
     O polinômio de Legendre de primeiro tipo.

     Referência: Abramowitz e Stegun, equações 22.5.50 e 22.5.51,página
     779.

 -- Função: legendre_q (<n>, <x>)
     O polinômio de Legendre de primeiro tipo.

     Referência: Abramowitz e Stegun, equações 8.5.3 e 8.1.8.

 -- Função: orthopoly_recur (<f>, <args>)
     Retorna uma relação recursiva para a família de funções ortogonais
     <f> com argumentos <args>.  A recursividade é com relação ao grau
     do polinômio.

          (%i1) orthopoly_recur (legendre_p, [n, x]);
                          (2 n - 1) P     (x) x + (1 - n) P     (x)
                                     n - 1                 n - 2
          (%o1)   P (x) = -----------------------------------------
                   n                          n

     O segundo argumento a 'orthopoly_recur' deve ser uma lista com o
     número correto de argumentos para a função <f>; se o número de
     argumetnos não for o correto, Maxima sinaliza com um erro.

          (%i1) orthopoly_recur (jacobi_p, [n, x]);

          Function jacobi_p needs 4 arguments, instead it received 2
           -- an error.  Quitting.  To debug this try debugmode(true);

     Adicionalmente, quando <f> não for o nome de uma das famílias de
     polinômios ortogonais, um erro é sinalizado.

          (%i1) orthopoly_recur (foo, [n, x]);

          A recursion relation for foo isn't known to Maxima
           -- an error.  Quitting.  To debug this try debugmode(true);

 -- Variable: orthopoly_returns_intervals
     Valor padrão: 'true'

     Quando 'orthopoly_returns_intervals' for 'true', resultados em
     ponto flutuante são retornados na forma 'interval (<c>, <r>)', onde
     <c> é o centro de um intervalo e <r> é seu raio.  O centro pode ser
     um número complexo; nesse caso, o intervalo é um disco no plano
     complexo.

 -- Função: orthopoly_weight (<f>, <args>)

     Retorna uma lista de três elementos; o primeiro elemento é a
     fórmula do peso para a família de polinômios ortogonais <f> com
     argumentos fornecidos pela lista <args>; os segundos e terceiros
     elementos fornecem os pontos finais inferior e superior do
     intervalo de ortogonalidade.  Por exemplo,

          (%i1) w : orthopoly_weight (hermite, [n, x]);
                                      2
                                   - x
          (%o1)                 [%e    , - inf, inf]
          (%i2) integrate (w[1] * hermite (3, x) * hermite (2, x), x, w[2], w[3]);
          (%o2)                           0

     A variável principal de <f> deve ser um símbolo; Se não for, Maxima
     sinaliza com um erro.

 -- Função: pochhammer (<n>, <x>)
     O símbolo de Pochhammer.  Para inteiros não negativos <n> com '<n>
     <= pochhammer_max_index', a expressão 'pochhammer (<x>, <n>)'
     avalia para o produto '<x> (<x> + 1) (<x> + 2) ... (<x> + n - 1)'
     when '<n> > 0' e para 1 quando '<n> = 0'.  Para valores negativos
     de <n>, 'pochhammer (<x>, <n>)' é definido como '(-1)^<n> /
     pochhammer (1 - <x>, -<n>)'.  Dessa forma

          (%i1) pochhammer (x, 3);
          (%o1)                   x (x + 1) (x + 2)
          (%i2) pochhammer (x, -3);
                                           1
          (%o2)               - -----------------------
                                (1 - x) (2 - x) (3 - x)

     Para converter um símbolo de Pochhammer em um quociente de funções
     gama, (veja Abramowitz e Stegun, equação 6.1.22) use 'makegamma';
     por exemplo

          (%i1) makegamma (pochhammer (x, n));
                                    gamma(x + n)
          (%o1)                     ------------
                                      gamma(x)

     Quando <n> exceder 'pochhammer_max_index' ou quando <n> for
     simbólico, 'pochhammer' retorna uma forma substantiva.

          (%i1) pochhammer (x, n);
          (%o1)                         (x)
                                           n

 -- Variável: pochhammer_max_index
     Valor padrão: 100

     'pochhammer (<n>, <x>)' expande para um produto se e somente se
     '<n> <= pochhammer_max_index'.

     Exemplos:

          (%i1) pochhammer (x, 3), pochhammer_max_index : 3;
          (%o1)                   x (x + 1) (x + 2)
          (%i2) pochhammer (x, 4), pochhammer_max_index : 3;
          (%o2)                         (x)
                                           4

     Referência: Abramowitz e Stegun, equação 6.1.16,página 256.

 -- Função: spherical_bessel_j (<n>, <x>)
     A Função de Bessel esférica de primeiro tipo.

     Referência: Abramowitz e Stegun, equações 10.1.8,página 437 e
     10.1.15,página 439.

 -- Função: spherical_bessel_y (<n>, <x>)
     A Função de Bessel esférica de segundo tipo.

     Referência: Abramowitz e Stegun, equações 10.1.9,página 437 e
     10.1.15,página 439.

 -- Função: spherical_hankel1 (<n>, <x>)
     A Função de Hankel esférica de primeiro tipo.

     Referência: Abramowitz e Stegun, equação 10.1.36,página 439.

 -- Função: spherical_hankel2 (<n>, <x>)
     A Função de Hankel esférica de segundo tipo.

     Referência: Abramowitz e Stegun, equação 10.1.17,página 439.

 -- Função: spherical_harmonic (<n>, <m>, <x>, <y>)
     A função armônica esférica.

     Referência: Merzbacher 9.64.

 -- Função: unit_step (<x>)
     A função de passo de unidade contínua à esquerda; dessa forma
     'unit_step (<x>)' tende para '<x> <= 0' e é igual a 1 para '<x> >
     0'.

     Se você quiser uma função de passo de unidade que tome o valor 1/2
     em zero, use '(1 + signum (<x>))/2'.

 -- Função: ultraspherical (<n>, <a>, <x>)
     A função polinômial ultraesférica (também conhecida como função
     polinomial de Gegenbauer).

     Referência: Abramowitz e Stegun, equação 22.5.46,página 779.


File: maxima.info,  Node: plotdf,  Next: romberg,  Prev: orthopoly,  Up: Top

66 plotdf
*********

* Menu:

* Introdução a plotdf::
* Funções e Variáveis Definidas para plotdf::


File: maxima.info,  Node: Introdução a plotdf,  Next: Funções e Variáveis Definidas para plotdf,  Prev: plotdf,  Up: plotdf

66.1 Introdução a plotdf
========================

A função 'plotdf' cria um gráfico do campo de direção de uma Equação
Diferencial Ordinária (EDO) de primeira ordem ou um sistema de duas
EDO's de primeira ordem autônomas.

   Uma vez que esse é um apcote adicional, com o objetivo de usá-lo você
deve primeiramente chamá-lo com 'load("plotdf")'.  Você também precisa
do Xmaxima instalado, mesmo que você execute o Maxima usando uma
interface diferente.

   Para montar um gráfico do campo de direção de uma EDO simples, a EDO
deve ser escrita na forma:
            dy
            -- = F(x,y)
            dx

   e a função <F> pode ser dada como um argumento para 'plotdf'.  A
variável independente está sempre identificada como <x>, e a variável
dependente como <y>.  Essas duas variáveis podem não ter quaisquer
valores atribuídos a elas.

   Para montar o gráfico do campo de direção de um conjunto de duas
EDO's autônomas, elas devem ser escritas na forma
            dx             dy
            -- = G(x,y)    -- = F(x,y)
            dt             dt

   e o argumento para 'plotdf' pode ser uma lista com as duas funções
<F> e <G>, em qualquer ordem.

   Se somente uma EDO for fornecida, 'plotdf' irá admitir implicitamente
'x=t', e 'G(x,y)=1', transformando a equação não autônoma em um sistema
de duas equações autônomas.


File: maxima.info,  Node: Funções e Variáveis Definidas para plotdf,  Prev: Introdução a plotdf,  Up: plotdf

66.2 Funções e Variáveis Definidas para plotdf
==============================================

 -- Função: plotdf (<dydx>,...opções...)
 -- Função: plotdf ('['<dxdt>,<dydt>']',...opções...)

     Mostra um campo de direção em duas dimensões <x> e <y>.

     <dydx>, <dxdt> e <dydt> são expressões que dependem de <x> e <y>.
     Adicionalmente para essas duas variáveis, as expressões podem
     também depender de um conjunto de parâmetros, com valores numéricos
     fornecidos com os 'parâmetros' opção (a sintaxe de opção é
     fornecida abaixo), ou com um intervalo de valores permitidos
     especificados por meio de uma opção <sliders>.

     Muitas outras opções podem ser fornecidas dentro do comando, ou
     selecionadas no menu.  Curvas integrais podem ser obtidas por meio
     de um clique no gráfico, ou com a opção 'trajectory_at'.  A direção
     da integração pode ser controlada com a opção 'direction', que pode
     ter valores de _forward_ (adiante), _backward_(para trás) or _both_
     (ambos).  O número de passos de integração é fornecido por meio de
     'nsteps' e o intervalo de tempo entre eles é escolhido com a opção
     'tstep'.  O método de Adams Moulton é usado para a integração; é
     também possível alternar para um método adaptativo de Runge-Kutta
     de quarta ordem.

     Menu da janela do gráfico:

     O menu na janela do gráfico tem as seguintes opções: _Zoom_, irá
     modificar o comportamento do mouse de forma que seja permitido a
     você aproximar uma região do gráfico por meio de um clique nessa
     região como o botão esquerdo.  Cada clique próximo a um ponto do
     gráfico amplia esse gráfico, mantendo o contro no ponto onde você
     clicou.  Mantendo a tecla <Shift> pressioada enquanto clica, afasta
     para a ampliação anterior.  Para continuar calculando trajetórias
     quando você clica sobre um ponto, selecione _Integrate_ a partir do
     menu.

     A opção _Config_ no menu pode ser usada para mudar a(s) EDO(s) em
     uso e para várias outras escolhas.  Após as mudanças de
     configuração serem feitas, a opção do menu _Replot_ estará
     selecionada, para ativar as novas escolhas.  Se um par de
     coordenadas for fornecido em um campo _Trajectory at_ na caixa de
     diálogo _Config_ do menu, e a tecla <enter> fo pressionada, uma
     nova curva integral será mostrada, adicionalmente com as outras já
     mostradas.  Quando _Replot_ está selecionada, somente a última
     curva integral fornecida será mostrada.

     Mantendo o botão direito do mouse pressionado enquanto o cursor é
     movido, pode ser usado para arrastar as laterais do gráfico para
     cima ou para baixo.  Parâmetros adicionais tais como o número de
     passos, o valor inicial de <t> e os centros de x e y e raios, podem
     ser escolhidos no menu Config.

     Uma cópia do gráfico pode ser impressa para uma impressora
     Postscript, ou gravada como um arquivo postscript, usando a opção
     _Save_ do menu.  Para alternar entre imprimir e gravar para um
     arquivo Postscript, _Print Options_ pode ser selecionada na janela
     de diálogo de _Config_.  Após as escolhas na janela de diálogo
     _Save_ serem fornecidas, "Save" deve ser selecionada no primeiro
     menu, para cirar o arquivo ou imprimir o gráfico.

     Opções de gráfico:

     O comando 'plotdf' pode incluir muitos comandos, cada comando é uma
     lista de dois ou mais itens.  O primeiro item é o nome da opção, e
     o restante compreende o valor ou valores atribuídos à opção.

     As opçõesque são reconhecidas por 'plotdf' são as seguintes:

        * "tstep" define o comprimento dos incrementos sobre a variável
          independente <t>, usado para calcular uma curva integral.  Se
          somente uma expressão <dydx> for fornecida a 'plotdf', a
          variável <x> será diretamente proporcional a <t>.  O valor
          padrão é 0.1.

        * "nsteps" define o número de passos de comprimento 'tstep' que
          será usando para a variável independente, para calcular uma
          curva integral.  O valor padrão é 100.

        * "direction" define a direção da variável independente que será
          seguida para calcular uma curva integral.  Possíveis valores
          são 'forward', para fazer a variável independente aumentar
          'nsteps' vezes, com incrementos de 'tstep', 'backward', para
          fazer a variável independente diminuir, ou 'both' que irá
          conduzir a um curva integral que amplia 'nsteps' adiante, e
          'nsteps' para trás.  As palavras chave 'right' e 'left' podem
          ser usadas como sinonimos para 'forward' e 'backward'.  O
          valor padrão é 'both'.

        * "tinitial" define o valor inicial da variável <t> usada para
          calcular curva integral.  Uma vez que equações diferenciais
          forem autônomas, aquela esxolha irá aparecer somente no
          gráfico das curvas como funções de <t>.  O valor padrão é 0.

        * "versus_t" é usado para criar uma segunda janela de gráfico,
          com um gráfico de uma curva integral, como duas funções <x>,
          <y>, da variável independente <t>.  Se para 'versus_t' for
          atribuído qualquer valor diferente de 0, a segunda janela de
          gráfico será mostrada.  A segunda janela de gráfico inclui
          outro menu, semelhante ao menu da janela de gráfico principal.
          O valor padrão é 0.

        * "trajectory_at" define as coordenadas <xinitial> e <yinitial>
          para o ponto de partida de uma curva integral.  A opção está
          vazia por padrão.

        * "parameters" define uma lista de parâmetros, e seus valores
          numéricos, usados na definição das equações diferenciais.  O
          nome e valores dos parâmetros devem ser fornecidos em uma
          seqüência de caracteres com uma seqüência de pares
          'nome=valor' separados por vírgula.

        * "sliders" define uma lista de parâmetros que será modificada
          interativamente usando botões de deslizamento, e o intervalo
          de variação desses parâmetros.  Os nomes e intervalos dos
          parâmetros devem ser fornecidos in a seqüência de caracteres
          com uma seqüência de elementos 'name=min:max' separados por
          vírgula.

        * "xfun" define uma seqüência de caracteres com uma seqüência de
          funções separadas com ponto e vírgula <x> para serem
          mostradas, no topo do campo de direção.  Essas funções irão
          ser passadas pelo Tcl e não pelo Maxima.

        * "xradius" é metade do comprimento do intervalo dos valores que
          irão ser mostrados na direção x.  O valor padrão é 10.

        * "yradius" é metade do comprimento do intervalo dos valores que
          irão ser mostrados na direção y.  O valor padrão é 10.

        * "xcenter" é a coordenada x do ponto no centro do gráfico.  O
          valor padrão é 0.

        * "ycenter" é a coordenada y do ponto no centro do gráfico.  O
          valor padrão é 0.

        * "width" define a largura da janela do gráfico, em pixels.  O
          valor padrão é 500.

        * "height" define a altura da janela do gráfico, em pixels.  O
          valor padrão é 500.

     Exemplos:

     NOTA: Dependendo da interface usada para executar o Maxima, as
     funções que usam 'openmath', em particular 'plotdf', podem
     possivelmente disparar um erro se erminarem com ponto e vírgula e
     não com um sinal de dólar.  Para evitar problemas, usamos um sinal
     de dólar em todos os exemplos abaixo.

        * Para mostrar o campo de direção da equação diferencial y' =
          exp(-x) + y e a solução que vai em toda a extensão do
          intervalo (2, -0.1):
               (%i1) load("plotdf")$

               (%i2) plotdf(exp(-x)+y,[trajectory_at,2,-0.1]);

        * Para obter o campo de direção para a equação diff(y,x) = x -
          y^2 e a solução com condição inicial y(-1) = 3, podemos usar o
          comando:
               (%i3) plotdf(x-y^2,[xfun,"sqrt(x);-sqrt(x)"],
                         [trajectory_at,-1,3], [direction,forward],
                         [yradius,5],[xcenter,6]);
          O gráfico também mostra a função y = sqrt(x).

        * O seguinte exemplo mostra o campo de direção de um oscilador
          harmônico, definido pelas duas equações dx/dt = y e dy/dt =
          -k*x/m, e a curva integral em todo o intervalo (x,y) = (6,0),
          com um botão de deslizamento que irá permitir a você mudar o
          valor de m interativamente (k está fixado em 2):
               (%i4) plotdf([y,-k*x/m],[parameters,"m=2,k=2"],
                           [sliders,"m=1:5"], [trajectory_at,6,0]);

        * Para montar o gráfico do campo de direção da equação de
          Duffing, m*x''+c*x'+k*x+b*x^3 = 0, introduzimos a variável
          y=x' e usamos:
               (%i5) plotdf([y,-(k*x + c*y + b*x^3)/m],
                             [parameters,"k=-1,m=1.0,c=0,b=1"],
                             [sliders,"k=-2:2,m=-1:1"],[tstep,0.1]);

        * O campo de direção para um pêdulo amortecido, incluindo a
          solução para as condições iniciais fornecidas, com um botão de
          deslizamento que pode ser usado para mudar o valor da massa m,
          e com um gráfico das duas variáveis de estado como uma função
          do tempo:

               (%i6) plotdf([y,-g*sin(x)/l - b*y/m/l],
                        [parameters,"g=9.8,l=0.5,m=0.3,b=0.05"],
                        [trajectory_at,1.05,-9],[tstep,0.01],
                        [xradius,6],[yradius,14],
                        [xcenter,-4],[direction,forward],[nsteps,300],
                        [sliders,"m=0.1:1"], [versus_t,1]);


File: maxima.info,  Node: romberg,  Next: simplex,  Prev: plotdf,  Up: Top

67 romberg
**********

* Menu:

* Funções e Variáveis Definidas para romberg::


File: maxima.info,  Node: Funções e Variáveis Definidas para romberg,  Prev: Top,  Up: Top

67.1 Funções e Variáveis Definidas para romberg
===============================================

 -- Função: romberg (<expr>, <x>, <a>, <b>)
 -- Função: romberg (<F>, <a>, <b>)

     Calcula uma integração numérica pelo método de Romberg.

     'romberg(<expr>, <x>, <a>, <b>)' retorna uma estimativa da integral
     'integrate(<expr>, <x>, <a>, <b>)'.  <expr> deve ser uma expressão
     que avalie para um valor em ponto flutuante quando <x> estiver
     associado a um valor em ponto flutuante.

     'romberg(<F>, <a>, <b>)' retorna uma estimativa da integral
     'integrate(<F>(x), x, <a>, <b>)' onde 'x' representa o não nomeado,
     isolado argumeno de <F>; o atual argumento não é chamado 'x'.  <F>
     deve ser uma função do Maxima ou do Lisp que retorne um valor em
     ponto flutuante quando o argumento for um número em ponto
     flutuante.  <F> pode nomear uma função traduzida ou compilada do
     Maxima.

     A precisão de 'romberg' é governada pelas variáveis globais
     'rombergabs' e 'rombergtol'.  'romberg' termina com sucesso quando
     a diferença absoluta entre duas aproximações sucessivas for menor
     que 'rombergabs', ou a diferença relativa em aproximações
     sucessivas for menor que 'rombergtol'.  Dessa forma quando
     'rombergabs' for 0.0 (o padrão) somente o erro relativo tem algum
     efeito sobre 'romberg'.

     'romberg' divide ao meio o tamanho do passo no máximo 'rombergit'
     vezes antes de interromper; o número máximo de avaliações de função
     é portanto '2^rombergit'.  Se o critério de erro estabelecido por
     'rombergabs' e por 'rombergtol' não for satisfeito, 'romberg'
     mostra uma mensagem de erro.  'romberg' sempre faz ao menos
     'rombergmin' iterações; isso é uma intenção eurísstica de previnir
     encerramentos espúrios quando o integrando for oscilatório.

     'romberg' repetidamente avalia o integrando após associar a
     variável de integração a um valor específico (e não antes).  Essa
     política de avaliação torna possível aninhar chamadas a 'romberg',
     para calcular integrais multidimensionais.  Todavia, os cálculos de
     erro não tomam os erros de integrações aninhadas em consideração,
     então erros podem ser subestimados.  Também, métodos imaginados
     especialmente para problemas multidimensionais podem retornar a
     mesma precisão com poucas avaliações de função.

     'load(romberg)' torna essa função disponível para uso.

     Veja também 'QUADPACK', uma coleção de funções de integração
     numérica.

     Exemplos:

     Uma integração unidimensonal.

          (%i1) load (romberg);
          (%o1)    /usr/share/maxima/5.11.0/share/numeric/romberg.lisp
          (%i2) f(x) := 1/((x - 1)^2 + 1/100) + 1/((x - 2)^2 + 1/1000) + 1/((x - 3)^2 + 1/200);
                              1                 1                1
          (%o2) f(x) := -------------- + --------------- + --------------
                               2    1           2    1            2    1
                        (x - 1)  + ---   (x - 2)  + ----   (x - 3)  + ---
                                   100              1000              200
          (%i3) rombergtol : 1e-6;
          (%o3)                 9.9999999999999995E-7
          (%i4) rombergit : 15;
          (%o4)                          15
          (%i5) estimate : romberg (f(x), x, -5, 5);
          (%o5)                   173.6730736617464
          (%i6) exact : integrate (f(x), x, -5, 5);
          (%o6) 10 sqrt(10) atan(70 sqrt(10))
           + 10 sqrt(10) atan(30 sqrt(10)) + 10 sqrt(2) atan(80 sqrt(2))
           + 10 sqrt(2) atan(20 sqrt(2)) + 10 atan(60) + 10 atan(40)
          (%i7) abs (estimate - exact) / exact, numer;
          (%o7)                7.5527060865060088E-11

     Uma integração bidimensional, implementada com chamadas aninhadas a
     'romberg'.

          (%i1) load (romberg);
          (%o1)    /usr/share/maxima/5.11.0/share/numeric/romberg.lisp
          (%i2) g(x, y) := x*y / (x + y);
                                              x y
          (%o2)                   g(x, y) := -----
                                             x + y
          (%i3) rombergtol : 1e-6;
          (%o3)                 9.9999999999999995E-7
          (%i4) estimate : romberg (romberg (g(x, y), y, 0, x/2), x, 1, 3);
          (%o4)                   0.81930239628356
          (%i5) assume (x > 0);
          (%o5)                        [x > 0]
          (%i6) integrate (integrate (g(x, y), y, 0, x/2), x, 1, 3);
                                                    3
                                              2 log(-) - 1
                              9                     2        9
          (%o6)       - 9 log(-) + 9 log(3) + ------------ + -
                              2                    6         2
          (%i7) exact : radcan (%);
                              26 log(3) - 26 log(2) - 13
          (%o7)             - --------------------------
                                          3
          (%i8) abs (estimate - exact) / exact, numer;
          (%o8)                1.3711979871851024E-10

 -- Variável de opção: rombergabs
     Valor padrão: 0.0

     A precisão de 'romberg' é governada pelas variávies globais
     'rombergabs' e 'rombergtol'.  'romberg' termina com sucesso quando
     a diferença absoluta entre duas aproximações sucessivas for menor
     que 'rombergabs', ou a diferença relativa em aproximações
     sucessivas for menor que 'rombergtol'.  Dessa forma quando
     'rombergabs' for 0.0 (o padrão) somente o erro relativo tem algum
     efeito sobre 'romberg'.

     Veja também 'rombergit' e 'rombergmin'.

 -- Variável de opção: rombergit
     Valor padrão: 11

     'romberg' divide ao meio o tamanho do passo no máximo 'rombergit'
     vezes antes de interromper; o número máximo de avaliações de função
     é portanto '2^rombergit'.  'romberg' sempre faz ao menos
     'rombergmin' iterações; isso é uma intenção eurísstica de previnir
     encerramentos espúrios quando o integrando for oscilatório.

     Veja também 'rombergabs' e 'rombergtol'.

 -- Variável de opção: rombergmin
     Valor padrão: 0

     'romberg' sempre faz ao menos 'rombergmin' iterações; isso é uma
     intenção eurísstica para prevenir terminações espúrias quando o
     integrando for.

     Veja também 'rombergit', 'rombergabs', e 'rombergtol'.

 -- Variável de opção: rombergtol
     Valor padrão: 1e-4

     A precisão de 'romberg' é governada pelas variáveis globais
     'rombergabs' e 'rombergtol'.  'romberg' termina com sucesso quando
     a diferença absoluta entre duas aproximações sucessivas for menor
     que 'rombergabs', ou a diferença relativa em aproximações
     sucessivas for menor que 'rombergtol'.  Dessa forma quando
     'rombergabs' for 0.0 (o padrão) somente o erro relativo tem algum
     efeito sobre 'romberg'.

     Veja também 'rombergit' e 'rombergmin'.


File: maxima.info,  Node: simplex,  Next: simplification,  Prev: romberg,  Up: Top

68 simplex
**********

* Menu:

* Introdução a simplex::
* Funções e Variáveis Definidas para simplex::


File: maxima.info,  Node: Introdução a simplex,  Next: Funções e Variáveis Definidas para simplex,  Prev: simplex,  Up: simplex

68.1 Introdução a simplex
=========================

'simplex' é um pacote para otimização linear usando o algorítmo simplex.

   Exemplo:

     (%i1) load("simplex")$
     (%i2) minimize_sx(x+y, [3*x+2*y>2, x+4*y>3]);
                       9        7       1
     (%o2)            [--, [y = --, x = -]]
                       10       10      5


File: maxima.info,  Node: Funções e Variáveis Definidas para simplex,  Prev: Introdução a simplex,  Up: simplex

68.2 Funções e Variáveis Definidas para simplex
===============================================

 -- Variável de opção: epsilon_sx
     Valor padrão: '10^-8'

     Epsilon usando para cálculos numéricos em 'linear_program'.

     Veja também: 'linear_program'.

 -- Função: linear_program (<A>, <b>, <c>)

     'linear_program' é uma implementação do algorítmo simplex.
     'linear_program(A, b, c)' calcula um vetor <x> para o qual 'c.x' é
     o mínimo possível entre vetores para os quais 'A.x = b' e 'x >= 0'.
     O argumento <A> é uma matriz e os argumentos <b> e <c> são listas.

     'linear_program' retorna uma lista contendo o vetor minimizado <x>
     e o valor mínimo 'c.x'.  Se o problema for não associado, é
     retornado "Problem not bounded!"  e se o problema for não viável, é
     retornado "Problem not feasible!".

     Para usar essa função primeiramente chame o pacote 'simplex' com
     'load(simplex);'.

     Exemplo:

          (%i2) A: matrix([1,1,-1,0], [2,-3,0,-1], [4,-5,0,0])$
          (%i3) b: [1,1,6]$
          (%i4) c: [1,-2,0,0]$
          (%i5) linear_program(A, b, c);
                             13     19        3
          (%o5)            [[--, 4, --, 0], - -]
                             2      2         2

     Veja também: 'minimize_sx', 'scale_sx', e 'epsilon_sx'.

 -- Função: maximize_sx (<obj>, <cond>, [<pos>])

     Maximiza a função linear objetiva <obj> submetida a alguma
     restrição linear <cond>.  Veja 'minimize_sx' para uma descrição
     detalhada de argumentos e valores de retorno.

     Veja também: 'minimize_sx'.

 -- Função: minimize_sx (<obj>, <cond>, [<pos>])

     Minimiza uma função linear objetiva <obj> submetida a alguma
     restrição linear <cond>.  <cond> é uma lista de equações lineares
     ou desigualdades.  Em desigualdades estritas '>' é substituido por
     '>=' e '<' por '<='.  O argumento opcional <pos> é uma lista de
     variáveis de decisão que são assumidas como sendo positivas.

     Se o mínimo existir, 'minimize_sx' retorna uma lista que contém o
     menor valor da função objetiva e uma lista de valores de variáveis
     de decisão para os quais o mínimo é alcançado.  Se o problema for
     não associado, 'minimize_sx' retorna "Problem not bounded!"  e se o
     problema for não viável, é retornado "Ploblem not feasible!".

     As variáveis de decisão não são assumidas para serem não negativas
     por padrão.  Se todas as variáveis de dicisão forem não negativas,
     escolha 'nonegative_sx' para 'true'.  Se somente algumas das
     variáveis de decisão forem positivas, coloque-as então no argumento
     opcional <pos> (note que isso é mais eficiente que adicionar
     restrições).

     'minimize_sx' utiliza o algorítmo simplex que é implementado na
     função 'linear_program' do Maxima.

     Para usar essa função primeiramente chame o pacote 'simplex' com
     'load(simplex);'.

     Exemplos:

          (%i1) minimize_sx(x+y, [3*x+y=0, x+2*y>2]);
                                4       6        2
          (%o1)                [-, [y = -, x = - -]]
                                5       5        5
          (%i2) minimize_sx(x+y, [3*x+y>0, x+2*y>2]), nonegative_sx=true;
          (%o2)                [1, [y = 1, x = 0]]
          (%i3) minimize_sx(x+y, [3*x+y=0, x+2*y>2]), nonegative_sx=true;
          (%o3)                Problem not feasible!
          (%i4) minimize_sx(x+y, [3*x+y>0]);
          (%o4)                Problem not bounded!

     Veja também: 'maximize_sx', 'nonegative_sx', 'epsilon_sx'.

 -- Variável de opção: nonegative_sx
     Valor padrão: 'false'

     Se 'nonegative_sx' for verdadeiro (true) todas as variáveis de
     decisão para 'minimize_sx' e 'maximize_sx' são assumidas para serem
     positivas.

     Veja também: 'minimize_sx'.


File: maxima.info,  Node: simplification,  Next: solve_rec,  Prev: simplex,  Up: Top

69 simplification
*****************

* Menu:

* Introdução a simplification::
* Funções e Variáveis Definidas para simplification::


File: maxima.info,  Node: Introdução a simplification,  Next: Funções e Variáveis Definidas para simplification,  Prev: simplification,  Up: simplification

69.1 Introdução a simplification
================================

O diretó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.


File: maxima.info,  Node: Funções e Variáveis Definidas para simplification,  Prev: Introdução a simplification,  Up: simplification

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

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.

69.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
     usuário, 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, 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 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> objetos 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> objetos selecionados de um
     conjunto de <n> objetos.

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

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

   Faça 'disprule (all)' para ver uma lista completa das definiçõ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 informaçã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 comparação em decisões, e não para o propósito de
avaliação de 'X'.

   O usuário 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 você pode desejar remover
essas regras após fazer uso delas.  Faça '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 definição da segunda
regra multiplicativa.

69.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'.
     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 seçõ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 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 função disponível para uso.  'demo
     (rducon)' faz uma demonstração dessa função.

69.2.6 Pacote scifac
--------------------

 -- Função: gcfac (<expr>)
     'gcfac' função de fatoração que tenta aplicar a mesma heurística
     que cientístas aplicam em tentativas de fazer expressões
     extremamente simples.  'gcfac' está limitada a fatoraçõ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 fatoraçõ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 fatoraçã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 fatoração de um par.

     'load (scifac)' torna essa função disponível para uso.  'demo
     (scifac)' faz uma demonstração dessa função.

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


File: maxima.info,  Node: solve_rec,  Next: stats,  Prev: simplification,  Up: Top

70 solve_rec
************

* Menu:

* Introdução a solve_rec::
* Funções e Variáveis Definidas para solve_rec::


File: maxima.info,  Node: Introdução a solve_rec,  Next: Funções e Variáveis Definidas para solve_rec,  Prev: solve_rec,  Up: solve_rec

70.1 Introdução a solve_rec
===========================

'solve_rec' é um pacote para resolver recorrências lineares com
coeficientes polinomiais.

   Um arquivo de domostração está disponivel com 'demo(solve_rec);'.

   Exemplo:

     (%i1) load("solve_rec")$
     (%i2) solve_rec((n+4)*s[n+2] + s[n+1] - (n+1)*s[n], s[n]);
                                         n
                      %k  (2 n + 3) (- 1)          %k
                        1                            2
     (%o2)       s  = -------------------- + ---------------
                  n     (n + 1) (n + 2)      (n + 1) (n + 2)


File: maxima.info,  Node: Funções e Variáveis Definidas para solve_rec,  Prev: Introdução a solve_rec,  Up: solve_rec

70.2 Funções e Variáveis Definidas para solve_rec
=================================================

 -- Função: reduce_order (<rec>, <sol>, <var>)

     Reduz a ordem de recorrência linear <rec> quando uma solução
     particular <sol> for conhecida.  A recorrência reduzida pode ser
     usada para pegar outras soluções.

     Exemplo:

          (%i3) rec: x[n+2] = x[n+1] + x[n]/n;
                                                x
                                                 n
          (%o3)               x      = x      + --
                               n + 2    n + 1   n
          (%i4) solve_rec(rec, x[n]);
          WARNING: found some hypergeometrical solutions!
          (%o4)                    x  = %k  n
                                    n     1
          (%i5) reduce_order(rec, n, x[n]);
          (%t5)                    x  = n %z
                                    n       n

                                     n - 1
                                     ====
                                     \
          (%t6)                %z  =  >     %u
                                 n   /        %j
                                     ====
                                     %j = 0

          (%o6)             (- n - 2) %u     - %u
                                        n + 1     n
          (%i6) solve_rec((n+2)*%u[n+1] + %u[n], %u[n]);
                                               n
                                      %k  (- 1)
                                        1
          (%o6)                 %u  = ----------
                                  n    (n + 1)!

          So the general solution is

                       n - 1
                       ====        n
                       \      (- 1)
                 %k  n  >    -------- + %k  n
                   2   /     (n + 1)!     1
                       ====
                       n = 0

 -- Variável de opção: simplify_products
     Valor padrão: 'true'

     Se 'simplify_products' for 'true', 'solve_rec' irá tentar
     simplificar produtos no resultado.

     Veja também: 'solve_rec'.

 -- Função: simplify_sum (<expr>)

     Tenta simplificar todos os somatórios que aparecem na <expr> para
     uma forma a mais simplificada possível.

     'simplify_sum' usa os algorítmos de Gosper e de Zeilberger para
     simplificar somatórios.

     Para usar essa função primeiramente chame o pacote 'simplify_sum'
     com 'load(simplify_sum)'.

     Exemplo:

          (%i1) load("simplify_sum")$
          (%i2) sum(binom(n+k,k)/2^k, k, 0, n) + sum(binom(2*n, 2*k), k, 0, n);
                   n                            n
                  ====                         ====
                  \      binomial(n + k, k)    \
          (%o2)    >     ------------------ +   >    binomial(2 n, 2 k)
                  /               k            /
                  ====           2             ====
                  k = 0                        k = 0
          (%i3) simplify_sum(%);
                                         n
                                        4     n
          (%o3)                         -- + 2
                                        2

 -- Função: solve_rec (<eqn>, <var>, [<init>])
     Encontra soluções hipergeométricas para a recorrência linear <eqn>
     com coeficientes polinomiais na variável <var>.  Argumentos
     opcionais <init> são as condições iniciais.

     'solve_rec' pode resolver recorrências lineares com coeficientes
     constantes, encontrando soluções hipergeométricas para recorrências
     lineares homogêneas com coeficientes polinomiais, soluções
     racionais para recorrências lineares com coeficientes polinomiais e
     pode resolver recorrências do tipo de Ricatti.

     Note que o tempo de execução do algorítmo usado para encontrar
     soluções hipergeométricas aumenta exponencialmente com o grau do
     coeficiente lider e guia.

     Para usar essa função primeiramente chame o pacote 'solve_rec' com
     'load(solve_rec);'.

     Exemplo de recorrência linear com coeficientes constantes:

          (%i2) solve_rec(a[n]=a[n-1]+a[n-2]+n/2^n, a[n]);
                                  n          n
                     (sqrt(5) - 1)  %k  (- 1)
                                      1           n
          (%o2) a  = ------------------------- - ----
                 n               n                  n
                                2                5 2
                                                          n
                                             (sqrt(5) + 1)  %k
                                                              2    2
                                           + ------------------ - ----
                                                      n              n
                                                     2            5 2

     Exemplo de recorrência linear com coeficientes polinomiais:

          (%i7) 2*x*(x+1)*y[x] - (x^2+3*x-2)*y[x+1] + (x-1)*y[x+2];
                                   2
          (%o7) (x - 1) y      - (x  + 3 x - 2) y      + 2 x (x + 1) y
                         x + 2                   x + 1                x
          (%i8) solve_rec(%, y[x], y[1]=1, y[3]=3);
                                        x
                                     3 2    x!
          (%o9)                 y  = ---- - --
                                 x    4     2

     Exemplo de recorrência do tipo de Ricatti:

          (%i2) x*y[x+1]*y[x] - y[x+1]/(x+2) + y[x]/(x-1) = 0;
                                      y         y
                                       x + 1     x
          (%o2)         x y  y      - ------ + ----- = 0
                           x  x + 1   x + 2    x - 1
          (%i3) solve_rec(%, y[x], y[3]=5)$
          (%i4) ratsimp(minfactorial(factcomb(%)));
                                             3
                                         30 x  - 30 x
          (%o4) y  = - -------------------------------------------------
                 x        6      5       4       3       2
                       5 x  - 3 x  - 25 x  + 15 x  + 20 x  - 12 x - 1584

     Veja também: 'solve_rec_rat', 'simplify_products', e
     'product_use_gamma'.

 -- Função: solve_rec_rat (<eqn>, <var>, [<init>])

     Encontra soluções racionais para recorrências lineares.  Veja
     solve_rec para uma descrição dos argumentos.

     Para usar essa função primeirametne chame o pacote 'solve_rec' com
     'load(solve_rec);'.

     Exemplo:

          (%i1) (x+4)*a[x+3] + (x+3)*a[x+2] - x*a[x+1] + (x^2-1)*a[x];
          (%o1)  (x + 4) a      + (x + 3) a      - x a
                          x + 3            x + 2      x + 1
                                                             2
                                                         + (x  - 1) a
                                                                      x
          (%i2) solve_rec_rat(% = (x+2)/(x+1), a[x]);
                                 1
          (%o2)      a  = ---------------
                      x   (x - 1) (x + 1)

     Veja também: 'solve_rec'.

 -- Variável de opção: product_use_gamma
     Valor padrão: 'true'

     Quando simplificando produtos, 'solve_rec' introduz a função gama
     dentro da expressão se 'product_use_gamma' for 'true'.

     Veja também: 'simplify_products', 'solve_rec'.

 -- Função: summand_to_rec (<summand>, <k>, <n>)
 -- Função: summand_to_rec (<summand>, [<k>, <lo>, <hi>], <n>)

     Retorna a recorrência satisfeita pelo somatório

               sup
              ====
              \
               >     x
              /
              ====
            k = inf

     onde x é hipergeométrico em <k> e <n>.  SE <inf> e <sup> forem
     omitidos, são assumidos como sendo 'inf = -inf' e 'sup = inf'.

     Para usar essa função primeiro chame o pacote 'simplify_sum' com
     'load(simplify_sum)'.

     Exemplo:

          (%i1) load("simplify_sum")$
          (%i2) summand: binom(n,k);
          (%o2)                           binomial(n, k)
          (%i3) summand_to_rec(summand,k,n);
          (%o3)                      2 sm  - sm      = 0
                                         n     n + 1
          (%i7) summand: binom(n, k)/(k+1);
                                          binomial(n, k)
          (%o7)                           --------------
                                              k + 1
          (%i8) summand_to_rec(summand, [k, 0, n], n);
          (%o8)               2 (n + 1) sm  - (n + 2) sm      = - 1
                                          n             n + 1


File: maxima.info,  Node: stats,  Next: stirling,  Prev: solve_rec,  Up: Top

71 stats
********

* Menu:

* Introdução a stats::
* Funções e Variáveis Definidas para inference_result::
* Funções e Variáveis Definidas para stats::
* Funções e Variáveis Definidas para distribuições especiais::


File: maxima.info,  Node: Introdução a stats,  Next: Funções e Variáveis Definidas para inference_result,  Prev: Top,  Up: Top

71.1 Introdução a stats
=======================

O pacote 'stats' contém um conjunto de procedimentos de inferência
clássica estatística e procedimentos de teste.

   Todas essas funções retornam um objeto do Maxima chamado
'inference_result' que contém os resultados necessários para inferências
de manipulação e tomada de decisões.

   A variável global 'stats_numer' controla se resultados são mostrados
em ponto flutuante ou simbólico e no formato racional; seu valor padrão
é 'true' e os resultados são retornados no formato de ponto flutuante.

   O pacote 'descriptive' contém alguns utilitários para manipular
estruturas de dados (listas e matrizes); por exemplo, para extrair
subamostras.  O pacote 'descriptive' também contém alguns exemplos sobre
como usar o pacote 'numericalio' para ler dados a partir de arquivo no
formato texto plano.  Veja 'descriptive' e 'numericalio' para maiores
detalhes.

   O pacote 'stats' precisa dos pacotes 'descriptive', 'distrib' e
'inference_result'.

   Para comentários, erros ou sugestões, por favor contate o autor em

   <'mario AT edu DOT xunta DOT es'>.


File: maxima.info,  Node: Funções e Variáveis Definidas para inference_result,  Next: Funções e Variáveis Definidas para stats,  Prev: Introdução a stats,  Up: Top

71.2 Funções e Variáveis Definidas para inference_result
========================================================

 -- Função: inference_result (<título>, <valores>, <números>)

     Constrói um objeto 'inference_result' do tipo retornado pelas
     funções stats.  O argumento <título> é uma seqüência de caracteres
     do Maxima co o nome do procedimento; <valores> é uma lissta com
     elementos da forma 'símbolo = valor' e <números> é uma lista com
     números inteiros positivos no intervalo de um para
     'length(<valores>)', indicando que valores serão mostrados por
     padrão.

     Exemplo:

     Este é um exemplo que mostras os resultados associados a um
     retángulo.  O título deste objeto é a seqüência de caraceteres
     '"Retângulo"', o qual armazena cinco resultados, a saber ''base',
     ''altura', ''diagonal', ''área', e ''perímetro', porém só mostra o
     primeiro, segundo, quinto e quarto resultado.  O resultado
     ''diagonal' também é armazenado neste objeto, no entanto não é
     mostrado por padrão; para se ter acesso a este valor, faz-se uso da
     função 'take_inference'.

          (%i1) load(inference_result)$
          (%i2) b: 3$ h: 2$
          (%i3) inference_result("Retângulo",
                                  ['base=b,
                                   'altura=h,
                                   'diagonal=sqrt(b^2+h^2),
                                   'área=b*h,
                                   'perímetro=2*(b+h)],
                                  [1,2,5,4] );
                                  |   Retângulo
                                  |
                                  |    base = 3
                                  |
          (%o3)                   |   altura = 2
                                  |
                                  | perímetro = 10
                                  |
                                  |    area = 6
          (%i4) take_inference('diagonal,%);
          (%o4)                        sqrt(13)

     Veja também 'take_inference'.

 -- Função: inferencep (<obj>)

     Retorna 'true' ou 'false', dependendo se <obj> é um objeto
     'inference_result' ou não.

 -- Função: items_inference (<obj>)

     Retorna uma lista com os nomes dos itens em <obj>, que devem ser um
     objeto 'inference_result'.

     Exemplo:

     O objeto 'inference_result' armazena dois valores, a saber ''pi' e
     ''e', mas somente o segundo é mostrado.  A função 'items_inference'
     retorna os nomes de todos os itens, não importa se eles são ou não
     mostrados.

          (%i1) load(inference_result)$
          (%i2) inference_result("Hi", ['pi=%pi,'e=%e],[2]);
                                      |   Hi
          (%o2)                       |
                                      | e = %e
          (%i3) items_inference(%);
          (%o3)                        [pi, e]

 -- Função: take_inference (<n>, <obj>)
 -- Função: take_inference (<nome>, <obj>)
 -- Função: take_inference (<lista>, <obj>)

     Retorna o <n>-ésimo valor armazenado em <obj> se <n> for um inteiro
     positivo, ou o item chamado <nome> se esse for o nome de um item.
     Se o primeiro argumento for uma lista de números e/ou símbolos, a
     função 'take_inference' retorna uma lista com os resultados
     correspondentes.

     Exemplo:

     Fornece um objeto 'inference_result', a função 'take_inference' é
     chamada com o objetivo de extrair alguma informação armazenada
     nesse objeto.

          (%i1) load(inference_result)$
          (%i2) b: 3$ h: 2$
          (%i3) sol: inference_result("Retângulo",
                                      ['base=b,
                                       'altura=h,
                                       'diagonal=sqrt(b^2+h^2),
                                       'area=b*h,
                                       'perímetro=2*(b+h)],
                                      [1,2,5,4] );
                                  |   Retângulo
                                  |
                                  |    base = 3
                                  |
          (%o3)                   |   altura = 2
                                  |
                                  | perímetro = 10
                                  |
                                  |    area = 6
          (%i4) take_inference('base,sol);
          (%o4)                           3
          (%i5) take_inference(5,sol);
          (%o5)                          10
          (%i6) take_inference([1,'diagonal],sol);
          (%o6)                     [3, sqrt(13)]
          (%i7) take_inference(items_inference(sol),sol);
          (%o7)                [3, 2, sqrt(13), 6, 10]

     Veja também 'inference_result' e 'take_inference'.


File: maxima.info,  Node: Funções e Variáveis Definidas para stats,  Next: Funções e Variáveis Definidas para distribuições especiais,  Prev: Funções e Variáveis Definidas para inference_result,  Up: Top

71.3 Funções e Variáveis Definidas para stats
=============================================

 -- Variável de opção: stats_numer
     Valor padrão: 'true'

     Se 'stats_numer' for 'true', funções de inferência estatística
     retornam seus resultados em números com ponto flutuante.  Se
     'stats_numer' for 'false', resultados são fornecidos em formato
     simbólico e racional.

 -- Função: test_mean (<x>)
 -- Função: test_mean (<x>, <opção_1>, <opção_2>, ...)

     Esse é o teste-<t> de média.  O argumento <x> é uma lista ou uma
     matriz coluna contendo uma amostra unidimensional.  'test_mean'
     tamb;em executa um teste assintótico baseado no Teorema do Limite
     Central se a opção ''asymptotic' for 'true'.

     Opções:

        * ''mean', o valor padrão é '0', é o valor da média a ser
          verificado.

        * ''alternative', o valor padrão é ''twosided', é a hipótese
          alternativa; valores válidos são: ''twosided', ''greater' e
          ''less'.

        * ''dev', o valor padrão é ''unknown', corresponde ao valor do
          desvio padrão quando esse valor de desvio padrão for
          conhecido; valores válidos são: ''unknown' ou uma expressão
          positiva.

        * ''conflevel', o valor padrão é '95/100', nível de confidência
          para o intervalo de confidência; deve ser uma expressão que
          toma um valor em (0,1).

        * ''asymptotic', o valor padrão é 'false', indica se 'test_mean'
          exeecuta um teste-<t> exato ou um teste assintótico
          baseando-se no Teorema do Limite Central; valores válidos são
          'true' e 'false'.

     A saída da função 'test_mean' é um objeto 'inference_result' do
     Maxima mostrando os seguintes resultados:

       1. ''mean_estimate': a média da amostra.

       2. ''conf_level': nível de confidência selecionado pelo usuário.

       3. ''conf_interval': intervalo de confidência para a média da
          população.

       4. ''method': procedimento de inferência.

       5. ''hypotheses': hipótese do nulo e hipótese alternativa a ser
          testada.

       6. ''statistic': valor da amostra estatística a ser usado para
          testar a hipótese do nulo.

       7. ''distribution': distribuição da amostra estatística,
          juntamente com seus parâmetro(s).

       8. ''p_value': valores de p do teste.

     Exemplos:

     Executa um teste-<t> exato com variância desconhecida.  A hipótese
     do nulo é H_0: mean=50 contra a alternativa unilatera H_1: mean<50;
     conforme os resultados, o valor de p é muito grande, não existem
     evidências paa rejeitar H_0.

          (%i1) load("stats")$
          (%i2) data: [78,64,35,45,45,75,43,74,42,42]$
          (%i3) test_mean(data,'conflevel=0.9,'alternative='less,'mean=50);
                    |                 MEAN TEST
                    |
                    |            mean_estimate = 54.3
                    |
                    |              conf_level = 0.9
                    |
                    | conf_interval = [minf, 61.51314273502712]
                    |
          (%o3)     |  method = Exact t-test. Unknown variance.
                    |
                    | hypotheses = H0: mean = 50 , H1: mean < 50
                    |
                    |       statistic = .8244705235071678
                    |
                    |       distribution = [student_t, 9]
                    |
                    |        p_value = .7845100411786889

     Nesta ocasião Maxima executa um testte assintótico, baseado no
     Teorema do Limite Central.  A hipótese do nulo é H_0: equal(mean,
     50) contra a alternativa de duas vias H_1: not equal(mean, 50);
     conforme os resultados, o valor de p é muito pequeno, H_0 pode ser
     rejeitado em favor da alternativa H_1.  Note que, como indicado
     pela componente 'Method', esse procedimento pode ser aplicado a
     grandes amostras.

          (%i1) load("stats")$
          (%i2) test_mean([36,118,52,87,35,256,56,178,57,57,89,34,25,98,35,
                        98,41,45,198,54,79,63,35,45,44,75,42,75,45,45,
                        45,51,123,54,151],
                        'asymptotic=true,'mean=50);
                    |                       MEAN TEST
                    |
                    |           mean_estimate = 74.88571428571429
                    |
                    |                   conf_level = 0.95
                    |
                    | conf_interval = [57.72848600856194, 92.04294256286663]
                    |
          (%o2)     |    method = Large sample z-test. Unknown variance.
                    |
                    |       hypotheses = H0: mean = 50 , H1: mean # 50
                    |
                    |             statistic = 2.842831192874313
                    |
                    |             distribution = [normal, 0, 1]
                    |
                    |             p_value = .004471474652002261

 -- Função: test_means_difference (<x1>, <x2>)
 -- Função: test_means_difference (<x1>, <x2>, <opção_1>, <opção_2>,
          ...)

     Esse é o teste-<t> de diferença de médias entre duas amostras.  Os
     argumentos <x1> e <x2> são listas ou matrizes colunas contendo duas
     amostras independentes.  No caso de diferentes variâncias
     desconhecidas (veja opções ''dev1', ''dev2' e ''varequal' abaixo),
     os graus de liberdade são calculados por meio da aproximação de
     Welch.  'test_means_difference' também executa um teste assintótico
     baseado no Teorema do Limite Central se a opção ''asymptotic' for
     escolhida para 'true'.

     Opções:

        * 
        * ''alternative', o valor padrão é ''twosided', é a hipótese
          alternativa; valores válidos são: ''twosided', ''greater' e
          ''less'.

        * ''dev1', o valor padrão é ''unknown', é o valor do desvio
          padrão da amostra <x1> quando esse desvio for conhecido;
          valores válidos são: ''unknown' ou uma expressão positiva.

        * ''dev2', o valor padrão é ''unknown', é o valor do desvio
          padrão da amostra <x2> quando esse desvio for conhecido;
          valores válidos são: ''unknown' ou uma expressão positiva.

        * ''varequal', o valor padrão é 'false', se variâncias podem
          serem consideradas como iguais ou não; essa opção tem efeito
          somente quando ''dev1' e/ou ''dev2' forem ''unknown'.

        * ''conflevel', o valor padrão é '95/100', nível de confidência
          para o intervalo de confidência; deve ser uma expressão que
          toma valores em (0,1).

          Nota de Tradução: (0,1) representa intervalo aberto.

        * ''asymptotic', o valor padrão é 'false', indica se
          'test_means_difference' executa um teste-<t> exato ou um teste
          assíntótico baseando-se no Teorema do Limite Central; valores
          válidos são 'true' e 'false'.

     A saída da função 'test_means_difference' é um objeto
     'inference_result' do Maxima mostrando os seguintes resultados:

       1. ''diff_estimate': a diferença de médias estimadas.

       2. ''conf_level': nível de confidência selecionado pelo usuário.

       3. ''conf_interval': intervalo de confidência para a diferença de
          médias.

       4. ''method': procedimento de inferência.

       5. ''hypotheses': a hipótese do nulo e a hipótese alternativa a
          serem testadas.

       6. ''statistic': valor da amostra estatística usado para testar a
          hipótese do nulo.

       7. ''distribution': distribuição da amostra estatística,
          juntamente com seu(s) parâmetro(s).

       8. ''p_value': valor de p do teste.

     Exemplos:

     A igualdade de médias é testada com duas pequenas amostras <x> e
     <y>, contra a alternativa H_1: m_1>m_2, sendo m_1 e m_2 as médias
     das populações; variâncias são desconhecidas e supostamente
     admitidas para serem diferentes.

          (%i1) load("stats")$
          (%i2) x: [20.4,62.5,61.3,44.2,11.1,23.7]$
          (%i3) y: [1.2,6.9,38.7,20.4,17.2]$
          (%i4) test_means_difference(x,y,'alternative='greater);
                      |              DIFFERENCE OF MEANS TEST
                      |
                      |         diff_estimate = 20.31999999999999
                      |
                      |                 conf_level = 0.95
                      |
                      |    conf_interval = [- .04597417812882298, inf]
                      |
          (%o4)       |        method = Exact t-test. Welch approx.
                      |
                      | hypotheses = H0: mean1 = mean2 , H1: mean1 > mean2
                      |
                      |           statistic = 1.838004300728477
                      |
                      |    distribution = [student_t, 8.62758740184604]
                      |
                      |            p_value = .05032746527991905

     O mesmo teste que antes, mas agora as variâncias são admitidas
     serem supostamente iguais.

          (%i1) load("stats")$
          (%i2) x: [20.4,62.5,61.3,44.2,11.1,23.7]$
          (%i3) y: matrix([1.2],[6.9],[38.7],[20.4],[17.2])$
          (%i4) test_means_difference(x,y,'alternative='greater,'varequal=true);
                      |              DIFFERENCE OF MEANS TEST
                      |
                      |         diff_estimate = 20.31999999999999
                      |
                      |                 conf_level = 0.95
                      |
                      |     conf_interval = [- .7722627696897568, inf]
                      |
          (%o4)       |   method = Exact t-test. Unknown equal variances
                      |
                      | hypotheses = H0: mean1 = mean2 , H1: mean1 > mean2
                      |
                      |           statistic = 1.765996124515009
                      |
                      |           distribution = [student_t, 9]
                      |
                      |            p_value = .05560320992529344

 -- Função: test_variance (<x>)
 -- Função: test_variance (<x>, <opção_1>, <opção_2>, ...)

     Esse é o teste da variância <chi^2>.  O argumento <x> é uma lista
     ou uma matriz coluna contendo uma amostra unidimensional tomada
     entre a população normal.

     Opções:

        * ''mean', o valor padrão é ''unknown', é a média da população,
          quando for conhecida.

        * ''alternative', o valor padrão é ''twosided', é a hipótese
          alternativa; valores válidos são: ''twosided', ''greater' e
          ''less'.

        * ''variance', o valor padrão é '1', isso é o valor (positivo)
          da variância a ser testado.

        * ''conflevel', o valor padrão é '95/100', nível de confidência
          para o intervalo de confidência; deve ser uma expressão que
          toma valores em (0,1).

     A saída da função 'test_variance' está no objeto 'inference_result'
     do Maxima mostrando os seguintes resultados:

       1. ''var_estimate': a variância da amostra.

       2. ''conf_level': nível de confidência selecionado pelo usuário.

       3. ''conf_interval': intervalo de confidência para a variância da
          população.

       4. ''method': procedimento de inferência.

       5. ''hypotheses': a hipótese do nulo e a hipótese alternativa a
          serem testadas.

       6. ''statistic': valor da amostra estatística usado para testar a
          hipótese do nulo.

       7. ''distribution': distribuição da amostra estatística,
          juntamente com seu parâmetro.

       8. ''p_value': o valor de p do teste.

     Exemplos:

     Isso é testado se a variância de uma população com média
     desconhhecida for igual ou maior que 200.

          (%i1) load("stats")$
          (%i2) x: [203,229,215,220,223,233,208,228,209]$
          (%i3) test_variance(x,'alternative='greater,'variance=200);
                       |                  VARIANCE TEST
                       |
                       |              var_estimate = 110.75
                       |
                       |                conf_level = 0.95
                       |
                       |     conf_interval = [57.13433376937479, inf]
                       |
          (%o3)        | method = Variance Chi-square test. Unknown mean.
                       |
                       |    hypotheses = H0: var = 200 , H1: var > 200
                       |
                       |                 statistic = 4.43
                       |
                       |             distribution = [chi2, 8]
                       |
                       |           p_value = .8163948512777689

 -- Função: test_variance_ratio (<x1>, <x2>)
 -- Função: test_variance_ratio (<x1>, <x2>, <opção_1>, <opção_2>, ...)

     Isso é o teste <F> da razão de variância para duas populações
     normais.  Os argumentos <x1> e <x2> são listas ou matrizes colunas
     contendo duas amostras independentes.

     Opções:

        * ''alternative', o valor padrão é ''twosided', é a hipótese
          alternativa; valores válidos são: ''twosided', ''greater' e
          ''less'.

        * ''mean1', o valor padrão é ''unknown', quando for conhecida,
          isso é a média da população da qual <x1> foi tomada.

        * ''mean2', o valor padrão é ''unknown', quando for conhecida,
          isso é a média da população da qual <x2> foi tomada.

        * ''conflevel', o valor padrão é '95/100', nível de confidência
          para o intervalo de confidência da razão; deve ser uma
          expressão que tome valores em (0,1).

     A saída da função 'test_variance_ratio' é um objeto
     'inference_result' do Maxima mostrando os seguintes resultados:

       1. ''ratio_estimate': a razão de variância da amostra.

       2. ''conf_level': nível de confidência selecionado pelo usuário.

       3. ''conf_interval': intervalo de confidência para a razão de
          variância.

       4. ''method': procedimento de inferência.

       5. ''hypotheses': a hipótese do nulo e a hipótese alternativa a
          serem testadas.

       6. ''statistic': valor da amostra estatística usado para testar a
          hipótese do nulo.

       7. ''distribution': distribuição da amostra estatística,
          juntamente com seus parâmetros.

       8. ''p_value': o valor de p do teste.

     Exemplos:

     a igualdade das variâncias de duas populações normais é verificado
     contra a alternativa que a primeira é maior que a segunda.

          (%i1) load("stats")$
          (%i2) x: [20.4,62.5,61.3,44.2,11.1,23.7]$
          (%i3) y: [1.2,6.9,38.7,20.4,17.2]$
          (%i4) test_variance_ratio(x,y,'alternative='greater);
                        |              VARIANCE RATIO TEST
                        |
                        |       ratio_estimate = 2.316933391522034
                        |
                        |               conf_level = 0.95
                        |
                        |    conf_interval = [.3703504689507268, inf]
                        |
          (%o4)         | method = Variance ratio F-test. Unknown means.
                        |
                        | hypotheses = H0: var1 = var2 , H1: var1 > var2
                        |
                        |         statistic = 2.316933391522034
                        |
                        |            distribution = [f, 5, 4]
                        |
                        |          p_value = .2179269692254457

 -- Função: test_sign (<x>)
 -- Função: test_sign (<x>, <opção_1>, <opção_2>, ...)

     Esse é o teste de sinal não paramétrico para a mediana de uma
     população contínua.  O argumento <x> é uma lista ou uma matriz
     coluna contendo uma amostra unidimensional.

     Opções:

        * ''alternative', o valor padrão é ''twosided', é a hipótese
          alternativa; valores válidos são: ''twosided', ''greater' e
          ''less'.

        * ''median', o valor padrão é '0', é o valor da mediana a ser
          verificado.

     A saída da função 'test_sign' é um objeto 'inference_result' do
     Maxima mostrando os seguintes resultados:

       1. ''med_estimate': a mediana da amostra.

       2. ''method': procedimento de inferência.

       3. ''hypotheses': a hipótese do nulo e a hipótese alternativa a
          serem testadas.

       4. ''statistic': valor da amostra estatística usada para testar a
          hipótese do nulo.

       5. ''distribution': distribuição da amostra estatística,
          juntamente com seu(s) parâmetro(s).

       6. ''p_value': o valor de p do teste.

     Exemplos:

     Verifica se a população da qual a amostra foi tomada tem mediana 6,
     contra a alternativa H_1: median > 6.

          (%i1) load("stats")$
          (%i2) x: [2,0.1,7,1.8,4,2.3,5.6,7.4,5.1,6.1,6]$
          (%i3) test_sign(x,'median=6,'alternative='greater);
                         |                  SIGN TEST
                         |
                         |              med_estimate = 5.1
                         |
                         |      method = Non parametric sign test.
                         |
          (%o3)          | hypotheses = H0: median = 6 , H1: median > 6
                         |
                         |                statistic = 7
                         |
                         |      distribution = [binomial, 10, 0.5]
                         |
                         |         p_value = .05468749999999989

 -- Função: test_signed_rank (<x>)
 -- Função: test_signed_rank (<x>, <opção_1>, <opção_2>, ...)

     Esse é o teste de ranque sinalizado de Wilcoxon para fazer
     inferências sobre a mediana de uma população contínua.  O argumento
     <x> é uma lista ou uma matriz coluna contendo uma amostra
     unidimensional.  Executa uma aproximação normal se o tamanho da
     amostra for maior que 20, ou se existirem zeros ou houverem
     empates.

     Veja também 'pdf_rank_test' e 'cdf_rank_test'.

     Opções:

        * ''median', o valor padrão é '0', é o valor da mediana a ser
          verificado.

        * ''alternative', o valor padrão é ''twosided', é a hipótese
          alternativa; valores válidos são: ''twosided', ''greater' e
          ''less'.

     A saída da função 'test_signed_rank' é um objeto 'inference_result'
     do Maxima com os seguintes resultados:

       1. ''med_estimate': a mediana da amostra.

       2. ''method': procedimento de inferência.

       3. ''hypotheses': a hipótese do nulo e a hipótese alternativa a
          serem testadas.

       4. ''statistic': valor da amostra estatística usado para testar a
          hipótese do nulo.

       5. ''distribution': distribuição da amostra estatística,
          juntamente com seu(s) parâmetro(s).

       6. ''p_value': o valor de p do teste.

     Exemplos:

     Verifica a hipótese do nulo H_0: median = 15 contra a alternativa
     H_1: median > 15.  Esse é um teste exato, ua vez que não exite
     empates.

          (%i1) load("stats")$
          (%i2) x: [17.1,15.9,13.7,13.4,15.5,17.6]$
          (%i3) test_signed_rank(x,median=15,alternative=greater);
                           |             SIGNED RANK TEST
                           |
                           |           med_estimate = 15.7
                           |
                           |           method = Exact test
                           |
          (%o3)            | hypotheses = H0: med = 15 , H1: med > 15
                           |
                           |              statistic = 14
                           |
                           |     distribution = [signed_rank, 6]
                           |
                           |            p_value = 0.28125

     Verifica a hipótese do nulo H_0: equal(median, 2.5) contra a
     alternativa H_1: not equal(median, 2.5).  Esse é um teste
     aproximado, uma vez que ocorrem empates.

          (%i1) load("stats")$
          (%i2) y:[1.9,2.3,2.6,1.9,1.6,3.3,4.2,4,2.4,2.9,1.5,3,2.9,4.2,3.1]$
          (%i3) test_signed_rank(y,median=2.5);
                       |                 SIGNED RANK TEST
                       |
                       |                med_estimate = 2.9
                       |
                       |          method = Asymptotic test. Ties
                       |
          (%o3)        |    hypotheses = H0: med = 2.5 , H1: med # 2.5
                       |
                       |                 statistic = 76.5
                       |
                       | distribution = [normal, 60.5, 17.58195097251724]
                       |
                       |           p_value = .3628097734643669

 -- Função: test_rank_sum (<x1>, <x2>)
 -- Função: test_rank_sum (<x1>, <x2>, <opção_1>)

     Esse é o teste de Wilcoxon-Mann-Whitney para comparação das
     medianas de duas populações contínuas.  Os primeiros dois
     argumentos <x1> e <x2> são listas ou matrizes colunas com os dados
     de duas amostras independentes.  Executa aproximação normal se
     quaisquer dos tamanhos de amostra for maior que 10, ou se houverem
     empates.

     Opção:

        * ''alternative', o valor padrão é ''twosided', é a hipótese
          alternativa; valores válidos são: ''twosided', ''greater' e
          ''less'.

     A saída da função 'test_rank_sum' é um objeto 'inference_result' do
     Maxima com os seguintes resultados:

       1. ''method': procedimento de inferência.

       2. ''hypotheses': a hipótese do nulo e a hipótese alternativa a
          serem testadas.

       3. ''statistic': valor da amostra estatística usada para testar a
          hipótese do nulo.

       4. ''distribution': distribuição da amostra estatística,
          juntamente com seus parâmetros.

       5. ''p_value': o valor de p do teste.

     Exemplos:

     Verifica se populações possuem medianas similares.  Tamanhos de
     amotra são pequenos e é feito um teste exato.

          (%i1) load("stats")$
          (%i2) x:[12,15,17,38,42,10,23,35,28]$
          (%i3) y:[21,18,25,14,52,65,40,43]$
          (%i4) test_rank_sum(x,y);
                        |                 RANK SUM TEST
                        |
                        |              method = Exact test
                        |
                        | hypotheses = H0: med1 = med2 , H1: med1 # med2
          (%o4)         |
                        |                 statistic = 22
                        |
                        |        distribution = [rank_sum, 9, 8]
                        |
                        |          p_value = .1995886466474702

     Agora, com grandes amostras e empates, o procedimento faz
     aproximação norma.  A hipótese alternativa é H_1: median1 <
     median2.

          (%i1) load("stats")$
          (%i2) x: [39,42,35,13,10,23,15,20,17,27]$
          (%i3) y: [20,52,66,19,41,32,44,25,14,39,43,35,19,56,27,15]$
          (%i4) test_rank_sum(x,y,'alternative='less);
                       |                  RANK SUM TEST
                       |
                       |          method = Asymptotic test. Ties
                       |
                       |  hypotheses = H0: med1 = med2 , H1: med1 < med2
          (%o4)        |
                       |                 statistic = 48.5
                       |
                       | distribution = [normal, 79.5, 18.95419580097078]
                       |
                       |           p_value = .05096985666598441

 -- Função: test_normality (<x>)

     Teste de Shapiro-Wilk para normalidade.  O argumento <x> é uma
     lista de números, e o tamanho da amostra deve ser maior que 2 e
     menor ou igua a 5000, de outra forma, a função 'test_normality'
     sinaliza com um erro.

     Referência:

     [1] Algorithm AS R94, Applied Statistics (1995), vol.44, no.4,
     547-551

     A saída da função 'test_normality' é um objeto 'inference_result'
     do Maxima com os seguintes resultados:

       1. ''statistic': valor do <W> estatístico.

       2. ''p_value': valor de p sob a hipótese de normalidade.

     Exemplos:

     Verifica a normalidade de uma população, baseada em uma amostra de
     tamanho 9.

          (%i1) load("stats")$
          (%i2) x:[12,15,17,38,42,10,23,35,28]$
          (%i3) test_normality(x);
                                 |      SHAPIRO - WILK TEST
                                 |
          (%o3)                  | statistic = .9251055695162436
                                 |
                                 |  p_value = .4361763918860381

 -- Função: simple_linear_regression (<x>)
 -- Função: simple_linear_regression (<x> <opção_1>)

     Regressão linear simples, y_i=a+b x_i+e_i, onde os e_i são
     N(0,sigma) variáveis aleatórias independentes.  O argumento <x>
     deve ser uma matriz de duas colunas ou uma lista de pares.

     Opções:

        * ''conflevel', o valor padrão é '95/100', nível de confidência
          para o intervalo de confidência; isso deve ser uma expressão
          que tome valores em (0,1).

        * ''regressor', o valor padrão é ''x', nome da variável
          independente.

     A saída da função 'simple_linear_regression' é um objeto
     'inference_result' do Maxima com os seguintes resultados:

       1. ''model': a equação ajustada.  Útil para fazer novas
          previsões.  Veja exemplos abaixo.

       2. ''means': média de duas variáveis pseudo-aleatórias.

       3. ''variances': variâncias de ambas as variáveis.

       4. ''correlation': coeficiente de correlação.

       5. ''adc': coeficiente de determinação ajustado.

       6. ''a_estimation': estimador do parâmetro <a>.

       7. ''a_conf_int': intervalo de confidência do parâmetro <a>.

       8. ''b_estimation': estimador do parâmetro <b>.

       9. ''b_conf_int': intervalo de confidência do parâmetro <b>.

       10. ''hypotheses': a hipótese do nulo e a hipótese alternativa
          sobre o parâmetro <b>.

       11. ''statistic': valor da amostra estatística usado para testar
          a hipótese do nulo.

       12. ''distribution': distribuição da amostra estatística,
          juntamente com seu parâmetro.

       13. ''p_value': o valor de p do teste sobre <b>.

       14. ''v_estimation': estimador de variância imparcial, ou
          variância residual.

       15. ''v_conf_int': intervalo de confidência da variância.

       16. ''cond_mean_conf_int': intervalo de confidência paa a média
          condicionada.  Veja exemplos abaixo.

       17. ''new_pred_conf_int': intervalo de confidência para uma nova
          previsão.  Veja exemplos abaixo.

       18. ''residuals': lista de pares (previsão, resíduo), ordenados
          em relação às previsões.  Útil para achar o melhor da análise
          de ajuste.  Veja exemplos abaixo.

     Somente os itens 1, 4, 14, 9, 10, 11, 12, e 13 acima, nessa ordem,
     são mostrados por padrão.  Os restantes escondem-se até que o
     usuário faça uso de funções 'items_inference' e 'take_inference'.

     Exemplo:

     Ajustando um modelo linear para uma amostras de duas variáveis.  A
     entrada '%i4' monta p gráfico da amostra junto com a linha de
     regressão; a entrada '%i5' calcula 'y' dado 'x=113'; a média e o
     intervalo de confidência para uma nova previsão quando 'x=113' são
     também calculados.

          (%i1) load("stats")$
          (%i2) s:[[125,140.7],[130,155.1],[135,160.3],[140,167.2],[145,169.8]]$
          (%i3) z:simple_linear_regression(s,conflevel=0.99);
                     |               SIMPLE LINEAR REGRESSION
                     |
                     |   model = 1.405999999999985 x - 31.18999999999804
                     |
                     |           correlation = .9611685255255155
                     |
                     |           v_estimation = 13.57966666666665
                     |
          (%o3)      | b_conf_int = [.04469633662525263, 2.767303663374718]
                     |
                     |          hypotheses = H0: b = 0 ,H1: b # 0
                     |
                     |            statistic = 6.032686683658114
                     |
                     |            distribution = [student_t, 3]
                     |
                     |             p_value = 0.0038059549413203
          (%i4) plot2d([[discrete, s], take_inference(model,z)],
                        [x,120,150],
                        [gnuplot_curve_styles, ["with points","with lines"]] )$
          (%i5) take_inference(model,z), x=133;
          (%o5)                         155.808
          (%i6) take_inference(means,z);
          (%o6)                     [135.0, 158.62]
          (%i7) take_inference(new_pred_conf_int,z), x=133;
          (%o7)              [132.0728595995113, 179.5431404004887]


File: maxima.info,  Node: Funções e Variáveis Definidas para distribuições especiais,  Prev: Funções e Variáveis Definidas para stats,  Up: Top

71.4 Funções e Variáveis Definidas para distribuições especiais
===============================================================

 -- Função: pdf_signed_rank (<x>, <n>)
     Função densidade de probabilidade da distribuição exata da
     estatística do rank sinalizado.  O argumento <x> é um número real e
     <n> um inteiro positivo.

     Veja também 'test_signed_rank'.

 -- Função: cdf_signed_rank (<x>, <n>)
     Função de densidade cumulativa da distribuição exata da estatística
     do rank sinalizado.  O argumento <x> é um número real e <n> um
     inteiro positivo.

     Veja também 'test_signed_rank'.

 -- Função: pdf_rank_sum (<x>, <n>, <m>)
     Função densidade de probabilidade da distribuição exata da
     estatística do somatório do rank.  O argumento <x> é um número real
     e <n> e <m> são ambos inteiros positivos.

     Veja também 'test_rank_sum'.

 -- Função: cdf_rank_sum (<x>, <n>, <m>)
     Função de densidade cumulativa da distribuição exata da estatística
     do somatório do rank.  O argumento <x> é um número real e <n> e <m>
     são ambos inteiro positivos.

     Veja também 'test_rank_sum'.


File: maxima.info,  Node: stirling,  Next: stringproc,  Prev: stats,  Up: Top

72 stirling
***********

* Menu:

* Funções e Variáveis Definidas para stirling::


File: maxima.info,  Node: Funções e Variáveis Definidas para stirling,  Prev: stirling,  Up: stirling

72.1 Funções e Variáveis Definidas para stirling
================================================

 -- Função: stirling (<z>,<n>)
     Substitui 'gamma(x)' pela fórmula de Stirling O(1/x^(2n-1)).
     Quando <n> for um inteiro estritamente negativo, sinaliza um erro.

     Referência: Abramowitz & Stegun, " Handbook of mathematical
     functions", 6.1.40.

     Exemplos:
          (%i1) load (stirling)$

          (%i2) stirling(gamma(%alpha+x)/gamma(x),1);
                 1/2 - x             x + %alpha - 1/2
          (%o2) x        (x + %alpha)
                                             1           1
                                      --------------- - ---- - %alpha
                                      12 (x + %alpha)   12 x
                                    %e
          (%i3) taylor(%,x,inf,1);
                              %alpha       2    %alpha
                    %alpha   x       %alpha  - x       %alpha
          (%o3)/T/ x       + -------------------------------- + . . .
                                           2 x
          (%i4) map('factor,%);
                                                 %alpha - 1
                   %alpha   (%alpha - 1) %alpha x
          (%o4)   x       + -------------------------------
                                            2

     A função 'stirling' conhece a diferença entre a variável <gamma> e
     a função 'gamma':

          (%i5) stirling(gamma + gamma(x),0);
                                              x - 1/2   - x
          (%o5)    gamma + sqrt(2) sqrt(%pi) x        %e
          (%i6) stirling(gamma(y) + gamma(x),0);
                                   y - 1/2   - y
          (%o6) sqrt(2) sqrt(%pi) y        %e
                                                        x - 1/2   - x
                                   + sqrt(2) sqrt(%pi) x        %e

     Para usar essa função escreva primeiro 'load("stirling")'.


File: maxima.info,  Node: stringproc,  Next: unit,  Prev: stirling,  Up: Top

73 stringproc
*************

* Menu:

* Introdução a manipulação de seqüências de caracteres::
* Funções e Variáveis para entrada e saída::
* Funções e Variáveis para caracteres::
* Funções e Variáveis para seqüências de caracteres::


File: maxima.info,  Node: Introdução a manipulação de seqüências de caracteres,  Next: Funções e Variáveis para entrada e saída,  Prev: stringproc,  Up: stringproc

73.1 Introdução a manipulação de seqüências de caracteres
=========================================================

O arquivo 'stringproc.lisp' amplia a compatibilidade do Maxima de
trabalhar com seqüências de caracteres e adiciona algumas funções úteis
a entrada e saída de dados.

   Para esclarecimentos e correções por favor mande um e-mail para
van.nek at arcor.de .

   No Maxima uma seqüência de caracteres é facilmente contruída
digitando "texto" (qualquer texto desejado entre aspas duplas).  Note
que seqüências de caracteres do Maxima não são seqüências de caracteres
do Lisp e vice-versa.  'stringp' realiza testes para seqüências de
caracteres do Maxima, e 'lstringp' realiza testes para seqüências de
caracteres do Lisp.  Se por alguma razão voce tiver um valor, que é uma
seqüência de caracteres do Lisp, talvez quando estiver usando a função
'sconcat' do Maxima, você pode converter via 'sunlisp'.

     (%i1) m: "text";
     (%o1)                         text
     (%i2) [stringp(m),lstringp(m)];
     (%o2)                     [true, false]
     (%i3) l: sconcat("text");
     (%o3)                         text
     (%i4) [stringp(l),lstringp(l)];
     (%o4)                     [false, true]
     (%i5) stringp( sunlisp(l) );
     (%o5)                         true

   Todas as funções em 'stringproc.lisp', que retornarem seqüências de
caracteres, retornam seqüências de caracteres do Maxima.

   Caracteres são introduzidos como seqüências de caracteres do Maxima
de comprimento 1.  Com certeza, esses caracteres não são caracteres do
Lisp.  Testes podem ser realizados com 'charp' ( 'lcharp' e conversões
do Lisp para o Maxima com 'cunlisp').

     (%i1) c: "e";
     (%o1)                           e
     (%i2) [charp(c),lcharp(c)];
     (%o2)                     [true, false]
     (%i3) supcase(c);
     (%o3)                           E
     (%i4) charp(%);
     (%o4)                         true

   Novamente, todas as funções em 'stringproc.lisp', que retornam
caracteres, retornam caracteres do Maxima.  devido a esse fato, que os
caracteres introduzidos são seqüências de caracteres comprimento 1, você
pode usar muitas das funções de seqüência de caracteres também para
caracteres.  Como visto, 'supcase' é um exemplo.

   É importante saber, que o primeiro caractere em uma seqüência de
caracteres do Maxima éstá na posição 1.  Isso é designado devido ao fato
de o primeiro elemento em uma lista do Maxima está na posição 1 também.
Veja definições de 'charat' e de 'charlist' para obter exemplos.

   Em aplicações fnções de seqüência de caractere são muitas vezes
usadas quando estamos trabalhando com arquivos.  Você encontrará algumas
úteis funções de fluxo e funções de impressões em 'stringproc.lisp'.  O
seguinte exemplo mostra algumas das funções aqui introduzidas no
trabalho.

   Exemplo:

   'openw' retorna um fluxo de saída para um arquivo, 'printf' então
permite escrita formatada para esse arquivo.  Veja 'printf' para
detalhes.

     +(%i1) s: openw("E:/file.txt");
     +(%o1)                    #<output stream E:/file.txt>
     +(%i2) for n:0 thru 10 do printf( s, "~d ", fib(n) );
     +(%o2)                                done
     +(%i3) printf( s, "~%~d ~f ~a ~a ~f ~e ~a~%",
                    42,1.234,sqrt(2),%pi,1.0e-2,1.0e-2,1.0b-2 );
     +(%o3)                                false
     +(%i4) close(s);
     +(%o4)                                true

   Após fechar o fluxo você pode abrí-lo novamente, dessa vez com
direção de entrada.  'readline' retorna a linha completa como uma
seqüência de caracteres.  O pacote 'stringproc' agora oferece muitas
funções para manipulação de seqüências de caracteres.  A troca de
indicações/fichas pode ser realizada por 'split' ou por 'tokens'.

     (%i5) s: openr("E:/file.txt");
     (%o5)                     #<input stream E:/file.txt>
     (%i6) readline(s);
     (%o6)                     0 1 1 2 3 5 8 13 21 34 55
     (%i7) line: readline(s);
     (%o7)               42 1.234 sqrt(2) %pi 0.01 1.0E-2 1.0b-2
     (%i8) list: tokens(line);
     (%o8)           [42, 1.234, sqrt(2), %pi, 0.01, 1.0E-2, 1.0b-2]
     (%i9) map( parsetoken, list );
     (%o9)           [42, 1.234, false, false, 0.01, 0.01, false]

   'parsetoken' somente analiza números inteiros e em ponto flutuante.
A análise de símbolos ou grandes números em ponto flutuante precisa de
'parse_string', que irá ser disponibilizada para uso automaticamente
através de 'eval_string.lisp'.

     (%i10) map( parse_string, list );
     (%o10)           [42, 1.234, sqrt(2), %pi, 0.01, 0.01, 1.0b-2]
     (%i11) float(%);
     (%o11) [42.0, 1.234, 1.414213562373095, 3.141592653589793, 0.01, 0.01, 0.01]
     (%i12) readline(s);
     (%o12)                               false
     (%i13) close(s)$

   'readline' retorna 'false' quado o fim de arquivo acontecer.


File: maxima.info,  Node: Funções e Variáveis para entrada e saída,  Next: Funções e Variáveis para caracteres,  Prev: Introdução a manipulação de seqüências de caracteres,  Up: stringproc

73.2 Funções e Variáveis para entrada e saída
=============================================

Exemplo:

     (%i1) s: openw("E:/file.txt");
     (%o1)                     #<output stream E:/file.txt>
     (%i2) control:
      "~2tAn atom: ~20t~a~%~2tand a list: ~20t~{~r ~}~%~2tand an integer: ~20t~d~%"$
     (%i3) printf( s,control, 'true,[1,2,3],42 )$
     (%o3)                                false
     (%i4) close(s);
     (%o4)                                true
     (%i5) s: openr("E:/file.txt");
     (%o5)                     #<input stream E:/file.txt>
     (%i6) while stringp( tmp:readline(s) ) do print(tmp)$
       An atom:          true
       and a list:       one two three
       and an integer:   42
     (%i7) close(s)$

 -- Função: close (<fluxo>)
     Fecha <fluxo> e retorna 'true' se <fluxo> tiver sido aberto
     anteriormente.

 -- Função: flength (<fluxo>)
     Retorna o número de elementos em <fluxo>.

 -- Função: fposition (<fluxo>)
 -- Função: fposition (<fluxo>, <pos>)
     Retorna a posição corrente em <fluxo>, se <pos> não está sendo
     usada.  Se <pos> estiver sendo usada, 'fposition' escolhe a posição
     em <fluxo>.  <pos> tem que ser um número positivo, o primeiro
     elemento em <fluxo> está na posição 1.

 -- Função: freshline ()
 -- Função: freshline (<fluxo>)
     escreve uma nova linha (em <fluxo>), se a posição atual não for um
     início de linha.  Veja também 'newline'.

 -- Função: newline ()
 -- Função: newline (<fluxo>)
     Escreve uma nova linha (para <fluxo>).  Veja 'sprint' para um
     exemplo de uso de 'newline()'.  Note que existem alguns casos, onde
     'newline()'não trabalha como esperado.

 -- Função: opena (<arquivo>)
     Retorna um fluxo de saída para <arquivo>.  Se um arquivo já
     existente tiver sido aberto, 'opena' anexa os elementos ao final do
     arquivo.

 -- Função: openr (<arquivo>)
     Retorna um fluxo para <arquivo>.  Se <arquivo> não existir, ele
     será criado.

 -- Função: openw (<arquivo>)
     Retorna um fluxo de saída para <arquivo>.  Se <arquivo> não
     existir, será criado.  Se um arquivo já existente for aberto,
     'openw' modifica destrutivametne o <arquivo>.

 -- Função: printf (<dest>, <seq_caracte>)
 -- Função: printf (<dest>, <seq_caracte>, <expr_1>, ..., <expr_n>)
     Torna a função FORMAT do Lisp Comum disponível no Maxima.
     (Retirado de gcl.info: "format produces formatted output by
     outputting the caracteres of control-string string and observing
     that a tilde introduces a directive.  The caractere after the
     tilde, possibly preceded by prefix parameters and modifiers,
     specifies what kind of formatting is desired.  Most directives use
     one or more elements of args to create their output.")

     A seguinte descrição e oa exemplos podem fornecer uma idéia de uso
     de 'printf'.  Veja um referência de Lisp para maiores informações.

             ~%       nova linha
             ~&       novíssima line
             ~t       tabulação
             ~$       monetário
             ~d       inteiro decimal
             ~b       inteiro binário
             ~o       inteiro octal
             ~x       inteiro hexadecimal
             ~br      inteiro de base b
             ~r       soletra um inteiro
             ~p       plural
             ~f       ponto flutuante
             ~e       notação científica
             ~g       ~f ou ~e, dependendo  da magnitude
             ~a       como mostrado pela função print do Maxima
             ~s       seqüências de caracteres entre "aspas duplas"
             ~~       ~
             ~<       justificação de texto, ~> terminador de justificação de texto
             ~(       conversão de caixa alta/baixa, ~) terminador de conversão de caixa
             ~[       seleção, ~] terminador de seleção
             ~{       iteração, ~} terminador de iteração

     Por favor note que não existe especificador de formato para grandes
     números em ponto flutuante.  Todavia grandes números em ponto
     flutuante podem simplesmente serem mostrados por meio da diretiva
     '~a'.  '~s' mostra a seqüências de caracteres entre "aspas duplas",
     você pode evitar isso usando '~a'.  Note que a diretiva de seleção
     '~[' é indexada em zero.  Também note que existem algumas
     diretivas, que não trabalham no Maxima.  Por exemplo, '~:[' falha.

          (%i1) printf( false, "~a ~a ~4f ~a ~@r",
                        "String",sym,bound,sqrt(12),144), bound = 1.234;
          (%o1)                 String sym 1.23 2*sqrt(3) CXLIV
          (%i2) printf( false,"~{~a ~}",["one",2,"THREE"] );
          (%o2)                          one 2 THREE
          (%i3) printf( true,"~{~{~9,1f ~}~%~}",mat ),
                        mat = args( matrix([1.1,2,3.33],[4,5,6],[7,8.88,9]) )$
                1.1       2.0       3.3
                4.0       5.0       6.0
                7.0       8.9       9.0
          (%i4) control: "~:(~r~) bird~p ~[is~;are~] singing."$
          (%i5) printf( false,control, n,n,if n=1 then 0 else 1 ), n=2;
          (%o5)                    Two birds are singing.

     Se <dest> for um fluxo ou 'true', então 'printf' retorna 'false'.
     De outra forma, 'printf' retorna uma seqüência de caracteres
     contendo a saída.

 -- Função: readline (<fluxo>)
     Retorna uma seqüência de caracteres contendo os caracteres a partir
     da posição corrente em <fluxo> até o fim de linha ou <false> se o
     fim de linha do arquivo for encontrado.

 -- Função: sprint (<expr_1>, ..., <expr_n>)
     Avalia e mostra seus argumentos um após o outro 'sobre uma linha'
     iniciando na posição mais à esquerda.  Os números são mostrados com
     o '-' à direita do número, e isso desconsidera o comprimento da
     linha.  'newline()', que irá ser chamada automaticamente a partir
     de 'stringproc.lisp' pode ser útil, se você desejar colocar uma
     parada de linha intermediária.

          (%i1) for n:0 thru 22 do sprint( fib(n) )$
          0 1 1 2 3 5 8 13 21 34 55 89 144 233 377 610 987 1597 2584 4181 6765 10946 17711
          (%i2) for n:0 thru 22 do (
                   sprint(fib(n)), if mod(n,10)=9 then newline() )$
          0 1 1 2 3 5 8 13 21 34
          55 89 144 233 377 610 987 1597 2584 4181
          6765 10946 17711


File: maxima.info,  Node: Funções e Variáveis para caracteres,  Next: Funções e Variáveis para seqüências de caracteres,  Prev: Funções e Variáveis para entrada e saída,  Up: stringproc

73.3 Funções e Variáveis para caracteres
========================================

 -- Função: alphacharp (<caractere>)
     Retorna 'true' se <caractere> for um caractere alfabético.

 -- Função: alphanumericp (<caractere>)
     Retorna 'true' se <caractere> for um caractere alfabético ou um
     dígito.

 -- Função: ascii (<int>)
     Retorna o caractere correspondente ao código numérico ASCII <int>.
     ( -1 < int < 256 )

          (%i1) for n from 0 thru 255 do (
          tmp: ascii(n), if alphacharp(tmp) then sprint(tmp), if n=96 then newline() )$
          A B C D E F G H I J K L M N O P Q R S T U V W X Y Z
          a b c d e f g h i j k l m n o p q r s t u v w x y z

 -- Função: cequal (<caractere_1>, <caractere_2>)
     Retorna 'true' se <caractere_1> e <caractere_2> forem os mesmos.

 -- Função: cequalignore (<caractere_1>, <caractere_2>)
     como 'cequal' mas ignora a caixa alta/baixa.

 -- Função: cgreaterp (<caractere_1>, <caractere_2>)
     Retorna 'true' se o código numérico ASCII do <caractere_1> for
     maior que o código numérico ASCII do <caractere_2>.

 -- Função: cgreaterpignore (<caractere_1>, <caractere_2>)
     Como 'cgreaterp' mas ignora a caixa alta/baixa.

 -- Função: charp (<obj>)
     Retorna 'true' se <obj> for um caractere do Maxima.  Veja na seção
     "Introdução a manipulação de seqüências de caracteres" para ter um
     exemplo.

 -- Função: cint (<caractere>)
     Retorna o código numéico ASCII de <caractere>.

 -- Função: clessp (<caractere_1>, <caractere_2>)
     Retorna 'true' se o código numérico ASCII de <caractere_1> for
     menor que o código numérico ASCII de <caractere_2>.

 -- Função: clesspignore (<caractere_1>, <caractere_2>)
     Como em 'clessp' ignora a caixa alta/baixa.

 -- Função: constituent (<caractere>)
     Retorna 'true' se <caractere> for caractere gráfico e não o
     caractere de espaço em branco.  Um caractere gráfico é um caractere
     que se pode ver, adicionado o caractere de espaço em branco.
     ('constituent' foi definida por Paul Graham, em ANSI Common Lisp,
     1996, página 67.)

          (%i1) for n from 0 thru 255 do (
          tmp: ascii(n), if constituent(tmp) then sprint(tmp) )$
          ! " #  %  ' ( ) * + , - . / 0 1 2 3 4 5 6 7 8 9 : ; < = > ? @ A B
          C D E F G H I J K L M N O P Q R S T U V W X Y Z [ \ ] ^ _ ` a b c
          d e f g h i j k l m n o p q r s t u v w x y z { | } ~

 -- Função: cunlisp (<lisp_char>)
     Converte um caractere do Lisp em um caractere do Maxima.  (Você
     pode não precisar dessa função.)

 -- Função: digitcharp (<caractere>)
     Retorna 'true' se <caractere> for um dígito (algarismo de 0 a 9).

 -- Função: lcharp (<obj>)
     Retorna 'true' se <obj> for um caractere do Lisp.  (Você pode não
     precisar dessa função.)

 -- Função: lowercasep (<caractere>)
     Retorna 'true' se <caractere> for um caractere em caixa baixa.

 -- Variable: newline
     O caractere de nova linha.

 -- Variável: space
     O caractere de espaço em branco.

 -- Variável: tab
     O caractere de tabulação.

 -- Função: uppercasep (<caractere>)
     Retorna 'true' se <caractere> for um caractere em caixa alta.


File: maxima.info,  Node: Funções e Variáveis para seqüências de caracteres,  Prev: Funções e Variáveis para caracteres,  Up: stringproc

73.4 Funções e Variáveis para seqüências de caracteres
======================================================

 -- Função: sunlisp (<lisp_string>)
     Converte uma seqüência de caracteres do Lisp em uma seqüência de
     caracteres do Maxima.  (Em geral você pode não precisar dessa
     função.)

 -- Função: lstringp (<obj>)
     Retorna 'true' se <obj> is uma seqüência de caracteres do Lisp.
     (Em geral você pode não precisar dessa função.)

 -- Função: stringp (<obj>)
     Retorna 'true' se <obj> for uma seqüência de caracteres do Maxima.
     Veja a introdução para obter exemplos.

 -- Função: charat (<seq_caracte>, <n>)
     Retorna o <n>-ésimo caractere de <seq_caracte>.  O primeiro
     caractere em <seq_caracte> é retornado com <n> = 1.

          (%i1) charat("Lisp",1);
          (%o1)                           L

 -- Função: charlist (<seq_caracte>)
     Retorna a lsita de todos os caracteres em <seq_caracte>.

          (%i1) charlist("Lisp");
          (%o1)                     [L, i, s, p]
          (%i2) %[1];
          (%o2)                           L

 -- Função: parsetoken (<seq_caracte>)
     'parsetoken' converte a primeira ficha em <seq_caracte> para o
     correspondente número ou retorna 'false' se o número não puder ser
     determinado.  O conjunto de delimitadores para a troca de fichas é
     '{space, comma, semicolon, tab, newline}'

     Nota de tradução: espaço, vírgula, ponto e vírgula, tabulação e
     nova linha.

          (%i1) 2*parsetoken("1.234 5.678");
          (%o1)                         2.468

     Para analizar você pode também usar a função 'parse_string'.  Veja
     a descrição no arquivo 'share\contrib\eval_string.lisp'.

 -- Função: sconc (<expr_1>, ..., <expr_n>)
     Avalia seus argumentos e concatena-os em uma seqüência de
     caracteres.  'sconc' é como 'sconcat' mas retorna uma seqüência de
     caracteres do Maxima.

          (%i1) sconc("xx[",3,"]:",expand((x+y)^3));
          (%o1)             xx[3]:y^3+3*x*y^2+3*x^2*y+x^3
          (%i2) stringp(%);
          (%o2)                         true

 -- Função: scopy (<seq_caracte>)
     Retorna uma cópia de <seq_caracte> como uma nova seqüência de
     caracteres.

 -- Função: sdowncase (<seq_caracte>)
 -- Função: sdowncase (<seq_caracte>, <início>)
 -- Função: sdowncase (<seq_caracte>, <início>, <fim>)
     Como em 'supcase', mas caracteres em caixa alta são convertidos
     para caracteres em caixa baixa.

 -- Função: sequal (<seq_caracte__1>, <seq_caracte__2>)
     Retorna 'true' se <seq_caracte__1> e <seq_caracte__2> tiverem o
     mesmo comprimento e contiverem os mesmos caracteres.

 -- Função: sequalignore (<seq_caracte__1>, <seq_caracte__2>)
     Como em 'sequal' mas igonara a caixa alta/baixa.

 -- Função: sexplode (<seq_caracte>)
     'sexplode' é um apelido para a função 'charlist'.

 -- Função: simplode (<lista>)
 -- Função: simplode (<lista>, <delim>)
     'simplode' takes uma 'lista' ou expressões e concatena-as em uma
     seqüência de caracteres.  Se nenhum delimitador <delim> for usado,
     'simplode' funciona como 'sconc' e não utiliza delimitador.
     <delim> pode ser qualquer seqüência de caracteres.

          (%i1) simplode(["xx[",3,"]:",expand((x+y)^3)]);
          (%o1)             xx[3]:y^3+3*x*y^2+3*x^2*y+x^3
          (%i2) simplode( sexplode("stars")," * " );
          (%o2)                   s * t * a * r * s
          (%i3) simplode( ["One","more","coffee."]," " );
          (%o3)                   One more coffee.

 -- Função: sinsert (<seq>, <seq_caracte>, <pos>)
     Retorna uma seqüência de caracteres que é uma concatenação de
     'substring (<seq_caracte>, 1, <pos> - 1)', a seqüência de
     caracteres <seq> e 'substring (<seq_caracte>, <pos>)'.  Note que o
     primeiro caractere está em <seq_caracte> e está na posição 1.

          (%i1) s: "A submarine."$
          (%i2) sconc( substring(s,1,3),"yellow ",substring(s,3) );
          (%o2)                  A yellow submarine.
          (%i3) sinsert("hollow ",s,3);
          (%o3)                  A hollow submarine.

 -- Função: sinvertcase (<seq_caracte>)
 -- Função: sinvertcase (<seq_caracte>, <início>)
 -- Função: sinvertcase (<seq_caracte>, <início>, <fim>)
     Retorna <seq_caracte> exceto que cada caractere da posição <início>
     até a posição <fim> está invertido.  Se a posição <fim> não for
     fornecida, todos os caracteres do início ao <fim> de <seq_caracte>
     são substituídos.

          (%i1) sinvertcase("sInvertCase");
          (%o1)                      SiNVERTcASE

 -- Função: slength (<seq_caracte>)
     Retorna número de caracteres em <seq_caracte>.

 -- Função: smake (<num>, <caractere>)
     Retorna uma nova seqüência de caracteres repetindo <num> vezes
     <caractere>.

          (%i1) smake(3,"w");
          (%o1)                          www

 -- Função: smismatch (<seq_caracte__1>, <seq_caracte__2>)
 -- Função: smismatch (<seq_caracte__1>, <seq_caracte__2>, <test>)
     Retorna a posição do primeiro caractere de <seq_caracte__1> no qual
     <seq_caracte__1> e <seq_caracte__2> diferem ou 'false' em caso
     contrário.  A função padrao de teste para coincidência é 'sequal'.
     Se 'smismatch' pode ignorar a caixa alta/baixa, use 'sequalignore'
     como função de teste.

          (%i1) smismatch("seven","seventh");
          (%o1)                           6

 -- Função: split (<seq_caracte>)
 -- Função: split (<seq_caracte>, <delim>)
 -- Função: split (<seq_caracte>, <delim>, <multiple>)
     Retorna a lista de todas as fichas em <seq_caracte>.  Cada ficha é
     uma seqüência de caracteres não analisada.  'split' usa <delim>
     como delimitador.  Se <delim> não for fornecido, o caractere de
     espaço é o delimitador padrão.  <multiple> é uma variável booleana
     com 'true' como valor padrão.  Multiplos delimitadores são lidos
     como um.  Essa função é útil se tabulações são gravadas com
     caracteres de espaço multiplos.  Se <multiple> for escolhido para
     'false', cada delimitador é considerado.

          (%i1) split("1.2   2.3   3.4   4.5");
          (%o1)                 [1.2, 2.3, 3.4, 4.5]
          (%i2) split("first;;third;fourth",";",false);
          (%o2)               [first, , third, fourth]

 -- Função: sposition (<caractere>, <seq_caracte>)
     Retorna a posição do primeiro caractere em <seq_caracte> que
     coincide com <caractere>.  O primeiro caractere em <seq_caracte>
     está na posição 1.  Para que os caracteres que coincidirem
     desconsiderem a caixa alta/baixa veja 'ssearch'.

 -- Função: sremove (<seq>, <seq_caracte>)
 -- Função: sremove (<seq>, <seq_caracte>, <test>)
 -- Função: sremove (<seq>, <seq_caracte>, <test>, <início>)
 -- Função: sremove (<seq>, <seq_caracte>, <test>, <início>, <fim>)
     Retorna uma seqüência de caracteres como <seq_caracte> mas com
     todas as subseqüências de caracteres que coincidirem com <seq>.  A
     função padrão de teste de coincidência é 'sequal'.  Se 'sremove'
     puder ignorar a caixa alta/baixa enquanto busca por <seq>, use
     'sequalignore' como teste.  Use <início> e <fim> para limitar a
     busca.  Note que o primeiro caractere em <seq_caracte> está na
     posição 1.

          (%i1) sremove("n't","I don't like coffee.");
          (%o1)                   I do like coffee.
          (%i2) sremove ("DO ",%,'sequalignore);
          (%o2)                    I like coffee.

 -- Função: sremovefirst (<seq>, <seq_caracte>)
 -- Função: sremovefirst (<seq>, <seq_caracte>, <test>)
 -- Função: sremovefirst (<seq>, <seq_caracte>, <test>, <início>)
 -- Função: sremovefirst (<seq>, <seq_caracte>, <test>, <início>, <fim>)
     Como em 'sremove' exceto qie a primeira subseqüência de caracteres
     que coincide com 'seq' é removida.

 -- Função: sreverse (<seq_caracte>)
     Retorna uma seqüência de caracteres com todos os caracteres de
     <seq_caracte> em ordem reversa.

 -- Função: ssearch (<seq>, <seq_caracte>)
 -- Função: ssearch (<seq>, <seq_caracte>, <test>)
 -- Função: ssearch (<seq>, <seq_caracte>, <test>, <início>)
 -- Função: ssearch (<seq>, <seq_caracte>, <test>, <início>, <fim>)
     Retorna a posição da primeira subseqüência de caracteres de
     <seq_caracte> que coincide com a seqüência de caracteres <seq>.  A
     função padrão de teste de coincidência é 'sequal'.  Se 'ssearch'
     puder igonorar a caixa alta/baixa, use 'sequalignore' como função
     de teste.  Use <início> e <fim> para limitar a busca.  Note que o
     primeiro caractere em <seq_caracte> está na posição 1.

          (%i1) ssearch("~s","~{~S ~}~%",'sequalignore);
          (%o1)                                  4

 -- Função: ssort (<seq_caracte>)
 -- Função: ssort (<seq_caracte>, <test>)
     Retorna uma seqüência de caracteres que contém todos os caracteres
     de <seq_caracte> em uma ordem tal que não existam dois caracteres
     <c> sucessivos e <d> seja tal que 'test (<c>, <d>)' seja 'false' e
     'test (<d>, <c>)' seja 'true'.  A função padrão de teste para
     ordenaçào é <clessp>.  O conjunto de funções de teste é '{clessp,
     clesspignore, cgreaterp, cgreaterpignore, cequal, cequalignore}'.

          (%i1) ssort("I don't like Mondays.");
          (%o1)                    '.IMaddeiklnnoosty
          (%i2) ssort("I don't like Mondays.",'cgreaterpignore);
          (%o2)                 ytsoonnMlkIiedda.'

 -- Função: ssubst (<nova>, <antiga>, <seq_caracte>)
 -- Função: ssubst (<nova>, <antiga>, <seq_caracte>, <test>)
 -- Função: ssubst (<nova>, <antiga>, <seq_caracte>, <test>, <início>)
 -- Função: ssubst (<nova>, <antiga>, <seq_caracte>, <test>, <início>,
          <fim>)
     Retorna uma seqüência de caracteres como <seq_caracte> exceto que
     todas as subseqüências de caracteres que coincidirem com <antiga>
     são substituídas por <nova>.  <antiga> e <nova> não precisam ser de
     mesmo comprimento.  A função padrão de teste para coincidência é
     para coincidências é 'sequal'.  Se 'ssubst' puder ignorar a cixa
     alta/baixa enquanto procurando por <antiga>, use 'sequalignore'
     como função de teste.  Use <início> e <fim> para limitar a busca.
     Note que o primeiro caractere em <seq_caracte> está na posição 1.

          (%i1) ssubst("like","hate","I hate Thai food. I hate green tea.");
          (%o1)          I like Thai food. I like green tea.
          (%i2) ssubst("Indian","thai",%,'sequalignore,8,12);
          (%o2)         I like Indian food. I like green tea.

 -- Função: ssubstfirst (<nova>, <antiga>, <seq_caracte>)
 -- Função: ssubstfirst (<nova>, <antiga>, <seq_caracte>, <test>)
 -- Função: ssubstfirst (<nova>, <antiga>, <seq_caracte>, <test>,
          <início>)
 -- Função: ssubstfirst (<nova>, <antiga>, <seq_caracte>, <test>,
          <início>, <fim>)
     Como em 'subst' exceto que somente a primeira subseqüência de
     caracteres que coincidir com <antiga> é substituída.

 -- Função: strim (<seq>,<seq_caracte>)
     Retorna uma seqüência de caracteres como <seq_caracte>, mas com
     todos os caracteres que aparecerem em <seq> removidos de ambas as
     extremidades.

          (%i1) "/* comment */"$
          (%i2) strim(" /*",%);
          (%o2)                        comment
          (%i3) slength(%);
          (%o3)                           7

 -- Função: striml (<seq>, <seq_caracte>)
     Como em 'strim' exceto que somente a extremidade esquerda de
     <seq_caracte> é recordada.

 -- Função: strimr (<seq>, <seq_caracte>)
     Como em 'strim' exceto que somente a extremidade direita de
     seqüência de caracteres é recortada.

 -- Função: substring (<seq_caracte>, <início>)
 -- Função: substring (<seq_caracte>, <início>, <fim>)
     Retorna a subseqüência de caracteres de <seq_caracte> começando na
     posição <início> e terminando na posição <fim>.  O caractere na
     posição <fim> não é incluído.  Se <fim> não for fornecido, a
     subseqüência de caracteres contém o restante da seqüência de
     caracteres.  Note que o primeiro caractere em <seq_caracte> está na
     posição 1.

          (%i1) substring("substring",4);
          (%o1)                        string
          (%i2) substring(%,4,6);
          (%o2)                          in

 -- Função: supcase (<seq_caracte>)
 -- Função: supcase (<seq_caracte>, <início>)
 -- Função: supcase (<seq_caracte>, <início>, <fim>)
     Retorna <seq_caracte> exceto que caracteres em caixa baixa a partir
     da posição <início> até a posição <fim> são substituídos pelo
     correspondente caracteres em caixa alta.  Se <fim> não for
     fornecido, todos os caracteres em caixa baixa de <início> até o fim
     de <seq_caracte> são substituídos.

          (%i1) load("stringproc")$
          (%i1) supcase("english",1,2);
          (%o1)                        English

 -- Função: tokens (<seq_caracte>)
 -- Função: tokens (<seq_caracte>, <test>)
     Retorna uma lista de fichas, que tiverem sido extrídos de
     <seq_caracte>.  As fichas são subseqüências de caracteres cujos
     caracteres satisfazem a uma determinada função de teste.  Se o
     teste não for fornecido, <constituent> é usada como teste padrão.
     '{constituent, alphacharp, digitcharp, lowercasep, uppercasep,
     charp, characterp, alphanumericp}' é o conjunto de fnções de teste.
     (A verão Lisp de 'tokens' é escrita por Paul Graham.  ANSI Common
     Lisp, 1996, page 67.)

          (%i1) tokens("24 October 2005");
          (%o1)                  [24, October, 2005]
          (%i2) tokens("05-10-24",'digitcharp);
          (%o2)                     [05, 10, 24]
          (%i3) map(parsetoken,%);
          (%o3)                      [5, 10, 24]


File: maxima.info,  Node: unit,  Next: zeilberger,  Prev: stringproc,  Up: Top

74 unit
*******

* Menu:

* Introdução a Units::
* Funções e Variáveis Definidas para Units::


File: maxima.info,  Node: Introdução a Units,  Next: Funções e Variáveis Definidas para Units,  Prev: unit,  Up: unit

74.1 Introdução a Units
=======================

O pacote _unit_ torna o usuário apto a converter entre unidades
arbitrárias e trabalhar com dimensões em equações.  O funcionamento
desse pacote é radicalmente diferente do pacote original units do Maxima
- apesar de o original conter uma lista básica de definições, o pacote
atual usa um conjunto de regras para permitir ao usuário escolher, sobre
uma base dimensional, qual a resposta fianl de unidade pode ser
convertida.  Isso irá separar unidades em lugar de misturá-las na tela,
permitindo ao usuário durante a leitura identificar as unidades
associadas com uma resposta em particular.  Isso permitirá ao usuário
simplificar uma expressão em sua Base fundamental de Unidades, bem como
fornecer ajuste fino sobre a simplificação de unidades derivadas.
Análise dimensional é possível, e uma variedade de ferramentas está
disponível para gerenciar a conversão e também uma variedade de opções
de simplificação.  Adicionalmente para personalizar conversão
automática, _units_ também fornede um manual tradicional de opções de
conversão.

   Nota -quando conversões de unidade forem não exatas Maxima irá fazer
aproximações resultando em frações.  Esso é uma conceqüência das
técnicas usadas para simplificar unidades.  A mensagem de alerta desse
tipo de substituição está desabilitada por padrão no caso de inidades
(normalmente essas mensagens estão habilitadas) uma vez que essa
situação de iemissão de mensagens de alerta ocorre freqüêntemente e os
alertas confundem a saída.  (O estado atual de 'ratprint' é
restabelecido após uma conversão de unidades, de forma que modificações
de usuário para aquela configuração irão ser preservadas de outra
forma.)  Se o usuário precisar dessa informação para 'units', ele pode
escolher _unitverbose:on_ para reativar a impressão de mensagens de
alerta do processo de conversão.

   _unit_ está inclído no Maxima no diretório share/contrib/unit
directory.  Isso segue aos pacotes normais do Maxima conforme
convenções:

     (%i1) load("unit")$
     *******************************************************************
     *                       Units version 0.50                        *
     *          Definitions based on the NIST Reference on             *
     *              Constants, Units, and Uncertainty                  *
     *       Conversion factors from various sources including         *
     *                   NIST and the GNU units package                *
     *******************************************************************

     Redefining necessary functions...
     WARNING: DEFUN/DEFMACRO: redefining function TOPLEVEL-MACSYMA-EVAL ...
     WARNING: DEFUN/DEFMACRO: redefining function MSETCHK ...
     WARNING: DEFUN/DEFMACRO: redefining function KILL1 ...
     WARNING: DEFUN/DEFMACRO: redefining function NFORMAT ...
     Initializing unit arrays...
     Done.

   As mensagens WARNING (DE ALERTA) são esperadas n ão uma causa de
preocupação - elas indicam que o pacote _unit_ está redefinindo funções
anteriormente definidas no local adequado do Maxima.  Essa redefinição é
necessária com o bojetivo de manusear adequadamente as unidades.  O
usuário pode estar consciente que se outras modificações tiverem sido
feitas para essas funções por outros pacotes essas novas mudanças irão
ser sobrescritas por meio desse processo de disponibilização do pacote
'unit'.

   O arquivo _unit.mac_ também chama um arquivo lisp, a saber
_unit-functions.lisp_, que contém as funçãoes lisp necessárias ao
pacote.

   Clifford Yapp é o autor primário.  Ele recebeu grande contribuição de
Barton Willis da University of Nebraska at Kearney (UNK), Robert Dodier,
e da intrépida tribo da lista de mensagens do Maxima.

   Existem provavelmente muitos erros.  Diga-me quais.  'float' e
'numer' não fazem o que é esperado.

   PORFAZER : funcionalidade de dimensão, manuseio de temperatura, a
função 'showabbr' e Cia.  Ltda.  Mostrar exemplos com adição de
quantidades contendo unidades.


File: maxima.info,  Node: Funções e Variáveis Definidas para Units,  Prev: Introdução a Units,  Up: unit

74.2 Funções e Variáveis Definidas para Units
=============================================

 -- Função: setunits (<list>)
     Por padrão, o pacote _unit_ não usa qualquer dimensões derivadas,
     mas irá converter todas as unidades nas sete fundamentais do
     sistema MKS.
          (%i2) N;
                                               kg m
          (%o2)                                ----
                                                 2
                                                s
          (%i3) dyn;
                                             1      kg m
          (%o3)                           (------) (----)
                                           100000     2
                                                     s
          (%i4) g;
                                              1
          (%o4)                             (----) (kg)
                                             1000
          (%i5) centigram*inch/minutes^2;
                                            127        kg m
          (%o5)                       (-------------) (----)
                                       1800000000000     2
                                                        s

     Em alguns casos esse é o comportamento desejado.  Se o usuário
     desejar usar outras unidades, isso é conseguido com o comando
     'setunits':
          (%i6) setunits([centigram,inch,minute]);
          (%o6)                                done
          (%i7) N;
                                      1800000000000   %in cg
          (%o7)                      (-------------) (------)
                                           127            2
                                                      %min
          (%i8) dyn;
                                         18000000   %in cg
          (%o8)                         (--------) (------)
                                           127          2
                                                    %min
          (%i9) g;
          (%o9)                             (100) (cg)
          (%i10) centigram*inch/minutes^2;
                                              %in cg
          (%o10)                              ------
                                                  2
                                              %min

     A escolha de unidades é completamente flexível.  Por exemplo, se
     quisermos voltar para quiilogramas, metros, e segundos como padrão
     para essas dimensão nós podemos fazer:
          (%i11) setunits([kg,m,s]);
          (%o11)                               done
          (%i12) centigram*inch/minutes^2;
                                            127        kg m
          (%o12)                      (-------------) (----)
                                       1800000000000     2
                                                        s

     Unidade derivadas são também manuseáveis por meio desse comando:
          (%i17) setunits(N);
          (%o17)                               done
          (%i18) N;
          (%o18)                                 N
          (%i19) dyn;
                                              1
          (%o19)                           (------) (N)
                                            100000
          (%i20) kg*m/s^2;
          (%o20)                                 N
          (%i21) centigram*inch/minutes^2;
                                              127
          (%o21)                        (-------------) (N)
                                         1800000000000

     Note que o pacote _unit_ reconhece a combinação não MKS de massa,
     comprimento, e tempo inverso elevado ao quadrado como uma força, e
     converte isso para Newtons.  É dessa forma que Maxima trabalha
     geralmente.  Se, por exemplo, nós preferirmos dinas em lugar de
     Newtons, simplesmente fazemos o seguinte:
          (%i22) setunits(dyn);
          (%o22)                               done
          (%i23) kg*m/s^2;
          (%o23)                          (100000) (dyn)
          (%i24) centigram*inch/minutes^2;
                                            127
          (%o24)                         (--------) (dyn)
                                          18000000

     Para descontinuar simplificando para qualquer unidade de força,
     usamos o comando 'uforget':
          (%i26) uforget(dyn);
          (%o26)                               false
          (%i27) kg*m/s^2;
                                               kg m
          (%o27)                               ----
                                                 2
                                                s
          (%i28) centigram*inch/minutes^2;
                                            127        kg m
          (%o28)                      (-------------) (----)
                                       1800000000000     2
                                                        s
     Isso pode trabalhar igualmente bem com 'uforget(N)' ou
     'uforget(%force)'.

     Veja também 'uforget'.  Para usar essa função escreva primeiro
     'load("unit")'.

 -- Função: uforget (<list>)
     Por padrão, o pacote _unit_ converte todas as unidades para as sete
     unidaes fundamentais do sitema MKS de unidades.  Ess comportamento
     pode ser mudado com o comando 'setunits'.  Após o qual, o usuário
     pode restabelecer o comportamento padrão para uma dimensão em
     particular mediante o comando 'uforget':
          (%i13) setunits([centigram,inch,minute]);
          (%o13)                               done
          (%i14) centigram*inch/minutes^2;
                                              %in cg
          (%o14)                              ------
                                                  2
                                              %min
          (%i15) uforget([cg,%in,%min]);
          (%o15)                      [false, false, false]
          (%i16) centigram*inch/minutes^2;
                                            127        kg m
          (%o16)                      (-------------) (----)
                                       1800000000000     2
                                                        s

     'uforget' opera sobre dimensões, não sobre unidades, de forma que
     qualquer unidade de uma dimensão em particular irá trabalhar.  A
     própia dimensão é também um argumento legal.

     Veja também 'setunits'.  To use this function write first
     'load("unit")'.

 -- Função: convert (<expr>, <list>)
     Quando do restabelecimento dos valores padrão o ambiente global é
     destruído, existe o comando 'convert', que permite conversões
     imediatas.  'convert' pode aceitar um argumetno simples ou uma
     lista de unidades a serem usadas na conversão.  Quando uma operação
     de conversão for concluída, o sistema normal de avaliação global é
     contornado, com o objetivo de evitar que o resultado desejado seja
     convertido novamente.  Como conseqüência, em cálculos aproximados
     alertas de "rat" irão ser visíveis se o ambiente global que
     controla esse comportamento ('ratprint') for 'true'.  'convert'
     também é útil para uma verificação pontual e imediata da precisão
     de uma conversão global.  Outro recurso é que 'convert' irá
     permitir a um usuário fazer um Base de Conversões Dimensionais
     mesmo se o ambiente global for escolhido para simplificar par uma
     Dimensão Derivada.

          (%i2) kg*m/s^2;
                                               kg m
          (%o2)                                ----
                                                 2
                                                s
          (%i3) convert(kg*m/s^2,[g,km,s]);
                                               g km
          (%o3)                                ----
                                                 2
                                                s
          (%i4) convert(kg*m/s^2,[g,inch,minute]);

          `rat' replaced 39.37007874015748 by 5000/127 = 39.37007874015748
                                        18000000000   %in g
          (%o4)                        (-----------) (-----)
                                            127           2
                                                      %min
          (%i5) convert(kg*m/s^2,[N]);
          (%o5)                                  N
          (%i6) convert(kg*m^2/s^2,[N]);
          (%o6)                                 m N
          (%i7) setunits([N,J]);
          (%o7)                                done
          (%i8) convert(kg*m^2/s^2,[N]);
          (%o8)                                 m N
          (%i9) convert(kg*m^2/s^2,[N,inch]);

          `rat' replaced 39.37007874015748 by 5000/127 = 39.37007874015748
                                           5000
          (%o9)                           (----) (%in N)
                                           127
          (%i10) convert(kg*m^2/s^2,[J]);
          (%o10)                                 J
          (%i11) kg*m^2/s^2;
          (%o11)                                 J
          (%i12) setunits([g,inch,s]);
          (%o12)                               done
          (%i13) kg*m/s^2;
          (%o13)                                 N
          (%i14) uforget(N);
          (%o14)                               false
          (%i15) kg*m/s^2;
                                          5000000   %in g
          (%o15)                         (-------) (-----)
                                            127       2
                                                     s
          (%i16) convert(kg*m/s^2,[g,inch,s]);

          `rat' replaced 39.37007874015748 by 5000/127 = 39.37007874015748
                                          5000000   %in g
          (%o16)                         (-------) (-----)
                                            127       2
                                                     s

     Veja também 'setunits' e 'uforget'.  Para usar essa função
     primeiramente escreva 'load("unit")'.

 -- Variável de opção: usersetunits
     Valor padrão: none

     Se um usuário desejar ter um comportamento padrão de unidade
     diferente daquele descrito, ele pode fazer uso de _maxima-init.mac_
     e da variável _usersetunits_.  O pacote _unit_ irá verificar o
     arquivo _maxima-init.mac_ na inicialização para ver se a essa
     variável foi atribuído uma lista.  Se isso aconteceu, o pacote
     _unit_ irá usar 'setunits' sobre aquela lista e pegar as unidades
     lá colocadas para serem as padrões.  'uforget' irá reverter para o
     comportamento definido por 'usersetunits' sobrescrevendo seus
     próprios padrões.  Por exemplo, Se tivermos um arquivo
     _maxima-init.mac_ contendo:
          usersetunits : [N,J];
     nós poderemos ver o seguinte comportamento:
          (%i1) load("unit")$
          *******************************************************************
          *                       Units version 0.50                        *
          *          Definitions based on the NIST Reference on             *
          *              Constants, Units, and Uncertainty                  *
          *       Conversion factors from various sources including         *
          *                   NIST and the GNU units package                *
          *******************************************************************

          Redefining necessary functions...
          WARNING: DEFUN/DEFMACRO: redefining function TOPLEVEL-MACSYMA-EVAL ...
          WARNING: DEFUN/DEFMACRO: redefining function MSETCHK ...
          WARNING: DEFUN/DEFMACRO: redefining function KILL1 ...
          WARNING: DEFUN/DEFMACRO: redefining function NFORMAT ...
          Initializing unit arrays...
          Done.
          User defaults found...
          User defaults initialized.
          (%i2) kg*m/s^2;
          (%o2)                                  N
          (%i3) kg*m^2/s^2;
          (%o3)                                  J
          (%i4) kg*m^3/s^2;
          (%o4)                                 J m
          (%i5) kg*m*km/s^2;
          (%o5)                             (1000) (J)
          (%i6) setunits([dyn,eV]);
          (%o6)                                done
          (%i7) kg*m/s^2;
          (%o7)                           (100000) (dyn)
          (%i8) kg*m^2/s^2;
          (%o8)                     (6241509596477042688) (eV)
          (%i9) kg*m^3/s^2;
          (%o9)                    (6241509596477042688) (eV m)
          (%i10) kg*m*km/s^2;
          (%o10)                   (6241509596477042688000) (eV)
          (%i11) uforget([dyn,eV]);
          (%o11)                           [false, false]
          (%i12) kg*m/s^2;
          (%o12)                                 N
          (%i13) kg*m^2/s^2;
          (%o13)                                 J
          (%i14) kg*m^3/s^2;
          (%o14)                                J m
          (%i15) kg*m*km/s^2;
          (%o15)                            (1000) (J)
     Sem 'usersetunits', as entradas iniciais poderiam ter sido
     convertidas para o sistema de unidades MKS, e 'uforget' poderia ter
     resultado em um retorno para as regras do MKS. Em vez disso, as
     preferências do usuário foram respeitadas em ambos os casos.  Note
     que esse podem ainda serem sobrescritos se for desejado.  Para
     eliminar completamente essa simplificação - i.e.  ter as
     preferências de usuário escolhidas para os padrões de unidade do
     Maxima - o comando 'dontusedimension' pode ser usado.  'uforget'
     pode restabelecer as preferências de usuário novamente, mas somente
     se 'usedimension' liberar isso para uso.  Alternativamente,
     'kill(usersetunits)' irá remover completametne todo o conhecimento
     dessas escolhas de usuário da sessão atual.  Aqui está alguns
     exemplos de como esssas várias opções trabalham.
          (%i2) kg*m/s^2;
          (%o2)                                  N
          (%i3) kg*m^2/s^2;
          (%o3)                                  J
          (%i4) setunits([dyn,eV]);
          (%o4)                                done
          (%i5) kg*m/s^2;
          (%o5)                           (100000) (dyn)
          (%i6) kg*m^2/s^2;
          (%o6)                     (6241509596477042688) (eV)
          (%i7) uforget([dyn,eV]);
          (%o7)                          [false, false]
          (%i8) kg*m/s^2;
          (%o8)                                  N
          (%i9) kg*m^2/s^2;
          (%o9)                                  J
          (%i10) dontusedimension(N);
          (%o10)                             [%force]
          (%i11) dontusedimension(J);
          (%o11)                         [%energy, %force]
          (%i12) kg*m/s^2;
                                               kg m
          (%o12)                               ----
                                                 2
                                                s
          (%i13) kg*m^2/s^2;
                                                   2
                                               kg m
          (%o13)                               -----
                                                 2
                                                s
          (%i14) setunits([dyn,eV]);
          (%o14)                               done
          (%i15) kg*m/s^2;
                                               kg m
          (%o15)                               ----
                                                 2
                                                s
          (%i16) kg*m^2/s^2;
                                                   2
                                               kg m
          (%o16)                               -----
                                                 2
                                                s
          (%i17) uforget([dyn,eV]);
          (%o17)                         [false, false]
          (%i18) kg*m/s^2;
                                               kg m
          (%o18)                               ----
                                                 2
                                                s
          (%i19) kg*m^2/s^2;
                                                   2
                                               kg m
          (%o19)                               -----
                                                 2
                                                s
          (%i20) usedimension(N);
          Done.  To have Maxima simplify to this dimension, use setunits([unit])
          to select a unit.
          (%o20)                               true
          (%i21) usedimension(J);
          Done.  To have Maxima simplify to this dimension, use setunits([unit])
          to select a unit.
          (%o21)                               true
          (%i22) kg*m/s^2;
                                               kg m
          (%o22)                               ----
                                                 2
                                                s
          (%i23) kg*m^2/s^2;
                                                   2
                                               kg m
          (%o23)                               -----
                                                 2
                                                s
          (%i24) setunits([dyn,eV]);
          (%o24)                               done
          (%i25) kg*m/s^2;
          (%o25)                          (100000) (dyn)
          (%i26) kg*m^2/s^2;
          (%o26)                    (6241509596477042688) (eV)
          (%i27) uforget([dyn,eV]);
          (%o27)                           [false, false]
          (%i28) kg*m/s^2;
          (%o28)                                 N
          (%i29) kg*m^2/s^2;
          (%o29)                                 J
          (%i30) kill(usersetunits);
          (%o30)                               done
          (%i31) uforget([dyn,eV]);
          (%o31)                          [false, false]
          (%i32) kg*m/s^2;
                                               kg m
          (%o32)                               ----
                                                 2
                                                s
          (%i33) kg*m^2/s^2;
                                                   2
                                               kg m
          (%o33)                               -----
                                                 2
                                                s
     Desafortunadamente essa ampla variedade de opções é um pouco confus
     no início, mas uma vez que o usuário cultiva o uso delas o usuário
     perceberá que elas permitem completo controle sobre seu ambiente de
     trabalho.

 -- Função: metricexpandall (<x>)
     Reconstrói listas de unidades globais automaticamente criando todas
     as unidades métricas desejadas.  <x> é um argumento numérico que é
     usado para especificar quantos prefixos métricos o usuário deseja
     que seja definido.  Os argumentos são os seguintes, com cada maior
     número definindo todos os menores números de unidade:
                     0 - none. Only base units
                     1 - kilo, centi, milli
          (default)  2 - giga, mega, kilo, hecto, deka, deci, centi, milli,
                         micro, nano
                     3 - peta, tera, giga, mega, kilo, hecto, deka, deci,
                         centi, milli, micro, nano, pico, femto
                     4 - all
     Normalmente, Maxima não irá definir a expansão completa desses
     resultados em uma grande número de unidades, mas 'metricexpandall'
     pode ser usada para reconstruir a lista em um estilo mais ou menos
     completo.  A variável relevante no arquivo _unit.mac_ é
     <%unitexpand>.

 -- Variável: %unitexpand
     Valor padrão: '2'

     Ess é o valor fornecido a 'metricexpandall' durante a inicialização
     de _unit_.


File: maxima.info,  Node: zeilberger,  Next: Índice de Funções e Variáveis,  Prev: unit,  Up: Top

75 zeilberger
*************

* Menu:

* Introdução a zeilberger::
* Funções e Variáveis Definidas para zeilberger::


File: maxima.info,  Node: Introdução a zeilberger,  Next: Funções e Variáveis Definidas para zeilberger,  Prev: zeilberger,  Up: zeilberger

75.1 Introdução a zeilberger
============================

'zeilberger' é uma implementação do algorítmo de Zeilberger para
somatório hipergeométricos definidos, e também para o algorítmo de
Gosper para somatórios hipergeométricos indefinidos.

   'zeilberger' faz uso do método de otimização "filtering" desenvolvido
por Axel Riese.

   'zeilberger' foi desenvolvido por Fabrizio Caruso.

   'load (zeilberger)' torna esse pacote disponível para uso.

75.1.1 O problema dos somatórios hipergeométricos indefinidos
-------------------------------------------------------------

'zeilberger' implementa o algorítmo de Gosper para somatório
hipergeométrico indefinido.  Dado um termo hipergeométrico F_k em k
queremos encontrar sua anti-diferença hipergeométrica, isto é, um termo
hipergeométrico f_k tal que F_k = f_(k+1) - f_k.

75.1.2 O problema dos somatórios hipergeométricos definidos
-----------------------------------------------------------

'zeilberger' implementa o algorítmo de Zeilberger para somatório
hipergeométrico definido.  Dado um termo hipergeométrico apropriado (em
n e k) F_(n,k) e um inteiro positivo d queremos encontrar um d-ésima
ordem de recorrência linear com coeficientes polinomiais (em n) para
F_(n,k) e uma função racional R em n e k tal que

   a_0 F_(n,k) + ... + a_d F_(n+d),k = Delta_K(R(n,k) F_(n,k))

   onde Delta_k é o k-seguinte operador de diferença, i.e., Delta_k(t_k)
:= t_(k+1) - t_k.

75.1.3 Níveis de detalhe nas informações
----------------------------------------

Existe também versões de níveis de detalhe fornecidos pelos comandos que
são chamados (os níveis) através da adição de um dos seguintes prefixos:

'Summary'
     Apenas um sumário é mostrado no final
'Verbose'
     Algumas informações nos passos intermediários
'VeryVerbose'
     Muita informação
'Extra'
     Muito mais informação incluindo informação sobre o sistema linear
     no algorítmo de Zeilberger

   Por exemplo: 'GosperVerbose', 'parGosperVeryVerbose',
'ZeilbergerExtra', 'AntiDifferenceSummary'.


File: maxima.info,  Node: Funções e Variáveis Definidas para zeilberger,  Prev: Introdução a zeilberger,  Up: zeilberger

75.2 Funções e Variáveis Definidas para zeilberger
==================================================

 -- Função: AntiDifference (<F_k>, <k>)

     Retorna a anti-diferença hipergeométrica de <F_k>, se essa
     anti-diferença.  De outra forma 'AntiDifference' retorna
     'no_hyp_antidifference'.

 -- Função: Gosper (<F_k>, <k>)
     Retorna o certificado racional <R(k)> para <F_k>, isto é, uma
     função racional tal que

     F_k = R(k+1) F_(k+1) - R(k) F_k

     se essa função racional exitir.  De outra forma, 'Gosper' retorna
     'no_hyp_sol'.

 -- Função: GosperSum (<F_k>, <k>, <a>, <b>)

     Retorna o somatório de <F_k> de <k> = <a> a <k> = <b> se <F_k>
     tiver ma diferença hipergeométrica.  De outra forma, 'GosperSum'
     retorna 'nongosper_summable'.

     Exemplos:

          (%i1) load (zeilberger);
          (%o1)  /usr/share/maxima/share/contrib/Zeilberger/zeilberger.mac
          (%i2) GosperSum ((-1)^k*k / (4*k^2 - 1), k, 1, n);

          Dependent equations eliminated:  (1)
                                     3       n + 1
                                (n + -) (- 1)
                                     2               1
          (%o2)               - ------------------ - -
                                            2        4
                                2 (4 (n + 1)  - 1)
          (%i3) GosperSum (1 / (4*k^2 - 1), k, 1, n);
                                          3
                                    - n - -
                                          2       1
          (%o3)                  -------------- + -
                                          2       2
                                 4 (n + 1)  - 1
          (%i4) GosperSum (x^k, k, 1, n);
                                    n + 1
                                   x          x
          (%o4)                    ------ - -----
                                   x - 1    x - 1
          (%i5) GosperSum ((-1)^k*a! / (k!*(a - k)!), k, 1, n);
                                          n + 1
                          a! (n + 1) (- 1)              a!
          (%o5)       - ------------------------- - ----------
                        a (- n + a - 1)! (n + 1)!   a (a - 1)!
          (%i6) GosperSum (k*k!, k, 1, n);

          Dependent equations eliminated:  (1)
          (%o6)                     (n + 1)! - 1
          (%i7) GosperSum ((k + 1)*k! / (k + 1)!, k, 1, n);
                            (n + 1) (n + 2) (n + 1)!
          (%o7)             ------------------------ - 1
                                    (n + 2)!
          (%i8) GosperSum (1 / ((a - k)!*k!), k, 1, n);
          (%o8)                  nonGosper_summable

 -- Função: parGosper (<F_{n,k}>, <k>, <n>, <d>)
     Tenta encontrar uma recorrência de <d>-ésima ordem para <F_{n,k}>.

     O algorítmo retorna uma seqüência [s_1, s_2, ..., s_m] de soluções.
     Cada solução tem a forma

     [R(n, k), [a_0, a_1, ..., a_d]]

     'parGosper' retorna '[]' caso não consiga encontrar uma
     recorrência.

 -- Função: Zeilberger (<F_{n,k}>, <k>, <n>)
     Tenta calcular o somatório hipergeométrico indefinido de <F_{n,k}>.

     'Zeilberger' primeiro invoca 'Gosper', e se 'Gosper' não conseguir
     encontrar uma solução, então 'Zeilberger' invoca 'parGosper'com
     ordem 1, 2, 3, ..., acima de 'MAX_ORD'.  Se Zeilberger encontrar
     uma solução antes de esticar 'MAX_ORD', Zeilberger para e retorna a
     solução.

     O algorítmo retorna uma seqüência [s_1, s_2, ..., s_m] de soluções.
     Cada solução tem a forma

     [R(n,k), [a_0, a_1, ..., a_d]]

     'Zeilberger' retorna '[]' se não conseguir encontrar uma solução.

     'Zeilberger' invoca 'Gosper' somente se 'gosper_in_zeilberger' for
     'true'.

75.3 Variáveis globais gerais
=============================

 -- Variável global: MAX_ORD
     Valor padrão: 5

     'MAX_ORD' é a ordem máxima de recorrência tentada por 'Zeilberger'.

 -- Variável global: simplified_output
     Valor padrão: 'false'

     Quando 'simplified_output' for 'true', funções no pacote
     'zeilberger' tentam simplificação adicional da solução.

 -- Variável global: linear_solver
     Valor padrão: 'linsolve'

     'linear_solver' nomeia o resolvedor que é usado para resolver o
     sistema de equações no algorítmo de Zeilberger.

 -- Variável global: warnings
     Valor padrão: 'true'

     Quando 'warnings' for 'true', funções no pacote 'zeilberger'
     imprimem mensagens de alerta durante a execução.

 -- Variável global: gosper_in_zeilberger
     Valor padrão: 'true'

     Quando 'gosper_in_zeilberger' for 'true', a função 'Zeilberger'
     chama 'Gosper' antes de chamar 'parGosper'.  De outra forma,
     'Zeilberger' vai imediatamente para 'parGosper'.

 -- Variável global: trivial_solutions
     Valor padrão: 'true'

     Quando 'trivial_solutions' for 'true', 'Zeilberger' retorna
     soluções que possuem certificado igual a zero, ou todos os
     coeficientes iguais a zero.

75.4 Variáveis relacionadas ao teste modular
============================================

 -- Variável global: mod_test
     Valor padrão: 'false'

     Quando 'mod_test' for 'true', 'parGosper' executa um teste modular
     discartando sistemas sem solução.

 -- Variável global: modular_linear_solver
     Valor padrão: 'linsolve'

     'modular_linear_solver' nomeia o resolvedor linear usado pelo teste
     modular em 'parGosper'.

 -- Variável global: ev_point
     Valor padrão: 'big_primes[10]'

     'ev_point' é o valor no qual a variável <n> é avaliada no momento
     da execução do teste modular em 'parGosper'.

 -- Variável global: mod_big_prime
     Valor padrão: 'big_primes[1]'

     'mod_big_prime' é o módulo usado pelo teste modular em 'parGosper'.

 -- Variável global: mod_threshold
     Valor padrão: 4

     'mod_threshold' is the maior ordem para a qual o teste modular em
     'parGosper' é tentado.


File: maxima.info,  Node: Índice de Funções e Variáveis,  Prev: zeilberger,  Up: Top

76 Índice de Funções e Variáveis
********************************

Appendix A Índice de Funções e Variáveis
****************************************

[index]
* Menu:

* !:                                     Operadores Geral.   (line    8)
* !!:                                    Operadores Geral.   (line   67)
* #:                                     Operadores Geral.   (line   85)
* %:                                     Funções e Variáveis Definidas para Entrada e Saída.
                                                             (line   92)
* %%:                                    Funções e Variáveis Definidas para Entrada e Saída.
                                                             (line  105)
* %c:                                    Funções e Variáveis Definidas para contrib_ode.
                                                             (line   76)
* %e:                                    Funções e Variáveis Definidas para Constantes.
                                                             (line    6)
* %edispflag:                            Funções e Variáveis Definidas para Entrada e Saída.
                                                             (line  139)
* %emode:                                Funções e Variáveis Definidas para Expressões.
                                                             (line  551)
* %enumer:                               Funções e Variáveis Definidas para Expressões.
                                                             (line  568)
* %e_to_numlog:                          Funções e Variáveis Definidas para Logarítmos.
                                                             (line    6)
* %gamma:                                Funções e Variáveis Definidas para Teoria dos Números.
                                                             (line  220)
* %i:                                    Funções e Variáveis Definidas para Constantes.
                                                             (line   11)
* %k1:                                   Funções e Variáveis Definidas para contrib_ode.
                                                             (line   80)
* %k2:                                   Funções e Variáveis Definidas para contrib_ode.
                                                             (line   85)
* %phi:                                  Funções e Variáveis Definidas para Constantes.
                                                             (line   27)
* %pi:                                   Funções e Variáveis Definidas para Constantes.
                                                             (line   81)
* %rnum_list:                            Funções e Variáveis Definidas para Equações.
                                                             (line    6)
* %th:                                   Funções e Variáveis Definidas para Entrada e Saída.
                                                             (line  146)
* %unitexpand:                           Funções e Variáveis Definidas para Units.
                                                             (line  416)
* ':                                     Introdução a Linha de Comando.
                                                             (line    6)
* '':                                    Introdução a Linha de Comando.
                                                             (line   90)
* *:                                     Operadores Aritméticos.
                                                             (line    8)
* **:                                    Operadores Aritméticos.
                                                             (line  172)
* +:                                     Operadores Aritméticos.
                                                             (line    6)
* -:                                     Operadores Aritméticos.
                                                             (line    7)
* .:                                     Operadores Geral.   (line  112)
* /:                                     Operadores Aritméticos.
                                                             (line    9)
* ::                                     Operadores Geral.   (line  123)
* :::                                    Operadores Geral.   (line  126)
* ::=:                                   Operadores Geral.   (line  131)
* :=:                                    Operadores Geral.   (line  217)
* <:                                     Operadores Relacionais.
                                                             (line    6)
* <=:                                    Operadores Relacionais.
                                                             (line    7)
* =:                                     Operadores Geral.   (line  221)
* >:                                     Operadores Relacionais.
                                                             (line    9)
* >=:                                    Operadores Relacionais.
                                                             (line    8)
* ?:                                     Funções e Variáveis Definidas para Entrada e Saída.
                                                             (line  167)
* ??:                                    Funções e Variáveis Definidas para Entrada e Saída.
                                                             (line  179)
* [:                                     Funções e Variáveis Definidas para Matrizes e Álgebra Linear.
                                                             (line 1133)
* ]:                                     Funções e Variáveis Definidas para Matrizes e Álgebra Linear.
                                                             (line 1134)
* ^:                                     Operadores Aritméticos.
                                                             (line   10)
* ^^:                                    Operadores Geral.   (line    6)
* _:                                     Funções e Variáveis Definidas para Entrada e Saída.
                                                             (line   46)
* __:                                    Funções e Variáveis Definidas para Entrada e Saída.
                                                             (line    6)
* |:                                     Funções e Variáveis Definidas para itensor.
                                                             (line 1408)
* ~:                                     Funções e Variáveis Definidas para itensor.
                                                             (line 1375)
* abasep:                                Funções e Variáveis Definidas para o Pacote atensor.
                                                             (line  133)
* abs:                                   Operadores Geral.   (line  374)
* absboxchar:                            Funções e Variáveis Definidas para Entrada e Saída.
                                                             (line  186)
* absint:                                Funções e Variáveis Definidas para Séries de Fourier.
                                                             (line   28)
* absint <1>:                            Funções e Variáveis Definidas para Séries de Fourier.
                                                             (line   29)
* absint <2>:                            Funções e Variáveis Definidas para Séries de Fourier.
                                                             (line   30)
* absolute_real_time:                    Funções e Variáveis Definidas para Ambiente em Tempo de Execução.
                                                             (line  124)
* acos:                                  Funções e Variáveis Definidas para Trigonometria.
                                                             (line    6)
* acosh:                                 Funções e Variáveis Definidas para Trigonometria.
                                                             (line    9)
* acot:                                  Funções e Variáveis Definidas para Trigonometria.
                                                             (line   12)
* acoth:                                 Funções e Variáveis Definidas para Trigonometria.
                                                             (line   15)
* acsc:                                  Funções e Variáveis Definidas para Trigonometria.
                                                             (line   18)
* acsch:                                 Funções e Variáveis Definidas para Trigonometria.
                                                             (line   21)
* activate:                              Funções e Variáveis Definidas para Contextos.
                                                             (line    6)
* activecontexts:                        Funções e Variáveis Definidas para Contextos.
                                                             (line   15)
* adapt_depth:                           Funções e Variáveis Definidas para draw.
                                                             (line 1048)
* addcol:                                Funções e Variáveis Definidas para Matrizes e Álgebra Linear.
                                                             (line    6)
* additive:                              Operadores Geral.   (line  378)
* addmatrices:                           Funções e Variáveis Definidas para linearalgebra.
                                                             (line    6)
* addrow:                                Funções e Variáveis Definidas para Matrizes e Álgebra Linear.
                                                             (line   10)
* adim:                                  Funções e Variáveis Definidas para o Pacote atensor.
                                                             (line   77)
* Adição:                                Operadores Aritméticos.
                                                             (line    7)
* adjoin:                                Funções e Variáveis Definidas para Conjuntos.
                                                             (line    6)
* adjoint:                               Funções e Variáveis Definidas para Matrizes e Álgebra Linear.
                                                             (line   14)
* af:                                    Funções e Variáveis Definidas para o Pacote atensor.
                                                             (line  101)
* aform:                                 Funções e Variáveis Definidas para o Pacote atensor.
                                                             (line   84)
* agd:                                   Funções e Variáveis Definidas para simplification.
                                                             (line  253)
* airy_ai:                               Funções e Variáveis Definidas para Funções Especiais.
                                                             (line    6)
* airy_bi:                               Funções e Variáveis Definidas para Funções Especiais.
                                                             (line   25)
* airy_dai:                              Funções e Variáveis Definidas para Funções Especiais.
                                                             (line   20)
* airy_dbi:                              Funções e Variáveis Definidas para Funções Especiais.
                                                             (line   39)
* Ajuda:                                 Funções e Variáveis Definidas para Ajuda.
                                                             (line   93)
* algebraic:                             Funções e Variáveis Definidas para Polinômios.
                                                             (line    6)
* algepsilon:                            Funções e Variáveis Definidas para ponto Flutuante.
                                                             (line   14)
* algexact:                              Funções e Variáveis Definidas para Equações.
                                                             (line   15)
* algsys:                                Funções e Variáveis Definidas para Equações.
                                                             (line   31)
* algsys <1>:                            Funções e Variáveis Definidas para Equações.
                                                             (line   32)
* alg_type:                              Funções e Variáveis Definidas para o Pacote atensor.
                                                             (line   72)
* alias:                                 Funções e Variáveis Definidas para Linha de Comando.
                                                             (line    6)
* aliases:                               Funções e Variáveis Definidas para Opções Diversas.
                                                             (line    6)
* allbut:                                Operadores Geral.   (line  393)
* allroots:                              Funções e Variáveis Definidas para Equações.
                                                             (line  132)
* allroots <1>:                          Funções e Variáveis Definidas para Equações.
                                                             (line  133)
* allsym:                                Funções e Variáveis Definidas para itensor.
                                                             (line  516)
* all_dotsimp_denoms:                    Funções e Variáveis Definidas para Funções Afins.
                                                             (line  129)
* alphabetic:                            Funções e Variáveis Definidas para Opções Diversas.
                                                             (line   14)
* alphacharp:                            Funções e Variáveis para caracteres.
                                                             (line    6)
* alphanumericp:                         Funções e Variáveis para caracteres.
                                                             (line    9)
* and:                                   Operadores Geral.   (line  315)
* antid:                                 Funções e Variáveis Definidas para Diferenciação.
                                                             (line    6)
* antidiff:                              Funções e Variáveis Definidas para Diferenciação.
                                                             (line   60)
* AntiDifference:                        Funções e Variáveis Definidas para zeilberger.
                                                             (line    6)
* antisymmetric:                         Operadores Geral.   (line  421)
* append:                                Funções e Variáveis Definidas para Listas.
                                                             (line    6)
* appendfile:                            Funções e Variáveis Definidas para Entrada e Saída.
                                                             (line  208)
* apply:                                 Funções e Variáveis para Definição de Função.
                                                             (line    6)
* apply1:                                Funções e Variáveis Definidas para Regras e Modelos.
                                                             (line    6)
* apply2:                                Funções e Variáveis Definidas para Regras e Modelos.
                                                             (line   20)
* applyb1:                               Funções e Variáveis Definidas para Regras e Modelos.
                                                             (line   33)
* apropos:                               Funções e Variáveis Definidas para Opções Diversas.
                                                             (line   33)
* args:                                  Funções e Variáveis Definidas para Opções Diversas.
                                                             (line   44)
* arithmetic:                            Funções e Variáveis Definidas para simplification.
                                                             (line  212)
* arithsum:                              Funções e Variáveis Definidas para simplification.
                                                             (line  230)
* array:                                 Funções e Variáveis Definidas para Arrays.
                                                             (line    6)
* array <1>:                             Funções e Variáveis Definidas para Arrays.
                                                             (line    7)
* array <2>:                             Funções e Variáveis Definidas para Arrays.
                                                             (line    8)
* arrayapply:                            Funções e Variáveis Definidas para Arrays.
                                                             (line   37)
* arrayinfo:                             Funções e Variáveis Definidas para Arrays.
                                                             (line   44)
* arraymake:                             Funções e Variáveis Definidas para Arrays.
                                                             (line  140)
* arrays:                                Funções e Variáveis Definidas para Arrays.
                                                             (line  185)
* ascii:                                 Funções e Variáveis para caracteres.
                                                             (line   13)
* asec:                                  Funções e Variáveis Definidas para Trigonometria.
                                                             (line   24)
* asech:                                 Funções e Variáveis Definidas para Trigonometria.
                                                             (line   27)
* asin:                                  Funções e Variáveis Definidas para Trigonometria.
                                                             (line   30)
* asinh:                                 Funções e Variáveis Definidas para Trigonometria.
                                                             (line   33)
* askexp:                                Funções e Variáveis Definidas para Simplificação.
                                                             (line    6)
* askinteger:                            Funções e Variáveis Definidas para Simplificação.
                                                             (line   13)
* askinteger <1>:                        Funções e Variáveis Definidas para Simplificação.
                                                             (line   14)
* askinteger <2>:                        Funções e Variáveis Definidas para Simplificação.
                                                             (line   15)
* askinteger <3>:                        Funções e Variáveis Definidas para Simplificação.
                                                             (line   16)
* asksign:                               Funções e Variáveis Definidas para Simplificação.
                                                             (line   29)
* assoc:                                 Funções e Variáveis Definidas para Listas.
                                                             (line   14)
* assoc <1>:                             Funções e Variáveis Definidas para Listas.
                                                             (line   15)
* assoc_legendre_p:                      Funções e Variáveis Definidas para polinômios ortogonais.
                                                             (line    6)
* assoc_legendre_q:                      Funções e Variáveis Definidas para polinômios ortogonais.
                                                             (line   12)
* assume:                                Funções e Variáveis Definidas para Contextos.
                                                             (line   22)
* assumescalar:                          Funções e Variáveis Definidas para Contextos.
                                                             (line   76)
* assume_pos:                            Funções e Variáveis Definidas para Contextos.
                                                             (line   99)
* assume_pos_pred:                       Funções e Variáveis Definidas para Contextos.
                                                             (line  124)
* asymbol:                               Funções e Variáveis Definidas para o Pacote atensor.
                                                             (line   89)
* asympa:                                Funções e Variáveis Definidas para Funções Especiais.
                                                             (line   44)
* at:                                    Funções e Variáveis Definidas para Expressões.
                                                             (line    6)
* at <1>:                                Funções e Variáveis Definidas para Expressões.
                                                             (line    7)
* atan:                                  Funções e Variáveis Definidas para Trigonometria.
                                                             (line   36)
* atan2:                                 Funções e Variáveis Definidas para Trigonometria.
                                                             (line   39)
* atanh:                                 Funções e Variáveis Definidas para Trigonometria.
                                                             (line   43)
* atensimp:                              Funções e Variáveis Definidas para o Pacote atensor.
                                                             (line   63)
* atom:                                  Funções e Variáveis Definidas para Listas.
                                                             (line   24)
* atomgrad:                              Funções e Variáveis Definidas para Diferenciação.
                                                             (line  110)
* atrig1:                                Funções e Variáveis Definidas para Trigonometria.
                                                             (line   46)
* atvalue:                               Funções e Variáveis Definidas para Diferenciação.
                                                             (line  115)
* atvalue <1>:                           Funções e Variáveis Definidas para Diferenciação.
                                                             (line  116)
* augcoefmatrix:                         Funções e Variáveis Definidas para Matrizes e Álgebra Linear.
                                                             (line   18)
* augmented_lagrangian_method:           Funções e Variáveis Definidas para augmented_lagrangian.
                                                             (line    6)
* augmented_lagrangian_method <1>:       Funções e Variáveis Definidas para augmented_lagrangian.
                                                             (line    7)
* av:                                    Funções e Variáveis Definidas para o Pacote atensor.
                                                             (line  108)
* axis_3d:                               Funções e Variáveis Definidas para draw.
                                                             (line  533)
* axis_bottom:                           Funções e Variáveis Definidas para draw.
                                                             (line  465)
* axis_left:                             Funções e Variáveis Definidas para draw.
                                                             (line  482)
* axis_right:                            Funções e Variáveis Definidas para draw.
                                                             (line  516)
* axis_top:                              Funções e Variáveis Definidas para draw.
                                                             (line  499)
* backsubst:                             Funções e Variáveis Definidas para Equações.
                                                             (line  190)
* backtrace:                             Funções e Variáveis Definidas para Fluxo de Programa.
                                                             (line    6)
* backtrace <1>:                         Funções e Variáveis Definidas para Fluxo de Programa.
                                                             (line    7)
* barsplot:                              Funções e Variáveis Definidas para gráficos estatísticos.
                                                             (line  170)
* barsplot <1>:                          Funções e Variáveis Definidas para gráficos estatísticos.
                                                             (line  171)
* barsplot <2>:                          Funções e Variáveis Definidas para gráficos estatísticos.
                                                             (line  172)
* barsplot <3>:                          Funções e Variáveis Definidas para gráficos estatísticos.
                                                             (line  173)
* Base do logarítmo natural:             Funções e Variáveis Definidas para Constantes.
                                                             (line    7)
* bashindices:                           Funções e Variáveis Definidas para Arrays.
                                                             (line  214)
* batch:                                 Funções e Variáveis Definidas para Entrada e Saída.
                                                             (line  217)
* batchload:                             Funções e Variáveis Definidas para Entrada e Saída.
                                                             (line  253)
* bc2:                                   Funções e Variáveis Definidas para Equações Diferenciais.
                                                             (line    6)
* bdvac:                                 Funções e Variáveis Definidas para ctensor.
                                                             (line  788)
* belln:                                 Funções e Variáveis Definidas para Conjuntos.
                                                             (line   24)
* berlefact:                             Funções e Variáveis Definidas para Polinômios.
                                                             (line   12)
* bern:                                  Funções e Variáveis Definidas para Teoria dos Números.
                                                             (line    6)
* bernpoly:                              Funções e Variáveis Definidas para Teoria dos Números.
                                                             (line   24)
* bessel:                                Funções e Variáveis Definidas para Funções Especiais.
                                                             (line   52)
* besselexpand:                          Funções e Variáveis Definidas para Funções Especiais.
                                                             (line  122)
* bessel_i:                              Funções e Variáveis Definidas para Funções Especiais.
                                                             (line   89)
* bessel_j:                              Funções e Variáveis Definidas para Funções Especiais.
                                                             (line   58)
* bessel_k:                              Funções e Variáveis Definidas para Funções Especiais.
                                                             (line  107)
* bessel_y:                              Funções e Variáveis Definidas para Funções Especiais.
                                                             (line   75)
* beta:                                  Funções e Variáveis Definidas para Funções Especiais.
                                                             (line  160)
* bezout:                                Funções e Variáveis Definidas para Polinômios.
                                                             (line   19)
* bffac:                                 Funções e Variáveis Definidas para ponto Flutuante.
                                                             (line    6)
* bfhzeta:                               Funções e Variáveis Definidas para Teoria dos Números.
                                                             (line   34)
* bfloat:                                Funções e Variáveis Definidas para ponto Flutuante.
                                                             (line   19)
* bfloatp:                               Funções e Variáveis Definidas para ponto Flutuante.
                                                             (line   30)
* bfpsi:                                 Funções e Variáveis Definidas para ponto Flutuante.
                                                             (line   34)
* bfpsi0:                                Funções e Variáveis Definidas para ponto Flutuante.
                                                             (line   35)
* bftorat:                               Funções e Variáveis Definidas para ponto Flutuante.
                                                             (line   46)
* bftrunc:                               Funções e Variáveis Definidas para ponto Flutuante.
                                                             (line   55)
* bfzeta:                                Funções e Variáveis Definidas para Teoria dos Números.
                                                             (line   27)
* bimetric:                              Funções e Variáveis Definidas para ctensor.
                                                             (line  812)
* binomial:                              Funções e Variáveis Definidas para Teoria dos Números.
                                                             (line   45)
* block:                                 Funções e Variáveis para Definição de Função.
                                                             (line   65)
* block <1>:                             Funções e Variáveis para Definição de Função.
                                                             (line   66)
* blockmatrixp:                          Funções e Variáveis Definidas para linearalgebra.
                                                             (line   21)
* bode_gain:                             Funções e Variáveis Definidas para bode.
                                                             (line    6)
* bode_phase:                            Funções e Variáveis Definidas para bode.
                                                             (line   51)
* border:                                Funções e Variáveis Definidas para draw.
                                                             (line  755)
* bothcoef:                              Funções e Variáveis Definidas para Polinômios.
                                                             (line   23)
* box:                                   Funções e Variáveis Definidas para Expressões.
                                                             (line   52)
* box <1>:                               Funções e Variáveis Definidas para Expressões.
                                                             (line   53)
* boxchar:                               Funções e Variáveis Definidas para Expressões.
                                                             (line  101)
* boxplot:                               Funções e Variáveis Definidas para gráficos estatísticos.
                                                             (line  224)
* boxplot <1>:                           Funções e Variáveis Definidas para gráficos estatísticos.
                                                             (line  225)
* break:                                 Funções e Variáveis para Definição de Função.
                                                             (line  115)
* breakup:                               Funções e Variáveis Definidas para Equações.
                                                             (line  199)
* bug_report:                            Definições para Detecção e Relato de Erros.
                                                             (line   52)
* buildq:                                Macros.             (line    6)
* build_info:                            Definições para Detecção e Relato de Erros.
                                                             (line   62)
* burn:                                  Funções e Variáveis Definidas para Teoria dos Números.
                                                             (line   68)
* cabs:                                  Operadores Geral.   (line  429)
* canform:                               Funções e Variáveis Definidas para itensor.
                                                             (line  579)
* canten:                                Funções e Variáveis Definidas para itensor.
                                                             (line  497)
* cardinality:                           Funções e Variáveis Definidas para Conjuntos.
                                                             (line   51)
* carg:                                  Funções e Variáveis Definidas para Expressões.
                                                             (line  114)
* cartan:                                Funções e Variáveis Definidas para Diferenciação.
                                                             (line  171)
* cartesian_product:                     Funções e Variáveis Definidas para Conjuntos.
                                                             (line   69)
* catch:                                 Funções e Variáveis para Definição de Função.
                                                             (line  121)
* cauchysum:                             Funções e Variáveis Definidas para Séries.
                                                             (line    6)
* cbffac:                                Funções e Variáveis Definidas para ponto Flutuante.
                                                             (line   63)
* cdf_bernoulli:                         Funções e Variáveis Definidas para distribuições discretas.
                                                             (line  186)
* cdf_beta:                              Funções e Variáveis Definidas para distribuições contínuas.
                                                             (line  778)
* cdf_binomial:                          Funções e Variáveis Definidas para distribuições discretas.
                                                             (line   12)
* cdf_cauchy:                            Funções e Variáveis Definidas para distribuições contínuas.
                                                             (line 1286)
* cdf_chi2:                              Funções e Variáveis Definidas para distribuições contínuas.
                                                             (line  198)
* cdf_continuous_uniform:                Funções e Variáveis Definidas para distribuições contínuas.
                                                             (line  861)
* cdf_discrete_uniform:                  Funções e Variáveis Definidas para distribuições discretas.
                                                             (line  362)
* cdf_exp:                               Funções e Variáveis Definidas para distribuições contínuas.
                                                             (line  463)
* cdf_f:                                 Funções e Variáveis Definidas para distribuições contínuas.
                                                             (line  355)
* cdf_gamma:                             Funções e Variáveis Definidas para distribuições contínuas.
                                                             (line  694)
* cdf_geometric:                         Funções e Variáveis Definidas para distribuições discretas.
                                                             (line  291)
* cdf_gumbel:                            Funções e Variáveis Definidas para distribuições contínuas.
                                                             (line 1311)
* cdf_hypergeometric:                    Funções e Variáveis Definidas para distribuições discretas.
                                                             (line  419)
* cdf_laplace:                           Funções e Variáveis Definidas para distribuições contínuas.
                                                             (line 1237)
* cdf_logistic:                          Funções e Variáveis Definidas para distribuições contínuas.
                                                             (line  915)
* cdf_lognormal:                         Funções e Variáveis Definidas para distribuições contínuas.
                                                             (line  629)
* cdf_negative_binomial:                 Funções e Variáveis Definidas para distribuições discretas.
                                                             (line  501)
* cdf_normal:                            Funções e Variáveis Definidas para distribuições contínuas.
                                                             (line   11)
* cdf_pareto:                            Funções e Variáveis Definidas para distribuições contínuas.
                                                             (line  964)
* cdf_poisson:                           Funções e Variáveis Definidas para distribuições discretas.
                                                             (line   98)
* cdf_rank_sum:                          Funções e Variáveis Definidas para distribuições especiais.
                                                             (line   27)
* cdf_rayleigh:                          Funções e Variáveis Definidas para distribuições contínuas.
                                                             (line 1076)
* cdf_signed_rank:                       Funções e Variáveis Definidas para distribuições especiais.
                                                             (line   13)
* cdf_student_t:                         Funções e Variáveis Definidas para distribuições contínuas.
                                                             (line   89)
* cdf_weibull:                           Funções e Variáveis Definidas para distribuições contínuas.
                                                             (line 1013)
* cdisplay:                              Funções e Variáveis Definidas para ctensor.
                                                             (line  838)
* ceiling:                               Operadores Geral.   (line  432)
* central_moment:                        Funções e Variáveis Definidas para estatística descritiva.
                                                             (line  140)
* central_moment <1>:                    Funções e Variáveis Definidas para estatística descritiva.
                                                             (line  141)
* cequal:                                Funções e Variáveis para caracteres.
                                                             (line   22)
* cequalignore:                          Funções e Variáveis para caracteres.
                                                             (line   25)
* cf:                                    Funções e Variáveis Definidas para Teoria dos Números.
                                                             (line   81)
* cfdisrep:                              Funções e Variáveis Definidas para Teoria dos Números.
                                                             (line  145)
* cfexpand:                              Funções e Variáveis Definidas para Teoria dos Números.
                                                             (line  161)
* cflength:                              Funções e Variáveis Definidas para Teoria dos Números.
                                                             (line  177)
* cframe_flag:                           Funções e Variáveis Definidas para ctensor.
                                                             (line 1085)
* cgeodesic:                             Funções e Variáveis Definidas para ctensor.
                                                             (line  782)
* cgreaterp:                             Funções e Variáveis para caracteres.
                                                             (line   28)
* cgreaterpignore:                       Funções e Variáveis para caracteres.
                                                             (line   32)
* changename:                            Funções e Variáveis Definidas para itensor.
                                                             (line   17)
* changevar:                             Funções e Variáveis Definidas para Integração.
                                                             (line    6)
* chaosgame:                             Funções e Variáveis Definidas para dynamics.
                                                             (line    6)
* charat:                                Funções e Variáveis para seqüências de caracteres.
                                                             (line   19)
* charfun:                               Operadores Geral.   (line  477)
* charfun2:                              Funções e Variáveis Definidas para interpol.
                                                             (line   59)
* charlist:                              Funções e Variáveis para seqüências de caracteres.
                                                             (line   26)
* charp:                                 Funções e Variáveis para caracteres.
                                                             (line   35)
* charpoly:                              Funções e Variáveis Definidas para Matrizes e Álgebra Linear.
                                                             (line   31)
* chebyshev_t:                           Funções e Variáveis Definidas para polinômios ortogonais.
                                                             (line   17)
* chebyshev_u:                           Funções e Variáveis Definidas para polinômios ortogonais.
                                                             (line   22)
* checkdiv:                              Funções e Variáveis Definidas para ctensor.
                                                             (line  772)
* check_overlaps:                        Funções e Variáveis Definidas para Funções Afins.
                                                             (line   86)
* cholesky:                              Funções e Variáveis Definidas para linearalgebra.
                                                             (line   68)
* cholesky <1>:                          Funções e Variáveis Definidas para linearalgebra.
                                                             (line   69)
* christof:                              Funções e Variáveis Definidas para ctensor.
                                                             (line  187)
* cint:                                  Funções e Variáveis para caracteres.
                                                             (line   40)
* clear_rules:                           Funções e Variáveis Definidas para Regras e Modelos.
                                                             (line  954)
* clessp:                                Funções e Variáveis para caracteres.
                                                             (line   43)
* clesspignore:                          Funções e Variáveis para caracteres.
                                                             (line   47)
* close:                                 Funções e Variáveis para entrada e saída.
                                                             (line   24)
* closefile:                             Funções e Variáveis Definidas para Entrada e Saída.
                                                             (line  268)
* cmetric:                               Funções e Variáveis Definidas para ctensor.
                                                             (line   14)
* cmetric <1>:                           Funções e Variáveis Definidas para ctensor.
                                                             (line   15)
* cnonmet_flag:                          Funções e Variáveis Definidas para ctensor.
                                                             (line 1101)
* coeff:                                 Funções e Variáveis Definidas para Polinômios.
                                                             (line   37)
* coefmatrix:                            Funções e Variáveis Definidas para Matrizes e Álgebra Linear.
                                                             (line   67)
* cograd:                                Funções e Variáveis Definidas para ctensor.
                                                             (line  719)
* col:                                   Funções e Variáveis Definidas para Matrizes e Álgebra Linear.
                                                             (line   76)
* collapse:                              Funções e Variáveis Definidas para Entrada e Saída.
                                                             (line  271)
* collectterms:                          Funções e Variáveis Definidas para simplification.
                                                             (line  137)
* color:                                 Funções e Variáveis Definidas para draw.
                                                             (line  927)
* colorbox:                              Funções e Variáveis Definidas para draw.
                                                             (line  596)
* columnop:                              Funções e Variáveis Definidas para linearalgebra.
                                                             (line   26)
* columns:                               Funções e Variáveis Definidas para draw.
                                                             (line 1181)
* columnspace:                           Funções e Variáveis Definidas para linearalgebra.
                                                             (line   37)
* columnswap:                            Funções e Variáveis Definidas para linearalgebra.
                                                             (line   32)
* columnvector:                          Funções e Variáveis Definidas para Matrizes e Álgebra Linear.
                                                             (line   80)
* combination:                           Funções e Variáveis Definidas para simplification.
                                                             (line  279)
* combine:                               Funções e Variáveis Definidas para Polinômios.
                                                             (line   52)
* commutative:                           Operadores Geral.   (line  494)
* comp2pui:                              Funções e Variáveis Definidas para Simetrias.
                                                             (line    9)
* compare:                               Operadores Geral.   (line  499)
* compfile:                              Funções e Variáveis para Definição de Função.
                                                             (line  144)
* compfile <1>:                          Funções e Variáveis para Definição de Função.
                                                             (line  145)
* compfile <2>:                          Funções e Variáveis para Definição de Função.
                                                             (line  146)
* compile:                               Funções e Variáveis para Definição de Função.
                                                             (line  163)
* compile <1>:                           Funções e Variáveis para Definição de Função.
                                                             (line  164)
* compile <2>:                           Funções e Variáveis para Definição de Função.
                                                             (line  165)
* compile_file:                          Funções e Variáveis para Definição de Função.
                                                             (line 1202)
* compile_file <1>:                      Funções e Variáveis para Definição de Função.
                                                             (line 1203)
* compile_file <2>:                      Funções e Variáveis para Definição de Função.
                                                             (line 1204)
* components:                            Funções e Variáveis Definidas para itensor.
                                                             (line  187)
* concan:                                Funções e Variáveis Definidas para itensor.
                                                             (line  510)
* concat:                                Funções e Variáveis Definidas para Entrada e Saída.
                                                             (line  281)
* conjugate:                             Funções e Variáveis Definidas para Matrizes e Álgebra Linear.
                                                             (line  106)
* Conjunção lógica:                      Operadores Geral.   (line  316)
* conmetderiv:                           Funções e Variáveis Definidas para itensor.
                                                             (line  762)
* cons:                                  Funções e Variáveis Definidas para Listas.
                                                             (line   30)
* constant:                              Funções e Variáveis Definidas para Expressões.
                                                             (line  146)
* Constante de Euler:                    Funções e Variáveis Definidas para Constantes.
                                                             (line    7)
* Constante de Euler-Mascheroni:         Funções e Variáveis Definidas para Teoria dos Números.
                                                             (line  221)
* constantp:                             Funções e Variáveis Definidas para Expressões.
                                                             (line  150)
* constituent:                           Funções e Variáveis para caracteres.
                                                             (line   50)
* Consulta documentação:                 Funções e Variáveis Definidas para Entrada e Saída.
                                                             (line  168)
* Consulta documentação (busca inexata): Funções e Variáveis Definidas para Entrada e Saída.
                                                             (line  180)
* cont2part:                             Funções e Variáveis Definidas para Simetrias.
                                                             (line  208)
* content:                               Funções e Variáveis Definidas para Polinômios.
                                                             (line   56)
* context:                               Funções e Variáveis Definidas para Contextos.
                                                             (line  193)
* contexts:                              Funções e Variáveis Definidas para Contextos.
                                                             (line  207)
* continuous_freq:                       Funções e Variáveis Definidas para manipulação da dados.
                                                             (line    6)
* continuous_freq <1>:                   Funções e Variáveis Definidas para manipulação da dados.
                                                             (line    7)
* contortion:                            Funções e Variáveis Definidas para ctensor.
                                                             (line  654)
* contour:                               Funções e Variáveis Definidas para draw.
                                                             (line 1135)
* contour_levels:                        Funções e Variáveis Definidas para draw.
                                                             (line 1165)
* contour_plot:                          Funções e Variáveis Definidas para Montagem de Gráficos.
                                                             (line    6)
* contract:                              Funções e Variáveis Definidas para itensor.
                                                             (line  171)
* contract <1>:                          Funções e Variáveis Definidas para Simetrias.
                                                             (line  219)
* contragrad:                            Funções e Variáveis Definidas para ctensor.
                                                             (line  723)
* Contração com um vetor:                Funções e Variáveis Definidas para itensor.
                                                             (line 1409)
* contrib_ode:                           Funções e Variáveis Definidas para contrib_ode.
                                                             (line    6)
* convert:                               Funções e Variáveis Definidas para Units.
                                                             (line  142)
* coord:                                 Funções e Variáveis Definidas para itensor.
                                                             (line  740)
* copy:                                  Funções e Variáveis Definidas para linearalgebra.
                                                             (line   45)
* copylist:                              Funções e Variáveis Definidas para Listas.
                                                             (line   36)
* copymatrix:                            Funções e Variáveis Definidas para Matrizes e Álgebra Linear.
                                                             (line  125)
* cor:                                   Funções e Variáveis Definidas específicas para estatística descritiva de várias variáveis.
                                                             (line  110)
* cor <1>:                               Funções e Variáveis Definidas específicas para estatística descritiva de várias variáveis.
                                                             (line  111)
* cos:                                   Funções e Variáveis Definidas para Trigonometria.
                                                             (line   54)
* cosh:                                  Funções e Variáveis Definidas para Trigonometria.
                                                             (line   57)
* cosnpiflag:                            Funções e Variáveis Definidas para Séries de Fourier.
                                                             (line   55)
* cot:                                   Funções e Variáveis Definidas para Trigonometria.
                                                             (line   60)
* coth:                                  Funções e Variáveis Definidas para Trigonometria.
                                                             (line   63)
* cov:                                   Funções e Variáveis Definidas específicas para estatística descritiva de várias variáveis.
                                                             (line    6)
* cov1:                                  Funções e Variáveis Definidas específicas para estatística descritiva de várias variáveis.
                                                             (line   37)
* covdiff:                               Funções e Variáveis Definidas para itensor.
                                                             (line  912)
* covect:                                Funções e Variáveis Definidas para Matrizes e Álgebra Linear.
                                                             (line   81)
* covers:                                Funções e Variáveis Definidas para simplification.
                                                             (line  264)
* create_list:                           Funções e Variáveis Definidas para Listas.
                                                             (line   39)
* csc:                                   Funções e Variáveis Definidas para Trigonometria.
                                                             (line   66)
* csch:                                  Funções e Variáveis Definidas para Trigonometria.
                                                             (line   69)
* csetup:                                Funções e Variáveis Definidas para ctensor.
                                                             (line    9)
* cspline:                               Funções e Variáveis Definidas para interpol.
                                                             (line  121)
* cspline <1>:                           Funções e Variáveis Definidas para interpol.
                                                             (line  122)
* ctaylor:                               Funções e Variáveis Definidas para ctensor.
                                                             (line  323)
* ctaypov:                               Funções e Variáveis Definidas para ctensor.
                                                             (line 1120)
* ctaypt:                                Funções e Variáveis Definidas para ctensor.
                                                             (line 1125)
* ctayswitch:                            Funções e Variáveis Definidas para ctensor.
                                                             (line 1108)
* ctayvar:                               Funções e Variáveis Definidas para ctensor.
                                                             (line 1115)
* ctorsion_flag:                         Funções e Variáveis Definidas para ctensor.
                                                             (line 1094)
* ctransform:                            Funções e Variáveis Definidas para ctensor.
                                                             (line  667)
* ctranspose:                            Funções e Variáveis Definidas para linearalgebra.
                                                             (line   76)
* ctrgsimp:                              Funções e Variáveis Definidas para ctensor.
                                                             (line 1079)
* ct_coords:                             Funções e Variáveis Definidas para ctensor.
                                                             (line 1265)
* ct_coordsys:                           Funções e Variáveis Definidas para ctensor.
                                                             (line   33)
* ct_coordsys <1>:                       Funções e Variáveis Definidas para ctensor.
                                                             (line   34)
* cunlisp:                               Funções e Variáveis para caracteres.
                                                             (line   63)
* current_let_rule_package:              Funções e Variáveis Definidas para Regras e Modelos.
                                                             (line   50)
* cv:                                    Funções e Variáveis Definidas para estatística descritiva.
                                                             (line  165)
* cv <1>:                                Funções e Variáveis Definidas para estatística descritiva.
                                                             (line  166)
* dataplot:                              Funções e Variáveis Definidas para gráficos estatísticos.
                                                             (line    6)
* dataplot <1>:                          Funções e Variáveis Definidas para gráficos estatísticos.
                                                             (line    7)
* dataplot <2>:                          Funções e Variáveis Definidas para gráficos estatísticos.
                                                             (line    8)
* dataplot <3>:                          Funções e Variáveis Definidas para gráficos estatísticos.
                                                             (line    9)
* dblint:                                Funções e Variáveis Definidas para Integração.
                                                             (line   59)
* deactivate:                            Funções e Variáveis Definidas para Contextos.
                                                             (line  238)
* debugmode:                             Funções e Variáveis Definidas para Linha de Comando.
                                                             (line   12)
* declare:                               Funções e Variáveis Definidas para Expressões.
                                                             (line  180)
* declare_translated:                    Funções e Variáveis para Definição de Função.
                                                             (line 1231)
* declare_weights:                       Funções e Variáveis Definidas para Funções Afins.
                                                             (line   55)
* decsym:                                Funções e Variáveis Definidas para itensor.
                                                             (line  525)
* default_let_rule_package:              Funções e Variáveis Definidas para Regras e Modelos.
                                                             (line   64)
* defcon:                                Funções e Variáveis Definidas para itensor.
                                                             (line  148)
* defcon <1>:                            Funções e Variáveis Definidas para itensor.
                                                             (line  149)
* define:                                Funções e Variáveis para Definição de Função.
                                                             (line  178)
* define <1>:                            Funções e Variáveis para Definição de Função.
                                                             (line  179)
* define <2>:                            Funções e Variáveis para Definição de Função.
                                                             (line  180)
* define <3>:                            Funções e Variáveis para Definição de Função.
                                                             (line  181)
* define <4>:                            Funções e Variáveis para Definição de Função.
                                                             (line  182)
* define_variable:                       Funções e Variáveis para Definição de Função.
                                                             (line  270)
* defint:                                Funções e Variáveis Definidas para Integração.
                                                             (line  106)
* defmatch:                              Funções e Variáveis Definidas para Regras e Modelos.
                                                             (line   71)
* defmatch <1>:                          Funções e Variáveis Definidas para Regras e Modelos.
                                                             (line   72)
* defrule:                               Funções e Variáveis Definidas para Regras e Modelos.
                                                             (line  171)
* deftaylor:                             Funções e Variáveis Definidas para Séries.
                                                             (line   38)
* del:                                   Funções e Variáveis Definidas para Diferenciação.
                                                             (line  183)
* delete:                                Funções e Variáveis Definidas para Listas.
                                                             (line   67)
* delete <1>:                            Funções e Variáveis Definidas para Listas.
                                                             (line   68)
* deleten:                               Funções e Variáveis Definidas para ctensor.
                                                             (line 1054)
* Delimitador de Lista:                  Funções e Variáveis Definidas para Matrizes e Álgebra Linear.
                                                             (line 1135)
* delta:                                 Funções e Variáveis Definidas para Diferenciação.
                                                             (line  202)
* demo:                                  Funções e Variáveis Definidas para Ajuda.
                                                             (line    6)
* demoivre:                              Funções e Variáveis Definidas para Simplificação.
                                                             (line   37)
* demoivre <1>:                          Funções e Variáveis Definidas para Simplificação.
                                                             (line   38)
* denom:                                 Funções e Variáveis Definidas para Polinômios.
                                                             (line   68)
* dependencies:                          Funções e Variáveis Definidas para Diferenciação.
                                                             (line  216)
* depends:                               Funções e Variáveis Definidas para Diferenciação.
                                                             (line  226)
* derivabbrev:                           Funções e Variáveis Definidas para Diferenciação.
                                                             (line  281)
* derivdegree:                           Funções e Variáveis Definidas para Diferenciação.
                                                             (line  288)
* derivlist:                             Funções e Variáveis Definidas para Diferenciação.
                                                             (line  302)
* derivsubst:                            Funções e Variáveis Definidas para Diferenciação.
                                                             (line  306)
* describe:                              Funções e Variáveis Definidas para Ajuda.
                                                             (line   90)
* describe <1>:                          Funções e Variáveis Definidas para Ajuda.
                                                             (line   91)
* describe <2>:                          Funções e Variáveis Definidas para Ajuda.
                                                             (line   92)
* desolve:                               Funções e Variáveis Definidas para Equações Diferenciais.
                                                             (line   17)
* desolve <1>:                           Funções e Variáveis Definidas para Equações Diferenciais.
                                                             (line   18)
* DETCOEF:                               Funções e Variáveis Definidas para lsquares.
                                                             (line    6)
* determinant:                           Funções e Variáveis Definidas para Matrizes e Álgebra Linear.
                                                             (line  134)
* detout:                                Funções e Variáveis Definidas para Matrizes e Álgebra Linear.
                                                             (line  144)
* dgauss_a:                              Funções e Variáveis Definidas para contrib_ode.
                                                             (line  106)
* dgauss_b:                              Funções e Variáveis Definidas para contrib_ode.
                                                             (line  109)
* diag:                                  Funções e Variáveis Definidas para diag.
                                                             (line    6)
* diagmatrix:                            Funções e Variáveis Definidas para Matrizes e Álgebra Linear.
                                                             (line  171)
* diagmatrixp:                           Funções e Variáveis Definidas para ctensor.
                                                             (line  822)
* diagmetric:                            Funções e Variáveis Definidas para ctensor.
                                                             (line 1068)
* diag_matrix:                           Funções e Variáveis Definidas para linearalgebra.
                                                             (line   82)
* diff:                                  Funções e Variáveis Definidas para Diferenciação.
                                                             (line  389)
* diff <1>:                              Funções e Variáveis Definidas para Diferenciação.
                                                             (line  313)
* diff <2>:                              Funções e Variáveis Definidas para Diferenciação.
                                                             (line  314)
* diff <3>:                              Funções e Variáveis Definidas para Diferenciação.
                                                             (line  315)
* diff <4>:                              Funções e Variáveis Definidas para Diferenciação.
                                                             (line  316)
* diff <5>:                              Funções e Variáveis Definidas para itensor.
                                                             (line  598)
* digitcharp:                            Funções e Variáveis para caracteres.
                                                             (line   67)
* dim:                                   Funções e Variáveis Definidas para ctensor.
                                                             (line 1061)
* dimension:                             Funções e Variáveis Definidas para Equações.
                                                             (line  271)
* dimension <1>:                         Funções e Variáveis Definidas para Equações.
                                                             (line  272)
* direct:                                Funções e Variáveis Definidas para Simetrias.
                                                             (line  271)
* discrete_freq:                         Funções e Variáveis Definidas para manipulação da dados.
                                                             (line   25)
* disjoin:                               Funções e Variáveis Definidas para Conjuntos.
                                                             (line   88)
* disjointp:                             Funções e Variáveis Definidas para Conjuntos.
                                                             (line  107)
* Disjunção lógica:                      Operadores Geral.   (line  339)
* disolate:                              Funções e Variáveis Definidas para Expressões.
                                                             (line  479)
* disp:                                  Funções e Variáveis Definidas para Entrada e Saída.
                                                             (line  330)
* dispcon:                               Funções e Variáveis Definidas para Entrada e Saída.
                                                             (line  336)
* dispcon <1>:                           Funções e Variáveis Definidas para Entrada e Saída.
                                                             (line  337)
* dispflag:                              Funções e Variáveis Definidas para Equações.
                                                             (line  276)
* dispform:                              Funções e Variáveis Definidas para Expressões.
                                                             (line  488)
* dispfun:                               Funções e Variáveis para Definição de Função.
                                                             (line  360)
* dispfun <1>:                           Funções e Variáveis para Definição de Função.
                                                             (line  361)
* dispJordan:                            Funções e Variáveis Definidas para diag.
                                                             (line   94)
* display:                               Funções e Variáveis Definidas para Entrada e Saída.
                                                             (line  342)
* display2d:                             Funções e Variáveis Definidas para Entrada e Saída.
                                                             (line  356)
* display_format_internal:               Funções e Variáveis Definidas para Entrada e Saída.
                                                             (line  363)
* disprule:                              Funções e Variáveis Definidas para Regras e Modelos.
                                                             (line  185)
* disprule <1>:                          Funções e Variáveis Definidas para Regras e Modelos.
                                                             (line  186)
* dispterms:                             Funções e Variáveis Definidas para Entrada e Saída.
                                                             (line  386)
* distrib:                               Funções e Variáveis Definidas para Expressões.
                                                             (line  500)
* divide:                                Funções e Variáveis Definidas para Polinômios.
                                                             (line   71)
* divisors:                              Funções e Variáveis Definidas para Conjuntos.
                                                             (line  120)
* Divisão:                               Operadores Aritméticos.
                                                             (line   10)
* divsum:                                Funções e Variáveis Definidas para Teoria dos Números.
                                                             (line  194)
* divsum <1>:                            Funções e Variáveis Definidas para Teoria dos Números.
                                                             (line  195)
* dkummer_m:                             Funções e Variáveis Definidas para contrib_ode.
                                                             (line  130)
* dkummer_u:                             Funções e Variáveis Definidas para contrib_ode.
                                                             (line  133)
* do:                                    Funções e Variáveis Definidas para Fluxo de Programa.
                                                             (line   53)
* doallmxops:                            Funções e Variáveis Definidas para Matrizes e Álgebra Linear.
                                                             (line  183)
* domain:                                Funções e Variáveis Definidas para Simplificação.
                                                             (line   55)
* domxexpt:                              Funções e Variáveis Definidas para Matrizes e Álgebra Linear.
                                                             (line  191)
* domxmxops:                             Funções e Variáveis Definidas para Matrizes e Álgebra Linear.
                                                             (line  223)
* domxnctimes:                           Funções e Variáveis Definidas para Matrizes e Álgebra Linear.
                                                             (line  230)
* dontfactor:                            Funções e Variáveis Definidas para Matrizes e Álgebra Linear.
                                                             (line  236)
* doscmxops:                             Funções e Variáveis Definidas para Matrizes e Álgebra Linear.
                                                             (line  246)
* doscmxplus:                            Funções e Variáveis Definidas para Matrizes e Álgebra Linear.
                                                             (line  252)
* dot0nscsimp:                           Funções e Variáveis Definidas para Matrizes e Álgebra Linear.
                                                             (line  258)
* dot0simp:                              Funções e Variáveis Definidas para Matrizes e Álgebra Linear.
                                                             (line  264)
* dot1simp:                              Funções e Variáveis Definidas para Matrizes e Álgebra Linear.
                                                             (line  270)
* dotassoc:                              Funções e Variáveis Definidas para Matrizes e Álgebra Linear.
                                                             (line  276)
* dotconstrules:                         Funções e Variáveis Definidas para Matrizes e Álgebra Linear.
                                                             (line  282)
* dotdistrib:                            Funções e Variáveis Definidas para Matrizes e Álgebra Linear.
                                                             (line  290)
* dotexptsimp:                           Funções e Variáveis Definidas para Matrizes e Álgebra Linear.
                                                             (line  296)
* dotident:                              Funções e Variáveis Definidas para Matrizes e Álgebra Linear.
                                                             (line  302)
* dotproduct:                            Funções e Variáveis Definidas para linearalgebra.
                                                             (line  103)
* dotscrules:                            Funções e Variáveis Definidas para Matrizes e Álgebra Linear.
                                                             (line  307)
* dotsimp:                               Funções e Variáveis Definidas para Funções Afins.
                                                             (line   67)
* dpart:                                 Funções e Variáveis Definidas para Expressões.
                                                             (line  522)
* draw:                                  Funções e Variáveis Definidas para draw.
                                                             (line 1646)
* draw2d:                                Funções e Variáveis Definidas para draw.
                                                             (line 1671)
* draw3d:                                Funções e Variáveis Definidas para draw.
                                                             (line 1680)
* draw_pipes:                            Funções e Variáveis Definidas para draw.
                                                             (line 1689)
* dscalar:                               Funções e Variáveis Definidas para Diferenciação.
                                                             (line  394)
* dscalar <1>:                           Funções e Variáveis Definidas para ctensor.
                                                             (line  752)
* Duplo fatorial:                        Operadores Geral.   (line   68)
* e:                                     Funções e Variáveis Definidas para Constantes.
                                                             (line    7)
* echelon:                               Funções e Variáveis Definidas para Matrizes e Álgebra Linear.
                                                             (line  313)
* eigens_by_jacobi:                      Funções e Variáveis Definidas para linearalgebra.
                                                             (line  109)
* eigens_by_jacobi <1>:                  Funções e Variáveis Definidas para linearalgebra.
                                                             (line  110)
* eigenvalues:                           Funções e Variáveis Definidas para Matrizes e Álgebra Linear.
                                                             (line  344)
* eigenvectors:                          Funções e Variáveis Definidas para Matrizes e Álgebra Linear.
                                                             (line  370)
* eighth:                                Funções e Variáveis Definidas para Listas.
                                                             (line   88)
* einstein:                              Funções e Variáveis Definidas para ctensor.
                                                             (line  223)
* eivals:                                Funções e Variáveis Definidas para Matrizes e Álgebra Linear.
                                                             (line  345)
* eivects:                               Funções e Variáveis Definidas para Matrizes e Álgebra Linear.
                                                             (line  371)
* elapsed_real_time:                     Funções e Variáveis Definidas para Ambiente em Tempo de Execução.
                                                             (line  138)
* elapsed_run_time:                      Funções e Variáveis Definidas para Ambiente em Tempo de Execução.
                                                             (line  154)
* ele2comp:                              Funções e Variáveis Definidas para Simetrias.
                                                             (line   28)
* ele2polynome:                          Funções e Variáveis Definidas para Simetrias.
                                                             (line  493)
* ele2pui:                               Funções e Variáveis Definidas para Simetrias.
                                                             (line   22)
* elem:                                  Funções e Variáveis Definidas para Simetrias.
                                                             (line   34)
* elementp:                              Funções e Variáveis Definidas para Conjuntos.
                                                             (line  163)
* eliminate:                             Funções e Variáveis Definidas para Polinômios.
                                                             (line   87)
* elliptic_e:                            Funções e Variáveis Definidas para Integrais Elípticas.
                                                             (line   13)
* elliptic_ec:                           Funções e Variáveis Definidas para Integrais Elípticas.
                                                             (line   44)
* elliptic_eu:                           Funções e Variáveis Definidas para Integrais Elípticas.
                                                             (line   19)
* elliptic_f:                            Funções e Variáveis Definidas para Integrais Elípticas.
                                                             (line    6)
* elliptic_kc:                           Funções e Variáveis Definidas para Integrais Elípticas.
                                                             (line   36)
* elliptic_pi:                           Funções e Variáveis Definidas para Integrais Elípticas.
                                                             (line   29)
* ematrix:                               Funções e Variáveis Definidas para Matrizes e Álgebra Linear.
                                                             (line  409)
* emptyp:                                Funções e Variáveis Definidas para Conjuntos.
                                                             (line  175)
* endcons:                               Funções e Variáveis Definidas para Listas.
                                                             (line   92)
* enhanced3d:                            Funções e Variáveis Definidas para draw.
                                                             (line  615)
* entermatrix:                           Funções e Variáveis Definidas para Matrizes e Álgebra Linear.
                                                             (line  413)
* entertensor:                           Funções e Variáveis Definidas para itensor.
                                                             (line    9)
* entier:                                Operadores Geral.   (line  530)
* Entrada anterior:                      Funções e Variáveis Definidas para Entrada e Saída.
                                                             (line   47)
* epsilon_sx:                            Funções e Variáveis Definidas para simplex.
                                                             (line    6)
* eps_height:                            Funções e Variáveis Definidas para draw.
                                                             (line  445)
* eps_width:                             Funções e Variáveis Definidas para draw.
                                                             (line  425)
* equal:                                 Operadores Geral.   (line  535)
* equalp:                                Funções e Variáveis Definidas para Séries de Fourier.
                                                             (line    6)
* equiv_classes:                         Funções e Variáveis Definidas para Conjuntos.
                                                             (line  186)
* erf:                                   Funções e Variáveis Definidas para Integração.
                                                             (line  118)
* erfflag:                               Funções e Variáveis Definidas para Integração.
                                                             (line  122)
* errcatch:                              Funções e Variáveis Definidas para Fluxo de Programa.
                                                             (line  242)
* error:                                 Funções e Variáveis Definidas para Fluxo de Programa.
                                                             (line  253)
* error <1>:                             Funções e Variáveis Definidas para Fluxo de Programa.
                                                             (line  254)
* errormsg:                              Funções e Variáveis Definidas para Fluxo de Programa.
                                                             (line  269)
* error_size:                            Funções e Variáveis Definidas para Entrada e Saída.
                                                             (line  400)
* error_syms:                            Funções e Variáveis Definidas para Entrada e Saída.
                                                             (line  444)
* euler:                                 Funções e Variáveis Definidas para Teoria dos Números.
                                                             (line  211)
* ev:                                    Funções e Variáveis Definidas para Linha de Comando.
                                                             (line   24)
* eval:                                  Operadores Geral.   (line  707)
* eval_string:                           Funções e Variáveis Definidas para eval_string.
                                                             (line    6)
* evenp:                                 Operadores Geral.   (line  711)
* every:                                 Funções e Variáveis Definidas para Conjuntos.
                                                             (line  219)
* every <1>:                             Funções e Variáveis Definidas para Conjuntos.
                                                             (line  220)
* evflag:                                Funções e Variáveis Definidas para Linha de Comando.
                                                             (line  191)
* evfun:                                 Funções e Variáveis Definidas para Linha de Comando.
                                                             (line  247)
* evolution:                             Funções e Variáveis Definidas para dynamics.
                                                             (line   17)
* evolution2d:                           Funções e Variáveis Definidas para dynamics.
                                                             (line   31)
* evundiff:                              Funções e Variáveis Definidas para itensor.
                                                             (line  661)
* ev_point:                              Funções e Variáveis Definidas para zeilberger.
                                                             (line  153)
* example:                               Funções e Variáveis Definidas para Ajuda.
                                                             (line  154)
* example <1>:                           Funções e Variáveis Definidas para Ajuda.
                                                             (line  155)
* exp:                                   Funções e Variáveis Definidas para Expressões.
                                                             (line  536)
* expand:                                Funções e Variáveis Definidas para Simplificação.
                                                             (line   61)
* expand <1>:                            Funções e Variáveis Definidas para Simplificação.
                                                             (line   62)
* expandwrt:                             Funções e Variáveis Definidas para Simplificação.
                                                             (line  102)
* expandwrt_denom:                       Funções e Variáveis Definidas para Simplificação.
                                                             (line  115)
* expandwrt_factored:                    Funções e Variáveis Definidas para Simplificação.
                                                             (line  124)
* explose:                               Funções e Variáveis Definidas para Simetrias.
                                                             (line  235)
* expon:                                 Funções e Variáveis Definidas para Simplificação.
                                                             (line  133)
* Exponenciação:                         Operadores Aritméticos.
                                                             (line   11)
* exponenciação não comutativa:          Operadores Geral.   (line    7)
* exponentialize:                        Funções e Variáveis Definidas para Simplificação.
                                                             (line  141)
* exponentialize <1>:                    Funções e Variáveis Definidas para Simplificação.
                                                             (line  142)
* expop:                                 Funções e Variáveis Definidas para Simplificação.
                                                             (line  156)
* express:                               Funções e Variáveis Definidas para Diferenciação.
                                                             (line  399)
* Expressão de entrada atual:            Funções e Variáveis Definidas para Entrada e Saída.
                                                             (line    7)
* expt:                                  Funções e Variáveis Definidas para Entrada e Saída.
                                                             (line  459)
* exptdispflag:                          Funções e Variáveis Definidas para Entrada e Saída.
                                                             (line  466)
* exptisolate:                           Funções e Variáveis Definidas para Expressões.
                                                             (line  579)
* exptsubst:                             Funções e Variáveis Definidas para Expressões.
                                                             (line  585)
* exsec:                                 Funções e Variáveis Definidas para simplification.
                                                             (line  269)
* extdiff:                               Funções e Variáveis Definidas para itensor.
                                                             (line 1438)
* extract_linear_equations:              Funções e Variáveis Definidas para Funções Afins.
                                                             (line  111)
* extremal_subset:                       Funções e Variáveis Definidas para Conjuntos.
                                                             (line  287)
* extremal_subset <1>:                   Funções e Variáveis Definidas para Conjuntos.
                                                             (line  288)
* ezgcd:                                 Funções e Variáveis Definidas para Polinômios.
                                                             (line  114)
* f90:                                   Funções e Variáveis Definidas para f90.
                                                             (line    6)
* facexpand:                             Funções e Variáveis Definidas para Polinômios.
                                                             (line  120)
* facsum:                                Funções e Variáveis Definidas para simplification.
                                                             (line   58)
* facsum_combine:                        Funções e Variáveis Definidas para simplification.
                                                             (line  115)
* factcomb:                              Funções e Variáveis Definidas para Polinômios.
                                                             (line  127)
* factlim:                               Funções e Variáveis Definidas para Simplificação.
                                                             (line  166)
* factor:                                Funções e Variáveis Definidas para Polinômios.
                                                             (line  135)
* factor <1>:                            Funções e Variáveis Definidas para Polinômios.
                                                             (line  136)
* factorfacsum:                          Funções e Variáveis Definidas para simplification.
                                                             (line  130)
* factorflag:                            Funções e Variáveis Definidas para Polinômios.
                                                             (line  267)
* factorial:                             Funções e Variáveis Definidas para Teoria dos Números.
                                                             (line  223)
* factorout:                             Funções e Variáveis Definidas para Polinômios.
                                                             (line  273)
* factorsum:                             Funções e Variáveis Definidas para Polinômios.
                                                             (line  278)
* facts:                                 Funções e Variáveis Definidas para Contextos.
                                                             (line  241)
* facts <1>:                             Funções e Variáveis Definidas para Contextos.
                                                             (line  242)
* false:                                 Funções e Variáveis Definidas para Constantes.
                                                             (line   14)
* fasttimes:                             Funções e Variáveis Definidas para Polinômios.
                                                             (line  297)
* fast_central_elements:                 Funções e Variáveis Definidas para Funções Afins.
                                                             (line   74)
* fast_linsolve:                         Funções e Variáveis Definidas para Funções Afins.
                                                             (line    6)
* Fatorial:                              Operadores Geral.   (line    9)
* fb:                                    Funções e Variáveis Definidas para ctensor.
                                                             (line 1211)
* feature:                               Funções e Variáveis Definidas para Ambiente em Tempo de Execução.
                                                             (line    6)
* featurep:                              Funções e Variáveis Definidas para Ambiente em Tempo de Execução.
                                                             (line   15)
* features:                              Funções e Variáveis Definidas para Contextos.
                                                             (line  253)
* fft:                                   Funções e Variáveis Definidas para Numérico.
                                                             (line   61)
* fib:                                   Funções e Variáveis Definidas para Teoria dos Números.
                                                             (line  227)
* fibtophi:                              Funções e Variáveis Definidas para Teoria dos Números.
                                                             (line  238)
* fifth:                                 Funções e Variáveis Definidas para Listas.
                                                             (line   97)
* filename_merge:                        Funções e Variáveis Definidas para Entrada e Saída.
                                                             (line  472)
* file_name:                             Funções e Variáveis Definidas para draw.
                                                             (line  366)
* file_output_append:                    Funções e Variáveis Definidas para Entrada e Saída.
                                                             (line  193)
* file_search:                           Funções e Variáveis Definidas para Entrada e Saída.
                                                             (line  479)
* file_search <1>:                       Funções e Variáveis Definidas para Entrada e Saída.
                                                             (line  480)
* file_search_demo:                      Funções e Variáveis Definidas para Entrada e Saída.
                                                             (line  523)
* file_search_lisp:                      Funções e Variáveis Definidas para Entrada e Saída.
                                                             (line  522)
* file_search_maxima:                    Funções e Variáveis Definidas para Entrada e Saída.
                                                             (line  521)
* file_type:                             Funções e Variáveis Definidas para Entrada e Saída.
                                                             (line  558)
* fillarray:                             Funções e Variáveis Definidas para Arrays.
                                                             (line  222)
* filled_func:                           Funções e Variáveis Definidas para draw.
                                                             (line  721)
* fill_color:                            Funções e Variáveis Definidas para draw.
                                                             (line  975)
* findde:                                Funções e Variáveis Definidas para ctensor.
                                                             (line  673)
* find_root:                             Funções e Variáveis Definidas para Numérico.
                                                             (line  220)
* find_root <1>:                         Funções e Variáveis Definidas para Numérico.
                                                             (line  221)
* find_root_abs:                         Funções e Variáveis Definidas para Numérico.
                                                             (line  268)
* find_root_error:                       Funções e Variáveis Definidas para Numérico.
                                                             (line  281)
* find_root_rel:                         Funções e Variáveis Definidas para Numérico.
                                                             (line  295)
* first:                                 Funções e Variáveis Definidas para Listas.
                                                             (line  101)
* fix:                                   Operadores Geral.   (line  715)
* flatten:                               Funções e Variáveis Definidas para Conjuntos.
                                                             (line  306)
* flength:                               Funções e Variáveis para entrada e saída.
                                                             (line   28)
* flipflag:                              Funções e Variáveis Definidas para itensor.
                                                             (line  135)
* float:                                 Funções e Variáveis Definidas para ponto Flutuante.
                                                             (line   68)
* float2bf:                              Funções e Variáveis Definidas para ponto Flutuante.
                                                             (line   75)
* floatnump:                             Funções e Variáveis Definidas para ponto Flutuante.
                                                             (line   83)
* floor:                                 Operadores Geral.   (line  636)
* flush:                                 Funções e Variáveis Definidas para itensor.
                                                             (line  716)
* flush1deriv:                           Funções e Variáveis Definidas para itensor.
                                                             (line  864)
* flushd:                                Funções e Variáveis Definidas para itensor.
                                                             (line  720)
* flushnd:                               Funções e Variáveis Definidas para itensor.
                                                             (line  724)
* for:                                   Funções e Variáveis Definidas para Fluxo de Programa.
                                                             (line  273)
* forget:                                Funções e Variáveis Definidas para Contextos.
                                                             (line  278)
* forget <1>:                            Funções e Variáveis Definidas para Contextos.
                                                             (line  279)
* fortindent:                            Funções e Variáveis Definidas para Numérico.
                                                             (line  126)
* fortran:                               Funções e Variáveis Definidas para Numérico.
                                                             (line  134)
* fortspaces:                            Funções e Variáveis Definidas para Numérico.
                                                             (line  187)
* fourcos:                               Funções e Variáveis Definidas para Séries de Fourier.
                                                             (line   66)
* fourexpand:                            Funções e Variáveis Definidas para Séries de Fourier.
                                                             (line   60)
* fourier:                               Funções e Variáveis Definidas para Séries de Fourier.
                                                             (line   42)
* fourint:                               Funções e Variáveis Definidas para Séries de Fourier.
                                                             (line   78)
* fourintcos:                            Funções e Variáveis Definidas para Séries de Fourier.
                                                             (line   82)
* fourintsin:                            Funções e Variáveis Definidas para Séries de Fourier.
                                                             (line   86)
* foursimp:                              Funções e Variáveis Definidas para Séries de Fourier.
                                                             (line   46)
* foursin:                               Funções e Variáveis Definidas para Séries de Fourier.
                                                             (line   70)
* fourth:                                Funções e Variáveis Definidas para Listas.
                                                             (line  114)
* fposition:                             Funções e Variáveis para entrada e saída.
                                                             (line   31)
* fposition <1>:                         Funções e Variáveis para entrada e saída.
                                                             (line   32)
* fpprec:                                Funções e Variáveis Definidas para ponto Flutuante.
                                                             (line   87)
* fpprintprec:                           Funções e Variáveis Definidas para ponto Flutuante.
                                                             (line   96)
* frame_bracket:                         Funções e Variáveis Definidas para ctensor.
                                                             (line  458)
* freeof:                                Funções e Variáveis Definidas para Expressões.
                                                             (line  591)
* freshline:                             Funções e Variáveis para entrada e saída.
                                                             (line   38)
* freshline <1>:                         Funções e Variáveis para entrada e saída.
                                                             (line   39)
* fullmap:                               Operadores Geral.   (line  718)
* fullmapl:                              Operadores Geral.   (line  737)
* fullratsimp:                           Funções e Variáveis Definidas para Polinômios.
                                                             (line  305)
* fullratsubst:                          Funções e Variáveis Definidas para Polinômios.
                                                             (line  343)
* fullsetify:                            Funções e Variáveis Definidas para Conjuntos.
                                                             (line  388)
* full_listify:                          Funções e Variáveis Definidas para Conjuntos.
                                                             (line  373)
* funcsolve:                             Funções e Variáveis Definidas para Equações.
                                                             (line  284)
* functions:                             Funções e Variáveis para Definição de Função.
                                                             (line  445)
* fundef:                                Funções e Variáveis para Definição de Função.
                                                             (line  491)
* funmake:                               Funções e Variáveis para Definição de Função.
                                                             (line  512)
* funp:                                  Funções e Variáveis Definidas para Séries de Fourier.
                                                             (line   20)
* funp <1>:                              Funções e Variáveis Definidas para Séries de Fourier.
                                                             (line   21)
* gamma:                                 Funções e Variáveis Definidas para Funções Especiais.
                                                             (line  163)
* gammalim:                              Funções e Variáveis Definidas para Funções Especiais.
                                                             (line  172)
* gaussprob:                             Funções e Variáveis Definidas para simplification.
                                                             (line  242)
* gauss_a:                               Funções e Variáveis Definidas para contrib_ode.
                                                             (line   90)
* gauss_b:                               Funções e Variáveis Definidas para contrib_ode.
                                                             (line  103)
* gcd:                                   Funções e Variáveis Definidas para Polinômios.
                                                             (line  389)
* gcdex:                                 Funções e Variáveis Definidas para Polinômios.
                                                             (line  410)
* gcdex <1>:                             Funções e Variáveis Definidas para Polinômios.
                                                             (line  411)
* gcdivide:                              Funções e Variáveis Definidas para simplification.
                                                             (line  203)
* gcfac:                                 Funções e Variáveis Definidas para simplification.
                                                             (line  427)
* gcfactor:                              Funções e Variáveis Definidas para Polinômios.
                                                             (line  444)
* gd:                                    Funções e Variáveis Definidas para simplification.
                                                             (line  248)
* gdet:                                  Funções e Variáveis Definidas para ctensor.
                                                             (line 1130)
* genfact:                               Funções e Variáveis Definidas para Expressões.
                                                             (line  681)
* genindex:                              Funções e Variáveis Definidas para Opções Diversas.
                                                             (line   57)
* genmatrix:                             Funções e Variáveis Definidas para Matrizes e Álgebra Linear.
                                                             (line  450)
* genmatrix <1>:                         Funções e Variáveis Definidas para Matrizes e Álgebra Linear.
                                                             (line  451)
* genmatrix <2>:                         Funções e Variáveis Definidas para Matrizes e Álgebra Linear.
                                                             (line  452)
* gensumnum:                             Funções e Variáveis Definidas para Opções Diversas.
                                                             (line   63)
* gen_laguerre:                          Funções e Variáveis Definidas para polinômios ortogonais.
                                                             (line   27)
* geometric:                             Funções e Variáveis Definidas para simplification.
                                                             (line  218)
* geometric_mean:                        Funções e Variáveis Definidas para estatística descritiva.
                                                             (line  370)
* geometric_mean <1>:                    Funções e Variáveis Definidas para estatística descritiva.
                                                             (line  371)
* geosum:                                Funções e Variáveis Definidas para simplification.
                                                             (line  235)
* get:                                   Funções e Variáveis Definidas para Listas.
                                                             (line  118)
* get_lu_factors:                        Funções e Variáveis Definidas para linearalgebra.
                                                             (line  169)
* gfactor:                               Funções e Variáveis Definidas para Polinômios.
                                                             (line  450)
* gfactorsum:                            Funções e Variáveis Definidas para Polinômios.
                                                             (line  460)
* ggf:                                   Funções e Variáveis Definidas para ggf.
                                                             (line   36)
* GGFCFMAX:                              Funções e Variáveis Definidas para ggf.
                                                             (line   21)
* GGFINFINITY:                           Funções e Variáveis Definidas para ggf.
                                                             (line    6)
* globalsolve:                           Funções e Variáveis Definidas para Equações.
                                                             (line  305)
* global_variances:                      Funções e Variáveis Definidas específicas para estatística descritiva de várias variáveis.
                                                             (line   68)
* global_variances <1>:                  Funções e Variáveis Definidas específicas para estatística descritiva de várias variáveis.
                                                             (line   69)
* gnuplot_close:                         Funções e Variáveis Definidas para Montagem de Gráficos.
                                                             (line  649)
* gnuplot_replot:                        Funções e Variáveis Definidas para Montagem de Gráficos.
                                                             (line  659)
* gnuplot_replot <1>:                    Funções e Variáveis Definidas para Montagem de Gráficos.
                                                             (line  660)
* gnuplot_reset:                         Funções e Variáveis Definidas para Montagem de Gráficos.
                                                             (line  666)
* gnuplot_restart:                       Funções e Variáveis Definidas para Montagem de Gráficos.
                                                             (line  654)
* gnuplot_start:                         Funções e Variáveis Definidas para Montagem de Gráficos.
                                                             (line  643)
* go:                                    Funções e Variáveis Definidas para Fluxo de Programa.
                                                             (line  277)
* Gosper:                                Funções e Variáveis Definidas para zeilberger.
                                                             (line   12)
* GosperSum:                             Funções e Variáveis Definidas para zeilberger.
                                                             (line   21)
* gosper_in_zeilberger:                  Funções e Variáveis Definidas para zeilberger.
                                                             (line  124)
* gr2d:                                  Funções e Variáveis Definidas para draw.
                                                             (line 1216)
* gr3d:                                  Funções e Variáveis Definidas para draw.
                                                             (line 1501)
* gradef:                                Funções e Variáveis Definidas para Diferenciação.
                                                             (line  460)
* gradef <1>:                            Funções e Variáveis Definidas para Diferenciação.
                                                             (line  461)
* gradefs:                               Funções e Variáveis Definidas para Diferenciação.
                                                             (line  505)
* gramschmidt:                           Funções e Variáveis Definidas para Matrizes e Álgebra Linear.
                                                             (line  510)
* grid:                                  Funções e Variáveis Definidas para draw.
                                                             (line  154)
* grind:                                 Funções e Variáveis Definidas para Entrada e Saída.
                                                             (line  570)
* grind <1>:                             Funções e Variáveis Definidas para Entrada e Saída.
                                                             (line  571)
* grobner_basis:                         Funções e Variáveis Definidas para Funções Afins.
                                                             (line   22)
* gschmit:                               Funções e Variáveis Definidas para Matrizes e Álgebra Linear.
                                                             (line  511)
* halfangles:                            Funções e Variáveis Definidas para Trigonometria.
                                                             (line   72)
* hankel:                                Funções e Variáveis Definidas para linearalgebra.
                                                             (line  176)
* hankel <1>:                            Funções e Variáveis Definidas para linearalgebra.
                                                             (line  177)
* harmonic:                              Funções e Variáveis Definidas para simplification.
                                                             (line  224)
* harmonic_mean:                         Funções e Variáveis Definidas para estatística descritiva.
                                                             (line  343)
* harmonic_mean <1>:                     Funções e Variáveis Definidas para estatística descritiva.
                                                             (line  344)
* hav:                                   Funções e Variáveis Definidas para simplification.
                                                             (line  274)
* head_angle:                            Funções e Variáveis Definidas para draw.
                                                             (line  817)
* head_both:                             Funções e Variáveis Definidas para draw.
                                                             (line  774)
* head_length:                           Funções e Variáveis Definidas para draw.
                                                             (line  794)
* head_type:                             Funções e Variáveis Definidas para draw.
                                                             (line  852)
* hermite:                               Funções e Variáveis Definidas para polinômios ortogonais.
                                                             (line   32)
* hessian:                               Funções e Variáveis Definidas para linearalgebra.
                                                             (line  184)
* hilbert_matrix:                        Funções e Variáveis Definidas para linearalgebra.
                                                             (line  190)
* hipow:                                 Funções e Variáveis Definidas para Polinômios.
                                                             (line  463)
* histogram:                             Funções e Variáveis Definidas para gráficos estatísticos.
                                                             (line  119)
* histogram <1>:                         Funções e Variáveis Definidas para gráficos estatísticos.
                                                             (line  120)
* histogram <2>:                         Funções e Variáveis Definidas para gráficos estatísticos.
                                                             (line  121)
* histogram <3>:                         Funções e Variáveis Definidas para gráficos estatísticos.
                                                             (line  122)
* hodge:                                 Funções e Variáveis Definidas para itensor.
                                                             (line 1469)
* horner:                                Funções e Variáveis Definidas para Numérico.
                                                             (line  193)
* horner <1>:                            Funções e Variáveis Definidas para Numérico.
                                                             (line  194)
* i:                                     Funções e Variáveis Definidas para Constantes.
                                                             (line   12)
* ibase:                                 Funções e Variáveis Definidas para Entrada e Saída.
                                                             (line  670)
* ic1:                                   Funções e Variáveis Definidas para Equações Diferenciais.
                                                             (line   68)
* ic2:                                   Funções e Variáveis Definidas para Equações Diferenciais.
                                                             (line   77)
* icc1:                                  Funções e Variáveis Definidas para itensor.
                                                             (line 1101)
* icc2:                                  Funções e Variáveis Definidas para itensor.
                                                             (line 1119)
* ichr1:                                 Funções e Variáveis Definidas para itensor.
                                                             (line  887)
* ichr2:                                 Funções e Variáveis Definidas para itensor.
                                                             (line  895)
* icounter:                              Funções e Variáveis Definidas para itensor.
                                                             (line  346)
* icurvature:                            Funções e Variáveis Definidas para itensor.
                                                             (line  902)
* ic_convert:                            Funções e Variáveis Definidas para itensor.
                                                             (line 1562)
* ident:                                 Funções e Variáveis Definidas para Matrizes e Álgebra Linear.
                                                             (line  552)
* identfor:                              Funções e Variáveis Definidas para linearalgebra.
                                                             (line  195)
* identfor <1>:                          Funções e Variáveis Definidas para linearalgebra.
                                                             (line  196)
* identity:                              Funções e Variáveis Definidas para Conjuntos.
                                                             (line  406)
* idiff:                                 Funções e Variáveis Definidas para itensor.
                                                             (line  612)
* idim:                                  Funções e Variáveis Definidas para itensor.
                                                             (line  882)
* idummy:                                Funções e Variáveis Definidas para itensor.
                                                             (line  332)
* idummyx:                               Funções e Variáveis Definidas para itensor.
                                                             (line  340)
* ieqn:                                  Funções e Variáveis Definidas para Equações.
                                                             (line  362)
* ieqnprint:                             Funções e Variáveis Definidas para Equações.
                                                             (line  392)
* if:                                    Funções e Variáveis Definidas para Fluxo de Programa.
                                                             (line  290)
* ifactors:                              Funções e Variáveis Definidas para Teoria dos Números.
                                                             (line  264)
* ifb:                                   Funções e Variáveis Definidas para itensor.
                                                             (line 1069)
* ifc1:                                  Funções e Variáveis Definidas para itensor.
                                                             (line 1138)
* ifc2:                                  Funções e Variáveis Definidas para itensor.
                                                             (line 1153)
* ifg:                                   Funções e Variáveis Definidas para itensor.
                                                             (line 1178)
* ifgi:                                  Funções e Variáveis Definidas para itensor.
                                                             (line 1183)
* ifr:                                   Funções e Variáveis Definidas para itensor.
                                                             (line 1167)
* iframes:                               Funções e Variáveis Definidas para itensor.
                                                             (line 1063)
* iframe_bracket_form:                   Funções e Variáveis Definidas para itensor.
                                                             (line 1188)
* ifri:                                  Funções e Variáveis Definidas para itensor.
                                                             (line 1172)
* ifs:                                   Funções e Variáveis Definidas para dynamics.
                                                             (line   43)
* ift:                                   Funções e Variáveis Definidas para Numérico.
                                                             (line   48)
* ift <1>:                               Funções e Variáveis Definidas para Numérico.
                                                             (line   62)
* igeodesic_coords:                      Funções e Variáveis Definidas para itensor.
                                                             (line  958)
* igeowedge_flag:                        Funções e Variáveis Definidas para itensor.
                                                             (line 1508)
* Igual (igualdade sintática):           Operadores Geral.   (line  222)
* ikt1:                                  Funções e Variáveis Definidas para itensor.
                                                             (line 1245)
* ikt2:                                  Funções e Variáveis Definidas para itensor.
                                                             (line 1260)
* ilt:                                   Funções e Variáveis Definidas para Integração.
                                                             (line  128)
* imagpart:                              Funções e Variáveis Definidas para Expressões.
                                                             (line  686)
* imetric:                               Funções e Variáveis Definidas para itensor.
                                                             (line  872)
* imetric <1>:                           Funções e Variáveis Definidas para itensor.
                                                             (line  873)
* implicit_derivative:                   Funções e Variáveis Definidas para impdiff.
                                                             (line    6)
* implicit_plot:                         Funções e Variáveis Definidas para implicit_plot.
                                                             (line    6)
* implicit_plot <1>:                     Funções e Variáveis Definidas para implicit_plot.
                                                             (line    7)
* inchar:                                Funções e Variáveis Definidas para Entrada e Saída.
                                                             (line  685)
* indexed_tensor:                        Funções e Variáveis Definidas para itensor.
                                                             (line  181)
* indices:                               Funções e Variáveis Definidas para itensor.
                                                             (line   49)
* inf:                                   Funções e Variáveis Definidas para Constantes.
                                                             (line   18)
* inf <1>:                               Funções e Variáveis Definidas para Opções Diversas.
                                                             (line   70)
* inferencep:                            Funções e Variáveis Definidas para inference_result.
                                                             (line   50)
* inference_result:                      Funções e Variáveis Definidas para inference_result.
                                                             (line    6)
* infeval:                               Funções e Variáveis Definidas para Linha de Comando.
                                                             (line  315)
* Infinito Complexo:                     Funções e Variáveis Definidas para Constantes.
                                                             (line   22)
* Infinito negativo:                     Funções e Variáveis Definidas para Constantes.
                                                             (line   25)
* Infinito positivo real:                Funções e Variáveis Definidas para Constantes.
                                                             (line   19)
* infinity:                              Funções e Variáveis Definidas para Constantes.
                                                             (line   21)
* infinity <1>:                          Funções e Variáveis Definidas para Opções Diversas.
                                                             (line   73)
* infix:                                 Funções e Variáveis Definidas para Expressões.
                                                             (line  694)
* infix <1>:                             Funções e Variáveis Definidas para Expressões.
                                                             (line  695)
* infix <2>:                             Funções e Variáveis Definidas para Expressões.
                                                             (line  696)
* inflag:                                Funções e Variáveis Definidas para Expressões.
                                                             (line  771)
* infolists:                             Funções e Variáveis Definidas para Opções Diversas.
                                                             (line   77)
* init_atensor:                          Funções e Variáveis Definidas para o Pacote atensor.
                                                             (line    6)
* init_atensor <1>:                      Funções e Variáveis Definidas para o Pacote atensor.
                                                             (line    7)
* init_ctensor:                          Funções e Variáveis Definidas para ctensor.
                                                             (line  140)
* inm:                                   Funções e Variáveis Definidas para itensor.
                                                             (line 1202)
* inmc1:                                 Funções e Variáveis Definidas para itensor.
                                                             (line 1215)
* inmc2:                                 Funções e Variáveis Definidas para itensor.
                                                             (line 1229)
* innerproduct:                          Funções e Variáveis Definidas para Matrizes e Álgebra Linear.
                                                             (line  555)
* inpart:                                Funções e Variáveis Definidas para Expressões.
                                                             (line  790)
* inprod:                                Funções e Variáveis Definidas para Matrizes e Álgebra Linear.
                                                             (line  556)
* inrt:                                  Funções e Variáveis Definidas para Teoria dos Números.
                                                             (line  277)
* integerp:                              Funções e Variáveis Definidas para Opções Diversas.
                                                             (line  135)
* integer_partitions:                    Funções e Variáveis Definidas para Conjuntos.
                                                             (line  418)
* integer_partitions <1>:                Funções e Variáveis Definidas para Conjuntos.
                                                             (line  419)
* integrate:                             Funções e Variáveis Definidas para Integração.
                                                             (line  171)
* integrate <1>:                         Funções e Variáveis Definidas para Integração.
                                                             (line  172)
* integrate_use_rootsof:                 Funções e Variáveis Definidas para Integração.
                                                             (line  354)
* integration_constant_counter:          Funções e Variáveis Definidas para Integração.
                                                             (line  346)
* intersect:                             Funções e Variáveis Definidas para Conjuntos.
                                                             (line  463)
* intersection:                          Funções e Variáveis Definidas para Conjuntos.
                                                             (line  467)
* intervalp:                             Funções e Variáveis Definidas para polinômios ortogonais.
                                                             (line   37)
* intfaclim:                             Funções e Variáveis Definidas para Polinômios.
                                                             (line  486)
* intopois:                              Funções e Variáveis Definidas para Funções Especiais.
                                                             (line  181)
* intosum:                               Funções e Variáveis Definidas para Simplificação.
                                                             (line  172)
* invariant1:                            Funções e Variáveis Definidas para ctensor.
                                                             (line  798)
* invariant2:                            Funções e Variáveis Definidas para ctensor.
                                                             (line  804)
* inverse_jacobi_cd:                     Funções e Variáveis Definidas para Funções Elípticas.
                                                             (line   66)
* inverse_jacobi_cn:                     Funções e Variáveis Definidas para Funções Elípticas.
                                                             (line   45)
* inverse_jacobi_cs:                     Funções e Variáveis Definidas para Funções Elípticas.
                                                             (line   63)
* inverse_jacobi_dc:                     Funções e Variáveis Definidas para Funções Elípticas.
                                                             (line   75)
* inverse_jacobi_dn:                     Funções e Variáveis Definidas para Funções Elípticas.
                                                             (line   48)
* inverse_jacobi_ds:                     Funções e Variáveis Definidas para Funções Elípticas.
                                                             (line   72)
* inverse_jacobi_nc:                     Funções e Variáveis Definidas para Funções Elípticas.
                                                             (line   60)
* inverse_jacobi_nd:                     Funções e Variáveis Definidas para Funções Elípticas.
                                                             (line   69)
* inverse_jacobi_ns:                     Funções e Variáveis Definidas para Funções Elípticas.
                                                             (line   51)
* inverse_jacobi_sc:                     Funções e Variáveis Definidas para Funções Elípticas.
                                                             (line   54)
* inverse_jacobi_sd:                     Funções e Variáveis Definidas para Funções Elípticas.
                                                             (line   57)
* inverse_jacobi_sn:                     Funções e Variáveis Definidas para Funções Elípticas.
                                                             (line   42)
* invert:                                Funções e Variáveis Definidas para Matrizes e Álgebra Linear.
                                                             (line  567)
* invert_by_lu:                          Funções e Variáveis Definidas para linearalgebra.
                                                             (line  211)
* inv_mod:                               Funções e Variáveis Definidas para Teoria dos Números.
                                                             (line  284)
* in_netmath:                            Funções e Variáveis Definidas para Montagem de Gráficos.
                                                             (line   34)
* ip_grid:                               Funções e Variáveis Definidas para draw.
                                                             (line 1200)
* ip_grid_in:                            Funções e Variáveis Definidas para draw.
                                                             (line 1208)
* is:                                    Operadores Geral.   (line  746)
* ishow:                                 Funções e Variáveis Definidas para itensor.
                                                             (line   41)
* isolate:                               Funções e Variáveis Definidas para Expressões.
                                                             (line  818)
* isolate_wrt_times:                     Funções e Variáveis Definidas para Expressões.
                                                             (line  836)
* isqrt:                                 Operadores Geral.   (line  822)
* items_inference:                       Funções e Variáveis Definidas para inference_result.
                                                             (line   55)
* itr:                                   Funções e Variáveis Definidas para itensor.
                                                             (line 1273)
* jacobi:                                Funções e Variáveis Definidas para Teoria dos Números.
                                                             (line  295)
* jacobi_cd:                             Funções e Variáveis Definidas para Funções Elípticas.
                                                             (line   30)
* jacobi_cn:                             Funções e Variáveis Definidas para Funções Elípticas.
                                                             (line    9)
* jacobi_cs:                             Funções e Variáveis Definidas para Funções Elípticas.
                                                             (line   27)
* jacobi_dc:                             Funções e Variáveis Definidas para Funções Elípticas.
                                                             (line   39)
* jacobi_dn:                             Funções e Variáveis Definidas para Funções Elípticas.
                                                             (line   12)
* jacobi_ds:                             Funções e Variáveis Definidas para Funções Elípticas.
                                                             (line   36)
* jacobi_nc:                             Funções e Variáveis Definidas para Funções Elípticas.
                                                             (line   24)
* jacobi_nd:                             Funções e Variáveis Definidas para Funções Elípticas.
                                                             (line   33)
* jacobi_ns:                             Funções e Variáveis Definidas para Funções Elípticas.
                                                             (line   15)
* jacobi_p:                              Funções e Variáveis Definidas para polinômios ortogonais.
                                                             (line   41)
* jacobi_sc:                             Funções e Variáveis Definidas para Funções Elípticas.
                                                             (line   18)
* jacobi_sd:                             Funções e Variáveis Definidas para Funções Elípticas.
                                                             (line   21)
* jacobi_sn:                             Funções e Variáveis Definidas para Funções Elípticas.
                                                             (line    6)
* JF:                                    Funções e Variáveis Definidas para diag.
                                                             (line   32)
* join:                                  Funções e Variáveis Definidas para Listas.
                                                             (line  143)
* jordan:                                Funções e Variáveis Definidas para diag.
                                                             (line   55)
* kdels:                                 Funções e Variáveis Definidas para itensor.
                                                             (line  369)
* kdelta:                                Funções e Variáveis Definidas para itensor.
                                                             (line  353)
* keepfloat:                             Funções e Variáveis Definidas para Polinômios.
                                                             (line  503)
* key:                                   Funções e Variáveis Definidas para draw.
                                                             (line 1056)
* kill:                                  Funções e Variáveis Definidas para Linha de Comando.
                                                             (line  323)
* kill <1>:                              Funções e Variáveis Definidas para Linha de Comando.
                                                             (line  324)
* kill <2>:                              Funções e Variáveis Definidas para Linha de Comando.
                                                             (line  325)
* kill <3>:                              Funções e Variáveis Definidas para Linha de Comando.
                                                             (line  326)
* kill <4>:                              Funções e Variáveis Definidas para Linha de Comando.
                                                             (line  327)
* kill <5>:                              Funções e Variáveis Definidas para Linha de Comando.
                                                             (line  328)
* kill <6>:                              Funções e Variáveis Definidas para Linha de Comando.
                                                             (line  329)
* kill <7>:                              Funções e Variáveis Definidas para Linha de Comando.
                                                             (line  330)
* killcontext:                           Funções e Variáveis Definidas para Contextos.
                                                             (line  287)
* kinvariant:                            Funções e Variáveis Definidas para ctensor.
                                                             (line 1216)
* kostka:                                Funções e Variáveis Definidas para Simetrias.
                                                             (line  445)
* kronecker_product:                     Funções e Variáveis Definidas para linearalgebra.
                                                             (line  216)
* kron_delta:                            Funções e Variáveis Definidas para Conjuntos.
                                                             (line  493)
* kt:                                    Funções e Variáveis Definidas para ctensor.
                                                             (line 1244)
* kummer_m:                              Funções e Variáveis Definidas para contrib_ode.
                                                             (line  112)
* kummer_u:                              Funções e Variáveis Definidas para contrib_ode.
                                                             (line  123)
* kurtosis:                              Funções e Variáveis Definidas para estatística descritiva.
                                                             (line  395)
* kurtosis <1>:                          Funções e Variáveis Definidas para estatística descritiva.
                                                             (line  396)
* kurtosis_bernoulli:                    Funções e Variáveis Definidas para distribuições discretas.
                                                             (line  257)
* kurtosis_beta:                         Funções e Variáveis Definidas para distribuições contínuas.
                                                             (line  818)
* kurtosis_binomial:                     Funções e Variáveis Definidas para distribuições discretas.
                                                             (line   56)
* kurtosis_chi2:                         Funções e Variáveis Definidas para distribuições contínuas.
                                                             (line  303)
* kurtosis_continuous_uniform:           Funções e Variáveis Definidas para distribuições contínuas.
                                                             (line  893)
* kurtosis_discrete_uniform:             Funções e Variáveis Definidas para distribuições discretas.
                                                             (line  395)
* kurtosis_exp:                          Funções e Variáveis Definidas para distribuições contínuas.
                                                             (line  573)
* kurtosis_f:                            Funções e Variáveis Definidas para distribuições contínuas.
                                                             (line  406)
* kurtosis_gamma:                        Funções e Variáveis Definidas para distribuições contínuas.
                                                             (line  733)
* kurtosis_geometric:                    Funções e Variáveis Definidas para distribuições discretas.
                                                             (line  321)
* kurtosis_gumbel:                       Funções e Variáveis Definidas para distribuições contínuas.
                                                             (line 1354)
* kurtosis_hypergeometric:               Funções e Variáveis Definidas para distribuições discretas.
                                                             (line  457)
* kurtosis_laplace:                      Funções e Variáveis Definidas para distribuições contínuas.
                                                             (line 1267)
* kurtosis_logistic:                     Funções e Variáveis Definidas para distribuições contínuas.
                                                             (line  945)
* kurtosis_lognormal:                    Funções e Variáveis Definidas para distribuições contínuas.
                                                             (line  669)
* kurtosis_negative_binomial:            Funções e Variáveis Definidas para distribuições discretas.
                                                             (line  546)
* kurtosis_normal:                       Funções e Variáveis Definidas para distribuições contínuas.
                                                             (line   52)
* kurtosis_pareto:                       Funções e Variáveis Definidas para distribuições contínuas.
                                                             (line  994)
* kurtosis_poisson:                      Funções e Variáveis Definidas para distribuições discretas.
                                                             (line  136)
* kurtosis_rayleigh:                     Funções e Variáveis Definidas para distribuições contínuas.
                                                             (line 1199)
* kurtosis_student_t:                    Funções e Variáveis Definidas para distribuições contínuas.
                                                             (line  135)
* kurtosis_weibull:                      Funções e Variáveis Definidas para distribuições contínuas.
                                                             (line 1043)
* labels:                                Funções e Variáveis Definidas para Linha de Comando.
                                                             (line  386)
* labels <1>:                            Funções e Variáveis Definidas para Linha de Comando.
                                                             (line  387)
* label_alignment:                       Funções e Variáveis Definidas para draw.
                                                             (line  876)
* label_orientation:                     Funções e Variáveis Definidas para draw.
                                                             (line  901)
* lagrange:                              Funções e Variáveis Definidas para interpol.
                                                             (line    6)
* lagrange <1>:                          Funções e Variáveis Definidas para interpol.
                                                             (line    7)
* laguerre:                              Funções e Variáveis Definidas para polinômios ortogonais.
                                                             (line   50)
* lambda:                                Funções e Variáveis para Definição de Função.
                                                             (line  597)
* lambda <1>:                            Funções e Variáveis para Definição de Função.
                                                             (line  598)
* lambda <2>:                            Funções e Variáveis para Definição de Função.
                                                             (line  599)
* laplace:                               Funções e Variáveis Definidas para Diferenciação.
                                                             (line  513)
* lassociative:                          Funções e Variáveis Definidas para Simplificação.
                                                             (line  183)
* last:                                  Funções e Variáveis Definidas para Listas.
                                                             (line  163)
* lbfgs:                                 Funções e Variáveis Definidas para lbfgs.
                                                             (line    6)
* lbfgs_ncorrections:                    Funções e Variáveis Definidas para lbfgs.
                                                             (line  173)
* lbfgs_nfeval_max:                      Funções e Variáveis Definidas para lbfgs.
                                                             (line  165)
* lc2kdt:                                Funções e Variáveis Definidas para itensor.
                                                             (line  397)
* lcharp:                                Funções e Variáveis para caracteres.
                                                             (line   70)
* lcm:                                   Funções e Variáveis Definidas para Teoria dos Números.
                                                             (line  302)
* lc_l:                                  Funções e Variáveis Definidas para itensor.
                                                             (line  465)
* lc_u:                                  Funções e Variáveis Definidas para itensor.
                                                             (line  489)
* ldefint:                               Funções e Variáveis Definidas para Integração.
                                                             (line  404)
* ldisp:                                 Funções e Variáveis Definidas para Entrada e Saída.
                                                             (line  703)
* ldisplay:                              Funções e Variáveis Definidas para Entrada e Saída.
                                                             (line  731)
* legendre_p:                            Funções e Variáveis Definidas para polinômios ortogonais.
                                                             (line   56)
* legendre_q:                            Funções e Variáveis Definidas para polinômios ortogonais.
                                                             (line   62)
* leinstein:                             Funções e Variáveis Definidas para ctensor.
                                                             (line  233)
* length:                                Funções e Variáveis Definidas para Listas.
                                                             (line  166)
* let:                                   Funções e Variáveis Definidas para Regras e Modelos.
                                                             (line  221)
* let <1>:                               Funções e Variáveis Definidas para Regras e Modelos.
                                                             (line  222)
* letrat:                                Funções e Variáveis Definidas para Regras e Modelos.
                                                             (line  303)
* letrules:                              Funções e Variáveis Definidas para Regras e Modelos.
                                                             (line  327)
* letrules <1>:                          Funções e Variáveis Definidas para Regras e Modelos.
                                                             (line  328)
* letsimp:                               Funções e Variáveis Definidas para Regras e Modelos.
                                                             (line  341)
* letsimp <1>:                           Funções e Variáveis Definidas para Regras e Modelos.
                                                             (line  342)
* letsimp <2>:                           Funções e Variáveis Definidas para Regras e Modelos.
                                                             (line  343)
* let_rule_packages:                     Funções e Variáveis Definidas para Regras e Modelos.
                                                             (line  356)
* levi_civita:                           Funções e Variáveis Definidas para itensor.
                                                             (line  391)
* lfg:                                   Funções e Variáveis Definidas para ctensor.
                                                             (line 1163)
* lfreeof:                               Funções e Variáveis Definidas para Expressões.
                                                             (line  899)
* lg:                                    Funções e Variáveis Definidas para ctensor.
                                                             (line 1197)
* lgtreillis:                            Funções e Variáveis Definidas para Simetrias.
                                                             (line  452)
* lhospitallim:                          Funções e Variáveis Definidas para Limites.
                                                             (line    6)
* lhs:                                   Funções e Variáveis Definidas para Equações.
                                                             (line  409)
* li:                                    Funções e Variáveis Definidas para Logarítmos.
                                                             (line   15)
* liediff:                               Funções e Variáveis Definidas para itensor.
                                                             (line  626)
* limit:                                 Funções e Variáveis Definidas para Limites.
                                                             (line   13)
* limit <1>:                             Funções e Variáveis Definidas para Limites.
                                                             (line   14)
* limit <2>:                             Funções e Variáveis Definidas para Limites.
                                                             (line   15)
* limsubst:                              Funções e Variáveis Definidas para Limites.
                                                             (line   48)
* Lindstedt:                             Funções e Variáveis Definidas para lindstedt.
                                                             (line    6)
* linear:                                Funções e Variáveis Definidas para Simplificação.
                                                             (line  188)
* linear <1>:                            Funções e Variáveis Definidas para simplification.
                                                             (line  196)
* linearinterpol:                        Funções e Variáveis Definidas para interpol.
                                                             (line   63)
* linearinterpol <1>:                    Funções e Variáveis Definidas para interpol.
                                                             (line   64)
* linear_program:                        Funções e Variáveis Definidas para simplex.
                                                             (line   13)
* linear_solver:                         Funções e Variáveis Definidas para zeilberger.
                                                             (line  112)
* linechar:                              Funções e Variáveis Definidas para Entrada e Saída.
                                                             (line  762)
* linel:                                 Funções e Variáveis Definidas para Entrada e Saída.
                                                             (line  774)
* linenum:                               Funções e Variáveis Definidas para Linha de Comando.
                                                             (line  422)
* line_type:                             Funções e Variáveis Definidas para draw.
                                                             (line 1006)
* line_width:                            Funções e Variáveis Definidas para draw.
                                                             (line  983)
* linsolve:                              Funções e Variáveis Definidas para Equações.
                                                             (line  448)
* linsolvewarn:                          Funções e Variáveis Definidas para Equações.
                                                             (line  519)
* linsolve_params:                       Funções e Variáveis Definidas para Equações.
                                                             (line  525)
* lispdisp:                              Funções e Variáveis Definidas para Entrada e Saída.
                                                             (line  784)
* listarith:                             Funções e Variáveis Definidas para Listas.
                                                             (line  177)
* listarray:                             Funções e Variáveis Definidas para Arrays.
                                                             (line  275)
* listconstvars:                         Funções e Variáveis Definidas para Expressões.
                                                             (line  862)
* listdummyvars:                         Funções e Variáveis Definidas para Expressões.
                                                             (line  870)
* listify:                               Funções e Variáveis Definidas para Conjuntos.
                                                             (line  601)
* listoftens:                            Funções e Variáveis Definidas para itensor.
                                                             (line   25)
* listofvars:                            Funções e Variáveis Definidas para Expressões.
                                                             (line  887)
* listp:                                 Funções e Variáveis Definidas para Listas.
                                                             (line  184)
* listp <1>:                             Funções e Variáveis Definidas para linearalgebra.
                                                             (line  220)
* listp <2>:                             Funções e Variáveis Definidas para linearalgebra.
                                                             (line  221)
* list_correlations:                     Funções e Variáveis Definidas específicas para estatística descritiva de várias variáveis.
                                                             (line  155)
* list_correlations <1>:                 Funções e Variáveis Definidas específicas para estatística descritiva de várias variáveis.
                                                             (line  156)
* list_nc_monomials:                     Funções e Variáveis Definidas para Funções Afins.
                                                             (line  121)
* list_nc_monomials <1>:                 Funções e Variáveis Definidas para Funções Afins.
                                                             (line  122)
* lmax:                                  Operadores Geral.   (line  826)
* lmin:                                  Operadores Geral.   (line  832)
* lmxchar:                               Funções e Variáveis Definidas para Matrizes e Álgebra Linear.
                                                             (line  596)
* load:                                  Funções e Variáveis Definidas para Entrada e Saída.
                                                             (line  800)
* loadfile:                              Funções e Variáveis Definidas para Entrada e Saída.
                                                             (line  830)
* loadprint:                             Funções e Variáveis Definidas para Entrada e Saída.
                                                             (line  840)
* local:                                 Funções e Variáveis para Definição de Função.
                                                             (line  718)
* locate_matrix_entry:                   Funções e Variáveis Definidas para linearalgebra.
                                                             (line  229)
* log:                                   Funções e Variáveis Definidas para Logarítmos.
                                                             (line   73)
* logabs:                                Funções e Variáveis Definidas para Logarítmos.
                                                             (line  109)
* logarc:                                Funções e Variáveis Definidas para Logarítmos.
                                                             (line  119)
* logarc <1>:                            Funções e Variáveis Definidas para Logarítmos.
                                                             (line  120)
* logconcoeffp:                          Funções e Variáveis Definidas para Logarítmos.
                                                             (line  129)
* logcontract:                           Funções e Variáveis Definidas para Logarítmos.
                                                             (line  139)
* logexpand:                             Funções e Variáveis Definidas para Logarítmos.
                                                             (line  161)
* lognegint:                             Funções e Variáveis Definidas para Logarítmos.
                                                             (line  172)
* lognumer:                              Funções e Variáveis Definidas para Logarítmos.
                                                             (line  178)
* logsimp:                               Funções e Variáveis Definidas para Logarítmos.
                                                             (line  187)
* logx:                                  Funções e Variáveis Definidas para draw.
                                                             (line   72)
* logy:                                  Funções e Variáveis Definidas para draw.
                                                             (line   89)
* logz:                                  Funções e Variáveis Definidas para draw.
                                                             (line  106)
* lopow:                                 Funções e Variáveis Definidas para Expressões.
                                                             (line  904)
* lorentz_gauge:                         Funções e Variáveis Definidas para itensor.
                                                             (line  953)
* lowercasep:                            Funções e Variáveis para caracteres.
                                                             (line   74)
* lpart:                                 Funções e Variáveis Definidas para Expressões.
                                                             (line  911)
* lratsubst:                             Funções e Variáveis Definidas para Polinômios.
                                                             (line  511)
* lreduce:                               Funções e Variáveis Definidas para Conjuntos.
                                                             (line  616)
* lreduce <1>:                           Funções e Variáveis Definidas para Conjuntos.
                                                             (line  617)
* lriem:                                 Funções e Variáveis Definidas para ctensor.
                                                             (line 1180)
* lriemann:                              Funções e Variáveis Definidas para ctensor.
                                                             (line  265)
* lsquares:                              Funções e Variáveis Definidas para lsquares.
                                                             (line   19)
* lsquares <1>:                          Funções e Variáveis Definidas para lsquares.
                                                             (line   20)
* lstringp:                              Funções e Variáveis para seqüências de caracteres.
                                                             (line   11)
* lsum:                                  Funções e Variáveis Definidas para Expressões.
                                                             (line 1474)
* ltreillis:                             Funções e Variáveis Definidas para Simetrias.
                                                             (line  459)
* lu_backsub:                            Funções e Variáveis Definidas para linearalgebra.
                                                             (line  257)
* lu_factor:                             Funções e Variáveis Definidas para linearalgebra.
                                                             (line  262)
* m1pbranch:                             Funções e Variáveis Definidas para Opções Diversas.
                                                             (line  163)
* macroexpand:                           Macros.             (line   90)
* macroexpand1:                          Macros.             (line  123)
* macroexpansion:                        Funções e Variáveis para Definição de Função.
                                                             (line  731)
* macros:                                Macros.             (line  154)
* mainvar:                               Funções e Variáveis Definidas para Simplificação.
                                                             (line  200)
* Maior que:                             Operadores Relacionais.
                                                             (line   10)
* Maior que ou igual a:                  Operadores Relacionais.
                                                             (line    9)
* makebox:                               Funções e Variáveis Definidas para itensor.
                                                             (line  756)
* makefact:                              Funções e Variáveis Definidas para Funções Especiais.
                                                             (line  184)
* makegamma:                             Funções e Variáveis Definidas para Funções Especiais.
                                                             (line  190)
* makelist:                              Funções e Variáveis Definidas para Listas.
                                                             (line  188)
* makelist <1>:                          Funções e Variáveis Definidas para Listas.
                                                             (line  189)
* makeOrders:                            Funções e Variáveis Definidas para makeOrders.
                                                             (line    6)
* makeset:                               Funções e Variáveis Definidas para Conjuntos.
                                                             (line  656)
* make_array:                            Funções e Variáveis Definidas para Arrays.
                                                             (line  367)
* make_random_state:                     Operadores Geral.   (line  906)
* make_random_state <1>:                 Operadores Geral.   (line  907)
* make_random_state <2>:                 Operadores Geral.   (line  908)
* make_random_state <3>:                 Operadores Geral.   (line  909)
* make_transform:                        Funções e Variáveis Definidas para Montagem de Gráficos.
                                                             (line  586)
* map:                                   Funções e Variáveis Definidas para Fluxo de Programa.
                                                             (line  342)
* mapatom:                               Funções e Variáveis Definidas para Fluxo de Programa.
                                                             (line  378)
* maperror:                              Funções e Variáveis Definidas para Fluxo de Programa.
                                                             (line  383)
* maplist:                               Funções e Variáveis Definidas para Fluxo de Programa.
                                                             (line  399)
* matchdeclare:                          Funções e Variáveis Definidas para Regras e Modelos.
                                                             (line  363)
* matchfix:                              Funções e Variáveis Definidas para Regras e Modelos.
                                                             (line  523)
* matchfix <1>:                          Funções e Variáveis Definidas para Regras e Modelos.
                                                             (line  524)
* matrix:                                Funções e Variáveis Definidas para Matrizes e Álgebra Linear.
                                                             (line  612)
* matrixmap:                             Funções e Variáveis Definidas para Matrizes e Álgebra Linear.
                                                             (line  738)
* matrixp:                               Funções e Variáveis Definidas para Matrizes e Álgebra Linear.
                                                             (line  743)
* matrixp <1>:                           Funções e Variáveis Definidas para linearalgebra.
                                                             (line  389)
* matrixp <2>:                           Funções e Variáveis Definidas para linearalgebra.
                                                             (line  390)
* matrix_element_add:                    Funções e Variáveis Definidas para Matrizes e Álgebra Linear.
                                                             (line  747)
* matrix_element_mult:                   Funções e Variáveis Definidas para Matrizes e Álgebra Linear.
                                                             (line  778)
* matrix_element_transpose:              Funções e Variáveis Definidas para Matrizes e Álgebra Linear.
                                                             (line  819)
* matrix_size:                           Funções e Variáveis Definidas para linearalgebra.
                                                             (line  400)
* mattrace:                              Funções e Variáveis Definidas para Matrizes e Álgebra Linear.
                                                             (line  867)
* mat_cond:                              Funções e Variáveis Definidas para linearalgebra.
                                                             (line  370)
* mat_cond <1>:                          Funções e Variáveis Definidas para linearalgebra.
                                                             (line  371)
* mat_fullunblocker:                     Funções e Variáveis Definidas para linearalgebra.
                                                             (line  405)
* mat_function:                          Funções e Variáveis Definidas para diag.
                                                             (line  180)
* mat_norm:                              Funções e Variáveis Definidas para linearalgebra.
                                                             (line  381)
* mat_norm <1>:                          Funções e Variáveis Definidas para linearalgebra.
                                                             (line  382)
* mat_norm <2>:                          Funções e Variáveis Definidas para linearalgebra.
                                                             (line  383)
* mat_trace:                             Funções e Variáveis Definidas para linearalgebra.
                                                             (line  411)
* mat_unblocker:                         Funções e Variáveis Definidas para linearalgebra.
                                                             (line  418)
* max:                                   Operadores Geral.   (line  838)
* maxapplydepth:                         Funções e Variáveis Definidas para Simplificação.
                                                             (line  213)
* maxapplyheight:                        Funções e Variáveis Definidas para Simplificação.
                                                             (line  219)
* maxi:                                  Funções e Variáveis Definidas para estatística descritiva.
                                                             (line  197)
* maxi <1>:                              Funções e Variáveis Definidas para estatística descritiva.
                                                             (line  198)
* maxima_tempdir:                        Funções e Variáveis Definidas para Ambiente em Tempo de Execução.
                                                             (line   31)
* maxima_userdir:                        Funções e Variáveis Definidas para Ambiente em Tempo de Execução.
                                                             (line   44)
* maximize_sx:                           Funções e Variáveis Definidas para simplex.
                                                             (line   40)
* maxnegex:                              Funções e Variáveis Definidas para Simplificação.
                                                             (line  225)
* maxposex:                              Funções e Variáveis Definidas para Simplificação.
                                                             (line  231)
* maxpsifracdenom:                       Funções e Variáveis Definidas para Funções Especiais.
                                                             (line  331)
* maxpsifracnum:                         Funções e Variáveis Definidas para Funções Especiais.
                                                             (line  324)
* maxpsinegint:                          Funções e Variáveis Definidas para Funções Especiais.
                                                             (line  316)
* maxpsiposint:                          Funções e Variáveis Definidas para Funções Especiais.
                                                             (line  310)
* maxtayorder:                           Funções e Variáveis Definidas para Séries.
                                                             (line   69)
* MAX_ORD:                               Funções e Variáveis Definidas para zeilberger.
                                                             (line  101)
* maybe:                                 Operadores Geral.   (line  799)
* mean:                                  Funções e Variáveis Definidas para estatística descritiva.
                                                             (line    6)
* mean <1>:                              Funções e Variáveis Definidas para estatística descritiva.
                                                             (line    7)
* meanlog:                               Funções e Variáveis Definidas para distribuições contínuas.
                                                             (line  926)
* mean_bernoulli:                        Funções e Variáveis Definidas para distribuições discretas.
                                                             (line  197)
* mean_beta:                             Funções e Variáveis Definidas para distribuições contínuas.
                                                             (line  800)
* mean_binomial:                         Funções e Variáveis Definidas para distribuições discretas.
                                                             (line   36)
* mean_chi2:                             Funções e Variáveis Definidas para distribuições contínuas.
                                                             (line  233)
* mean_continuous_uniform:               Funções e Variáveis Definidas para distribuições contínuas.
                                                             (line  873)
* mean_deviation:                        Funções e Variáveis Definidas para estatística descritiva.
                                                             (line  289)
* mean_deviation <1>:                    Funções e Variáveis Definidas para estatística descritiva.
                                                             (line  290)
* mean_discrete_uniform:                 Funções e Variáveis Definidas para distribuições discretas.
                                                             (line  375)
* mean_exp:                              Funções e Variáveis Definidas para distribuições contínuas.
                                                             (line  499)
* mean_f:                                Funções e Variáveis Definidas para distribuições contínuas.
                                                             (line  387)
* mean_gamma:                            Funções e Variáveis Definidas para distribuições contínuas.
                                                             (line  714)
* mean_geometric:                        Funções e Variáveis Definidas para distribuições discretas.
                                                             (line  302)
* mean_gumbel:                           Funções e Variáveis Definidas para distribuições contínuas.
                                                             (line 1322)
* mean_hypergeometric:                   Funções e Variáveis Definidas para distribuições discretas.
                                                             (line  433)
* mean_laplace:                          Funções e Variáveis Definidas para distribuições contínuas.
                                                             (line 1248)
* mean_lognormal:                        Funções e Variáveis Definidas para distribuições contínuas.
                                                             (line  650)
* mean_negative_binomial:                Funções e Variáveis Definidas para distribuições discretas.
                                                             (line  526)
* mean_normal:                           Funções e Variáveis Definidas para distribuições contínuas.
                                                             (line   32)
* mean_pareto:                           Funções e Variáveis Definidas para distribuições contínuas.
                                                             (line  975)
* mean_poisson:                          Funções e Variáveis Definidas para distribuições discretas.
                                                             (line  118)
* mean_rayleigh:                         Funções e Variáveis Definidas para distribuições contínuas.
                                                             (line 1115)
* mean_student_t:                        Funções e Variáveis Definidas para distribuições contínuas.
                                                             (line  110)
* mean_weibull:                          Funções e Variáveis Definidas para distribuições contínuas.
                                                             (line 1024)
* median:                                Funções e Variáveis Definidas para estatística descritiva.
                                                             (line  247)
* median <1>:                            Funções e Variáveis Definidas para estatística descritiva.
                                                             (line  248)
* median_deviation:                      Funções e Variáveis Definidas para estatística descritiva.
                                                             (line  316)
* median_deviation <1>:                  Funções e Variáveis Definidas para estatística descritiva.
                                                             (line  317)
* member:                                Funções e Variáveis Definidas para Listas.
                                                             (line  209)
* Menor que:                             Operadores Relacionais.
                                                             (line    7)
* Menor que ou igual a:                  Operadores Relacionais.
                                                             (line    8)
* Menos infinito:                        Funções e Variáveis Definidas para Constantes.
                                                             (line   25)
* method:                                Funções e Variáveis Definidas para contrib_ode.
                                                             (line   71)
* metricexpandall:                       Funções e Variáveis Definidas para Units.
                                                             (line  397)
* min:                                   Operadores Geral.   (line  848)
* minf:                                  Funções e Variáveis Definidas para Constantes.
                                                             (line   24)
* minfactorial:                          Funções e Variáveis Definidas para Teoria dos Números.
                                                             (line  308)
* mini:                                  Funções e Variáveis Definidas para estatística descritiva.
                                                             (line  182)
* mini <1>:                              Funções e Variáveis Definidas para estatística descritiva.
                                                             (line  183)
* minimalPoly:                           Funções e Variáveis Definidas para diag.
                                                             (line  123)
* minimize_sx:                           Funções e Variáveis Definidas para simplex.
                                                             (line   48)
* minor:                                 Funções e Variáveis Definidas para Matrizes e Álgebra Linear.
                                                             (line  876)
* mnewton:                               Funções e Variáveis Definidas para mnewton.
                                                             (line   22)
* mod:                                   Operadores Geral.   (line  868)
* ModeMatrix:                            Funções e Variáveis Definidas para diag.
                                                             (line  144)
* mode_checkp:                           Funções e Variáveis para Definição de Função.
                                                             (line  862)
* mode_check_errorp:                     Funções e Variáveis para Definição de Função.
                                                             (line  868)
* mode_check_warnp:                      Funções e Variáveis para Definição de Função.
                                                             (line  874)
* mode_declare:                          Funções e Variáveis para Definição de Função.
                                                             (line  879)
* mode_identity:                         Funções e Variáveis para Definição de Função.
                                                             (line  922)
* modular_linear_solver:                 Funções e Variáveis Definidas para zeilberger.
                                                             (line  147)
* modulus:                               Funções e Variáveis Definidas para Polinômios.
                                                             (line  536)
* mod_big_prime:                         Funções e Variáveis Definidas para zeilberger.
                                                             (line  159)
* mod_test:                              Funções e Variáveis Definidas para zeilberger.
                                                             (line  141)
* mod_threshold:                         Funções e Variáveis Definidas para zeilberger.
                                                             (line  164)
* moebius:                               Funções e Variáveis Definidas para Conjuntos.
                                                             (line  691)
* mon2schur:                             Funções e Variáveis Definidas para Simetrias.
                                                             (line   63)
* mono:                                  Funções e Variáveis Definidas para Funções Afins.
                                                             (line   99)
* monomial_dimensions:                   Funções e Variáveis Definidas para Funções Afins.
                                                             (line  105)
* multinomial:                           Funções e Variáveis Definidas para Simetrias.
                                                             (line  850)
* multinomial_coeff:                     Funções e Variáveis Definidas para Conjuntos.
                                                             (line  724)
* multinomial_coeff <1>:                 Funções e Variáveis Definidas para Conjuntos.
                                                             (line  725)
* multiplicative:                        Funções e Variáveis Definidas para Simplificação.
                                                             (line  237)
* Multiplicação:                         Operadores Aritméticos.
                                                             (line    9)
* Multiplicação não comutativa matricial: Operadores Geral.  (line  113)
* multiplicities:                        Funções e Variáveis Definidas para Equações.
                                                             (line  534)
* multi_elem:                            Funções e Variáveis Definidas para Simetrias.
                                                             (line   89)
* multi_orbit:                           Funções e Variáveis Definidas para Simetrias.
                                                             (line  353)
* multi_pui:                             Funções e Variáveis Definidas para Simetrias.
                                                             (line  104)
* multsym:                               Funções e Variáveis Definidas para Simetrias.
                                                             (line  366)
* multthru:                              Funções e Variáveis Definidas para Expressões.
                                                             (line  916)
* multthru <1>:                          Funções e Variáveis Definidas para Expressões.
                                                             (line  917)
* myoptions:                             Funções e Variáveis Definidas para Linha de Comando.
                                                             (line  426)
* N'ésima saída anterior:                Funções e Variáveis Definidas para Entrada e Saída.
                                                             (line  147)
* ncexpt:                                Funções e Variáveis Definidas para Matrizes e Álgebra Linear.
                                                             (line  881)
* ncharpoly:                             Funções e Variáveis Definidas para Matrizes e Álgebra Linear.
                                                             (line  888)
* nc_degree:                             Funções e Variáveis Definidas para Funções Afins.
                                                             (line   61)
* Negação lógica:                        Operadores Geral.   (line  362)
* negdistrib:                            Funções e Variáveis Definidas para Simplificação.
                                                             (line  253)
* negsumdispflag:                        Funções e Variáveis Definidas para Simplificação.
                                                             (line  264)
* newcontext:                            Funções e Variáveis Definidas para Contextos.
                                                             (line  304)
* newdet:                                Funções e Variáveis Definidas para Matrizes e Álgebra Linear.
                                                             (line  904)
* newline:                               Funções e Variáveis para caracteres.
                                                             (line   77)
* newline <1>:                           Funções e Variáveis para entrada e saída.
                                                             (line   43)
* newline <2>:                           Funções e Variáveis para entrada e saída.
                                                             (line   44)
* newton:                                Funções e Variáveis Definidas para Numérico.
                                                             (line  308)
* newtonepsilon:                         Funções e Variáveis Definidas para mnewton.
                                                             (line    6)
* newtonmaxiter:                         Funções e Variáveis Definidas para mnewton.
                                                             (line   14)
* nextlayerfactor:                       Funções e Variáveis Definidas para simplification.
                                                             (line   97)
* next_prime:                            Funções e Variáveis Definidas para Teoria dos Números.
                                                             (line  322)
* niceindices:                           Funções e Variáveis Definidas para Séries.
                                                             (line   76)
* niceindicespref:                       Funções e Variáveis Definidas para Séries.
                                                             (line  110)
* ninth:                                 Funções e Variáveis Definidas para Listas.
                                                             (line  245)
* nm:                                    Funções e Variáveis Definidas para ctensor.
                                                             (line 1249)
* nmc:                                   Funções e Variáveis Definidas para ctensor.
                                                             (line 1254)
* noeval:                                Funções e Variáveis Definidas para Simplificação.
                                                             (line  274)
* nolabels:                              Funções e Variáveis Definidas para Linha de Comando.
                                                             (line  433)
* noncentral_moment:                     Funções e Variáveis Definidas para estatística descritiva.
                                                             (line  115)
* noncentral_moment <1>:                 Funções e Variáveis Definidas para estatística descritiva.
                                                             (line  116)
* nonegative_sx:                         Funções e Variáveis Definidas para simplex.
                                                             (line   90)
* nonmetricity:                          Funções e Variáveis Definidas para ctensor.
                                                             (line  659)
* nonnegintegerp:                        Funções e Variáveis Definidas para linearalgebra.
                                                             (line  453)
* nonscalar:                             Funções e Variáveis Definidas para Matrizes e Álgebra Linear.
                                                             (line  909)
* nonscalarp:                            Funções e Variáveis Definidas para Matrizes e Álgebra Linear.
                                                             (line  913)
* nonzeroandfreeof:                      Funções e Variáveis Definidas para simplification.
                                                             (line  190)
* not:                                   Operadores Geral.   (line  361)
* notequal:                              Operadores Geral.   (line  681)
* noun:                                  Funções e Variáveis Definidas para Simplificação.
                                                             (line  279)
* noundisp:                              Funções e Variáveis Definidas para Simplificação.
                                                             (line  284)
* nounify:                               Funções e Variáveis Definidas para Expressões.
                                                             (line  961)
* nouns:                                 Funções e Variáveis Definidas para Simplificação.
                                                             (line  291)
* np:                                    Funções e Variáveis Definidas para ctensor.
                                                             (line 1220)
* npi:                                   Funções e Variáveis Definidas para ctensor.
                                                             (line 1224)
* nptetrad:                              Funções e Variáveis Definidas para ctensor.
                                                             (line  475)
* nroots:                                Funções e Variáveis Definidas para Equações.
                                                             (line  540)
* nterms:                                Funções e Variáveis Definidas para Expressões.
                                                             (line  969)
* ntermst:                               Funções e Variáveis Definidas para ctensor.
                                                             (line  830)
* nthroot:                               Funções e Variáveis Definidas para Equações.
                                                             (line  552)
* nticks:                                Funções e Variáveis Definidas para draw.
                                                             (line 1029)
* ntrig:                                 Funções e Variáveis Definidas para Trigonometria.
                                                             (line   78)
* nullity:                               Funções e Variáveis Definidas para linearalgebra.
                                                             (line  465)
* nullspace:                             Funções e Variáveis Definidas para linearalgebra.
                                                             (line  457)
* num:                                   Funções e Variáveis Definidas para Polinômios.
                                                             (line  559)
* numberp:                               Funções e Variáveis Definidas para Opções Diversas.
                                                             (line  181)
* numer:                                 Funções e Variáveis Definidas para Simplificação.
                                                             (line  298)
* numerval:                              Funções e Variáveis Definidas para Simplificação.
                                                             (line  306)
* numfactor:                             Funções e Variáveis Definidas para Funções Especiais.
                                                             (line  196)
* num_distinct_partitions:               Funções e Variáveis Definidas para Conjuntos.
                                                             (line  757)
* num_distinct_partitions <1>:           Funções e Variáveis Definidas para Conjuntos.
                                                             (line  758)
* num_partitions:                        Funções e Variáveis Definidas para Conjuntos.
                                                             (line  779)
* num_partitions <1>:                    Funções e Variáveis Definidas para Conjuntos.
                                                             (line  780)
* nusum:                                 Funções e Variáveis Definidas para Séries.
                                                             (line  139)
* Não igual (desigualdade sintática):    Operadores Geral.   (line   86)
* Número áureo:                          Funções e Variáveis Definidas para Constantes.
                                                             (line   28)
* obase:                                 Funções e Variáveis Definidas para Entrada e Saída.
                                                             (line  854)
* oddp:                                  Operadores Geral.   (line  897)
* ode2:                                  Funções e Variáveis Definidas para Equações Diferenciais.
                                                             (line   90)
* odelin:                                Funções e Variáveis Definidas para contrib_ode.
                                                             (line   11)
* ode_check:                             Funções e Variáveis Definidas para contrib_ode.
                                                             (line   42)
* op:                                    Funções e Variáveis Definidas para Expressões.
                                                             (line  976)
* opena:                                 Funções e Variáveis para entrada e saída.
                                                             (line   49)
* openr:                                 Funções e Variáveis para entrada e saída.
                                                             (line   54)
* openw:                                 Funções e Variáveis para entrada e saída.
                                                             (line   58)
* Operador Apóstrofo:                    Introdução a Linha de Comando.
                                                             (line    7)
* Operador apóstrofo-apóstrofo:          Introdução a Linha de Comando.
                                                             (line   91)
* Operador de atribuição:                Operadores Geral.   (line  124)
* Operador de atribuição (avalia o lado esquerdo da igualdade): Operadores Geral.
                                                             (line  127)
* Operador de definição de função:       Operadores Geral.   (line  218)
* Operador de definição de função de macro: Operadores Geral.
                                                             (line  132)
* Operador de equação:                   Operadores Geral.   (line  222)
* Operador de Subscrito:                 Funções e Variáveis Definidas para Matrizes e Álgebra Linear.
                                                             (line 1135)
* operatorp:                             Funções e Variáveis Definidas para Expressões.
                                                             (line 1023)
* operatorp <1>:                         Funções e Variáveis Definidas para Expressões.
                                                             (line 1024)
* opproperties:                          Funções e Variáveis Definidas para Simplificação.
                                                             (line  316)
* opsubst:                               Funções e Variáveis Definidas para Simplificação.
                                                             (line  324)
* opsubst <1>:                           Funções e Variáveis Definidas para opsubst.
                                                             (line    6)
* opsubst <2>:                           Funções e Variáveis Definidas para opsubst.
                                                             (line    7)
* opsubst <3>:                           Funções e Variáveis Definidas para opsubst.
                                                             (line    8)
* optimize:                              Funções e Variáveis Definidas para Expressões.
                                                             (line 1032)
* optimprefix:                           Funções e Variáveis Definidas para Expressões.
                                                             (line 1040)
* optionset:                             Funções e Variáveis Definidas para Linha de Comando.
                                                             (line  448)
* or:                                    Operadores Geral.   (line  338)
* orbit:                                 Funções e Variáveis Definidas para Simetrias.
                                                             (line  384)
* ordergreat:                            Funções e Variáveis Definidas para Expressões.
                                                             (line 1046)
* ordergreatp:                           Funções e Variáveis Definidas para Expressões.
                                                             (line 1053)
* orderless:                             Funções e Variáveis Definidas para Expressões.
                                                             (line 1057)
* orderlessp:                            Funções e Variáveis Definidas para Expressões.
                                                             (line 1071)
* orthogonal_complement:                 Funções e Variáveis Definidas para linearalgebra.
                                                             (line  469)
* orthopoly_recur:                       Funções e Variáveis Definidas para polinômios ortogonais.
                                                             (line   67)
* orthopoly_returns_intervals:           Funções e Variáveis Definidas para polinômios ortogonais.
                                                             (line   95)
* orthopoly_weight:                      Funções e Variáveis Definidas para polinômios ortogonais.
                                                             (line  104)
* outative:                              Funções e Variáveis Definidas para Simplificação.
                                                             (line  331)
* outchar:                               Funções e Variáveis Definidas para Entrada e Saída.
                                                             (line  867)
* outermap:                              Funções e Variáveis Definidas para Fluxo de Programa.
                                                             (line  474)
* outofpois:                             Funções e Variáveis Definidas para Funções Especiais.
                                                             (line  212)
* packagefile:                           Funções e Variáveis Definidas para Entrada e Saída.
                                                             (line  885)
* pade:                                  Funções e Variáveis Definidas para Séries.
                                                             (line  189)
* palette:                               Funções e Variáveis Definidas para draw.
                                                             (line  551)
* parGosper:                             Funções e Variáveis Definidas para zeilberger.
                                                             (line   68)
* parsetoken:                            Funções e Variáveis para seqüências de caracteres.
                                                             (line   34)
* parse_string:                          Funções e Variáveis Definidas para eval_string.
                                                             (line   23)
* part:                                  Funções e Variáveis Definidas para Expressões.
                                                             (line 1075)
* part2cont:                             Funções e Variáveis Definidas para Simetrias.
                                                             (line  242)
* partfrac:                              Funções e Variáveis Definidas para Teoria dos Números.
                                                             (line  328)
* partition:                             Funções e Variáveis Definidas para Expressões.
                                                             (line 1103)
* partition_set:                         Funções e Variáveis Definidas para Conjuntos.
                                                             (line  803)
* partpol:                               Funções e Variáveis Definidas para Simetrias.
                                                             (line  251)
* partswitch:                            Funções e Variáveis Definidas para Expressões.
                                                             (line 1116)
* pdf_bernoulli:                         Funções e Variáveis Definidas para distribuições discretas.
                                                             (line  171)
* pdf_beta:                              Funções e Variáveis Definidas para distribuições contínuas.
                                                             (line  773)
* pdf_binomial:                          Funções e Variáveis Definidas para distribuições discretas.
                                                             (line    6)
* pdf_cauchy:                            Funções e Variáveis Definidas para distribuições contínuas.
                                                             (line 1281)
* pdf_chi2:                              Funções e Variáveis Definidas para distribuições contínuas.
                                                             (line  176)
* pdf_continuous_uniform:                Funções e Variáveis Definidas para distribuições contínuas.
                                                             (line  856)
* pdf_discrete_uniform:                  Funções e Variáveis Definidas para distribuições discretas.
                                                             (line  357)
* pdf_exp:                               Funções e Variáveis Definidas para distribuições contínuas.
                                                             (line  445)
* pdf_f:                                 Funções e Variáveis Definidas para distribuições contínuas.
                                                             (line  350)
* pdf_gamma:                             Funções e Variáveis Definidas para distribuições contínuas.
                                                             (line  689)
* pdf_geometric:                         Funções e Variáveis Definidas para distribuições discretas.
                                                             (line  286)
* pdf_gumbel:                            Funções e Variáveis Definidas para distribuições contínuas.
                                                             (line 1306)
* pdf_hypergeometric:                    Funções e Variáveis Definidas para distribuições discretas.
                                                             (line  413)
* pdf_laplace:                           Funções e Variáveis Definidas para distribuições contínuas.
                                                             (line 1232)
* pdf_logistic:                          Funções e Variáveis Definidas para distribuições contínuas.
                                                             (line  910)
* pdf_lognormal:                         Funções e Variáveis Definidas para distribuições contínuas.
                                                             (line  624)
* pdf_negative_binomial:                 Funções e Variáveis Definidas para distribuições discretas.
                                                             (line  495)
* pdf_normal:                            Funções e Variáveis Definidas para distribuições contínuas.
                                                             (line    6)
* pdf_pareto:                            Funções e Variáveis Definidas para distribuições contínuas.
                                                             (line  959)
* pdf_poisson:                           Funções e Variáveis Definidas para distribuições discretas.
                                                             (line   93)
* pdf_rank_sum:                          Funções e Variáveis Definidas para distribuições especiais.
                                                             (line   20)
* pdf_rayleigh:                          Funções e Variáveis Definidas para distribuições contínuas.
                                                             (line 1057)
* pdf_signed_rank:                       Funções e Variáveis Definidas para distribuições especiais.
                                                             (line    6)
* pdf_student_t:                         Funções e Variáveis Definidas para distribuições contínuas.
                                                             (line   84)
* pdf_weibull:                           Funções e Variáveis Definidas para distribuições contínuas.
                                                             (line 1008)
* pearson_skewness:                      Funções e Variáveis Definidas para estatística descritiva.
                                                             (line  445)
* pearson_skewness <1>:                  Funções e Variáveis Definidas para estatística descritiva.
                                                             (line  446)
* permanent:                             Funções e Variáveis Definidas para Matrizes e Álgebra Linear.
                                                             (line  917)
* permut:                                Funções e Variáveis Definidas para Simetrias.
                                                             (line  856)
* permutation:                           Funções e Variáveis Definidas para simplification.
                                                             (line  285)
* permutations:                          Funções e Variáveis Definidas para Conjuntos.
                                                             (line  824)
* petrov:                                Funções e Variáveis Definidas para ctensor.
                                                             (line  523)
* pfeformat:                             Funções e Variáveis Definidas para Entrada e Saída.
                                                             (line  900)
* phi:                                   Funções e Variáveis Definidas para Constantes.
                                                             (line   28)
* pi:                                    Funções e Variáveis Definidas para Constantes.
                                                             (line   82)
* pickapart:                             Funções e Variáveis Definidas para Expressões.
                                                             (line 1123)
* pic_height:                            Funções e Variáveis Definidas para draw.
                                                             (line  405)
* pic_width:                             Funções e Variáveis Definidas para draw.
                                                             (line  385)
* piece:                                 Funções e Variáveis Definidas para Expressões.
                                                             (line 1210)
* playback:                              Funções e Variáveis Definidas para Linha de Comando.
                                                             (line  457)
* playback <1>:                          Funções e Variáveis Definidas para Linha de Comando.
                                                             (line  458)
* playback <2>:                          Funções e Variáveis Definidas para Linha de Comando.
                                                             (line  459)
* playback <3>:                          Funções e Variáveis Definidas para Linha de Comando.
                                                             (line  460)
* playback <4>:                          Funções e Variáveis Definidas para Linha de Comando.
                                                             (line  461)
* playback <5>:                          Funções e Variáveis Definidas para Linha de Comando.
                                                             (line  462)
* playback <6>:                          Funções e Variáveis Definidas para Linha de Comando.
                                                             (line  463)
* playback <7>:                          Funções e Variáveis Definidas para Linha de Comando.
                                                             (line  464)
* plog:                                  Funções e Variáveis Definidas para Logarítmos.
                                                             (line  193)
* plot2d:                                Funções e Variáveis Definidas para Montagem de Gráficos.
                                                             (line   42)
* plot2d <1>:                            Funções e Variáveis Definidas para Montagem de Gráficos.
                                                             (line   43)
* plot2d <2>:                            Funções e Variáveis Definidas para Montagem de Gráficos.
                                                             (line   44)
* plot3d:                                Funções e Variáveis Definidas para Montagem de Gráficos.
                                                             (line  548)
* plot3d <1>:                            Funções e Variáveis Definidas para Montagem de Gráficos.
                                                             (line  550)
* plot3d <2>:                            Funções e Variáveis Definidas para Montagem de Gráficos.
                                                             (line  551)
* plot3d <3>:                            Funções e Variáveis Definidas para Montagem de Gráficos.
                                                             (line  552)
* plot3d <4>:                            Funções e Variáveis Definidas para Montagem de Gráficos.
                                                             (line  553)
* plotdf:                                Funções e Variáveis Definidas para plotdf.
                                                             (line    6)
* plotdf <1>:                            Funções e Variáveis Definidas para plotdf.
                                                             (line    7)
* plot_options:                          Funções e Variáveis Definidas para Montagem de Gráficos.
                                                             (line  184)
* plsquares:                             Funções e Variáveis Definidas para lsquares.
                                                             (line  100)
* plsquares <1>:                         Funções e Variáveis Definidas para lsquares.
                                                             (line  101)
* plsquares <2>:                         Funções e Variáveis Definidas para lsquares.
                                                             (line  102)
* pochhammer:                            Funções e Variáveis Definidas para polinômios ortogonais.
                                                             (line  122)
* pochhammer_max_index:                  Funções e Variáveis Definidas para polinômios ortogonais.
                                                             (line  153)
* points_joined:                         Funções e Variáveis Definidas para draw.
                                                             (line  693)
* point_size:                            Funções e Variáveis Definidas para draw.
                                                             (line  633)
* point_type:                            Funções e Variáveis Definidas para draw.
                                                             (line  651)
* poisdiff:                              Funções e Variáveis Definidas para Funções Especiais.
                                                             (line  219)
* poisexpt:                              Funções e Variáveis Definidas para Funções Especiais.
                                                             (line  223)
* poisint:                               Funções e Variáveis Definidas para Funções Especiais.
                                                             (line  227)
* poislim:                               Funções e Variáveis Definidas para Funções Especiais.
                                                             (line  232)
* poismap:                               Funções e Variáveis Definidas para Funções Especiais.
                                                             (line  240)
* poisplus:                              Funções e Variáveis Definidas para Funções Especiais.
                                                             (line  246)
* poissimp:                              Funções e Variáveis Definidas para Funções Especiais.
                                                             (line  249)
* poisson:                               Funções e Variáveis Definidas para Funções Especiais.
                                                             (line  252)
* poissubst:                             Funções e Variáveis Definidas para Funções Especiais.
                                                             (line  256)
* poistimes:                             Funções e Variáveis Definidas para Funções Especiais.
                                                             (line  275)
* poistrim:                              Funções e Variáveis Definidas para Funções Especiais.
                                                             (line  278)
* polarform:                             Funções e Variáveis Definidas para Expressões.
                                                             (line 1215)
* polartorect:                           Funções e Variáveis Definidas para Numérico.
                                                             (line    6)
* polartorect <1>:                       Funções e Variáveis Definidas para Numérico.
                                                             (line   64)
* polydecomp:                            Funções e Variáveis Definidas para Polinômios.
                                                             (line  565)
* polymod:                               Operadores Geral.   (line  858)
* polymod <1>:                           Operadores Geral.   (line  859)
* polynome2ele:                          Funções e Variáveis Definidas para Simetrias.
                                                             (line  511)
* polynomialp:                           Funções e Variáveis Definidas para linearalgebra.
                                                             (line  478)
* polynomialp <1>:                       Funções e Variáveis Definidas para linearalgebra.
                                                             (line  479)
* polynomialp <2>:                       Funções e Variáveis Definidas para linearalgebra.
                                                             (line  480)
* polytocompanion:                       Funções e Variáveis Definidas para linearalgebra.
                                                             (line  517)
* poly_add:                              Funções e Variáveis Definidas para grobner.
                                                             (line   83)
* poly_buchberger:                       Funções e Variáveis Definidas para grobner.
                                                             (line  191)
* poly_buchberger_criterion:             Funções e Variáveis Definidas para grobner.
                                                             (line  185)
* poly_coefficient_ring:                 Funções e Variáveis Definidas para grobner.
                                                             (line   16)
* poly_colon_ideal:                      Funções e Variáveis Definidas para grobner.
                                                             (line  239)
* poly_content:                          Funções e Variáveis Definidas para grobner.
                                                             (line  159)
* poly_depends_p:                        Funções e Variáveis Definidas para grobner.
                                                             (line  230)
* poly_elimination_ideal:                Funções e Variáveis Definidas para grobner.
                                                             (line  233)
* poly_elimination_order:                Funções e Variáveis Definidas para grobner.
                                                             (line   36)
* poly_exact_divide:                     Funções e Variáveis Definidas para grobner.
                                                             (line  177)
* poly_expand:                           Funções e Variáveis Definidas para grobner.
                                                             (line  122)
* poly_expt:                             Funções e Variáveis Definidas para grobner.
                                                             (line  152)
* poly_gcd:                              Funções e Variáveis Definidas para grobner.
                                                             (line  255)
* poly_grobner:                          Funções e Variáveis Definidas para grobner.
                                                             (line  222)
* poly_grobner_algorithm:                Funções e Variáveis Definidas para grobner.
                                                             (line   58)
* poly_grobner_debug:                    Funções e Variáveis Definidas para grobner.
                                                             (line   53)
* poly_grobner_equal:                    Funções e Variáveis Definidas para grobner.
                                                             (line  258)
* poly_grobner_member:                   Funções e Variáveis Definidas para grobner.
                                                             (line  276)
* poly_grobner_subsetp:                  Funções e Variáveis Definidas para grobner.
                                                             (line  270)
* poly_ideal_intersection:               Funções e Variáveis Definidas para grobner.
                                                             (line  247)
* poly_ideal_polysaturation:             Funções e Variáveis Definidas para grobner.
                                                             (line  315)
* poly_ideal_polysaturation1:            Funções e Variáveis Definidas para grobner.
                                                             (line  304)
* poly_ideal_saturation:                 Funções e Variáveis Definidas para grobner.
                                                             (line  295)
* poly_ideal_saturation1:                Funções e Variáveis Definidas para grobner.
                                                             (line  286)
* poly_lcm:                              Funções e Variáveis Definidas para grobner.
                                                             (line  252)
* poly_minimization:                     Funções e Variáveis Definidas para grobner.
                                                             (line  211)
* poly_monomial_order:                   Funções e Variáveis Definidas para grobner.
                                                             (line    9)
* poly_multiply:                         Funções e Variáveis Definidas para grobner.
                                                             (line   97)
* poly_normalize:                        Funções e Variáveis Definidas para grobner.
                                                             (line  114)
* poly_normalize_list:                   Funções e Variáveis Definidas para grobner.
                                                             (line  217)
* poly_normal_form:                      Funções e Variáveis Definidas para grobner.
                                                             (line  181)
* poly_primary_elimination_order:        Funções e Variáveis Definidas para grobner.
                                                             (line   24)
* poly_primitive_part:                   Funções e Variáveis Definidas para grobner.
                                                             (line  107)
* poly_pseudo_divide:                    Funções e Variáveis Definidas para grobner.
                                                             (line  165)
* poly_reduced_grobner:                  Funções e Variáveis Definidas para grobner.
                                                             (line  226)
* poly_reduction:                        Funções e Variáveis Definidas para grobner.
                                                             (line  206)
* poly_return_term_list:                 Funções e Variáveis Definidas para grobner.
                                                             (line   46)
* poly_saturation_extension:             Funções e Variáveis Definidas para grobner.
                                                             (line  323)
* poly_secondary_elimination_order:      Funções e Variáveis Definidas para grobner.
                                                             (line   30)
* poly_subtract:                         Funções e Variáveis Definidas para grobner.
                                                             (line   90)
* poly_s_polynomial:                     Funções e Variáveis Definidas para grobner.
                                                             (line  103)
* poly_top_reduction_only:               Funções e Variáveis Definidas para grobner.
                                                             (line   68)
* posfun:                                Funções e Variáveis Definidas para Simplificação.
                                                             (line  349)
* potential:                             Funções e Variáveis Definidas para Integração.
                                                             (line  418)
* powerdisp:                             Funções e Variáveis Definidas para Séries.
                                                             (line  251)
* powers:                                Funções e Variáveis Definidas para Expressões.
                                                             (line 1219)
* powerseries:                           Funções e Variáveis Definidas para Séries.
                                                             (line  262)
* powerset:                              Funções e Variáveis Definidas para Conjuntos.
                                                             (line  845)
* powerset <1>:                          Funções e Variáveis Definidas para Conjuntos.
                                                             (line  846)
* power_mod:                             Funções e Variáveis Definidas para Teoria dos Números.
                                                             (line  353)
* pred:                                  Operadores Geral.   (line  901)
* prederror:                             Funções e Variáveis Definidas para Fluxo de Programa.
                                                             (line  409)
* prev_prime:                            Funções e Variáveis Definidas para Teoria dos Números.
                                                             (line  389)
* primep:                                Funções e Variáveis Definidas para Teoria dos Números.
                                                             (line  367)
* primep_number_of_tests:                Funções e Variáveis Definidas para Teoria dos Números.
                                                             (line  384)
* print:                                 Funções e Variáveis Definidas para Entrada e Saída.
                                                             (line  922)
* printf:                                Funções e Variáveis para entrada e saída.
                                                             (line   63)
* printf <1>:                            Funções e Variáveis para entrada e saída.
                                                             (line   64)
* printpois:                             Funções e Variáveis Definidas para Funções Especiais.
                                                             (line  286)
* printprops:                            Funções e Variáveis Definidas para Linha de Comando.
                                                             (line  507)
* printprops <1>:                        Funções e Variáveis Definidas para Linha de Comando.
                                                             (line  508)
* printprops <2>:                        Funções e Variáveis Definidas para Linha de Comando.
                                                             (line  509)
* prodrac:                               Funções e Variáveis Definidas para Simetrias.
                                                             (line  523)
* product:                               Funções e Variáveis Definidas para Expressões.
                                                             (line 1224)
* product_use_gamma:                     Funções e Variáveis Definidas para solve_rec.
                                                             (line  177)
* Produto Externo:                       Funções e Variáveis Definidas para itensor.
                                                             (line 1376)
* programmode:                           Funções e Variáveis Definidas para Equações.
                                                             (line  559)
* prompt:                                Funções e Variáveis Definidas para Linha de Comando.
                                                             (line  517)
* properties:                            Funções e Variáveis Definidas para Opções Diversas.
                                                             (line  210)
* props:                                 Funções e Variáveis Definidas para Opções Diversas.
                                                             (line  214)
* propvars:                              Funções e Variáveis Definidas para Opções Diversas.
                                                             (line  220)
* psexpand:                              Funções e Variáveis Definidas para Séries.
                                                             (line  300)
* psi:                                   Funções e Variáveis Definidas para Funções Especiais.
                                                             (line  291)
* psi <1>:                               Funções e Variáveis Definidas para ctensor.
                                                             (line  499)
* ptriangularize:                        Funções e Variáveis Definidas para linearalgebra.
                                                             (line  525)
* pui:                                   Funções e Variáveis Definidas para Simetrias.
                                                             (line  114)
* pui2comp:                              Funções e Variáveis Definidas para Simetrias.
                                                             (line  140)
* pui2ele:                               Funções e Variáveis Definidas para Simetrias.
                                                             (line  166)
* pui2polynome:                          Funções e Variáveis Definidas para Simetrias.
                                                             (line  530)
* puireduc:                              Funções e Variáveis Definidas para Simetrias.
                                                             (line  175)
* pui_direct:                            Funções e Variáveis Definidas para Simetrias.
                                                             (line  397)
* put:                                   Funções e Variáveis Definidas para Opções Diversas.
                                                             (line  225)
* qput:                                  Funções e Variáveis Definidas para Opções Diversas.
                                                             (line  247)
* qrange:                                Funções e Variáveis Definidas para estatística descritiva.
                                                             (line  270)
* qrange <1>:                            Funções e Variáveis Definidas para estatística descritiva.
                                                             (line  271)
* quad_qag:                              Funções e Variáveis Definidas para QUADPACK.
                                                             (line    6)
* quad_qag <1>:                          Funções e Variáveis Definidas para QUADPACK.
                                                             (line    8)
* quad_qagi:                             Funções e Variáveis Definidas para QUADPACK.
                                                             (line  125)
* quad_qagi <1>:                         Funções e Variáveis Definidas para QUADPACK.
                                                             (line  126)
* quad_qags:                             Funções e Variáveis Definidas para QUADPACK.
                                                             (line   69)
* quad_qags <1>:                         Funções e Variáveis Definidas para QUADPACK.
                                                             (line   70)
* quad_qawc:                             Funções e Variáveis Definidas para QUADPACK.
                                                             (line  196)
* quad_qawc <1>:                         Funções e Variáveis Definidas para QUADPACK.
                                                             (line  197)
* quad_qawf:                             Funções e Variáveis Definidas para QUADPACK.
                                                             (line  266)
* quad_qawf <1>:                         Funções e Variáveis Definidas para QUADPACK.
                                                             (line  268)
* quad_qawo:                             Funções e Variáveis Definidas para QUADPACK.
                                                             (line  344)
* quad_qawo <1>:                         Funções e Variáveis Definidas para QUADPACK.
                                                             (line  346)
* quad_qaws:                             Funções e Variáveis Definidas para QUADPACK.
                                                             (line  423)
* quad_qaws <1>:                         Funções e Variáveis Definidas para QUADPACK.
                                                             (line  425)
* quantile:                              Funções e Variáveis Definidas para estatística descritiva.
                                                             (line  227)
* quantile <1>:                          Funções e Variáveis Definidas para estatística descritiva.
                                                             (line  228)
* quantile_bernoulli:                    Funções e Variáveis Definidas para distribuições discretas.
                                                             (line  191)
* quantile_beta:                         Funções e Variáveis Definidas para distribuições contínuas.
                                                             (line  794)
* quantile_binomial:                     Funções e Variáveis Definidas para distribuições discretas.
                                                             (line   29)
* quantile_cauchy:                       Funções e Variáveis Definidas para distribuições contínuas.
                                                             (line 1291)
* quantile_chi2:                         Funções e Variáveis Definidas para distribuições contínuas.
                                                             (line  214)
* quantile_continuous_uniform:           Funções e Variáveis Definidas para distribuições contínuas.
                                                             (line  866)
* quantile_discrete_uniform:             Funções e Variáveis Definidas para distribuições discretas.
                                                             (line  368)
* quantile_exp:                          Funções e Variáveis Definidas para distribuições contínuas.
                                                             (line  481)
* quantile_f:                            Funções e Variáveis Definidas para distribuições contínuas.
                                                             (line  370)
* quantile_gamma:                        Funções e Variáveis Definidas para distribuições contínuas.
                                                             (line  708)
* quantile_geometric:                    Funções e Variáveis Definidas para distribuições discretas.
                                                             (line  296)
* quantile_gumbel:                       Funções e Variáveis Definidas para distribuições contínuas.
                                                             (line 1316)
* quantile_hypergeometric:               Funções e Variáveis Definidas para distribuições discretas.
                                                             (line  425)
* quantile_laplace:                      Funções e Variáveis Definidas para distribuições contínuas.
                                                             (line 1242)
* quantile_logistic:                     Funções e Variáveis Definidas para distribuições contínuas.
                                                             (line  920)
* quantile_lognormal:                    Funções e Variáveis Definidas para distribuições contínuas.
                                                             (line  644)
* quantile_negative_binomial:            Funções e Variáveis Definidas para distribuições discretas.
                                                             (line  518)
* quantile_normal:                       Funções e Variáveis Definidas para distribuições contínuas.
                                                             (line   26)
* quantile_pareto:                       Funções e Variáveis Definidas para distribuições contínuas.
                                                             (line  969)
* quantile_poisson:                      Funções e Variáveis Definidas para distribuições discretas.
                                                             (line  112)
* quantile_rayleigh:                     Funções e Variáveis Definidas para distribuições contínuas.
                                                             (line 1095)
* quantile_student_t:                    Funções e Variáveis Definidas para distribuições contínuas.
                                                             (line  104)
* quantile_weibull:                      Funções e Variáveis Definidas para distribuições contínuas.
                                                             (line 1018)
* quartile_skewness:                     Funções e Variáveis Definidas para estatística descritiva.
                                                             (line  468)
* quartile_skewness <1>:                 Funções e Variáveis Definidas para estatística descritiva.
                                                             (line  469)
* quit:                                  Funções e Variáveis Definidas para Linha de Comando.
                                                             (line  524)
* qunit:                                 Funções e Variáveis Definidas para Teoria dos Números.
                                                             (line  395)
* quotient:                              Funções e Variáveis Definidas para Polinômios.
                                                             (line  616)
* quotient <1>:                          Funções e Variáveis Definidas para Polinômios.
                                                             (line  617)
* radcan:                                Funções e Variáveis Definidas para Simplificação.
                                                             (line  353)
* radexpand:                             Funções e Variáveis Definidas para Simplificação.
                                                             (line  379)
* radsubstflag:                          Funções e Variáveis Definidas para Simplificação.
                                                             (line  399)
* random:                                Operadores Geral.   (line  933)
* random_bernoulli:                      Funções e Variáveis Definidas para distribuições discretas.
                                                             (line  274)
* random_bernoulli <1>:                  Funções e Variáveis Definidas para distribuições discretas.
                                                             (line  275)
* random_beta:                           Funções e Variáveis Definidas para distribuições contínuas.
                                                             (line  842)
* random_beta <1>:                       Funções e Variáveis Definidas para distribuições contínuas.
                                                             (line  843)
* random_beta_algorithm:                 Funções e Variáveis Definidas para distribuições contínuas.
                                                             (line  823)
* random_binomial:                       Funções e Variáveis Definidas para distribuições discretas.
                                                             (line   78)
* random_binomial <1>:                   Funções e Variáveis Definidas para distribuições discretas.
                                                             (line   79)
* random_binomial_algorithm:             Funções e Variáveis Definidas para distribuições discretas.
                                                             (line   61)
* random_cauchy:                         Funções e Variáveis Definidas para distribuições contínuas.
                                                             (line 1297)
* random_cauchy <1>:                     Funções e Variáveis Definidas para distribuições contínuas.
                                                             (line 1298)
* random_chi2:                           Funções e Variáveis Definidas para distribuições contínuas.
                                                             (line  336)
* random_chi2 <1>:                       Funções e Variáveis Definidas para distribuições contínuas.
                                                             (line  337)
* random_chi2_algorithm:                 Funções e Variáveis Definidas para distribuições contínuas.
                                                             (line  322)
* random_continuous_uniform:             Funções e Variáveis Definidas para distribuições contínuas.
                                                             (line  898)
* random_continuous_uniform <1>:         Funções e Variáveis Definidas para distribuições contínuas.
                                                             (line  899)
* random_discrete_uniform:               Funções e Variáveis Definidas para distribuições discretas.
                                                             (line  400)
* random_discrete_uniform <1>:           Funções e Variáveis Definidas para distribuições discretas.
                                                             (line  401)
* random_exp:                            Funções e Variáveis Definidas para distribuições contínuas.
                                                             (line  610)
* random_exp <1>:                        Funções e Variáveis Definidas para distribuições contínuas.
                                                             (line  611)
* random_exp_algorithm:                  Funções e Variáveis Definidas para distribuições contínuas.
                                                             (line  590)
* random_f:                              Funções e Variáveis Definidas para distribuições contínuas.
                                                             (line  431)
* random_f <1>:                          Funções e Variáveis Definidas para distribuições contínuas.
                                                             (line  432)
* random_f_algorithm:                    Funções e Variáveis Definidas para distribuições contínuas.
                                                             (line  411)
* random_gamma:                          Funções e Variáveis Definidas para distribuições contínuas.
                                                             (line  759)
* random_gamma <1>:                      Funções e Variáveis Definidas para distribuições contínuas.
                                                             (line  760)
* random_gamma_algorithm:                Funções e Variáveis Definidas para distribuições contínuas.
                                                             (line  738)
* random_geometric:                      Funções e Variáveis Definidas para distribuições discretas.
                                                             (line  343)
* random_geometric <1>:                  Funções e Variáveis Definidas para distribuições discretas.
                                                             (line  344)
* random_geometric_algorithm:            Funções e Variáveis Definidas para distribuições discretas.
                                                             (line  326)
* random_gumbel:                         Funções e Variáveis Definidas para distribuições contínuas.
                                                             (line 1359)
* random_gumbel <1>:                     Funções e Variáveis Definidas para distribuições contínuas.
                                                             (line 1360)
* random_hypergeometric:                 Funções e Variáveis Definidas para distribuições discretas.
                                                             (line  479)
* random_hypergeometric <1>:             Funções e Variáveis Definidas para distribuições discretas.
                                                             (line  480)
* random_hypergeometric_algorithm:       Funções e Variáveis Definidas para distribuições discretas.
                                                             (line  463)
* random_laplace:                        Funções e Variáveis Definidas para distribuições contínuas.
                                                             (line 1272)
* random_laplace <1>:                    Funções e Variáveis Definidas para distribuições contínuas.
                                                             (line 1273)
* random_logistic:                       Funções e Variáveis Definidas para distribuições contínuas.
                                                             (line  950)
* random_logistic <1>:                   Funções e Variáveis Definidas para distribuições contínuas.
                                                             (line  951)
* random_lognormal:                      Funções e Variáveis Definidas para distribuições contínuas.
                                                             (line  674)
* random_lognormal <1>:                  Funções e Variáveis Definidas para distribuições contínuas.
                                                             (line  675)
* random_negative_binomial:              Funções e Variáveis Definidas para distribuições discretas.
                                                             (line  568)
* random_negative_binomial <1>:          Funções e Variáveis Definidas para distribuições discretas.
                                                             (line  569)
* random_negative_binomial_algorithm:    Funções e Variáveis Definidas para distribuições discretas.
                                                             (line  551)
* random_normal:                         Funções e Variáveis Definidas para distribuições contínuas.
                                                             (line   70)
* random_normal <1>:                     Funções e Variáveis Definidas para distribuições contínuas.
                                                             (line   71)
* random_normal_algorithm:               Funções e Variáveis Definidas para distribuições contínuas.
                                                             (line   57)
* random_pareto:                         Funções e Variáveis Definidas para distribuições contínuas.
                                                             (line  999)
* random_pareto <1>:                     Funções e Variáveis Definidas para distribuições contínuas.
                                                             (line 1000)
* random_permutation:                    Funções e Variáveis Definidas para Conjuntos.
                                                             (line  875)
* random_poisson:                        Funções e Variáveis Definidas para distribuições discretas.
                                                             (line  157)
* random_poisson <1>:                    Funções e Variáveis Definidas para distribuições discretas.
                                                             (line  158)
* random_poisson_algorithm:              Funções e Variáveis Definidas para distribuições discretas.
                                                             (line  141)
* random_rayleigh:                       Funções e Variáveis Definidas para distribuições contínuas.
                                                             (line 1223)
* random_rayleigh <1>:                   Funções e Variáveis Definidas para distribuições contínuas.
                                                             (line 1224)
* random_student_t:                      Funções e Variáveis Definidas para distribuições contínuas.
                                                             (line  162)
* random_student_t <1>:                  Funções e Variáveis Definidas para distribuições contínuas.
                                                             (line  163)
* random_student_t_algorithm:            Funções e Variáveis Definidas para distribuições contínuas.
                                                             (line  140)
* random_weibull:                        Funções e Variáveis Definidas para distribuições contínuas.
                                                             (line 1048)
* random_weibull <1>:                    Funções e Variáveis Definidas para distribuições contínuas.
                                                             (line 1049)
* range:                                 Funções e Variáveis Definidas para estatística descritiva.
                                                             (line  212)
* range <1>:                             Funções e Variáveis Definidas para estatística descritiva.
                                                             (line  213)
* rank:                                  Funções e Variáveis Definidas para Matrizes e Álgebra Linear.
                                                             (line  921)
* rank <1>:                              Funções e Variáveis Definidas para linearalgebra.
                                                             (line  546)
* rassociative:                          Funções e Variáveis Definidas para Simplificação.
                                                             (line  405)
* rat:                                   Funções e Variáveis Definidas para Polinômios.
                                                             (line  624)
* rat <1>:                               Funções e Variáveis Definidas para Polinômios.
                                                             (line  625)
* ratalgdenom:                           Funções e Variáveis Definidas para Polinômios.
                                                             (line  675)
* ratchristof:                           Funções e Variáveis Definidas para ctensor.
                                                             (line 1135)
* ratcoef:                               Funções e Variáveis Definidas para Polinômios.
                                                             (line  683)
* ratcoef <1>:                           Funções e Variáveis Definidas para Polinômios.
                                                             (line  684)
* ratdenom:                              Funções e Variáveis Definidas para Polinômios.
                                                             (line  712)
* ratdenomdivide:                        Funções e Variáveis Definidas para Polinômios.
                                                             (line  726)
* ratdiff:                               Funções e Variáveis Definidas para Polinômios.
                                                             (line  770)
* ratdisrep:                             Funções e Variáveis Definidas para Polinômios.
                                                             (line  812)
* rateinstein:                           Funções e Variáveis Definidas para ctensor.
                                                             (line 1140)
* ratepsilon:                            Funções e Variáveis Definidas para Polinômios.
                                                             (line  823)
* ratexpand:                             Funções e Variáveis Definidas para Polinômios.
                                                             (line  829)
* ratexpand <1>:                         Funções e Variáveis Definidas para Polinômios.
                                                             (line  830)
* ratfac:                                Funções e Variáveis Definidas para Polinômios.
                                                             (line  878)
* rational:                              Funções e Variáveis Definidas para simplification.
                                                             (line  182)
* rationalize:                           Operadores Geral.   (line  974)
* ratmx:                                 Funções e Variáveis Definidas para Matrizes e Álgebra Linear.
                                                             (line  928)
* ratnumer:                              Funções e Variáveis Definidas para Polinômios.
                                                             (line  901)
* ratnump:                               Funções e Variáveis Definidas para Polinômios.
                                                             (line  915)
* ratp:                                  Funções e Variáveis Definidas para Polinômios.
                                                             (line  919)
* ratprint:                              Funções e Variáveis Definidas para Polinômios.
                                                             (line  926)
* ratriemann:                            Funções e Variáveis Definidas para ctensor.
                                                             (line 1147)
* ratsimp:                               Funções e Variáveis Definidas para Polinômios.
                                                             (line  933)
* ratsimp <1>:                           Funções e Variáveis Definidas para Polinômios.
                                                             (line  934)
* ratsimpexpons:                         Funções e Variáveis Definidas para Polinômios.
                                                             (line  982)
* ratsubst:                              Funções e Variáveis Definidas para Polinômios.
                                                             (line  988)
* ratvars:                               Funções e Variáveis Definidas para Polinômios.
                                                             (line 1023)
* ratvars <1>:                           Funções e Variáveis Definidas para Polinômios.
                                                             (line 1024)
* ratvars <2>:                           Funções e Variáveis Definidas para Polinômios.
                                                             (line 1025)
* ratweight:                             Funções e Variáveis Definidas para Polinômios.
                                                             (line 1045)
* ratweight <1>:                         Funções e Variáveis Definidas para Polinômios.
                                                             (line 1046)
* ratweights:                            Funções e Variáveis Definidas para Polinômios.
                                                             (line 1073)
* ratweyl:                               Funções e Variáveis Definidas para ctensor.
                                                             (line 1155)
* ratwtlvl:                              Funções e Variáveis Definidas para Polinômios.
                                                             (line 1083)
* read:                                  Funções e Variáveis Definidas para Entrada e Saída.
                                                             (line  992)
* readline:                              Funções e Variáveis para entrada e saída.
                                                             (line  124)
* readonly:                              Funções e Variáveis Definidas para Entrada e Saída.
                                                             (line 1007)
* read_hashed_array:                     Funções e Variáveis Definidas para numericalio.
                                                             (line   40)
* read_hashed_array <1>:                 Funções e Variáveis Definidas para numericalio.
                                                             (line   41)
* read_lisp_array:                       Funções e Variáveis Definidas para numericalio.
                                                             (line   16)
* read_lisp_array <1>:                   Funções e Variáveis Definidas para numericalio.
                                                             (line   17)
* read_list:                             Funções e Variáveis Definidas para numericalio.
                                                             (line   57)
* read_list <1>:                         Funções e Variáveis Definidas para numericalio.
                                                             (line   58)
* read_matrix:                           Funções e Variáveis Definidas para numericalio.
                                                             (line    6)
* read_matrix <1>:                       Funções e Variáveis Definidas para numericalio.
                                                             (line    7)
* read_maxima_array:                     Funções e Variáveis Definidas para numericalio.
                                                             (line   28)
* read_maxima_array <1>:                 Funções e Variáveis Definidas para numericalio.
                                                             (line   29)
* read_nested_list:                      Funções e Variáveis Definidas para numericalio.
                                                             (line   49)
* read_nested_list <1>:                  Funções e Variáveis Definidas para numericalio.
                                                             (line   50)
* realonly:                              Funções e Variáveis Definidas para Equações.
                                                             (line  571)
* realpart:                              Funções e Variáveis Definidas para Expressões.
                                                             (line 1282)
* realroots:                             Funções e Variáveis Definidas para Equações.
                                                             (line  577)
* realroots <1>:                         Funções e Variáveis Definidas para Equações.
                                                             (line  578)
* realroots <2>:                         Funções e Variáveis Definidas para Equações.
                                                             (line  579)
* realroots <3>:                         Funções e Variáveis Definidas para Equações.
                                                             (line  580)
* rearray:                               Funções e Variáveis Definidas para Arrays.
                                                             (line  410)
* rectform:                              Funções e Variáveis Definidas para Expressões.
                                                             (line 1288)
* recttopolar:                           Funções e Variáveis Definidas para Numérico.
                                                             (line   26)
* recttopolar <1>:                       Funções e Variáveis Definidas para Numérico.
                                                             (line   63)
* rediff:                                Funções e Variáveis Definidas para itensor.
                                                             (line  646)
* reduce_consts:                         Funções e Variáveis Definidas para simplification.
                                                             (line  392)
* reduce_order:                          Funções e Variáveis Definidas para solve_rec.
                                                             (line    6)
* refcheck:                              Funções e Variáveis Definidas para Depuração.
                                                             (line    6)
* rem:                                   Funções e Variáveis Definidas para Opções Diversas.
                                                             (line  270)
* remainder:                             Funções e Variáveis Definidas para Polinômios.
                                                             (line 1090)
* remainder <1>:                         Funções e Variáveis Definidas para Polinômios.
                                                             (line 1091)
* remarray:                              Funções e Variáveis Definidas para Arrays.
                                                             (line  417)
* remarray <1>:                          Funções e Variáveis Definidas para Arrays.
                                                             (line  418)
* rembox:                                Funções e Variáveis Definidas para Expressões.
                                                             (line 1292)
* rembox <1>:                            Funções e Variáveis Definidas para Expressões.
                                                             (line 1293)
* rembox <2>:                            Funções e Variáveis Definidas para Expressões.
                                                             (line 1294)
* remcomps:                              Funções e Variáveis Definidas para itensor.
                                                             (line  282)
* remcon:                                Funções e Variáveis Definidas para itensor.
                                                             (line  165)
* remcon <1>:                            Funções e Variáveis Definidas para itensor.
                                                             (line  166)
* remcoord:                              Funções e Variáveis Definidas para itensor.
                                                             (line  749)
* remcoord <1>:                          Funções e Variáveis Definidas para itensor.
                                                             (line  750)
* remfun:                                Funções e Variáveis Definidas para Séries de Fourier.
                                                             (line   11)
* remfun <1>:                            Funções e Variáveis Definidas para Séries de Fourier.
                                                             (line   12)
* remfunction:                           Funções e Variáveis Definidas para Linha de Comando.
                                                             (line  533)
* remfunction <1>:                       Funções e Variáveis Definidas para Linha de Comando.
                                                             (line  534)
* remlet:                                Funções e Variáveis Definidas para Regras e Modelos.
                                                             (line  629)
* remlet <1>:                            Funções e Variáveis Definidas para Regras e Modelos.
                                                             (line  630)
* remlet <2>:                            Funções e Variáveis Definidas para Regras e Modelos.
                                                             (line  631)
* remlet <3>:                            Funções e Variáveis Definidas para Regras e Modelos.
                                                             (line  632)
* remove:                                Funções e Variáveis Definidas para Opções Diversas.
                                                             (line  273)
* remove <1>:                            Funções e Variáveis Definidas para Opções Diversas.
                                                             (line  274)
* remove <2>:                            Funções e Variáveis Definidas para Opções Diversas.
                                                             (line  275)
* remove <3>:                            Funções e Variáveis Definidas para Opções Diversas.
                                                             (line  276)
* remove <4>:                            Funções e Variáveis Definidas para Opções Diversas.
                                                             (line  277)
* rempart:                               Funções e Variáveis Definidas para simplification.
                                                             (line  155)
* remrule:                               Funções e Variáveis Definidas para Regras e Modelos.
                                                             (line  651)
* remrule <1>:                           Funções e Variáveis Definidas para Regras e Modelos.
                                                             (line  652)
* remsym:                                Funções e Variáveis Definidas para itensor.
                                                             (line  575)
* remvalue:                              Funções e Variáveis Definidas para Opções Diversas.
                                                             (line  309)
* remvalue <1>:                          Funções e Variáveis Definidas para Opções Diversas.
                                                             (line  310)
* rename:                                Funções e Variáveis Definidas para itensor.
                                                             (line   73)
* rename <1>:                            Funções e Variáveis Definidas para itensor.
                                                             (line   74)
* reset:                                 Funções e Variáveis Definidas para Linha de Comando.
                                                             (line  549)
* residue:                               Funções e Variáveis Definidas para Integração.
                                                             (line  430)
* resolvante:                            Funções e Variáveis Definidas para Simetrias.
                                                             (line  557)
* resolvante_alternee1:                  Funções e Variáveis Definidas para Simetrias.
                                                             (line  731)
* resolvante_bipartite:                  Funções e Variáveis Definidas para Simetrias.
                                                             (line  742)
* resolvante_diedrale:                   Funções e Variáveis Definidas para Simetrias.
                                                             (line  762)
* resolvante_klein:                      Funções e Variáveis Definidas para Simetrias.
                                                             (line  781)
* resolvante_klein3:                     Funções e Variáveis Definidas para Simetrias.
                                                             (line  791)
* resolvante_produit_sym:                Funções e Variáveis Definidas para Simetrias.
                                                             (line  801)
* resolvante_unitaire:                   Funções e Variáveis Definidas para Simetrias.
                                                             (line  827)
* resolvante_vierer:                     Funções e Variáveis Definidas para Simetrias.
                                                             (line  837)
* rest:                                  Funções e Variáveis Definidas para Listas.
                                                             (line  249)
* rest <1>:                              Funções e Variáveis Definidas para Listas.
                                                             (line  250)
* Resultado anterior em expressão composta: Funções e Variáveis Definidas para Entrada e Saída.
                                                             (line  106)
* resultant:                             Funções e Variáveis Definidas para Polinômios.
                                                             (line 1099)
* resultant <1>:                         Funções e Variáveis Definidas para Polinômios.
                                                             (line 1100)
* return:                                Funções e Variáveis Definidas para Fluxo de Programa.
                                                             (line  422)
* reveal:                                Funções e Variáveis Definidas para Entrada e Saída.
                                                             (line 1025)
* reverse:                               Funções e Variáveis Definidas para Listas.
                                                             (line  256)
* revert:                                Funções e Variáveis Definidas para Séries.
                                                             (line  313)
* revert2:                               Funções e Variáveis Definidas para Séries.
                                                             (line  314)
* rhs:                                   Funções e Variáveis Definidas para Equações.
                                                             (line  625)
* ric:                                   Funções e Variáveis Definidas para ctensor.
                                                             (line 1189)
* ricci:                                 Funções e Variáveis Definidas para ctensor.
                                                             (line  202)
* riem:                                  Funções e Variáveis Definidas para ctensor.
                                                             (line 1172)
* riemann:                               Funções e Variáveis Definidas para ctensor.
                                                             (line  241)
* rinvariant:                            Funções e Variáveis Definidas para ctensor.
                                                             (line  283)
* risch:                                 Funções e Variáveis Definidas para Integração.
                                                             (line  445)
* rk:                                    Funções e Variáveis Definidas para dynamics.
                                                             (line   60)
* rk <1>:                                Funções e Variáveis Definidas para dynamics.
                                                             (line   61)
* rmxchar:                               Funções e Variáveis Definidas para Entrada e Saída.
                                                             (line 1080)
* rncombine:                             Funções e Variáveis Definidas para Opções Diversas.
                                                             (line  321)
* romberg:                               Funções e Variáveis Definidas para romberg.
                                                             (line    6)
* romberg <1>:                           Funções e Variáveis Definidas para romberg.
                                                             (line    7)
* rombergabs:                            Funções e Variáveis Definidas para romberg.
                                                             (line  107)
* rombergit:                             Funções e Variáveis Definidas para romberg.
                                                             (line  120)
* rombergmin:                            Funções e Variáveis Definidas para romberg.
                                                             (line  131)
* rombergtol:                            Funções e Variáveis Definidas para romberg.
                                                             (line  140)
* room:                                  Funções e Variáveis Definidas para Ambiente em Tempo de Execução.
                                                             (line   61)
* room <1>:                              Funções e Variáveis Definidas para Ambiente em Tempo de Execução.
                                                             (line   62)
* room <2>:                              Funções e Variáveis Definidas para Ambiente em Tempo de Execução.
                                                             (line   63)
* rootsconmode:                          Funções e Variáveis Definidas para Equações.
                                                             (line  664)
* rootscontract:                         Funções e Variáveis Definidas para Equações.
                                                             (line  670)
* rootsepsilon:                          Funções e Variáveis Definidas para Equações.
                                                             (line  731)
* rot_horizontal:                        Funções e Variáveis Definidas para draw.
                                                             (line  313)
* rot_vertical:                          Funções e Variáveis Definidas para draw.
                                                             (line  293)
* row:                                   Funções e Variáveis Definidas para Matrizes e Álgebra Linear.
                                                             (line  942)
* rowop:                                 Funções e Variáveis Definidas para linearalgebra.
                                                             (line  540)
* rowswap:                               Funções e Variáveis Definidas para linearalgebra.
                                                             (line  556)
* rreduce:                               Funções e Variáveis Definidas para Conjuntos.
                                                             (line  895)
* rreduce <1>:                           Funções e Variáveis Definidas para Conjuntos.
                                                             (line  896)
* run_testsuite:                         Definições para Detecção e Relato de Erros.
                                                             (line    6)
* run_testsuite <1>:                     Definições para Detecção e Relato de Erros.
                                                             (line    7)
* run_testsuite <2>:                     Definições para Detecção e Relato de Erros.
                                                             (line    8)
* run_testsuite <3>:                     Definições para Detecção e Relato de Erros.
                                                             (line    9)
* save:                                  Funções e Variáveis Definidas para Entrada e Saída.
                                                             (line 1087)
* save <1>:                              Funções e Variáveis Definidas para Entrada e Saída.
                                                             (line 1088)
* save <2>:                              Funções e Variáveis Definidas para Entrada e Saída.
                                                             (line 1089)
* save <3>:                              Funções e Variáveis Definidas para Entrada e Saída.
                                                             (line 1090)
* save <4>:                              Funções e Variáveis Definidas para Entrada e Saída.
                                                             (line 1091)
* save <5>:                              Funções e Variáveis Definidas para Entrada e Saída.
                                                             (line 1092)
* savedef:                               Funções e Variáveis Definidas para Entrada e Saída.
                                                             (line 1148)
* savefactors:                           Funções e Variáveis Definidas para Polinômios.
                                                             (line 1120)
* Saída anterior:                        Funções e Variáveis Definidas para Entrada e Saída.
                                                             (line   93)
* scalarmatrixp:                         Funções e Variáveis Definidas para Matrizes e Álgebra Linear.
                                                             (line  946)
* scalarp:                               Funções e Variáveis Definidas para Opções Diversas.
                                                             (line  336)
* scaled_bessel_i:                       Funções e Variáveis Definidas para Funções Especiais.
                                                             (line  142)
* scaled_bessel_i0:                      Funções e Variáveis Definidas para Funções Especiais.
                                                             (line  152)
* scaled_bessel_i1:                      Funções e Variáveis Definidas para Funções Especiais.
                                                             (line  156)
* scalefactors:                          Funções e Variáveis Definidas para Matrizes e Álgebra Linear.
                                                             (line  960)
* scanmap:                               Funções e Variáveis Definidas para Fluxo de Programa.
                                                             (line  426)
* scanmap <1>:                           Funções e Variáveis Definidas para Fluxo de Programa.
                                                             (line  427)
* schur2comp:                            Funções e Variáveis Definidas para Simetrias.
                                                             (line  191)
* sconc:                                 Funções e Variáveis para seqüências de caracteres.
                                                             (line   49)
* sconcat:                               Funções e Variáveis Definidas para Entrada e Saída.
                                                             (line  319)
* scopy:                                 Funções e Variáveis para seqüências de caracteres.
                                                             (line   59)
* scsimp:                                Funções e Variáveis Definidas para Simplificação.
                                                             (line  410)
* scurvature:                            Funções e Variáveis Definidas para ctensor.
                                                             (line  218)
* sdowncase:                             Funções e Variáveis para seqüências de caracteres.
                                                             (line   63)
* sdowncase <1>:                         Funções e Variáveis para seqüências de caracteres.
                                                             (line   64)
* sdowncase <2>:                         Funções e Variáveis para seqüências de caracteres.
                                                             (line   65)
* sec:                                   Funções e Variáveis Definidas para Trigonometria.
                                                             (line   84)
* sech:                                  Funções e Variáveis Definidas para Trigonometria.
                                                             (line   87)
* second:                                Funções e Variáveis Definidas para Listas.
                                                             (line  261)
* sequal:                                Funções e Variáveis para seqüências de caracteres.
                                                             (line   69)
* sequalignore:                          Funções e Variáveis para seqüências de caracteres.
                                                             (line   73)
* setcheck:                              Funções e Variáveis Definidas para Depuração.
                                                             (line   13)
* setcheckbreak:                         Funções e Variáveis Definidas para Depuração.
                                                             (line   44)
* setdifference:                         Funções e Variáveis Definidas para Conjuntos.
                                                             (line  938)
* setelmx:                               Funções e Variáveis Definidas para Matrizes e Álgebra Linear.
                                                             (line  977)
* setequalp:                             Funções e Variáveis Definidas para Conjuntos.
                                                             (line  963)
* setify:                                Funções e Variáveis Definidas para Conjuntos.
                                                             (line  979)
* setp:                                  Funções e Variáveis Definidas para Conjuntos.
                                                             (line  996)
* setunits:                              Funções e Variáveis Definidas para Units.
                                                             (line    6)
* setup_autoload:                        Funções e Variáveis Definidas para Opções Diversas.
                                                             (line  342)
* setval:                                Funções e Variáveis Definidas para Depuração.
                                                             (line   56)
* set_partitions:                        Funções e Variáveis Definidas para Conjuntos.
                                                             (line 1017)
* set_partitions <1>:                    Funções e Variáveis Definidas para Conjuntos.
                                                             (line 1018)
* set_plot_option:                       Funções e Variáveis Definidas para Montagem de Gráficos.
                                                             (line  592)
* set_random_state:                      Operadores Geral.   (line  928)
* set_up_dot_simplifications:            Funções e Variáveis Definidas para Funções Afins.
                                                             (line   37)
* set_up_dot_simplifications <1>:        Funções e Variáveis Definidas para Funções Afins.
                                                             (line   38)
* seventh:                               Funções e Variáveis Definidas para Listas.
                                                             (line  265)
* sexplode:                              Funções e Variáveis para seqüências de caracteres.
                                                             (line   76)
* sf:                                    Funções e Variáveis Definidas para o Pacote atensor.
                                                             (line   94)
* show:                                  Funções e Variáveis Definidas para Entrada e Saída.
                                                             (line 1159)
* showcomps:                             Funções e Variáveis Definidas para itensor.
                                                             (line  287)
* showratvars:                           Funções e Variáveis Definidas para Entrada e Saída.
                                                             (line 1165)
* showtime:                              Funções e Variáveis Definidas para Linha de Comando.
                                                             (line  560)
* sign:                                  Operadores Geral.   (line 1049)
* signum:                                Operadores Geral.   (line 1057)
* similaritytransform:                   Funções e Variáveis Definidas para Matrizes e Álgebra Linear.
                                                             (line  984)
* simple_linear_regression:              Funções e Variáveis Definidas para stats.
                                                             (line  637)
* simple_linear_regression <1>:          Funções e Variáveis Definidas para stats.
                                                             (line  638)
* simplified_output:                     Funções e Variáveis Definidas para zeilberger.
                                                             (line  106)
* simplify_products:                     Funções e Variáveis Definidas para solve_rec.
                                                             (line   54)
* simplify_sum:                          Funções e Variáveis Definidas para solve_rec.
                                                             (line   62)
* simplode:                              Funções e Variáveis para seqüências de caracteres.
                                                             (line   79)
* simplode <1>:                          Funções e Variáveis para seqüências de caracteres.
                                                             (line   80)
* simpmetderiv:                          Funções e Variáveis Definidas para itensor.
                                                             (line  782)
* simpmetderiv <1>:                      Funções e Variáveis Definidas para itensor.
                                                             (line  783)
* simpsum:                               Funções e Variáveis Definidas para Simplificação.
                                                             (line  419)
* simtran:                               Funções e Variáveis Definidas para Matrizes e Álgebra Linear.
                                                             (line  985)
* sin:                                   Funções e Variáveis Definidas para Trigonometria.
                                                             (line   90)
* sinh:                                  Funções e Variáveis Definidas para Trigonometria.
                                                             (line   93)
* sinnpiflag:                            Funções e Variáveis Definidas para Séries de Fourier.
                                                             (line   50)
* sinsert:                               Funções e Variáveis para seqüências de caracteres.
                                                             (line   93)
* sinvertcase:                           Funções e Variáveis para seqüências de caracteres.
                                                             (line  105)
* sinvertcase <1>:                       Funções e Variáveis para seqüências de caracteres.
                                                             (line  106)
* sinvertcase <2>:                       Funções e Variáveis para seqüências de caracteres.
                                                             (line  107)
* sixth:                                 Funções e Variáveis Definidas para Listas.
                                                             (line  269)
* skewness:                              Funções e Variáveis Definidas para estatística descritiva.
                                                             (line  420)
* skewness <1>:                          Funções e Variáveis Definidas para estatística descritiva.
                                                             (line  421)
* skewness_bernoulli:                    Funções e Variáveis Definidas para distribuições discretas.
                                                             (line  240)
* skewness_beta:                         Funções e Variáveis Definidas para distribuições contínuas.
                                                             (line  813)
* skewness_binomial:                     Funções e Variáveis Definidas para distribuições discretas.
                                                             (line   51)
* skewness_chi2:                         Funções e Variáveis Definidas para distribuições contínuas.
                                                             (line  284)
* skewness_continuous_uniform:           Funções e Variáveis Definidas para distribuições contínuas.
                                                             (line  888)
* skewness_discrete_uniform:             Funções e Variáveis Definidas para distribuições discretas.
                                                             (line  390)
* skewness_exp:                          Funções e Variáveis Definidas para distribuições contínuas.
                                                             (line  556)
* skewness_f:                            Funções e Variáveis Definidas para distribuições contínuas.
                                                             (line  401)
* skewness_gamma:                        Funções e Variáveis Definidas para distribuições contínuas.
                                                             (line  728)
* skewness_geometric:                    Funções e Variáveis Definidas para distribuições discretas.
                                                             (line  316)
* skewness_gumbel:                       Funções e Variáveis Definidas para distribuições contínuas.
                                                             (line 1340)
* skewness_hypergeometric:               Funções e Variáveis Definidas para distribuições discretas.
                                                             (line  451)
* skewness_laplace:                      Funções e Variáveis Definidas para distribuições contínuas.
                                                             (line 1262)
* skewness_logistic:                     Funções e Variáveis Definidas para distribuições contínuas.
                                                             (line  940)
* skewness_lognormal:                    Funções e Variáveis Definidas para distribuições contínuas.
                                                             (line  664)
* skewness_negative_binomial:            Funções e Variáveis Definidas para distribuições discretas.
                                                             (line  541)
* skewness_normal:                       Funções e Variáveis Definidas para distribuições contínuas.
                                                             (line   47)
* skewness_pareto:                       Funções e Variáveis Definidas para distribuições contínuas.
                                                             (line  989)
* skewness_poisson:                      Funções e Variáveis Definidas para distribuições discretas.
                                                             (line  131)
* skewness_rayleigh:                     Funções e Variáveis Definidas para distribuições contínuas.
                                                             (line 1175)
* skewness_student_t:                    Funções e Variáveis Definidas para distribuições contínuas.
                                                             (line  130)
* skewness_weibull:                      Funções e Variáveis Definidas para distribuições contínuas.
                                                             (line 1038)
* slength:                               Funções e Variáveis para seqüências de caracteres.
                                                             (line  116)
* smake:                                 Funções e Variáveis para seqüências de caracteres.
                                                             (line  119)
* smismatch:                             Funções e Variáveis para seqüências de caracteres.
                                                             (line  126)
* smismatch <1>:                         Funções e Variáveis para seqüências de caracteres.
                                                             (line  127)
* solve:                                 Funções e Variáveis Definidas para Equações.
                                                             (line  737)
* solve <1>:                             Funções e Variáveis Definidas para Equações.
                                                             (line  738)
* solve <2>:                             Funções e Variáveis Definidas para Equações.
                                                             (line  739)
* solvedecomposes:                       Funções e Variáveis Definidas para Equações.
                                                             (line  891)
* solveexplicit:                         Funções e Variáveis Definidas para Equações.
                                                             (line  897)
* solvefactors:                          Funções e Variáveis Definidas para Equações.
                                                             (line  904)
* solvenullwarn:                         Funções e Variáveis Definidas para Equações.
                                                             (line  911)
* solveradcan:                           Funções e Variáveis Definidas para Equações.
                                                             (line  919)
* solvetrigwarn:                         Funções e Variáveis Definidas para Equações.
                                                             (line  926)
* solve_inconsistent_error:              Funções e Variáveis Definidas para Equações.
                                                             (line  933)
* solve_rec:                             Funções e Variáveis Definidas para solve_rec.
                                                             (line   90)
* solve_rec_rat:                         Funções e Variáveis Definidas para solve_rec.
                                                             (line  154)
* some:                                  Funções e Variáveis Definidas para Conjuntos.
                                                             (line 1068)
* some <1>:                              Funções e Variáveis Definidas para Conjuntos.
                                                             (line 1069)
* somrac:                                Funções e Variáveis Definidas para Simetrias.
                                                             (line  547)
* sort:                                  Operadores Geral.   (line 1066)
* sort <1>:                              Operadores Geral.   (line 1067)
* space:                                 Funções e Variáveis para caracteres.
                                                             (line   80)
* sparse:                                Funções e Variáveis Definidas para Matrizes e Álgebra Linear.
                                                             (line 1009)
* specint:                               Funções e Variáveis Definidas para Funções Especiais.
                                                             (line  338)
* spherical_bessel_j:                    Funções e Variáveis Definidas para polinômios ortogonais.
                                                             (line  169)
* spherical_bessel_y:                    Funções e Variáveis Definidas para polinômios ortogonais.
                                                             (line  175)
* spherical_hankel1:                     Funções e Variáveis Definidas para polinômios ortogonais.
                                                             (line  181)
* spherical_hankel2:                     Funções e Variáveis Definidas para polinômios ortogonais.
                                                             (line  186)
* spherical_harmonic:                    Funções e Variáveis Definidas para polinômios ortogonais.
                                                             (line  191)
* splice:                                Macros.             (line  164)
* split:                                 Funções e Variáveis para seqüências de caracteres.
                                                             (line  137)
* split <1>:                             Funções e Variáveis para seqüências de caracteres.
                                                             (line  138)
* split <2>:                             Funções e Variáveis para seqüências de caracteres.
                                                             (line  139)
* sposition:                             Funções e Variáveis para seqüências de caracteres.
                                                             (line  154)
* sprint:                                Funções e Variáveis para entrada e saída.
                                                             (line  129)
* sqfr:                                  Funções e Variáveis Definidas para Polinômios.
                                                             (line 1128)
* sqrt:                                  Operadores Geral.   (line 1111)
* sqrtdenest:                            Funções e Variáveis Definidas para simplification.
                                                             (line  451)
* sqrtdispflag:                          Operadores Geral.   (line 1120)
* sremove:                               Funções e Variáveis para seqüências de caracteres.
                                                             (line  160)
* sremove <1>:                           Funções e Variáveis para seqüências de caracteres.
                                                             (line  161)
* sremove <2>:                           Funções e Variáveis para seqüências de caracteres.
                                                             (line  162)
* sremove <3>:                           Funções e Variáveis para seqüências de caracteres.
                                                             (line  163)
* sremovefirst:                          Funções e Variáveis para seqüências de caracteres.
                                                             (line  177)
* sremovefirst <1>:                      Funções e Variáveis para seqüências de caracteres.
                                                             (line  178)
* sremovefirst <2>:                      Funções e Variáveis para seqüências de caracteres.
                                                             (line  179)
* sremovefirst <3>:                      Funções e Variáveis para seqüências de caracteres.
                                                             (line  180)
* sreverse:                              Funções e Variáveis para seqüências de caracteres.
                                                             (line  184)
* ssearch:                               Funções e Variáveis para seqüências de caracteres.
                                                             (line  188)
* ssearch <1>:                           Funções e Variáveis para seqüências de caracteres.
                                                             (line  189)
* ssearch <2>:                           Funções e Variáveis para seqüências de caracteres.
                                                             (line  190)
* ssearch <3>:                           Funções e Variáveis para seqüências de caracteres.
                                                             (line  191)
* ssort:                                 Funções e Variáveis para seqüências de caracteres.
                                                             (line  202)
* ssort <1>:                             Funções e Variáveis para seqüências de caracteres.
                                                             (line  203)
* sstatus:                               Funções e Variáveis Definidas para Linha de Comando.
                                                             (line  572)
* ssubst:                                Funções e Variáveis para seqüências de caracteres.
                                                             (line  216)
* ssubst <1>:                            Funções e Variáveis para seqüências de caracteres.
                                                             (line  217)
* ssubst <2>:                            Funções e Variáveis para seqüências de caracteres.
                                                             (line  218)
* ssubst <3>:                            Funções e Variáveis para seqüências de caracteres.
                                                             (line  219)
* ssubstfirst:                           Funções e Variáveis para seqüências de caracteres.
                                                             (line  235)
* ssubstfirst <1>:                       Funções e Variáveis para seqüências de caracteres.
                                                             (line  236)
* ssubstfirst <2>:                       Funções e Variáveis para seqüências de caracteres.
                                                             (line  237)
* ssubstfirst <3>:                       Funções e Variáveis para seqüências de caracteres.
                                                             (line  239)
* staircase:                             Funções e Variáveis Definidas para dynamics.
                                                             (line  102)
* stardisp:                              Funções e Variáveis Definidas para Entrada e Saída.
                                                             (line 1171)
* stats_numer:                           Funções e Variáveis Definidas para stats.
                                                             (line    6)
* status:                                Funções e Variáveis Definidas para Ambiente em Tempo de Execução.
                                                             (line   71)
* status <1>:                            Funções e Variáveis Definidas para Ambiente em Tempo de Execução.
                                                             (line   72)
* status <2>:                            Funções e Variáveis Definidas para Ambiente em Tempo de Execução.
                                                             (line   73)
* std:                                   Funções e Variáveis Definidas para estatística descritiva.
                                                             (line   78)
* std <1>:                               Funções e Variáveis Definidas para estatística descritiva.
                                                             (line   79)
* std1:                                  Funções e Variáveis Definidas para estatística descritiva.
                                                             (line   96)
* std1 <1>:                              Funções e Variáveis Definidas para estatística descritiva.
                                                             (line   97)
* std_bernoulli:                         Funções e Variáveis Definidas para distribuições discretas.
                                                             (line  225)
* std_beta:                              Funções e Variáveis Definidas para distribuições contínuas.
                                                             (line  808)
* std_binomial:                          Funções e Variáveis Definidas para distribuições discretas.
                                                             (line   46)
* std_chi2:                              Funções e Variáveis Definidas para distribuições contínuas.
                                                             (line  267)
* std_continuous_uniform:                Funções e Variáveis Definidas para distribuições contínuas.
                                                             (line  883)
* std_discrete_uniform:                  Funções e Variáveis Definidas para distribuições discretas.
                                                             (line  385)
* std_exp:                               Funções e Variáveis Definidas para distribuições contínuas.
                                                             (line  537)
* std_f:                                 Funções e Variáveis Definidas para distribuições contínuas.
                                                             (line  396)
* std_gamma:                             Funções e Variáveis Definidas para distribuições contínuas.
                                                             (line  723)
* std_geometric:                         Funções e Variáveis Definidas para distribuições discretas.
                                                             (line  311)
* std_gumbel:                            Funções e Variáveis Definidas para distribuições contínuas.
                                                             (line 1335)
* std_hypergeometric:                    Funções e Variáveis Definidas para distribuições discretas.
                                                             (line  445)
* std_laplace:                           Funções e Variáveis Definidas para distribuições contínuas.
                                                             (line 1257)
* std_logistic:                          Funções e Variáveis Definidas para distribuições contínuas.
                                                             (line  935)
* std_lognormal:                         Funções e Variáveis Definidas para distribuições contínuas.
                                                             (line  659)
* std_negative_binomial:                 Funções e Variáveis Definidas para distribuições discretas.
                                                             (line  536)
* std_normal:                            Funções e Variáveis Definidas para distribuições contínuas.
                                                             (line   42)
* std_pareto:                            Funções e Variáveis Definidas para distribuições contínuas.
                                                             (line  984)
* std_poisson:                           Funções e Variáveis Definidas para distribuições discretas.
                                                             (line  126)
* std_rayleigh:                          Funções e Variáveis Definidas para distribuições contínuas.
                                                             (line 1154)
* std_student_t:                         Funções e Variáveis Definidas para distribuições contínuas.
                                                             (line  125)
* std_weibull:                           Funções e Variáveis Definidas para distribuições contínuas.
                                                             (line 1033)
* stirling:                              Funções e Variáveis Definidas para stirling.
                                                             (line    6)
* stirling1:                             Funções e Variáveis Definidas para Conjuntos.
                                                             (line 1139)
* stirling2:                             Funções e Variáveis Definidas para Conjuntos.
                                                             (line 1194)
* strim:                                 Funções e Variáveis para seqüências de caracteres.
                                                             (line  244)
* striml:                                Funções e Variáveis para seqüências de caracteres.
                                                             (line  255)
* strimr:                                Funções e Variáveis para seqüências de caracteres.
                                                             (line  259)
* string:                                Funções e Variáveis Definidas para Entrada e Saída.
                                                             (line 1177)
* stringdisp:                            Funções e Variáveis Definidas para Entrada e Saída.
                                                             (line 1184)
* stringout:                             Funções e Variáveis Definidas para Entrada e Saída.
                                                             (line 1206)
* stringout <1>:                         Funções e Variáveis Definidas para Entrada e Saída.
                                                             (line 1207)
* stringout <2>:                         Funções e Variáveis Definidas para Entrada e Saída.
                                                             (line 1208)
* stringout <3>:                         Funções e Variáveis Definidas para Entrada e Saída.
                                                             (line 1209)
* stringout <4>:                         Funções e Variáveis Definidas para Entrada e Saída.
                                                             (line 1210)
* stringp:                               Funções e Variáveis para seqüências de caracteres.
                                                             (line   15)
* sublis:                                Operadores Geral.   (line 1126)
* sublist:                               Operadores Geral.   (line 1135)
* sublist_indices:                       Funções e Variáveis Definidas para Listas.
                                                             (line  273)
* sublis_apply_lambda:                   Operadores Geral.   (line 1146)
* submatrix:                             Funções e Variáveis Definidas para Matrizes e Álgebra Linear.
                                                             (line 1016)
* submatrix <1>:                         Funções e Variáveis Definidas para Matrizes e Álgebra Linear.
                                                             (line 1017)
* submatrix <2>:                         Funções e Variáveis Definidas para Matrizes e Álgebra Linear.
                                                             (line 1018)
* subsample:                             Funções e Variáveis Definidas para manipulação da dados.
                                                             (line   46)
* subsample <1>:                         Funções e Variáveis Definidas para manipulação da dados.
                                                             (line   47)
* subset:                                Funções e Variáveis Definidas para Conjuntos.
                                                             (line 1257)
* subsetp:                               Funções e Variáveis Definidas para Conjuntos.
                                                             (line 1277)
* subst:                                 Operadores Geral.   (line 1152)
* substinpart:                           Operadores Geral.   (line 1191)
* substpart:                             Operadores Geral.   (line 1247)
* substring:                             Funções e Variáveis para seqüências de caracteres.
                                                             (line  263)
* substring <1>:                         Funções e Variáveis para seqüências de caracteres.
                                                             (line  264)
* Subtração:                             Operadores Aritméticos.
                                                             (line    8)
* subvar:                                Funções e Variáveis Definidas para Arrays.
                                                             (line  431)
* subvarp:                               Operadores Geral.   (line 1272)
* sum:                                   Funções e Variáveis Definidas para Expressões.
                                                             (line 1360)
* sumcontract:                           Funções e Variáveis Definidas para Simplificação.
                                                             (line  429)
* sumexpand:                             Funções e Variáveis Definidas para Simplificação.
                                                             (line  442)
* summand_to_rec:                        Funções e Variáveis Definidas para solve_rec.
                                                             (line  185)
* summand_to_rec <1>:                    Funções e Variáveis Definidas para solve_rec.
                                                             (line  186)
* sumsplitfact:                          Funções e Variáveis Definidas para Simplificação.
                                                             (line  470)
* sunlisp:                               Funções e Variáveis para seqüências de caracteres.
                                                             (line    6)
* supcase:                               Funções e Variáveis para seqüências de caracteres.
                                                             (line  277)
* supcase <1>:                           Funções e Variáveis para seqüências de caracteres.
                                                             (line  278)
* supcase <2>:                           Funções e Variáveis para seqüências de caracteres.
                                                             (line  279)
* supcontext:                            Funções e Variáveis Definidas para Contextos.
                                                             (line  311)
* supcontext <1>:                        Funções e Variáveis Definidas para Contextos.
                                                             (line  312)
* surface_hide:                          Funções e Variáveis Definidas para draw.
                                                             (line 1118)
* symbolp:                               Operadores Geral.   (line 1276)
* symmdifference:                        Funções e Variáveis Definidas para Conjuntos.
                                                             (line 1291)
* symmetric:                             Funções e Variáveis Definidas para Simplificação.
                                                             (line  476)
* symmetricp:                            Funções e Variáveis Definidas para ctensor.
                                                             (line  826)
* system:                                Funções e Variáveis Definidas para Entrada e Saída.
                                                             (line 1417)
* tab:                                   Funções e Variáveis para caracteres.
                                                             (line   83)
* take_inference:                        Funções e Variáveis Definidas para inference_result.
                                                             (line   75)
* take_inference <1>:                    Funções e Variáveis Definidas para inference_result.
                                                             (line   76)
* take_inference <2>:                    Funções e Variáveis Definidas para inference_result.
                                                             (line   77)
* tan:                                   Funções e Variáveis Definidas para Trigonometria.
                                                             (line   96)
* tanh:                                  Funções e Variáveis Definidas para Trigonometria.
                                                             (line   99)
* taylor:                                Funções e Variáveis Definidas para Séries.
                                                             (line  354)
* taylor <1>:                            Funções e Variáveis Definidas para Séries.
                                                             (line  355)
* taylor <2>:                            Funções e Variáveis Definidas para Séries.
                                                             (line  356)
* taylor <3>:                            Funções e Variáveis Definidas para Séries.
                                                             (line  357)
* taylor <4>:                            Funções e Variáveis Definidas para Séries.
                                                             (line  359)
* taylordepth:                           Funções e Variáveis Definidas para Séries.
                                                             (line  512)
* taylorinfo:                            Funções e Variáveis Definidas para Séries.
                                                             (line  519)
* taylorp:                               Funções e Variáveis Definidas para Séries.
                                                             (line  544)
* taylor_logexpand:                      Funções e Variáveis Definidas para Séries.
                                                             (line  548)
* taylor_order_coefficients:             Funções e Variáveis Definidas para Séries.
                                                             (line  564)
* taylor_simplifier:                     Funções e Variáveis Definidas para Séries.
                                                             (line  573)
* taylor_truncate_polynomials:           Funções e Variáveis Definidas para Séries.
                                                             (line  577)
* taytorat:                              Funções e Variáveis Definidas para Séries.
                                                             (line  586)
* tcl_output:                            Funções e Variáveis Definidas para Entrada e Saída.
                                                             (line  952)
* tcl_output <1>:                        Funções e Variáveis Definidas para Entrada e Saída.
                                                             (line  953)
* tcl_output <2>:                        Funções e Variáveis Definidas para Entrada e Saída.
                                                             (line  954)
* tcontract:                             Funções e Variáveis Definidas para Simetrias.
                                                             (line  258)
* tellrat:                               Funções e Variáveis Definidas para Polinômios.
                                                             (line 1144)
* tellrat <1>:                           Funções e Variáveis Definidas para Polinômios.
                                                             (line 1145)
* tellsimp:                              Funções e Variáveis Definidas para Regras e Modelos.
                                                             (line  698)
* tellsimpafter:                         Funções e Variáveis Definidas para Regras e Modelos.
                                                             (line  758)
* tensorkill:                            Funções e Variáveis Definidas para ctensor.
                                                             (line 1259)
* tentex:                                Funções e Variáveis Definidas para itensor.
                                                             (line 1527)
* tenth:                                 Funções e Variáveis Definidas para Listas.
                                                             (line  295)
* terminal:                              Funções e Variáveis Definidas para draw.
                                                             (line  123)
* testsuite_files:                       Definições para Detecção e Relato de Erros.
                                                             (line   34)
* test_mean:                             Funções e Variáveis Definidas para stats.
                                                             (line   14)
* test_mean <1>:                         Funções e Variáveis Definidas para stats.
                                                             (line   15)
* test_means_difference:                 Funções e Variáveis Definidas para stats.
                                                             (line  127)
* test_means_difference <1>:             Funções e Variáveis Definidas para stats.
                                                             (line  128)
* test_normality:                        Funções e Variáveis Definidas para stats.
                                                             (line  604)
* test_rank_sum:                         Funções e Variáveis Definidas para stats.
                                                             (line  531)
* test_rank_sum <1>:                     Funções e Variáveis Definidas para stats.
                                                             (line  532)
* test_sign:                             Funções e Variáveis Definidas para stats.
                                                             (line  392)
* test_sign <1>:                         Funções e Variáveis Definidas para stats.
                                                             (line  393)
* test_signed_rank:                      Funções e Variáveis Definidas para stats.
                                                             (line  448)
* test_signed_rank <1>:                  Funções e Variáveis Definidas para stats.
                                                             (line  449)
* test_variance:                         Funções e Variáveis Definidas para stats.
                                                             (line  247)
* test_variance <1>:                     Funções e Variáveis Definidas para stats.
                                                             (line  248)
* test_variance_ratio:                   Funções e Variáveis Definidas para stats.
                                                             (line  319)
* test_variance_ratio <1>:               Funções e Variáveis Definidas para stats.
                                                             (line  320)
* tex:                                   Funções e Variáveis Definidas para Entrada e Saída.
                                                             (line 1253)
* tex <1>:                               Funções e Variáveis Definidas para Entrada e Saída.
                                                             (line 1254)
* tex <2>:                               Funções e Variáveis Definidas para Entrada e Saída.
                                                             (line 1255)
* tex <3>:                               Funções e Variáveis Definidas para Entrada e Saída.
                                                             (line 1256)
* texput:                                Funções e Variáveis Definidas para Entrada e Saída.
                                                             (line 1302)
* texput <1>:                            Funções e Variáveis Definidas para Entrada e Saída.
                                                             (line 1303)
* texput <2>:                            Funções e Variáveis Definidas para Entrada e Saída.
                                                             (line 1304)
* texput <3>:                            Funções e Variáveis Definidas para Entrada e Saída.
                                                             (line 1305)
* third:                                 Funções e Variáveis Definidas para Listas.
                                                             (line  299)
* throw:                                 Funções e Variáveis Definidas para Fluxo de Programa.
                                                             (line  466)
* time:                                  Funções e Variáveis Definidas para Ambiente em Tempo de Execução.
                                                             (line   97)
* timedate:                              Funções e Variáveis Definidas para Ambiente em Tempo de Execução.
                                                             (line  108)
* timer:                                 Funções e Variáveis Definidas para Depuração.
                                                             (line   63)
* timer <1>:                             Funções e Variáveis Definidas para Depuração.
                                                             (line   64)
* timer <2>:                             Funções e Variáveis Definidas para Depuração.
                                                             (line   65)
* timer_devalue:                         Funções e Variáveis Definidas para Depuração.
                                                             (line  109)
* timer_info:                            Funções e Variáveis Definidas para Depuração.
                                                             (line  121)
* timer_info <1>:                        Funções e Variáveis Definidas para Depuração.
                                                             (line  122)
* title:                                 Funções e Variáveis Definidas para draw.
                                                             (line  168)
* tldefint:                              Funções e Variáveis Definidas para Integração.
                                                             (line  467)
* tlimit:                                Funções e Variáveis Definidas para Limites.
                                                             (line   54)
* tlimit <1>:                            Funções e Variáveis Definidas para Limites.
                                                             (line   55)
* tlimit <2>:                            Funções e Variáveis Definidas para Limites.
                                                             (line   56)
* tlimswitch:                            Funções e Variáveis Definidas para Limites.
                                                             (line   59)
* todd_coxeter:                          Funções e Variáveis Definidas para Grupos.
                                                             (line    6)
* todd_coxeter <1>:                      Funções e Variáveis Definidas para Grupos.
                                                             (line    7)
* toeplitz:                              Funções e Variáveis Definidas para linearalgebra.
                                                             (line  561)
* toeplitz <1>:                          Funções e Variáveis Definidas para linearalgebra.
                                                             (line  562)
* tokens:                                Funções e Variáveis para seqüências de caracteres.
                                                             (line  290)
* tokens <1>:                            Funções e Variáveis para seqüências de caracteres.
                                                             (line  291)
* totaldisrep:                           Funções e Variáveis Definidas para Polinômios.
                                                             (line 1196)
* totalfourier:                          Funções e Variáveis Definidas para Séries de Fourier.
                                                             (line   74)
* totient:                               Funções e Variáveis Definidas para Teoria dos Números.
                                                             (line  406)
* to_lisp:                               Funções e Variáveis Definidas para Linha de Comando.
                                                             (line  578)
* tpartpol:                              Funções e Variáveis Definidas para Simetrias.
                                                             (line  263)
* tr:                                    Funções e Variáveis Definidas para ctensor.
                                                             (line 1239)
* trace:                                 Funções e Variáveis Definidas para Depuração.
                                                             (line  141)
* trace <1>:                             Funções e Variáveis Definidas para Depuração.
                                                             (line  142)
* trace <2>:                             Funções e Variáveis Definidas para Depuração.
                                                             (line  143)
* tracematrix:                           Funções e Variáveis Definidas para simplification.
                                                             (line  176)
* trace_options:                         Funções e Variáveis Definidas para Depuração.
                                                             (line  172)
* trace_options <1>:                     Funções e Variáveis Definidas para Depuração.
                                                             (line  173)
* transcompile:                          Funções e Variáveis para Definição de Função.
                                                             (line  946)
* translate:                             Funções e Variáveis para Definição de Função.
                                                             (line  955)
* translate <1>:                         Funções e Variáveis para Definição de Função.
                                                             (line  956)
* translate <2>:                         Funções e Variáveis para Definição de Função.
                                                             (line  957)
* translate_file:                        Funções e Variáveis para Definição de Função.
                                                             (line 1012)
* translate_file <1>:                    Funções e Variáveis para Definição de Função.
                                                             (line 1013)
* transparent:                           Funções e Variáveis Definidas para draw.
                                                             (line  738)
* transpose:                             Funções e Variáveis Definidas para Matrizes e Álgebra Linear.
                                                             (line 1022)
* transrun:                              Funções e Variáveis para Definição de Função.
                                                             (line 1058)
* tree_reduce:                           Funções e Variáveis Definidas para Conjuntos.
                                                             (line 1321)
* tree_reduce <1>:                       Funções e Variáveis Definidas para Conjuntos.
                                                             (line 1322)
* treillis:                              Funções e Variáveis Definidas para Simetrias.
                                                             (line  467)
* treinat:                               Funções e Variáveis Definidas para Simetrias.
                                                             (line  475)
* triangularize:                         Funções e Variáveis Definidas para Matrizes e Álgebra Linear.
                                                             (line 1034)
* trigexpand:                            Funções e Variáveis Definidas para Trigonometria.
                                                             (line  102)
* trigexpandplus:                        Funções e Variáveis Definidas para Trigonometria.
                                                             (line  137)
* trigexpandtimes:                       Funções e Variáveis Definidas para Trigonometria.
                                                             (line  145)
* triginverses:                          Funções e Variáveis Definidas para Trigonometria.
                                                             (line  153)
* trigrat:                               Funções e Variáveis Definidas para Trigonometria.
                                                             (line  212)
* trigreduce:                            Funções e Variáveis Definidas para Trigonometria.
                                                             (line  168)
* trigreduce <1>:                        Funções e Variáveis Definidas para Trigonometria.
                                                             (line  169)
* trigsign:                              Funções e Variáveis Definidas para Trigonometria.
                                                             (line  195)
* trigsimp:                              Funções e Variáveis Definidas para Trigonometria.
                                                             (line  202)
* trivial_solutions:                     Funções e Variáveis Definidas para zeilberger.
                                                             (line  131)
* true:                                  Funções e Variáveis Definidas para Constantes.
                                                             (line   86)
* trunc:                                 Funções e Variáveis Definidas para Séries.
                                                             (line  591)
* tr_array_as_ref:                       Funções e Variáveis para Definição de Função.
                                                             (line 1065)
* tr_bound_function_applyp:              Funções e Variáveis para Definição de Função.
                                                             (line 1077)
* tr_file_tty_messagesp:                 Funções e Variáveis para Definição de Função.
                                                             (line 1089)
* tr_float_can_branch_complex:           Funções e Variáveis para Definição de Função.
                                                             (line 1098)
* tr_function_call_default:              Funções e Variáveis para Definição de Função.
                                                             (line 1113)
* tr_numer:                              Funções e Variáveis para Definição de Função.
                                                             (line 1127)
* tr_optimize_max_loop:                  Funções e Variáveis para Definição de Função.
                                                             (line 1133)
* tr_semicompile:                        Funções e Variáveis para Definição de Função.
                                                             (line 1141)
* tr_state_vars:                         Funções e Variáveis para Definição de Função.
                                                             (line 1148)
* tr_warnings_get:                       Funções e Variáveis para Definição de Função.
                                                             (line 1160)
* tr_warn_bad_function_calls:            Funções e Variáveis para Definição de Função.
                                                             (line 1164)
* tr_warn_fexpr:                         Funções e Variáveis para Definição de Função.
                                                             (line 1171)
* tr_warn_meval:                         Funções e Variáveis para Definição de Função.
                                                             (line 1178)
* tr_warn_mode:                          Funções e Variáveis para Definição de Função.
                                                             (line 1184)
* tr_warn_undeclared:                    Funções e Variáveis para Definição de Função.
                                                             (line 1190)
* tr_warn_undefined_variable:            Funções e Variáveis para Definição de Função.
                                                             (line 1196)
* ttyoff:                                Funções e Variáveis Definidas para Entrada e Saída.
                                                             (line 1437)
* ueivects:                              Funções e Variáveis Definidas para Matrizes e Álgebra Linear.
                                                             (line 1057)
* ufg:                                   Funções e Variáveis Definidas para ctensor.
                                                             (line 1168)
* uforget:                               Funções e Variáveis Definidas para Units.
                                                             (line  114)
* ug:                                    Funções e Variáveis Definidas para ctensor.
                                                             (line 1203)
* ultraspherical:                        Funções e Variáveis Definidas para polinômios ortogonais.
                                                             (line  204)
* undiff:                                Funções e Variáveis Definidas para itensor.
                                                             (line  651)
* Unidade imaginária:                    Funções e Variáveis Definidas para Constantes.
                                                             (line   12)
* union:                                 Funções e Variáveis Definidas para Conjuntos.
                                                             (line 1358)
* uniteigenvectors:                      Funções e Variáveis Definidas para Matrizes e Álgebra Linear.
                                                             (line 1056)
* unitvector:                            Funções e Variáveis Definidas para Matrizes e Álgebra Linear.
                                                             (line 1082)
* unit_step:                             Funções e Variáveis Definidas para polinômios ortogonais.
                                                             (line  196)
* unknown:                               Funções e Variáveis Definidas para Simplificação.
                                                             (line  483)
* unorder:                               Operadores Geral.   (line 1283)
* unsum:                                 Funções e Variáveis Definidas para Séries.
                                                             (line  607)
* untellrat:                             Funções e Variáveis Definidas para Polinômios.
                                                             (line 1206)
* untimer:                               Funções e Variáveis Definidas para Depuração.
                                                             (line   93)
* untimer <1>:                           Funções e Variáveis Definidas para Depuração.
                                                             (line   94)
* untrace:                               Funções e Variáveis Definidas para Depuração.
                                                             (line  228)
* untrace <1>:                           Funções e Variáveis Definidas para Depuração.
                                                             (line  229)
* uppercasep:                            Funções e Variáveis para caracteres.
                                                             (line   86)
* uric:                                  Funções e Variáveis Definidas para ctensor.
                                                             (line 1193)
* uricci:                                Funções e Variáveis Definidas para ctensor.
                                                             (line  208)
* uriem:                                 Funções e Variáveis Definidas para ctensor.
                                                             (line 1184)
* uriemann:                              Funções e Variáveis Definidas para ctensor.
                                                             (line  278)
* usersetunits:                          Funções e Variáveis Definidas para Units.
                                                             (line  215)
* user_preamble:                         Funções e Variáveis Definidas para draw.
                                                             (line  344)
* use_fast_arrays:                       Funções e Variáveis Definidas para Arrays.
                                                             (line  455)
* uvect:                                 Funções e Variáveis Definidas para Matrizes e Álgebra Linear.
                                                             (line 1083)
* values:                                Funções e Variáveis Definidas para Linha de Comando.
                                                             (line  582)
* vandermonde_matrix:                    Funções e Variáveis Definidas para linearalgebra.
                                                             (line  581)
* var:                                   Funções e Variáveis Definidas para estatística descritiva.
                                                             (line   32)
* var <1>:                               Funções e Variáveis Definidas para estatística descritiva.
                                                             (line   33)
* var1:                                  Funções e Variáveis Definidas para estatística descritiva.
                                                             (line   53)
* var1 <1>:                              Funções e Variáveis Definidas para estatística descritiva.
                                                             (line   54)
* var_bernoulli:                         Funções e Variáveis Definidas para distribuições discretas.
                                                             (line  210)
* var_beta:                              Funções e Variáveis Definidas para distribuições contínuas.
                                                             (line  804)
* var_binomial:                          Funções e Variáveis Definidas para distribuições discretas.
                                                             (line   41)
* var_chi2:                              Funções e Variáveis Definidas para distribuições contínuas.
                                                             (line  250)
* var_continuous_uniform:                Funções e Variáveis Definidas para distribuições contínuas.
                                                             (line  878)
* var_discrete_uniform:                  Funções e Variáveis Definidas para distribuições discretas.
                                                             (line  380)
* var_exp:                               Funções e Variáveis Definidas para distribuições contínuas.
                                                             (line  517)
* var_f:                                 Funções e Variáveis Definidas para distribuições contínuas.
                                                             (line  391)
* var_gamma:                             Funções e Variáveis Definidas para distribuições contínuas.
                                                             (line  718)
* var_geometric:                         Funções e Variáveis Definidas para distribuições discretas.
                                                             (line  306)
* var_gumbel:                            Funções e Variáveis Definidas para distribuições contínuas.
                                                             (line 1331)
* var_hypergeometric:                    Funções e Variáveis Definidas para distribuições discretas.
                                                             (line  439)
* var_laplace:                           Funções e Variáveis Definidas para distribuições contínuas.
                                                             (line 1252)
* var_logistic:                          Funções e Variáveis Definidas para distribuições contínuas.
                                                             (line  930)
* var_lognormal:                         Funções e Variáveis Definidas para distribuições contínuas.
                                                             (line  654)
* var_negative_binomial:                 Funções e Variáveis Definidas para distribuições discretas.
                                                             (line  531)
* var_normal:                            Funções e Variáveis Definidas para distribuições contínuas.
                                                             (line   37)
* var_pareto:                            Funções e Variáveis Definidas para distribuições contínuas.
                                                             (line  979)
* var_poisson:                           Funções e Variáveis Definidas para distribuições discretas.
                                                             (line  122)
* var_rayleigh:                          Funções e Variáveis Definidas para distribuições contínuas.
                                                             (line 1133)
* var_student_t:                         Funções e Variáveis Definidas para distribuições contínuas.
                                                             (line  115)
* var_weibull:                           Funções e Variáveis Definidas para distribuições contínuas.
                                                             (line 1028)
* vectorpotential:                       Operadores Geral.   (line 1306)
* vectorsimp:                            Funções e Variáveis Definidas para Matrizes e Álgebra Linear.
                                                             (line 1091)
* vect_cross:                            Funções e Variáveis Definidas para Matrizes e Álgebra Linear.
                                                             (line 1123)
* verbify:                               Funções e Variáveis Definidas para Expressões.
                                                             (line 1494)
* verbose:                               Funções e Variáveis Definidas para Séries.
                                                             (line  637)
* vers:                                  Funções e Variáveis Definidas para simplification.
                                                             (line  259)
* warnings:                              Funções e Variáveis Definidas para zeilberger.
                                                             (line  118)
* weyl:                                  Funções e Variáveis Definidas para ctensor.
                                                             (line 1207)
* weyl <1>:                              Funções e Variáveis Definidas para ctensor.
                                                             (line  292)
* while:                                 Funções e Variáveis Definidas para Fluxo de Programa.
                                                             (line  471)
* with_stdout:                           Funções e Variáveis Definidas para Entrada e Saída.
                                                             (line 1447)
* writefile:                             Funções e Variáveis Definidas para Entrada e Saída.
                                                             (line 1475)
* write_data:                            Funções e Variáveis Definidas para numericalio.
                                                             (line   63)
* write_data <1>:                        Funções e Variáveis Definidas para numericalio.
                                                             (line   64)
* wronskian:                             Funções e Variáveis Definidas para simplification.
                                                             (line  163)
* xlabel:                                Funções e Variáveis Definidas para draw.
                                                             (line  184)
* xrange:                                Funções e Variáveis Definidas para draw.
                                                             (line    6)
* xreduce:                               Funções e Variáveis Definidas para Conjuntos.
                                                             (line 1384)
* xreduce <1>:                           Funções e Variáveis Definidas para Conjuntos.
                                                             (line 1385)
* xthru:                                 Operadores Geral.   (line 1312)
* xtics:                                 Funções e Variáveis Definidas para draw.
                                                             (line  239)
* xu_grid:                               Funções e Variáveis Definidas para draw.
                                                             (line 1078)
* xy_file:                               Funções e Variáveis Definidas para draw.
                                                             (line  334)
* ylabel:                                Funções e Variáveis Definidas para draw.
                                                             (line  202)
* yrange:                                Funções e Variáveis Definidas para draw.
                                                             (line   27)
* ytics:                                 Funções e Variáveis Definidas para draw.
                                                             (line  257)
* yv_grid:                               Funções e Variáveis Definidas para draw.
                                                             (line 1098)
* Zeilberger:                            Funções e Variáveis Definidas para zeilberger.
                                                             (line   79)
* zerobern:                              Funções e Variáveis Definidas para Teoria dos Números.
                                                             (line  410)
* zeroequiv:                             Operadores Geral.   (line 1338)
* zerofor:                               Funções e Variáveis Definidas para linearalgebra.
                                                             (line  586)
* zerofor <1>:                           Funções e Variáveis Definidas para linearalgebra.
                                                             (line  587)
* zeromatrix:                            Funções e Variáveis Definidas para Matrizes e Álgebra Linear.
                                                             (line 1130)
* zeromatrixp:                           Funções e Variáveis Definidas para linearalgebra.
                                                             (line  601)
* zeta:                                  Funções e Variáveis Definidas para Teoria dos Números.
                                                             (line  416)
* zeta%pi:                               Funções e Variáveis Definidas para Teoria dos Números.
                                                             (line  430)
* zlabel:                                Funções e Variáveis Definidas para draw.
                                                             (line  220)
* zrange:                                Funções e Variáveis Definidas para draw.
                                                             (line   49)
* ztics:                                 Funções e Variáveis Definidas para draw.
                                                             (line  275)



Tag Table:
Node: Top266
Node: Introdução ao Maxima14385
Node: Detecção e Relato de Erros21868
Node: Definições para Detecção e Relato de Erros22093
Node: Ajuda24788
Node: Lisp e Maxima25016
Node: Descartando28992
Node: Documentação29794
Node: Funções e Variáveis Definidas para Ajuda30859
Node: Linha de Comando38101
Node: Introdução a Linha de Comando38329
Node: Funções e Variáveis Definidas para Linha de Comando47663
Node: Operadores74602
Node: N-Argumentos74895
Node: Operador não fixado75501
Node: Operador Pósfixado76091
Node: Operador Préfixado76608
Node: Operadores Aritméticos77025
Node: Operadores Relacionais85472
Node: Operadores Geral85719
Node: Expressões142501
Node: Introdução a Expressões142824
Node: Complexo144497
Node: Substantivos e Verbos145167
Node: Identificadores147759
Node: Seqüências de caracteres150109
Node: Desigualdade153041
Node: Sintaxe153325
Node: Funções e Variáveis Definidas para Expressões157692
Node: Simplificação219815
Node: Funções e Variáveis Definidas para Simplificação220009
Node: Montando Gráficos240802
Node: Funções e Variáveis Definidas para Montagem de Gráficos241016
Node: Entrada e Saída269607
Node: Comentários269843
Node: Arquivos271238
Node: Funções e Variáveis Definidas para Entrada e Saída271771
Node: Ponto Flutuante334108
Node: Funções e Variáveis Definidas para ponto Flutuante334309
Node: Contextos338890
Node: Funções e Variáveis Definidas para Contextos339068
Node: Polinômios352114
Node: Introdução a Polinômios352318
Node: Funções e Variáveis Definidas para Polinômios355532
Node: Constantes408485
Node: Funções e Variáveis Definidas para Constantes408662
Node: Logarítmos412286
Node: Funções e Variáveis Definidas para Logarítmos412466
Node: Trigonometria420956
Node: Introdução ao Pacote Trigonométrico421192
Node: Funções e Variáveis Definidas para Trigonometria422221
Node: Funções Especiais431498
Node: Introdução a Funções Especiais431748
Node: Funções e Variáveis Definidas para Funções Especiais433401
Node: Funções Elípticas447672
Node: Introdução a Funções Elípticas e Integrais447987
Node: Funções e Variáveis Definidas para Funções Elípticas451787
Node: Funções e Variáveis Definidas para Integrais Elípticas454306
Ref: elliptic_f454582
Ref: elliptic_e454798
Ref: elliptic_eu455029
Ref: elliptic_kc455622
Ref: elliptic_ec455911
Node: Limites456196
Node: Funções e Variáveis Definidas para Limites456371
Node: Diferenciação458994
Node: Funções e Variáveis Definidas para Diferenciação459236
Node: Integração483668
Node: Introdução a Integração483948
Node: Funções e Variáveis Definidas para Integração484943
Node: Introdução a QUADPACK507623
Ref: Introdução a QUADPACK-Footnote-1511265
Ref: Introdução a QUADPACK-Footnote-2511331
Ref: Introdução a QUADPACK-Footnote-3511397
Ref: Introdução a QUADPACK-Footnote-4511440
Ref: Introdução a QUADPACK-Footnote-5511502
Ref: Introdução a QUADPACK-Footnote-6511539
Ref: Introdução a QUADPACK-Footnote-7511578
Node: Funções e Variáveis Definidas para QUADPACK511761
Node: Equações530051
Node: Funções e Variáveis Definidas para Equações530231
Node: Equações Diferenciais570677
Node: Introdução a Equações Diferenciais570971
Node: Funções e Variáveis Definidas para Equações Diferenciais571633
Node: Numérico579976
Node: Introdução a Numérico580258
Node: Pacotes de Fourier580423
Node: Funções e Variáveis Definidas para Numérico581094
Node: Funções e Variáveis Definidas para Séries de Fourier595405
Node: Arrays598632
Node: Funções e Variáveis Definidas para Arrays598806
Node: Matrizes e Álgebra Linear619511
Node: Introdução a Matrizes e Álgebra Linear619839
Node: Ponto620172
Node: Vetores621558
Node: auto622558
Node: Funções e Variáveis Definidas para Matrizes e Álgebra Linear623314
Node: Funções Afins672411
Node: Funções e Variáveis Definidas para Funções Afins672612
Node: itensor678340
Node: Introdução a itensor678530
Node: Funções e Variáveis Definidas para itensor690808
Node: ctensor761581
Node: Introdução a ctensor761772
Node: Funções e Variáveis Definidas para ctensor766329
Node: Pacote atensor827115
Node: Introdução ao Pacote atensor827336
Node: Funções e Variáveis Definidas para o Pacote atensor831422
Node: Séries837041
Node: Introdução a Séries837238
Node: Funções e Variáveis Definidas para Séries837794
Node: Teoria dos Números866020
Node: Funções e Variáveis Definidas para Teoria dos Números866224
Node: Simetrias884098
Node: Funções e Variáveis Definidas para Simetrias884275
Node: Grupos920405
Node: Funções e Variáveis Definidas para Grupos920584
Node: Ambiente em Tempo de Execução922534
Node: Introdução a Ambiente em Tempo de Execução922852
Node: Interrupções924063
Node: Funções e Variáveis Definidas para Ambiente em Tempo de Execução925339
Node: Opções Diversas932269
Node: Introdução a Opções Diversas932542
Node: Compartilhado932945
Node: Funções e Variáveis Definidas para Opções Diversas933743
Node: Regras e Modelos948551
Node: Introdução a Regras e Modelos948787
Node: Funções e Variáveis Definidas para Regras e Modelos949894
Node: Listas995740
Node: Introdução a Listas995930
Node: Funções e Variáveis Definidas para Listas996840
Node: Conjuntos1009167
Node: Introdução a Conjuntos1009372
Node: Funções e Variáveis Definidas para Conjuntos1019897
Ref: adjoin1020119
Ref: belln1020606
Ref: cardinality1021593
Ref: cartesian_product1022137
Ref: disjoin1022874
Ref: disjointp1023573
Ref: divisors1023969
Ref: elementp1025584
Ref: emptyp1025981
Ref: equiv_classes1026301
Ref: every1027567
Ref: extremal_subset1030478
Ref: flatten1031192
Ref: full_listify1033823
Ref: fullsetify1034402
Ref: identity1035082
Ref: integer_partitions1035368
Ref: intersect1037321
Ref: intersection1037426
Ref: listify1042803
Ref: lreduce1043257
Ref: makeset1044683
Ref: moebius1046326
Ref: multinomial_coeff1047557
Ref: num_distinct_partitions1048837
Ref: num_partitions1049697
Ref: partition_set1050628
Ref: permutations1051385
Ref: powerset1052006
Ref: rreduce1053987
Ref: setdifference1055532
Ref: setequalp1056405
Ref: setify1057037
Ref: setp1057622
Ref: set_partitions1058225
Ref: some1059990
Ref: stirling11063024
Ref: stirling21065054
Ref: subset1067444
Ref: subsetp1068067
Ref: symmdifference1068477
Ref: tree_reduce1069565
Ref: union1070973
Ref: xreduce1071955
Node: Definição de Função1073706
Node: Introdução a Definição de Função1073974
Node: Função1074182
Node: Macros1079309
Node: Funções e Variáveis para Definição de Função1088030
Node: Fluxo de Programa1142968
Node: Introdução a Fluxo de Programa1143216
Node: Funções e Variáveis Definidas para Fluxo de Programa1143558
Node: Depurando1171528
Node: Depurando o Código Fonte1171774
Node: Comandos Palavra Chave1175858
Node: Funções e Variáveis Definidas para Depuração1178466
Node: augmented_lagrangian1188439
Node: Funções e Variáveis Definidas para augmented_lagrangian1188649
Node: bode1191147
Node: Funções e Variáveis Definidas para bode1191311
Node: contrib_ode1194628
Node: Introdução a contrib_ode1194964
Node: Funções e Variáveis Definidas para contrib_ode1200542
Node: Possibilidades de melhorias em contrib_ode1205420
Node: Casos de teste para contrib_ode1206775
Node: Referências bibliográficas para contrib_ode1207635
Node: descriptive1209209
Node: Introdução ao pacote descriptive1209648
Node: Funções e Variáveis Definidas para manipulação da dados1215283
Node: Funções e Variáveis Definidas para estatística descritiva1224069
Node: Funções e Variáveis Definidas específicas para estatística descritiva de várias variáveis1242130
Node: Funções e Variáveis Definidas para gráficos estatísticos1252554
Node: diag1264688
Node: Funções e Variáveis Definidas para diag1264839
Node: distrib1281802
Node: Introdução a distrib1282059
Node: Funções e Variáveis Definidas para distribuições contínuas1290123
Node: Funções e Variáveis Definidas para distribuições discretas1348128
Node: draw1373335
Node: Introdução a draw1373505
Node: Funções e Variáveis Definidas para draw1373994
Node: dynamics1433588
Node: Introdução a dynamics1433778
Node: Funções e Variáveis Definidas para dynamics1435480
Node: eval_string1444533
Node: Funções e Variáveis Definidas para eval_string1444705
Node: f901446426
Node: Funções e Variáveis Definidas para f901446569
Node: ggf1448414
Node: Funções e Variáveis Definidas para ggf1448553
Node: grobner1450426
Node: Introdução a grobner1450650
Node: Funções e Variáveis Definidas para grobner1452690
Node: impdiff1466286
Node: Funções e Variáveis Definidas para impdiff1466451
Node: implicit_plot1467097
Node: Funções e Variáveis Definidas para implicit_plot1467281
Node: interpol1468551
Node: Introdução a interpol1468744
Node: Funções e Variáveis Definidas para interpol1469144
Node: lbfgs1478837
Node: Introdução a lbfgs1479014
Node: Funções e Variáveis Definidas para lbfgs1480137
Node: lindstedt1489588
Node: Funções e Variáveis Definidas para lindstedt1489759
Node: linearalgebra1491360
Node: Introdução a linearalgebra1491577
Node: Funções e Variáveis Definidas para linearalgebra1496072
Node: lsquares1521595
Node: Funções e Variáveis Definidas para lsquares1521767
Node: makeOrders1531015
Node: Funções e Variáveis Definidas para makeOrders1531187
Node: mnewton1532238
Node: Funções e Variáveis Definidas para mnewton1532404
Node: numericalio1534117
Node: Introdução a numericalio1534321
Node: Funções e Variáveis Definidas para numericalio1537102
Node: opsubst1540917
Node: Funções e Variáveis Definidas para opsubst1541083
Node: orthopoly1543577
Node: Introdução a polinômios ortogonais1543794
Ref: Avaliação em Ponto Flutuante1555056
Node: Funções e Variáveis Definidas para polinômios ortogonais1562652
Node: plotdf1570302
Node: Introdução a plotdf1570483
Node: Funções e Variáveis Definidas para plotdf1571945
Node: romberg1581789
Node: Funções e Variáveis Definidas para romberg1581947
Node: simplex1588972
Node: Introdução a simplex1589163
Node: Funções e Variáveis Definidas para simplex1589642
Node: simplification1593565
Node: Introdução a simplification1593786
Node: Funções e Variáveis Definidas para simplification1594187
Node: solve_rec1614978
Node: Introdução a solve_rec1615177
Node: Funções e Variáveis Definidas para solve_rec1615916
Node: stats1624617
Node: Introdução a stats1624913
Node: Funções e Variáveis Definidas para inference_result1626151
Node: Funções e Variáveis Definidas para stats1631085
Node: Funções e Variáveis Definidas para distribuições especiais1660102
Node: stirling1661383
Node: Funções e Variáveis Definidas para stirling1661547
Node: stringproc1663560
Node: Introdução a manipulação de seqüências de caracteres1663875
Node: Funções e Variáveis para entrada e saída1668887
Node: Funções e Variáveis para caracteres1675386
Node: Funções e Variáveis para seqüências de caracteres1678749
Node: unit1692573
Node: Introdução a Units1692750
Node: Funções e Variáveis Definidas para Units1696874
Node: zeilberger1717079
Node: Introdução a zeilberger1717297
Node: Funções e Variáveis Definidas para zeilberger1719465
Node: Índice de Funções e Variáveis1725477

End Tag Table


Local Variables:
coding: iso-8859-1
End:
