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

Este é o 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: Fluxo de Programa,  Next: Depuração,  Prev: Definição de Função,  Up: Top

40 Fluxo de Programa
********************

* Menu:

* Introdução a Fluxo de Programa::
* Definições para Fluxo de Programa::


File: maxima.info,  Node: Introdução a Fluxo de Programa,  Next: Definições 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: Definições para Fluxo de Programa,  Prev: Introdução a Fluxo de Programa,  Up: Fluxo de Programa

40.2 Definições para Fluxo de Programa
======================================

 -- Função da class: backtrace ()
 -- Função da class: backtrace (<n>)
     Imprime a pilha de chamadas, que é, a lista de funções que foram
     chamadas pela função correntemente activa.

     ‘backtrace()’ imprime toda a pilha de chamadas.

     ‘backtrace (<n>)’ imprime as <n> mais recentes chamadas a funções,
     incluindo a função correntemente activa.

     ‘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 activa.

               (%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 da class: 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
          <condition> do <corpo>’
        • ‘for <Variável>: <valor_inicial> step <incremento> unless
          <condition> 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 anterior 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 afectar 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 da
     expressão de avaliaçã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 proximo
     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 actualizaçã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 corpo ‘do <corpo>’ que
     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 facto, 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 da class: 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 ficheiros ‘batch’ onde se suspeita que um erro
     possa estar ocorrendo o ‘errcatch’ terminará o ‘batch’ se o erro
     não for detectado.

 -- Função da class: error (<expr_1>, ..., <expr_n>)
 -- Variável de sistema da class: 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 sequência de caracteres de
     formato, que junta todas as sequê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 sequências de
     caracteres.

     ‘errormsg()’ formata e imprime ‘error’.  Isso efectivamente
     reimprime a mais recente mensagem de erro.

 -- Função da class: errormsg ()
     Reimprime a mais recente mensagem de erro.  A variável ‘error’
     recebe a mensagem, e ‘errormsg’ formata e imprime essa mensagem.

 -- Operador especial da class: for
     Usado em iterações.  Veja ‘do’ para uma descrição das facilidades
     de iteração do Maxima.

 -- Função da class: 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 da class: 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 tais que
     ‘is(<cond_k>)’ avaliem para ‘true’ ou para ‘false’; de outra forma
     é um erro.  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 da class: 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 expi se não forem
     todas as expi do mesmo comprimento e (2) aplique fn a [exp1,
     exp2,...]  se expi não forem todas do mesmo tipo de objecto.  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 da class: 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 da class: maperror
     Valor por omissão: ‘true’

     Quando ‘maperror’ é ‘false’, faz com que todas as funções mapeadas,
     por exemplo

          map (f, expr_1, expr_2, ...))

     (1) parem quando elas terminarem retornando a menor expi se não
     forem todas as expi do mesmo comprimento e (2) aplique ‘f’ a
     ‘[expr_1, expr_2, ...]’ se ‘expr_i’ não forem todas do mesmo tipo
     de objecto.

     Se ‘maperror’ for ‘true’ então uma ,mensagem de erro é mostrada nas
     duas instâncias acima.

 -- Função da class: 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 (excepto para simplificações e o caso onde ‘map’ faz um
     ‘apply’).

 -- Variável de opção da class: prederror
     Valor por omissã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 da class: return (valor)
     Pode ser usada para sair explicitamente de um bloco, levando seu
     argumento.  Veja ‘block’ para mais informação.

 -- Função da class: scanmap (<f>, <expr>)
 -- Função da class: scanmap (<f>, <expr>, bottomup)
     Recursivamente aplica <f> a <expr>, de cima para baixo.  Isso é
     muito útil quando uma factoraçã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))

     Neste caso, obtém-se a mesma resposta pelos dois métodos.

 -- Função da class: 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 da class: while
     Veja ‘do’.

 -- Função da class: 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 afectam 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: Depuração,  Next: augmented_lagrangian,  Prev: Fluxo de Programa,  Up: Top

41 Depuração
************

* Menu:

* Depuração do Código Fonte::
* Comandos Palavra Chave::
* Definições para Depuração::


File: maxima.info,  Node: Depuração do Código Fonte,  Next: Comandos Palavra Chave,  Up: Depuração

41.1 Depuração do Código Fonte
==============================

Maxima tem um depurador interno de código fonte.  O utilizador pode
escolher um ponto de parada numa função, e executar o programa linha por
linha a partir daí.  A pilha de chamadas pode ser examinada, juntamente
com as variáveis existentes nesse nível.

O comando ‘:help’ ou ‘:h’ mostra a lista de comandos de depuração.  (Em
geral, os comandos podem ser abreviados se a abreviação for única.  Se
não for única, as alternativas podem ser listadas.)  Dentro do
depurador, o utilizador pode também usar quaisquer 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 utilizador 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 a seguir.

     (%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 ficheiro ‘/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 E DE XMAXIMA

Se o utilizador estiver a executar o código sob o GNU Emacs numa janela
shell (shel dbl), ou estiver usando a interface gráfica, ‘xmaxima’,
então quando parar num ponto de parada, verá a sua posição actual no
ficheiro fonte apresentada na outra metade da janela, ou em vermelho
brilhante, ou com uma pequena seta apontando na direita da linha.
Poderá avançar uma linha por vez digitando M-n (Alt-n).

No Emacs pode executar o Maxima numa shell ‘dbl’, o qual requer o
ficheiro ‘dbl.el’ no directório elisp.  Verifique que tenha instalado os
ficheiros elisp ou adicionado o directório elisp do Maxima ao seu
caminho: e.g., adicione o seguinte ao seu ficheiro ‘.emacs’ ou ao seu
ficheiro ‘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 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 utilizador pode escolher um ponto de parada em certa linha do ficheiro
digitando ‘C-x space’.  Isso encontra qual a função onde o cursor está
posicionado, e mostra qual a linha daquela função onde 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
utilizador deve ter maxima-mode.el habilitado na janela na qual o
ficheiro ‘foobar.mac’ estiver interagindo.  Existe comandos adicional
disponíveis naquela janela de ficheiro, 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: Definições para Depuração,  Prev: Depuração do Código Fonte,  Up: Depuração

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 Keyword commands start
with a colon, ’:’.  Por exemplo, para avaliar um comando do Lisp, pode
escrever ‘:lisp’ seguido pelo comando a ser avaliado.

     (%i1) :lisp (+ 2 3)
     5

O número de argumentos necessários depende do comando em particular.
Também, não precisa escrever 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 sequência de
     caracteres, então essa sequência de caracteres é assumida
     referir-se a um ficheiro, e ‘n’ é o deslocamente a partir do início
     do ficheiro.  O deslocamento é opcional.  Se for omitido, é
     assumido ser zero (primeira linha da função ou do ficheiro).
‘:bt’
     Imprime na tela uma lista da pilha de frames
‘:continue’
     Continua a computação
‘:delete’
     Remove o ponto de parada seleccionado, ou todos se nenum for
     especificado
‘:disable’
     Desabilita os pontos de parada seleccionados, 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’, excepto ‘: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: Definições para Depuração,  Prev: Comandos Palavra Chave,  Up: Depuração

41.3 Definições para Depuração
==============================

 -- Variável de opção da class: refcheck
     Valor por omissã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 da class: setcheck
     Valor por omissã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
     actualmente 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 da class: setcheckbreak
     Valor por omissã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.  Consequentemente, se pode
     atribuir um valor diferente através da atribuição a ‘setval’.

     Veja também ‘setcheck’ e ‘setval’.

 -- Variável de sistema da class: setval
     Mantém o valor para o qual a variável está para ser escolhida
     quando um ‘setcheckbreak’ ocorrer.  Consequentemente, se pode
     atribuir um valor diferente através da atribuição a ‘setval’.

     Veja também ‘setcheck’ e ‘setcheckbreak’.

 -- Função da class: timer (<f_1>, ..., <f_n>)
 -- Função da class: 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
     colectadas.  ‘timer(f)$ timer(g)$’ coloca ‘f’ e então ‘g’ sobre a
     lista; a lista acumula de uma chamada para a chamada seguinte.

     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 da class: untimer (<f_1>, ..., <f_n>)
 -- Função da class: 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 actualmente na
     lista de funções estatisticamente monitoradas.

     Após ‘untimer (f)’ ser executada, ‘timer_info (f)’ ainda retorna
     estatisticas de tempo previamente colectadas, embora ‘timer_info()’
     (sem argumentos) não retorna informações sobre qualquer função que
     não estiver actualmente 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 da class: 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 da class: timer_info (<f_1>, ..., <f_n>)
 -- Função da class: 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 actualmente 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 da class: trace (<f_1>, ..., <f_n>)
 -- Função da class: 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.

     Sem argumentos, ‘trace’ retorna uma lista de todas as funções
     actualmente 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
     por ‘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 da class: trace_options (<f>, <option_1>, ..., <option_n>)
 -- Função da class: 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
          objectos 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 da class: untrace (<f_1>, ..., <f_n>)
 -- Função da class: 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: Depuração,  Up: Top

42 augmented_lagrangian
***********************

* Menu:

* Definições para augmented_lagrangian::


File: maxima.info,  Node: Definições para augmented_lagrangian,  Prev: augmented_lagrangian,  Up: augmented_lagrangian

42.1 Definições para augmented_lagrangian
=========================================

 -- Função da class: augmented_lagrangian_method (<FOM>, <xx>, <C>,
          <yy>)
 -- Função da class: 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 algoritmo 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 algoritmo de memória limitada BFGS (LBFGS), que é um
     algoritmo 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:

          (%i1) load ("lbfgs");
          (%o1) /home/robert/tmp/maxima-release-branch/maxima/share/lbfgs/\
          lbfgs.mac
          (%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: descriptive,  Prev: augmented_lagrangian,  Up: Top

43 bode
*******

* Menu:

* Definições para bode::


File: maxima.info,  Node: Definições para bode,  Prev: bode,  Up: bode

43.1 Definições para bode
=========================

 -- Função da class: 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 da class: 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: descriptive,  Next: diag,  Prev: bode,  Up: Top

44 descriptive
**************

* Menu:

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


File: maxima.info,  Node: Introdução ao pacote descriptive,  Next: Definições para manipulação da dados,  Prev: descriptive,  Up: descriptive

44.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 ficheiros no formato texto plano.  Por
exemplo, o ficheiro ‘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 objectivo 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 ficheiro ‘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 ficheiro 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
ficheiro ‘biomed.data’ (que é parte de outro grande ficheiro tomado do
Repósitório de Dados StatLib) contém quatro medidas sanguí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 sanguí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: Definições para manipulação da dados,  Next: Definições para estatística descritiva,  Prev: Introdução ao pacote descriptive,  Up: descriptive

44.2 Definições para manipulação da dados
=========================================

 -- Função da class: continuous_freq (<list>)
 -- Função da class: continuous_freq (<list>, <m>)
     O argumento 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 da class: discrete_freq (<list>)
     Conta as frequê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 as suas
     frequências absolutas.  Os comandos ‘? col’ e ‘? transpose’ podem
     ajudá-lo a entender o último comando de entrada.

 -- Função da class: subsample (<matriz_de_dados>, <expressão_lógica>)
 -- Função da class: 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
     ficheiro ‘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 sanguí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: Definições para estatística descritiva,  Next: Definições específicas para estatística descritiva de várias variáveis,  Prev: Definições para manipulação da dados,  Up: descriptive

44.3 Definições para estatística descritiva
===========================================

 -- Função da class: mean (<lista>)
 -- Função da class: 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 da class: var (<list>)
 -- Função da class: 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 da class: var1 (<lista>)
 -- Função da class: 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 da class: std (<lista>)
 -- Função da class: 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 da class: std1 (<lista>)
 -- Função da class: 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 da class: noncentral_moment (<lista>, <k>)
 -- Função da class: 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 da class: central_moment (<lista>, <k>)
 -- Função da class: 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 da class: cv (<lista>)
 -- Função da class: 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 da class: mini (<lista>)
 -- Função da class: 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 da class: maxi (<lista>)
 -- Função da class: 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 da class: range (<lista>)
 -- Função da class: 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 da class: quantile (<lista>, <p>)
 -- Função da class: 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 da class: median (<lista>)
 -- Função da class: 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 da class: qrange (<lista>)
 -- Função da class: 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 da class: mean_deviation (<lista>)
 -- Função da class: 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 da class: median_deviation (<lista>)
 -- Função da class: 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 da class: harmonic_mean (<lista>)
 -- Função da class: 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 da class: geometric_mean (<lista>)
 -- Função da class: 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 da class: kurtosis (<lista>)
 -- Função da class: 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 da class: skewness (<lista>)
 -- Função da class: 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 da class: pearson_skewness (<lista>)
 -- Função da class: 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 da class: quartile_skewness (<lista>)
 -- Função da class: 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: Definições específicas para estatística descritiva de várias variáveis,  Next: Definições para gráficos estatísticos,  Prev: Definições para estatística descritiva,  Up: descriptive

44.4 Definições específicas para estatística descritiva de várias variáveis
===========================================================================

 -- Função da class: 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 da class: 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 da class: global_variances (<matriz>)
 -- Função da class: 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 efectiva> ‘determinant(S_1)^(1/p)’, (defined in:
          Peña, D. (2002) <Análisis de datos multivariantes>;
          McGraw-Hill, Madrid.)
        • <desvio padrão efectivo>: ‘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 da class: cor (<matriz>)
 -- Função da class: 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 da class: list_correlations (<matriz>)
 -- Função da class: 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

        • <vector de correlação múltipla>: (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: Definições para gráficos estatísticos,  Prev: Definições específicas para estatística descritiva de várias variáveis,  Up: descriptive

44.5 Definições para gráficos estatísticos
==========================================

 -- Função da class: dataplot (<lista>)
 -- Função da class: dataplot (<lista>, <opção_1>, <opção_2>, ...)
 -- Função da class: dataplot (<matriz>)
 -- Função da class: dataplot (<matriz>, <opção_1>, <opção_2>, ...)
     A função ‘dataplot’ permite visualização directa 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/ficheiro da figura de saída; valores correctos são
          ‘"x"’, ‘"eps"’ e ‘"png"’, para a tela, formato de ficheiro
          postscript e formato de ficheiro 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
          seleccionar pontos em 2D para serem unidos ou isolados.

        • ‘'picturescales’, o valor padrão é ‘[1.0, 1.0]’, factor 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
     ficheiro 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 directamente, 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ào 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 da class: histogram (<lista>)
 -- Função da class: histogram (<lista>, <opção_1>, <opção_2>, ...)
 -- Função da class: histogram (<one_column_matrix>)
 -- Função da class: 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
          ficheiro da figura de saída; valores correctos são ‘"x"’,
          ‘"eps"’ e ‘"png"’, para a tela, formato de ficheiro postscript
          e formato de ficheiro 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]’, factor 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 = ["", "Frequê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 da class: barsplot (<lista>)
 -- Função da class: barsplot (<lista>, <opção_1>, <opção_2>, ...)
 -- Função da class: barsplot (<one_column_matrix>)
 -- Função da class: 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
          ficheiro da figura de saída; valores correctos são ‘"x"’,
          ‘"eps"’ e ‘"png"’, para a tela, formato de ficheiro postscript
          e formato de ficheiro 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]’, factor 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
     factores.  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 freqyuê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 da class: boxplot (<data>)
 -- Função da class: 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 facto 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
          ficheiro da figura de saída; valores correctos são ‘"x"’,
          ‘"eps"’ e ‘"png"’, para a tela, formato de ficheiro postscript
          e formato de ficheiro 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]’, factor 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

45 diag
*******

* Menu:

* Definições para diag::


File: maxima.info,  Node: Definições para diag,  Prev: diag,  Up: diag

45.1 Definições para diag
=========================

 -- Função da class: 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 da class: 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 da class: 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 da class: 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 da class: 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 prmeiramente ‘load("diag")’.  Veja
     também ‘jordan’ e ‘dispJordan’.

 -- Função da class: 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 da class: 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: dynamics,  Prev: diag,  Up: Top

46 distrib
**********

* Menu:

* Introdução a distrib::
* Definições para distribuições contínuas::
* Definições para distribuições discretas::


File: maxima.info,  Node: Introdução a distrib,  Next: Definições para distribuições contínuas,  Prev: distrib,  Up: distrib

46.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 facto, 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 algoritmo a ser usado.  O método
inverso genérico (baseado no facto 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óptimo em termos de
cronometragem, mas útil para fazer comparações com outros algoritmos.
Nesse exemplo, a ‘perandom_formance’ dos algoritmos ‘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 objectivo de fazer comparações visuais entre algoritmos 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>.

Para poder usar o pacote ‘distrib’ precisa primeiro carregá-lo
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: Definições para distribuições contínuas,  Next: Definições para distribuições discretas,  Prev: Introdução a distrib,  Up: distrib

46.2 Definições para distribuições contínuas
============================================

 -- Função da class: 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 da class: 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 da class: 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 da class: 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 da class: 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 da class: 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 da class: 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 da class: 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 da class: random_normal_algorithm
     Valor por omissão: ‘box_mueller’

     Esse é o algoritmo seleccionado para simular variáveis aleatórias
     normais.  O algoritmos implementados são ‘box_mueller’ e ‘inverse’:
        • ‘box_mueller’, Baseado no algoritmo 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 da class: random_normal (<m>,<s>)
 -- Função da class: 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 algoritmos implementados para essa função, e o
     algoritmo a ser usado pode ser seleccionado 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 da class: 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 da class: 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 da class: 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 da class: 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 da class: 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 da class: 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 da class: 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 da class: 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 da class: random_student_t_algorithm
     Valor por omissão: ‘ratio’

     Esse é o algoritmo seleccionado 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 facto 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 da class: random_student_t (<n>)
 -- Função da class: 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 algoritmos implementados para essa função, se pode
     seleccionar o algoritmo 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 da class: 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 da class: 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 da class: 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 da class: 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 da class: 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 da class: 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 da class: 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 da class: 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 da class: random_chi2_algorithm
     Valor por omissão: ‘ahrens_cheng’

     Esse é o algoritmo seleccionado para simular variáveis estatística
     pseudo-aleatórias Chi-quadradas.  Os algoritmos 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 da class: random_chi2 (<n>)
 -- Função da class: 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 algoritmos implementados para essa função, se pode
     seleccionar o algoritmo 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 da class: 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 da class: 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 da class: 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 da class: 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 da class: 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 da class: 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 da class: 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 da class: 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 da class: random_f_algorithm
     Valor por omissão: ‘inverse’

     Esse é o algoritmo seleccionado para simular variáveis estatísticas
     pseudo-aleatórias F. Os algoritmos implementados são ‘ratio’ e
     ‘inverse’:

        • ‘ratio’, baseado no facto 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 da class: random_f (<m>,<n>)
 -- Função da class: 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 algoritmos implementados para essa função, se pode
     seleccionar o algoritmo 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 da class: 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 da class: 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 da class: 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 da class: 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 da class: 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 da class: 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 da class: 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 da class: 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 da class: random_exp_algorithm
     Valor por omissão: ‘inverse’

     Esse é o algoritmo seleccionado para simular variáveis exponenciais
     estatística pseudo-aleatórias.  Os algoritmos implementados são
     ‘inverse’, ‘ahrens_cheng’ e ‘ahrens_dieter’

        • ‘inverse’, baseado no método inverso genérico.

        • ‘ahrens_cheng’, baseado no facto 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 algoritmo 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 da class: random_exp (<m>)
 -- Função da class: 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 algoritmos implementados para essa função, se pode
     seleccionar o algoritmo 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 da class: 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 da class: 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 da class: 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 da class: 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 da class: 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 da class: 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 da class: 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 da class: 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 da class: random_lognormal (<m>,<s>)
 -- Função da class: 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 algoritmos
     implementados para essa função, se pode seleccionar o algoritmo 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 da class: 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 da class: 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 da class: 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 da class: 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 da class: 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 da class: 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 da class: 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 da class: 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 da class: random_gamma_algorithm
     Valor por omissão: ‘ahrens_cheng’

     Esse é o algoritmo seleccionado para simular variáveis estatística
     gama pseudo-aleatórias.  Os algoritmos 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 da class: random_gamma (<a>,<b>)
 -- Função da class: 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 algoritmos implementados para essa função, se pode
     seleccionar o algoritmo 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 da class: 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 da class: 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 da class: 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 da class: 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 da class: 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 da class: 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 da class: 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 da class: 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 da class: random_beta_algorithm
     Valor por omissão: ‘cheng’

     Esse é o algoritmo seleccionado para simular variáveis estatísticas
     beta pseudo-aleatórias.  Os algoritmos implementados são ‘cheng’,
     ‘inverse’ e ‘ratio’

        • ‘cheng’, esse é o algoritmo 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 facto 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 da class: random_beta (<a>,<b>)
 -- Função da class: 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 algoritmos implementados para essa função, se pode
     seleccionar o algoritmo 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 da class: 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 da class: 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 da class: 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 da class: 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 da class: 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 da class: 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 da class: 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 da class: 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 da class: random_continuous_uniform (<a>,<b>)
 -- Função da class: 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 directa da função ‘random’ interna do Maxima.

     Veja também ‘random’.  Para fazer uso dessa função, escreva
     primeiramente ‘load("distrib")’.

 -- Função da class: 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 da class: 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 da class: 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 da class: 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 da class: 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 da class: 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 da class: 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 da class: 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 da class: random_logistic (<a>,<b>)
 -- Função da class: 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 da class: 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 da class: 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 da class: 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 da class: 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 da class: 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 da class: 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 da class: 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 da class: 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 da class: random_pareto (<a>,<b>)
 -- Função da class: 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 da class: 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 da class: 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 da class: 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 da class: 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 da class: 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 da class: 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 da class: 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 da class: 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 da class: random_weibull (<a>,<b>)
 -- Função da class: 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 da class: 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 da class: 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 da class: 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 da class: 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 da class: 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 da class: 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 da class: 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 da class: 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 da class: random_rayleigh (<b>)
 -- Função da class: 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 da class: 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 da class: 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 da class: 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 da class: 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 da class: 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 da class: 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 da class: 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 da class: 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 da class: random_laplace (<a>,<b>)
 -- Função da class: 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 da class: 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 da class: 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 da class: 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 da class: random_cauchy (<a>,<b>)
 -- Função da class: 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 da class: 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 da class: 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 da class: 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 da class: 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 da class: 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 da class: 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 da class: 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 da class: 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 da class: random_gumbel (<a>,<b>)
 -- Função da class: 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: Definições para distribuições discretas,  Prev: Definições para distribuições contínuas,  Up: distrib

46.3 Definições para distribuições discretas
============================================

 -- Função da class: 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 da class: 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 da class: 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 da class: 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 da class: 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 da class: 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 da class: 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 da class: 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 da class: random_binomial_algorithm
     Valor por omissão: ‘kachit’

     Esse é o algoritmo seleccionado para simular rvariáveis
     estatísticas pseudo-aleatórias binomiais.  Os algoritmos
     implementados são ‘kachit’, ‘bernoulli’ e ‘inverse’:

        • ‘kachit’, baseado no algoritmo 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 da class: random_binomial (<n>,<p>)
 -- Função da class: 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 algoritmos implementado para essa função, se pode
     seleccionar o algoritmo 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 da class: 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 da class: 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 da class: 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 da class: 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 da class: 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 da class: 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 da class: 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 da class: 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 da class: random_poisson_algorithm
     Valor por omissão: ‘ahrens_dieter’

     Esse é o algoritmo seleccionado para simular variáveis estatísticas
     pseudo-aleatórias de Poisson.Os algoritmos implementados são
     ‘ahrens_dieter’ e ‘inverse’:

        • ‘ahrens_dieter’, baseado no algoritmo 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 da class: random_poisson (<m>)
 -- Função da class: 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 algoritmos implementado para essa função, se pode
     seleccionar o algoritmo 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 da class: 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 da class: 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 da class: 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 da class: 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 da class: 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 da class: 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 da class: 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 da class: 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 da class: random_bernoulli (<p>)
 -- Função da class: 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 directa 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 da class: 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 da class: 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 da class: 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 da class: 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 da class: 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 da class: 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 da class: 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 da class: 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 da class: random_geometric_algorithm
     Valor por omissão: ‘bernoulli’

     Esse é o algoritmo seleccionado 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 algoritmo 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 da class: random_geometric (<p>)
 -- Função da class: 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 algoritmos implementados para essa função, se pode
     seleccionar o algoritmo 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 da class: 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 da class: 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 da class: 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 da class: 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 da class: 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 da class: 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 da class: 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 da class: 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 da class: random_discrete_uniform (<n>)
 -- Função da class: 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 directa 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 da class: 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 da class: 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 da class: 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 da class: 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 da class: 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 da class: 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 da class: 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 da class: 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 da class: random_hypergeometric_algorithm
     Valor por omissão: ‘kachit’

     Esse é o algoritmo seleccionado para simular variáveis estatísticas
     pseudo aleatórias hipergeométricas.Os algoritmos implementados são
     ‘kachit’ e ‘inverse’:

        • ‘kachit’, baseado no algoritmo 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 da class: random_hypergeometric (<n1>,<n2>,<n>)
 -- Função da class: 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 algoritmos implementados para essa função, se pode
     seleccionar o algoritmo 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 da class: 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 da class: 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 da class: 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 da class: 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 da class: 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 da class: 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 da class: 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 da class: 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 da class: random_negative_binomial_algorithm
     Valor por omissão: ‘bernoulli’

     Esse é o algoritmo seleccionado para simular variáveis estatísticas
     pseuso-aleatórias binomiais negativas.  Os algoritmos implementados
     são ‘devroye’, ‘bernoulli’ e ‘inverse’:

        • ‘devroye’, baseado no algoritmo 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 da class: random_negative_binomial (<n>,<p>)
 -- Função da class: 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 algoritmos implementados para essa função, se pode
     seleccionar o algoritmo 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: dynamics,  Next: eval_string,  Prev: distrib,  Up: Top

47 dynamics
***********

* Menu:

* O pacote dynamics::
* Análise gráfica de sistemas dinâmicos discretos::
* Visualização usando VTK::


File: maxima.info,  Node: O pacote dynamics,  Next: Análise gráfica de sistemas dinâmicos discretos,  Prev: dynamics,  Up: dynamics

47.1 O pacote dynamics
======================

O pacote adicional ‘dynamics’ inclui várias funções para criar diversas
representações gráficas de sistemas dinâmicos e fractais, para além duma
implementaçõ do método numérico de Runge-Kutta de quarta ordem, para
resolver sistemas de equações diferenciais.

Para usar as funções neste pacote será necessário primeiro que tudo
carregá-lo com ‘load("dynamics")’; as funções que criam gráficos
precisam que o Xmaxima esteja instalado.


File: maxima.info,  Node: Análise gráfica de sistemas dinâmicos discretos,  Next: Visualização usando VTK,  Prev: O pacote dynamics,  Up: dynamics

47.2 Análise gráfica de sistemas dinâmicos discretos
====================================================

 -- Função da class: chaosgame (‘[[’<x1>, <y1>‘]’...‘[’<xm>, <ym>‘]]’,
          ‘[’<x0>, <y0>‘]’, <b>, <n>, ...opções...);

     Usa o método designado de _jogo do caos_, para produzir fractais:
     desenha-se um ponto inicial (<x0>, <y0>) e logo escolhe-se
     aleatoriamente um dos <m> pontos ‘[’<x1>, <y1>‘]’...‘[’<xm>,
     <ym>‘]’.  A seguir, desenha-se um novo ponto que estará no segmento
     entre o último ponto desenhado e o ponto que se acabou de
     seleccionar aleatoriamente, a uma distância do ponto seleccionado
     que será <b> vezes o comprimento do segmento.  O processo repete-se
     <n> vezes.

 -- Função da class: evolution (<F>, <y0>, <n>,...opções...);

     Desenha <n+1> pontos num gráfico bidimensional (série de tempo),
     onde as coordenadas horizontais dos pontos são os números inteiros
     0, 1, 2, ..., <n>, e as coordenadas verticais são os valores <y(n)>
     correspondentes, obtidos a partir da relação de recorrência
                  y(n+1) = F(y(n))

     Com valor inicial <y(0)> igual a <y0>.  <F> deverá ser uma
     expressão que dependa unicamente da variável <y> (e não de <n>),
     <y0> deverá ser um número real e <n> um número inteiro positivo.

 -- Função da class: evolution2d (‘[’<F>, <G>‘]’, ‘[’<x0>, <y0>‘]’, <n>,
          ...opções...);

     Mostra, num gráfico bidimensional, os primeiros <n+1> pontos da
     sucessão definida a partir do sistema dinâmico discreto com
     relações de recorrência:
                  x(n+1) = F(x(n), y(n))    y(n+1) = G(x(n), y(n))

     Com valores iniciais <x0> e <y0>.  <F> e <G> deverão ser duas
     expressões que dependam unicamente de <x> e <y>.

 -- Função da class: ifs (‘[’<r1>,...,<rm>‘]’,‘[’<A1>,...,<Am>‘]’,
          ‘[[’<x1>,<y1>‘]’...‘[’<xm>, <ym>‘]]’, ‘[’<x0>,<y0>‘]’,
     <n>, ...opções...);

     Usa o método do Sistema de Funções Iteradas (IFS, em inglês
     _Iterated Function System_).  Esse método é semelhante ao método
     descrito na função ‘chaosgame’, mas em vez de aproximar o último
     ponto para ponto seleccionado aleatoriamente, as duas coordenadas
     do último ponto multiplicam-se por uma matriz 2 por 2 <Ai>
     correspondente ao ponto que tenha sido escolhido aleatoriamente.

     A selecção aleatória de um dos <m> pontos atractivos pode se
     realizada com uma função de probabilidade não uniforme, definida
     com os pesos <r1>,...,<rm>.  Pesos esses que deverão ser dados em
     forma acumulada; por exemplo, se quiser usar 3 pontos com
     probabilidades 0.2, 0.5 e 0.3, os pesos <r1>, <r2> e <r3> poderiam
     ser 2, 7 e 10, ou qualquer outro grupo de números que estejam na
     mesma proporção.

 -- Função da class: orbits (<F>, <y0>, <n1>, <n2>, [<x>, <x0>, <xf>,
          <xstep>], ...opções...);

     Desenha o diagrama de órbitas duma família de sistemas dinâmicos
     discretos unidimensionais, com um parâmetro <x>; esse tipo de
     diagrama usa-se para mostrar as bifurcações dum sistema discreto
     unidimensional.

     A função <F(y)> define uma sequência que começa com um valor
     inicial <y0>, igual que no caso da função ‘evolution’, mas neste
     caso a função também dependerá do parâmetro <x>, o qual terá
     valores compreendidos no intervalo de <x0> a <xf>, com incrementos
     <xstep>.  Cada valor usado para o parâmetro <x> apresenta-se no
     eixo horizontal.  No eixo vertical apresentam-se <n2> valores da
     sucessão <y(n1+1)>,..., <y(n1+n2+1)>, obtidos após deixá-la evoluir
     durante <n1> iterações iniciais.

 -- Função da class: rk (EDO, var, inicial, dominio)
 -- Função da class: rk ([EDO1,...,EDOm], [v1,...,vm],
          [inic1,...,inicm], domínio)

     A primeira forma usa-se para resolver numericamente uma equação
     diferencial ordinária de primeira ordem (EDO), e a segunda forma
     resolve numericamente um sistema de <m> dessas equações, usando o
     método de Runge-Kutta de quarta ordem.  <var> representa a variável
     dependente.  EDO deverá ser uma expressão que dependa unicamente
     das variáveis independente e dependente, e define a derivada da
     variável dependente em função da variável independente.

     A variável independente representa-se com <domínio>, que deverá ser
     uma lista com quatro elementos, como, por exemplo:
          [t, 0, 10, 0.1]
     o primeiro elemento da lista identifica a variável independente, os
     segundo e terceiro elementos são os valores inicial e final para
     essa variável, e o último elemento dá o valor dos incrementos que
     deverão ser usados dentro desse intervalo.

     Se se estiverem a resolver <m> equações, deverá haver <m> variáveis
     dependentes <v1>, <v2>, ..., <vm>.  Os valores iniciais para essas
     variáveis serão <inic1>, <inic2>, ..., <inicm>.  Continuará
     existindo apenas uma variável independente, definida pela lista
     <domain>, tal como no caso anterior.  <EDO1>, ..., <EDOm> são as
     expressões que definem as derivadas de cada uma das variáveis
     dependentes, em função da variável independente.  As únicas
     variáveis que podem aparecer em cada uma dessas expressões são a
     variável independente e qualquer uma das variáveis dependentes.  É
     importante que as derivadas <EDO1>, ..., <EDOm> sejam colocadas na
     lista na mesma ordem em que forem agrupadas as variáveis
     dependentes; por exemplo, o terceiro elemento da lista será
     interpretado como a derivada da terceira variável dependente.

     O programa tenta integrar as equações desde o valor inicial da
     variável independente, até o valor final, usando incrementos fixos.
     Se em algum passo uma das variáveis dependentes atingir um valor
     absoluto muito elevado, a integração será interrompida nesse ponto.
     O resultado será uma lista com um número de elementos igual ao
     número de iterações realizadas.  Cada elemento na lista de
     resultados é também uma lista com <m>+1 elementos: o valor da
     variável independente, seguido dos valores das variáveis
     dependentes nesse ponto.

 -- Função da class: staircase (<F>, <y0>, <n>, ...opções...);

     Desenha um diagrama de degraus (ou diagrama de teia de aranha) para
     a sucessão definida pela equação de recorrência
                  y(n+1) = F(y(n))

     A interpretação e valores permitidos dos parâmetros de entrada é
     igual que para a função ‘evolution’.  Um diagrama de degraus
     consiste num gráfico da função <F(y)>, junto com a recta <G(y)> ‘=’
     <y>.  Começa-se por desenhar um segmento vertical desde o ponto
     (<y0>, <y0>) na recta, até o ponto de intersecção com a função <F>.
     A seguir, desde esse ponto desenha-se um segmento horizontal até o
     ponto de intersecção com a recta, (<y1>, <y1>); o processo
     repete-se <n> vezes até alcançar o ponto (<yn>, <yn>).

Opções

Cada opção é uma lista com dois ou mais elementos.  O primeiro elemento
na lista é o nome da opção e os restantes são os argumentos para essa
opção.

As opções aceites pelas funções evolution, evolution2, staircase,
orbits, ifs e chaosgame são as seguintes:

   • “domain” especifica os valores mínimo y máximo da variável
     independente para o gráfico da função <F> representada por
     ‘staircase’.

   • “pointsize” define o raio de cada ponto desenhado, em unidades de
     pontos.  O valor por omissão é 1.

   • “xaxislabel” é o nome que será dado ao eixo horizontal.

   • “xcenter” é a coordenada x do ponto que deverá aparecer no centro
     do gráfico.  Esta opção não é usada pela função ‘orbits’.

   • “xradius” é metade do comprimento do intervalo de valores de x que
     serão representados.  Esta opção não é usada pela função ‘orbits’.

   • “yaxislabel” é o nome que será dado ao eixo vertical.

   • “ycenter” é a coordenada y do ponto que deverá aparecer no centro
     do gráfico.

   • “yradius” é metade do comprimento do intervalo de valores de y que
     serão representados.

As opções aceites pelos programas juli Exemplos

Representação gráfica e diagrama de degraus da sequência: 2, cos(2),
cos(cos(2)),...

     (%i1) load("dynamics")$
     (%i2) evolution(cos(y), 2, 11, [yaxislabel, "y"], [xaxislabel,"n"]);
     (%i3) staircase(cos(y), 1, 11, [domain, 0, 1.2]);

Se o seu processador for lento, terá que reduzir o número de iterações
usado nos exemplos seguintes.  E o valor de <pointsize> que dá os
melhores resultados dependerá do monitor e da resolução usada.  Terá que
experimentar com diferentes valores.

Diagrama de órbitas para o mapa quadrático
             y(n+1) = x + y(n)^2

     (%i4) orbits(y^2+x, 0, 50, 200, [x, -2, 0.25, 0.01], [pointsize, 0.9]);

Para ampliar a região à volta da bifurcação na parte de baixo, perto de
x ‘=’ -1.25, use o comando:
     (%i5) orbits(x+y^2, 0, 100, 400, [x,-1,-1.53,-0.001], [pointsize,0.9],
                  [ycenter,-1.2], [yradius,0.4]);

Evolução dum sistema em duas dimensões, que conduz 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],[-0.5,0],50000,[pointsize,0.7]);

E uma ampliação de uma pequena região no fractal:

     (%i9) evolution2d([f,g],[-0.5,0],300000,[pointsize,0.7], [xcenter,-0.7],
                       [ycenter,-0.3],[xradius,0.1],[yradius,0.1]);

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, [pointsize,0.7]);

O feto de Barnsley, obtido com o 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,[pointsize,0.9]);

Para resolver numericamente a equação diferencial

               dx/dt = t - x^2

Com valor inicial x(t=0) = 1, no intervalo de t desde 0 até 8, e com
incrementos de 0.1, usa-se:

     (%i20) resultados: rk(t-x^2,x,1,[t,0,8,0.1])$

os resultados ficarão armazenados na lista 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, com valores iniciais -1.25 e 0.75 para (x, 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: Visualização usando VTK,  Prev: Análise gráfica de sistemas dinâmicos discretos,  Up: dynamics

47.3 Visualização usando VTK
============================

A função scene cria imagens a três dimensões e animações, usando o
software _Visualization ToolKit_ (VTK). Para poder usar essa função é
necessário ter Xmaxima e VTK instalados no sistema (incluindo a libraria
para utilizar VTK desde TCL, que pode vir num pacote separado em alguns
sistemas).


File: maxima.info,  Node: eval_string,  Next: f90,  Prev: dynamics,  Up: Top

48 eval_string
**************

* Menu:

* Definições para eval_string::


File: maxima.info,  Node: Definições para eval_string,  Prev: eval_string,  Up: eval_string

48.1 Definições para eval_string
================================

 -- Função da class: eval_string (<str>)
     Entrega a sequência de caracteres do Maxima <str> como uma
     expressão do Maxima e a avalia.  <str> é uma sequência de
     caracteres do Maxima.  Essa sequê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 sequência de caracteres do Maxima.

     Exemplos:
          (%i1) load("eval_string")$

          (%i2) eval_string ("foo: 42; bar: foo^2 + baz");
          (%o2)                       42
          (%i3) eval_string ("(foo: 42, bar: foo^2 + baz)");
          (%o3)                   baz + 1764

     Para usar essa função escreva primeiro ‘load("eval_string")’.  Veja
     também ‘parse_string’.

 -- Função da class: parse_string (<str>)
     Entrega a sequência de caracteres do Maxima <str> como uma
     expressão do Maxima (sem fazer nenhuma avaliação dessa expressão).
     <str> é uma sequência de caracteres do Maxima.  Essa sequê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 sequência de caracteres do Maxima.

     Exemplos:
          (%i1) load("eval_string")$

          (%i2) parse_string ("foo: 42; bar: foo^2 + baz");
          (%o2)                    foo : 42
          (%i3) parse_string ("(foo: 42, bar: foo^2 + baz)");
                                             2
          (%o3)          (foo : 42, bar : foo  + baz)

     Para usar essa função escreva primeiro ‘load("eval_string")’.  Veja
     também a função ‘eval_string’.


File: maxima.info,  Node: f90,  Next: ggf,  Prev: eval_string,  Up: Top

49 f90
******

* Menu:

* Definições para f90::


File: maxima.info,  Node: Definições para f90,  Prev: f90,  Up: f90

49.1 Definições para f90
========================

 -- Função da class: f90 (<expr>)
     O comando f90 é uma actualização do comando ‘fortran’ original do
     maxima.  A principal diferença é na forma como são divididas as
     linhas muito compridas.

     No exemplo seguinte, observe como o comando ‘fortran’ divide linhas
     no meio de símbolos.  O comando ‘f90’ nunca separa uma linha no
     meio 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 função ‘f90’ foi criada como uma forma rápida de resolver um
     problema.  Não será necessariamente um bom exemplo a seguir para
     traduções de outras linguagens de programação.

     Para usar esta função, use primeiro ‘load("f90")’.


File: maxima.info,  Node: ggf,  Next: impdiff,  Prev: f90,  Up: Top

50 ggf
******

* Menu:

* Definições para ggf::


File: maxima.info,  Node: Definições para ggf,  Prev: ggf,  Up: ggf

50.1 Definições para ggf
========================

 -- Variável de Opção da class: GGFINFINITY
     Valor por omissã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 actual 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
     usar um valor muito grande, então poderá fornecer termos
     suficientes com o objectivo de fazer o cálculo preciso o bastante.

     Veja também ‘ggf’.

 -- Variável de opção da class: GGFCFMAX
     Valor por omissã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 da class: ggf (<l>)
     Calcula a função geradora (se for uma fração de dois polinómios) de
     uma sequê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: impdiff,  Next: interpol,  Prev: ggf,  Up: Top

51 impdiff
**********

* Menu:

* Definições para impdiff::


File: maxima.info,  Node: Definições para impdiff,  Prev: impdiff,  Up: impdiff

51.1 Definições para impdiff
============================

 -- Função da class: 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: interpol,  Next: lbfgs,  Prev: impdiff,  Up: Top

52 interpol
***********

* Menu:

* Introdução a interpol::
* Definições para interpol::


File: maxima.info,  Node: Introdução a interpol,  Next: Definições para interpol,  Prev: interpol,  Up: interpol

52.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: Definições para interpol,  Prev: Introdução a interpol,  Up: interpol

52.2 Definições para interpol
=============================

 -- Função da class: lagrange (<pontos>)
 -- Função da class: 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 da class: 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 da class: linearinterpol (<pontos>)
 -- Função da class: 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 da class: cspline (<pontos>)
 -- Função da class: 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

53 lbfgs
********

* Menu:

* Introdução a lbfgs::
* Definições para lbfgs::


File: maxima.info,  Node: Introdução a lbfgs,  Next: Definições para lbfgs,  Prev: Top,  Up: Top

53.1 Introdução a lbfgs
=======================

‘lbfgs’ é uma implementação do algoritmo[1] L-BFGS
(Broyden-Fletcher-Goldfarb-Shanno) para resolver problemas de
minimização não limitada através de um algoritmo de memória limitada
quasi-Newton (BFGS). Esse algoritmo é 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: Definições para lbfgs,  Prev: Introdução a lbfgs,  Up: Top

53.2 Definições para lbfgs
==========================

 -- Função da class: 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 algoritmo aplicado é um algoritmo de memória limitada[1]
     quasi-Newton (BFGS). Esse algoritmo é 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.

     <iprint> controla as messaens de progresso mostradas através de
     ‘lbfgs’.

     ‘iprint[1]’
          ‘<iprint>[1]’ controla a frequê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.

     Veja também ‘lbfgs_nfeval_max’ e ‘lbfgs_ncorrections’.

     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)

     Exemplo:

          (%i1) load ("lbfgs");
          (%o1)   /usr/share/maxima/5.10.0cvs/share/lbfgs/lbfgs.mac
          (%i2) FOM : '((1/length(X))*sum((F(X[i]) - Y[i])^2, i, 1, length(X)));
                                         2
                         sum((F(X ) - Y ) , i, 1, length(X))
                                 i     i
          (%o2)          -----------------------------------
                                      length(X)
          (%i3) X : [1, 2, 3, 4, 5];
          (%o3)                    [1, 2, 3, 4, 5]
          (%i4) Y : [0, 0.5, 1, 1.25, 1.5];
          (%o4)                [0, 0.5, 1, 1.25, 1.5]
          (%i5) F(x) := A/(1 + exp(-B*(x - C)));
                                             A
          (%o5)            F(x) := ----------------------
                                   1 + exp((- B) (x - C))
          (%i6) ''FOM;
                          A               2            A                2
          (%o6) ((----------------- - 1.5)  + (----------------- - 1.25)
                    - B (5 - C)                  - B (4 - C)
                  %e            + 1            %e            + 1
                      A             2            A               2
           + (----------------- - 1)  + (----------------- - 0.5)
                - B (3 - C)                - B (2 - C)
              %e            + 1          %e            + 1
                       2
                      A
           + --------------------)/5
                - B (1 - C)     2
             (%e            + 1)
          (%i7) estimates : lbfgs (FOM, '[A, B, C], [1, 1, 1], 1e-4, [1, 0]);
          *************************************************
            N=    3   NUMBER OF CORRECTIONS=25
                 INITIAL VALUES
           F=  1.348738534246918D-01   GNORM=  2.000215531936760D-01
          *************************************************

             I  NFN     FUNC                    GNORM                   STEPLENGTH

             1    3     1.177820636622582D-01   9.893138394953992D-02   8.554435968992371D-01
             2    6     2.302653892214013D-02   1.180098521565904D-01   2.100000000000000D+01
             3    8     1.496348495303005D-02   9.611201567691633D-02   5.257340567840707D-01
             4    9     7.900460841091139D-03   1.325041647391314D-02   1.000000000000000D+00
             5   10     7.314495451266917D-03   1.510670810312237D-02   1.000000000000000D+00
             6   11     6.750147275936680D-03   1.914964958023047D-02   1.000000000000000D+00
             7   12     5.850716021108205D-03   1.028089194579363D-02   1.000000000000000D+00
             8   13     5.778664230657791D-03   3.676866074530332D-04   1.000000000000000D+00
             9   14     5.777818823650782D-03   3.010740179797255D-04   1.000000000000000D+00

           THE MINIMIZATION TERMINATED WITHOUT DETECTING ERRORS.
           IFLAG = 0
          (%o7) [A = 1.461933911464101, B = 1.601593973254802,
                                                     C = 2.528933072164854]
          (%i8) plot2d ([F(x), [discrete, X, Y]], [x, -1, 6]), ''estimates;
          (%o8)

 -- Variãvel da class: lbfgs_nfeval_max
     Valor por omissão: 100

 -- Variãvel da class: lbfgs_ncorrections
     Valor por omissão: 25


File: maxima.info,  Node: lindstedt,  Next: linearalgebra,  Prev: lbfgs,  Up: Top

54 lindstedt
************

* Menu:

* Definições para lindstedt::


File: maxima.info,  Node: Definições para lindstedt,  Prev: lindstedt,  Up: lindstedt

54.1 Definições para lindstedt
==============================

 -- Função da class: 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

55 linearalgebra
****************

* Menu:

* Introdução a linearalgebra::
* Definições para linearalgebra::


File: maxima.info,  Node: Introdução a linearalgebra,  Next: Definições para linearalgebra,  Prev: linearalgebra,  Up: linearalgebra

55.1 Introdução a linearalgebra
===============================

‘linearalgebra’ é uma colecção de funções para álgebra linear.

Exemplo:

     (%i1) load ("linearalgebra");
     Warning - you are redefining the Maxima function require_list
     Warning - you are redefining the Maxima function matrix_size
     Warning - you are redefining the Maxima function rank
     (%o1) /usr/local/share/maxima/5.9.2/share/linearalgebra/linearalgebra.mac
     (%i2) M : matrix ([1, 2], [1, 2]);
                                 [ 1  2 ]
     (%o2)                       [      ]
                                 [ 1  2 ]
     (%i3) nullspace (M);
                                    [  1  ]
                                    [     ]
     (%o3)                     span([   1 ])
                                    [ - - ]
                                    [   2 ]
     (%i4) columnspace (M);
                                     [ 1 ]
     (%o4)                      span([   ])
                                     [ 1 ]
     (%i5) ptriangularize (M - z*ident(2), z);
                              [ 1   2 - z   ]
     (%o5)                    [             ]
                              [           2 ]
                              [ 0  3 z - z  ]
     (%i6) M : matrix ([1, 2, 3], [4, 5, 6], [7, 8, 9]) - z*ident(3);
                          [ 1 - z    2      3   ]
                          [                     ]
     (%o6)                [   4    5 - z    6   ]
                          [                     ]
                          [   7      8    9 - z ]
     (%i7) MM : ptriangularize (M, z);
                   [ 4  5 - z            6            ]
                   [                                  ]
                   [                2                 ]
                   [     66        z    102 z   132   ]
                   [ 0   --      - -- + ----- + ---   ]
     (%o7)         [     49        7     49     49    ]
                   [                                  ]
                   [               3        2         ]
                   [           49 z    245 z    147 z ]
                   [ 0    0    ----- - ------ - ----- ]
                   [            264      88      44   ]
     (%i8) algebraic : true;
     (%o8)                         true
     (%i9) tellrat (MM [3, 3]);
                              3       2
     (%o9)                  [z  - 15 z  - 18 z]
     (%i10) MM : ratsimp (MM);
                    [ 4  5 - z           6           ]
                    [                                ]
                    [                2               ]
     (%o10)         [     66      7 z  - 102 z - 132 ]
                    [ 0   --    - ------------------ ]
                    [     49              49         ]
                    [                                ]
                    [ 0    0             0           ]
     (%i11) nullspace (MM);
                             [        1         ]
                             [                  ]
                             [   2              ]
                             [  z  - 14 z - 16  ]
                             [  --------------  ]
     (%o11)             span([        8         ])
                             [                  ]
                             [    2             ]
                             [   z  - 18 z - 12 ]
                             [ - -------------- ]
                             [         12       ]
     (%i12) 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  ]
     (%o12)                 [                ]
                            [ 9   10  11  12 ]
                            [                ]
                            [ 13  14  15  16 ]
     (%i13) columnspace (M);
                                [ 1  ]  [ 2  ]
                                [    ]  [    ]
                                [ 5  ]  [ 6  ]
     (%o13)                span([    ], [    ])
                                [ 9  ]  [ 10 ]
                                [    ]  [    ]
                                [ 13 ]  [ 14 ]
     (%i14) apply ('orthogonal_complement, args (nullspace (transpose (M))));
                                [ 0 ]  [  1  ]
                                [   ]  [     ]
                                [ 1 ]  [  0  ]
     (%o14)                span([   ], [     ])
                                [ 2 ]  [ - 1 ]
                                [   ]  [     ]
                                [ 3 ]  [ - 2 ]


File: maxima.info,  Node: Definições para linearalgebra,  Prev: Introdução a linearalgebra,  Up: linearalgebra

55.2 Definições para linearalgebra
==================================

 -- Função da class: 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 da class: blockmatrixp (<M>)

     Retorna ‘true’ se e somente se <M> for uma matriz e toda entrada de
     <M> também for uma matriz.

 -- Função da class: 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 da class: 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 da class: 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 da class: copy (<e>)

     Retorna uma cópia da expressão <e> do Maxima.  Embora <e> possa ser
     qualquer expressão do Maxima, Afunção ‘copy’ é mais útil quando <e>
     for ou uma lista ou uma matriz; considere: load ("linearalgebra");
     m : [1,[2,3]]$ mm : m$ mm[2][1] : x$ m; mm;
          (%i1) load("linearalgebra")$
          (%i2) m : [1,[2,3]]$
          (%i3) mm : m$
          (%i4) mm[2][1] : x$
          (%i5) m;
          (%o5) [1,[x,3]]
          (%i6) mm;
          (%o6) [1,[x,3]]
     Vamos tentar a mesma experiência, mas dessa vez tomemos <mm> como
     sendo uma cópia de <m> m : [1,[2,3]]$ mm : copy(m)$ mm[2][1] : x$
     m; mm;
          (%i7) m : [1,[2,3]]$
          (%i8) mm : copy(m)$
          (%i9) mm[2][1] : x$
          (%i10) m;
          (%o10) [1,[2,3]]
          (%i11) mm;
          (%o11) [1,[x,3]]
     Dessa vez, a atribuição a <mm> não muda o valor de <m>.

 -- Função da class: cholesky (<M>)
 -- Função da class: cholesky (<M>, <corpo>)

     Retorna factorizaçã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
     <corpo>, veja ‘lu_factor’.

 -- Função da class: 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 da class: 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) load("linearalgebra")$

          (%i2) diag_matrix(diag_matrix(1,2),diag_matrix(3,4));

                                      [ [ 1  0 ]  [ 0  0 ] ]
                                      [ [      ]  [      ] ]
                                      [ [ 0  2 ]  [ 0  0 ] ]
          (%o2)                       [                    ]
                                      [ [ 0  0 ]  [ 3  0 ] ]
                                      [ [      ]  [      ] ]
                                      [ [ 0  0 ]  [ 0  4 ] ]
          (%i3) diag_matrix(p,q);

                                             [ p  0 ]
          (%o3)                              [      ]
                                             [ 0  q ]

 -- Função da class: dotproduct (<u>, <v>)

     Retorna o produto do ponto (produto escalar) dos vectores <u> e
     <v>.  Isso é o mesmo que ‘conjugate (transpose (<u>)) . <v>’.  Os
     argumentos <u> e <v> devem ser vectores coluna.

 -- Função da class: eigens_by_jacobi (<A>)
 -- Função da class: eigens_by_jacobi (<A>, <tipo_corpo>)

     Calculam os autovalores e autovectores 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) load ("linearalgebra");
          (%o1) /home/robert/tmp/maxima-head/maxima/share/linearalgebra/li\
          nearalgebra.mac
          (%i2) S : matrix ([1/sqrt(2), 1/sqrt(2)], [- 1/sqrt(2), 1/sqrt(2)]);
                               [     1         1    ]
                               [  -------   ------- ]
                               [  sqrt(2)   sqrt(2) ]
          (%o2)                [                    ]
                               [      1        1    ]
                               [ - -------  ------- ]
                               [   sqrt(2)  sqrt(2) ]
          (%i3) L : matrix ([sqrt(3), 0], [0, sqrt(5)]);
                                [ sqrt(3)     0    ]
          (%o3)                 [                  ]
                                [    0     sqrt(5) ]
          (%i4) M : S . L . transpose (S);
                      [ sqrt(5)   sqrt(3)  sqrt(5)   sqrt(3) ]
                      [ ------- + -------  ------- - ------- ]
                      [    2         2        2         2    ]
          (%o4)       [                                      ]
                      [ sqrt(5)   sqrt(3)  sqrt(5)   sqrt(3) ]
                      [ ------- - -------  ------- + ------- ]
                      [    2         2        2         2    ]
          (%i5) 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
          (%o5) [[1.732050807568877, 2.23606797749979],
                                  [  0.70710678118655   0.70710678118655 ]
                                  [                                      ]]
                                  [ - 0.70710678118655  0.70710678118655 ]
          (%i6) float ([[sqrt(3), sqrt(5)], S]);
          (%o6) [[1.732050807568877, 2.23606797749979],
                                  [  0.70710678118655   0.70710678118655 ]
                                  [                                      ]]
                                  [ - 0.70710678118655  0.70710678118655 ]
          (%i7) 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
          (%o7) [[1.732050807568877b0, 2.23606797749979b0],
                          [  7.071067811865475b-1   7.071067811865475b-1 ]
                          [                                              ]]
                          [ - 7.071067811865475b-1  7.071067811865475b-1 ]

 -- Função da class: 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 da class: hankel (<col>)
 -- Função da class: hankel (<col>, <lin>)

     Retorna uma matriz de Hankel <H>.  A primeira coluna de <H> é
     <col>; excepto para a primeira entrada, a última linha de <H> é
     <lin>.  O valor padrão para <lin> é o vector nulo com o mesmo
     comprimento que <col>.

 -- Função da class: 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 da class: 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 da class: identfor (<M>)
 -- Função da class: 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 da class: invert_by_lu (<M>, <(rng generalring)>)

     Inverte a matriz <M> através de factorização linear alta (LU). A
     factorização LU é concluída usando o anel <rng>.

 -- Função da class: kronecker_product (<A>, <B>)

     Retorna o produto de Kronecker das matrizes <A> e <B>.

 -- Função da class: listp (<e>, <p>)
 -- Função da class: 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 da class: 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 primeira 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 da class: 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 da class: 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 factorizaçã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 actual da factorização
     <LU> será a terceira linha da matriz <LU>.  Segundo, o factor
     triangular baixo de m é a parte triangular baixa de <LU> com as
     entradas de diagonal todas substituídas pela unidade.  Terceiro, o
     factor 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 factores 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 algoritmo 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 utilizador definida um novo anel.  Um
     utilizador que estiver familiazrizado com o Lisp Comum está apto
     para definir um novo corpo.  Para fazer isso, um utilizador 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 ficheiro ‘mring’ tem muitos
     exemplos.

     Para calcular a factorizaçã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 factorizaçã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 factorização, como
     entradas da matriz devem ser convertidas para expressões do Maxima.

     Veja também ‘get_lu_factors’.

     Exemplos:
          (%i1) load ("linearalgebra");
          Warning - you are redefining the Maxima function require_list
          Warning - you are redefining the Maxima function matrix_size
          Warning - you are redefining the Maxima function rank
          (%o1) /usr/local/share/maxima/5.9.2/share/linearalgebra/linearalgebra.mac
          (%i2) w[i,j] := random (1.0) + %i * random (1.0);
          (%o2)          w     := random(1.) + %i random(1.)
                          i, j
          (%i3) showtime : true$
          Evaluation took 0.00 seconds (0.00 elapsed)
          (%i4) M : genmatrix (w, 100, 100)$
          Evaluation took 7.40 seconds (8.23 elapsed)
          (%i5) lu_factor (M, complexfield)$
          Evaluation took 28.71 seconds (35.00 elapsed)
          (%i6) lu_factor (M, generalring)$
          Evaluation took 109.24 seconds (152.10 elapsed)
          (%i7) showtime : false$

          (%i8) M : matrix ([1 - z, 3], [3, 8 - z]);
                                  [ 1 - z    3   ]
          (%o8)                   [              ]
                                  [   3    8 - z ]
          (%i9) lu_factor (M, generalring);
                         [ 1 - z         3        ]
                         [                        ]
          (%o9)         [[   3            9       ], [1, 2]]
                         [ -----  - z - ----- + 8 ]
                         [ 1 - z        1 - z     ]
          (%i10) get_lu_factors (%);
                            [   1    0 ]  [ 1 - z         3        ]
                  [ 1  0 ]  [          ]  [                        ]
          (%o10) [[      ], [   3      ], [                9       ]]
                  [ 0  1 ]  [ -----  1 ]  [   0    - z - ----- + 8 ]
                            [ 1 - z    ]  [              1 - z     ]
          (%i11) %[1] . %[2] . %[3];
                                  [ 1 - z    3   ]
          (%o11)                  [              ]
                                  [   3    8 - z ]

 -- Função da class: mat_cond (<M>, 1)
 -- Função da class: 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 factorizaçã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 da class: mat_norm (<M>, 1)
 -- Função da class: mat_norm (<M>, inf)
 -- Função da class: 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 da class: matrixp (<e>, <p>)
 -- Função da class: 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 da class: matrix_size (<M>)

     Retorna uma lista com dois elementos que fornecem o número de
     linhas e colunas, respectivamente da matriz <M>.

 -- Função da class: 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 da class: 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 da class: 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 usar matrizes de bloco, muito provavelmente irá querer escolher
     ‘matrix_element_mult’ para ‘"."’ e ‘matrix_element_transpose’ para
     ‘'transpose’.  Veja também ‘mat_fullunblocker’.

     Exemplo:

          (%i1) load ("linearalgebra");
          Warning - you are redefining the Maxima function require_list
          Warning - you are redefining the Maxima function matrix_size
          Warning - you are redefining the Maxima function rank
          (%o1) /usr/local/share/maxima/5.9.2/share/linearalgebra/linearalgebra.mac
          (%i2) A : matrix ([1, 2], [3, 4]);
                                      [ 1  2 ]
          (%o2)                       [      ]
                                      [ 3  4 ]
          (%i3) B : matrix ([7, 8], [9, 10]);
                                      [ 7  8  ]
          (%o3)                       [       ]
                                      [ 9  10 ]
          (%i4) matrix ([A, B]);
                               [ [ 1  2 ]  [ 7  8  ] ]
          (%o4)                [ [      ]  [       ] ]
                               [ [ 3  4 ]  [ 9  10 ] ]
          (%i5) mat_unblocker (%);
                                   [ 1  2  7  8  ]
          (%o5)                    [             ]
                                   [ 3  4  9  10 ]

 -- Função da class: nonnegintegerp (<n>)

     Retorna ‘true’ se e somente se ‘<n> >= 0’ e <n> for um inteiro.

 -- Função da class: 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 da class: nullity (<M>)

     Se <M> for uma matriz, retorna a dimensão do espaço nulo de <M>.

 -- Função da class: 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 vector no intervalo de <v_1> até <v_n> deve ser um vector
     coluna.

 -- Função da class: polynomialp (<p>, <L>, <coeffp>, <exponp>)
 -- Função da class: polynomialp (<p>, <L>, <coeffp>)
 -- Função da class: 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 quiser usar um
     valor personalizado para <exponp>, deverá fornecer <coeffp> com um
     valor mesmo se 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) load ("linearalgebra");
          Warning - you are redefining the Maxima function require_list
          Warning - you are redefining the Maxima function matrix_size
          Warning - you are redefining the Maxima function rank
          (%o1) /usr/local/share/maxima/5.9.2/share/linearalgebra/linearalgebra.mac
          (%i2) polynomialp ((x + 1)*(x + 2), [x]);
          (%o2)                         true
          (%i3) polynomialp ((x + 1)*(x + 2)^a, [x]);
          (%o3)                         false

     Um exemplo usando um valor personalizado para ‘coeffp’ e para
     ‘exponp’:

          (%i1) load ("linearalgebra");
          Warning - you are redefining the Maxima function require_list
          Warning - you are redefining the Maxima function matrix_size
          Warning - you are redefining the Maxima function rank
          (%o1) /usr/local/share/maxima/5.9.2/share/linearalgebra/linearalgebra.mac
          (%i2) polynomialp ((x + 1)*(x + 2)^(3/2), [x], numberp, numberp);
          (%o2)                         true
          (%i3) polynomialp ((x^(1/2) + 1)*(x + 2)^(3/2), [x], numberp, numberp);
          (%o3)                         true

     Polinómios com duas variáveis:

          (%i1) load ("linearalgebra");
          Warning - you are redefining the Maxima function require_list
          Warning - you are redefining the Maxima function matrix_size
          Warning - you are redefining the Maxima function rank
          (%o1) /usr/local/share/maxima/5.9.2/share/linearalgebra/linearalgebra.mac
          (%i2) polynomialp (x^2 + 5*x*y + y^2, [x]);
          (%o2)                         false
          (%i3) polynomialp (x^2 + 5*x*y + y^2, [x, y]);
          (%o3)                         true

 -- Função da class: 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 da class: 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 da class: 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 da class: rank (<M>)

     Retorna o ranque daquela matriz <M>.  O rank é a dimensão do espaço
     coluna.  Exemplo:
          (%i1) load ("linearalgebra")$
          WARNING: DEFUN/DEFMACRO: redefining function $COPY in
                   /share/maxima/5.11.0/share/linearalgebra/linalg-utilities.lisp,
                   was defined in
                   /maxima-5.11.0/src/binary-clisp/comm2.fas
          (%i2) rank(matrix([1,2],[2,4]));
          (%o2)                                  1
          (%i3) rank(matrix([1,b],[c,d]));
          Proviso:  {d - b c # 0}
          (%o3)                                  2

 -- Função da class: 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 da class: toeplitz (<col>)
 -- Função da class: toeplitz (<col>, <lin>)

     Retorna uma matriz de Toeplitz <T>.  a primeira coluna de <T> é
     <col>; excepto para a primeira entrada, a primeira linha de <T> é
     <lin>.  O padrão para <lin> é o conjugado complexo de <col>.
     Exemplo:
          (%i1) load("linearalgebra")$

          (%i2)  toeplitz([1,2,3],[x,y,z]);

                                            [ 1  y  z ]
                                            [         ]
          (%o2)                             [ 2  1  y ]
                                            [         ]
                                            [ 3  2  1 ]
          (%i3)  toeplitz([1,1+%i]);

                                        [   1     1 - %I ]
          (%o3)                         [                ]
                                        [ %I + 1    1    ]

 -- Função da class: 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 da class: zerofor (<M>)
 -- Função da class: 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 da class: 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>.

