[ < ] | [ > ] |  | [ << ] | [ Up ] | [ >> ] |  |  |  |  | [Top] | [Contents] | [Índice] | [ ? ]

# 46. distrib

[ < ] | [ > ] |  | [ << ] | [ Up ] | [ >> ] |  |  |  |  | [Top] | [Contents] | [Índice] | [ ? ]

## 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'.

[ < ] | [ > ] |  | [ << ] | [ Up ] | [ >> ] |  |  |  |  | [Top] | [Contents] | [Índice] | [ ? ]

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

Função: pdf_normal (x,m,s)

  Retorna o valor em x da função densidade de probabilidade de uma variável aleatória Normal(m,s), com s>0. Para fazer uso dessa função, escreva primeiramente `load(distrib)`.

Função: cdf_normal (x,m,s)

  Retorna o valor em x da função distribuição de probabilidade de uma variável aleatória Normal(m,s), com s>0. Essa função é definida em termos de funções de erro internas do Maxima, `erf`.

      (%i1) load (distrib)$
      (%i2) assume(s>0)$ cdf_normal(x,m,s);
                                   x - m
                             erf(---------)
                                 sqrt(2) s    1
      (%o3)                  -------------- + -
                                   2          2

  Veja também `erf`.

Função: quantile_normal (q,m,s)

  Retorna o q-quantil de uma variável aleatória Normal(m,s), com s>0; em outras palavras, isso é o inverso de `cdf_normal`. O argumento q deve ser um elemento de [0,1]. Para fazer uso dessa função, escreva primeiramente `load(distrib)`.

Função: mean_normal (m,s)

  Retorna a média de uma variável aleatória Normal(m,s), com s>0, a saber m. Para fazer uso dessa função, escreva primeiramente `load(distrib)`.

Função: var_normal (m,s)

  Retorna a variância de uma variável aleatória Normal(m,s), com s>0, a saber s^2. Para fazer uso dessa função, escreva primeiramente `load(distrib)`.

Função: std_normal (m,s)

  Retorna o desvio padrão de uma variável aleatória Normal(m,s), com s>0, a saber s. Para fazer uso dessa função, escreva primeiramente `load(distrib)`.

Função: skewness_normal (m,s)

  Retorna o coeficiente de assimetria de uma variável aleatória Normal(m,s), com s>0, que é sempre igual a 0. Para fazer uso dessa função,escreva primeiramente `load(distrib)`.

Função: kurtosis_normal (m,s)

  Retorna o coeficiente de curtose de uma variável aleatória Normal(m,s), com s>0, que é sempre igual a 0. Para fazer uso dessa função, escreva primeiramente `load(distrib)`.

Variável de opção: random_normal_algorithm

  Valor 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: random_normal (m,s)
Função: random_normal (m,s,n)

  Retorna uma variável estatística pseudo-aleatória Normal(m,s), com s>0. Chamando `random_normal` com um terceiro argumento n, uma amostra aleatória de tamanho n será simulada.

  Existem dois 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: pdf_student_t (x,n)

  Retorna o valor em x da função densidade de probabilidade de uma variável aleatória de Student t(n), com n>0. Para fazer uso dessa função, escreva primeiramente `load(distrib)`.

Função: cdf_student_t (x,n)

  Retorna o valor em x da função distribuição de probabilidade de uma variável aleatória de Student t(n), com n>0. Essa função não tem uma forma definitiva e é calculada numericamente se a variável global `numer` for igual a `true`, de outra froma `cdf_student_t` retorna uma expressão nominal.

      (%i1) load (distrib)$
      (%i2) cdf_student_t(1/2, 7/3);
                                           1  7
      (%o2)                  cdf_student_t(-, -)
                                           2  3
      (%i3) %,numer;
      (%o3)                   .6698450596140417

Função: quantile_student_t (q,n)

  Retorna o q-quantil de uma variável aleatória de Student t(n), com n>0; em outras palavras, `quantile_student_t` é o inverso de `cdf_student_t`. O argumento q deve ser um elemento de [0,1]. Para fazer uso dessa função, escreva primeiramente `load(distrib)`.

Função: mean_student_t (n)

  Retorna a média de uma variável aleatória de Student t(n), com n>0, que é sempre igual a 0. Para fazer uso dessa função, escreva primeiramente `load(distrib)`.

Função: var_student_t (n)

  Retorna a variância de uma variável aleatória de Student t(n), com n>2.

      (%i1) load (distrib)$
      (%i2) assume(n>2)$  var_student_t(n);
                                      n
      (%o3)                         -----
                                    n - 2

Função: std_student_t (n)

  Retorna o desvio padrão de uma variável aleatória de Student t(n), com n>2. Para fazer uso dessa função, escreva primeiramente `load(distrib)`.

Função: skewness_student_t (n)

  Retorna o coeficiente de assimetria de uma variável aleatória de Student t(n), com n>3, que é sempre igual a 0. Para fazer uso dessa função, escreva primeiramente `load(distrib)`.

Função: kurtosis_student_t (n)

  Retorna o coeficiente de curtose de uma variável aleatória de Student t(n), com n>4. Para fazer uso dessa função, escreva primeiramente `load(distrib)`.

Variável de opção: random_student_t_algorithm

  Valor 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: random_student_t (n)
Função: random_student_t (n,m)

  Retorna uma variável estatística pseudo-aleatória de Student t(n), com n>0. Chamando `random_student_t` com um segundo argumento m, uma amostra aleatória de tamanho m será simulada.

  Existem dois 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: pdf_chi2 (x,n)

  Retorna o valor em x da função densidade de probabilidade de uma variável aleatória Chi-quadrada Chi^2(n), com n>0.

  A variável aleatória Chi^2(n) é equivalente a Gamma(n/2,2), portanto quando Maxima não tiver informação para pegar o resultado, uma forma nomial baseada na função de densidade densidade de probabilidade da função gama é retornada.

      (%i1) load (distrib)$
      (%i2) pdf_chi2(x,n);
                                          n
      (%o2)                  pdf_gamma(x, -, 2)
                                          2
      (%i3) assume(x>0, n>0)$  pdf_chi2(x,n);
                               n/2 - 1   - x/2
                              x        %e
      (%o4)                   ----------------
                                n/2       n
                               2    gamma(-)
                                          2

Função: cdf_chi2 (x,n)

  Retorna o valor em x da função distribuição de probabilidade de uma variável aleatória Chi-quadrada Chi^2(n), com n>0.

  Essa função não possui uma forma fechada e é calculada numericamante se a variável global `numer` for igual a `true`, de outra forma essa função retorna uma expressão nominal baseada na distribuição gama, uma vez que a variável aleatória Chi^2(n) é equivalente a é equivalente a Gamma(n/2,2).

      (%i1) load (distrib)$
      (%i2) cdf_chi2(3,4);
      (%o2)                  cdf_gamma(3, 2, 2)
      (%i3) cdf_chi2(3,4),numer;
      (%o3)                   .4421745996289249

Função: quantile_chi2 (q,n)

  Retorna o q-quantilede uma variável aleatória Chi-quadrada Chi^2(n), com n>0; em outras palavras, essa função é a inversa da função `cdf_chi2`. O argumento q deve ser um elemento de [0,1].

  This função não possui uma forma fechada e é calculada numericamante se a variável global `numer` for igual a `true`, de outra forma essa função retorna uma expressão nominal baseada no quantil da função gama, uma vez que a variável aleatória Chi^2(n) é equivalente a Gamma(n/2,2).

      (%i1) load (distrib)$
      (%i2) quantile_chi2(0.99,9);
      (%o2)                   21.66599433346194
      (%i3) quantile_chi2(0.99,n);
                                              n
      (%o3)              quantile_gamma(0.99, -, 2)
                                              2

Função: mean_chi2 (n)

  Retorna a média de uma variável aleatória Chi-quadrada Chi^2(n), com n>0.

  A variável aleatória Chi^2(n) é equivalente a Gamma(n/2,2), embora quando Maxima não tiver informação disponível para pegar o resultado, uma forma nominal baseada na média da função gama é retornada.

      (%i1) load (distrib)$
      (%i2) mean_chi2(n);
                                         n
      (%o2)                   mean_gamma(-, 2)
                                         2
      (%i3) assume(n>0)$ mean_chi2(n);
      (%o4)                           n

Função: var_chi2 (n)

  Retorna a variância de uma variável aleatória Chi-quadrada Chi^2(n), com n>0.

  A variável aleatória Chi^2(n) é equivalente a Gamma(n/2,2), embora quando Maxima não tiver informação disponível para pegar o resultado, uma forma nominal baseada na variância da função gama é retornada.

      (%i1) load (distrib)$
      (%i2) var_chi2(n);
                                         n
      (%o2)                    var_gamma(-, 2)
                                         2
      (%i3) assume(n>0)$ var_chi2(n);
      (%o4)                          2 n

Função: std_chi2 (n)

  Retorna o desvio padrão de uma variável aleatória Chi-quadrada Chi^2(n), com n>0.

  A variável aleatória Chi^2(n) é equivalente a Gamma(n/2,2), embora quando Maxima não tiver informação disponível para pegar o resultado, uma forma nominal baseada no desvio padrão da função gama é retornada.

      (%i1) load (distrib)$
      (%i2) std_chi2(n);
                                         n
      (%o2)                    std_gamma(-, 2)
                                         2
      (%i3) assume(n>0)$ std_chi2(n);
      (%o4)                    sqrt(2) sqrt(n)

Função: skewness_chi2 (n)

  Retorna o coeficiente de assimetria de uma variável aleatória Chi-quadrada Chi^2(n), com n>0.

  A variável aleatória Chi^2(n) é equivalente a Gamma(n/2,2), embora quando Maxima não tiver informação disponível para pegar o resultado, uma forma nominal baseada no coeficiente de assimetria da função gama é retornada.

      (%i1) load (distrib)$
      (%i2) skewness_chi2(n);
                                           n
      (%o2)                 skewness_gamma(-, 2)
                                           2
      (%i3) assume(n>0)$ skewness_chi2(n);
                                  2 sqrt(2)
      (%o4)                       ---------
                                   sqrt(n)

Função: kurtosis_chi2 (n)

  Retorna o coeficiente de curtose de uma variável aleatória Chi-quadrada Chi^2(n), com n>0.

  A variável aleatória Chi^2(n) é equivalente a Gamma(n/2,2), embora quando Maxima não tiver informação disponível para pegar o resultado, uma forma nominal baseada no coeficiente de curtose da função gama é retornada.

      (%i1) load (distrib)$
      (%i2) kurtosis_chi2(n);
                                           n
      (%o2)                 kurtosis_gamma(-, 2)
                                           2
      (%i3) assume(n>0)$ kurtosis_chi2(n);
                                     12
      (%o4)                          --
                                     n

Variável de opção: random_chi2_algorithm

  Valor 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: random_chi2 (n)
Função: random_chi2 (n,m)

  Retorna uma variável estatística pseudo-aleatória Chi-square Chi^2(n), com n>0. Chamando `random_chi2` com um segundo argumento m, uma amostra aleatória de tamanho m será simulada.

  Existem dois 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: pdf_f (x,m,n)

  Retorna o valor em x da função densidade de probabilidade de uma variável aleatória F, F(m,n), com m,n>0. Para fazer uso dessa função, escreva primeiramente `load(distrib)`.

Função: cdf_f (x,m,n)

  Retorna o valor em x da função distribuição de probabilidade de uma variável aleatória F, F(m,n), com m,n>0. Essa função não possui uma forma definitiva e é calculada numericamente se a variável global `numer` for igual a `true`, de outra forma retorna uma expressão nominal.

      (%i1) load (distrib)$
      (%i2) cdf_f(2,3,9/4);
                                           9
      (%o2)                    cdf_f(2, 3, -)
                                           4
      (%i3) %,numer;
      (%o3)                   0.66756728179008

Função: quantile_f (q,m,n)

  Retorna o q-quantil de uma variável aleatória F, F(m,n), com m,n>0; em outras palavras, essa função é o inverso de `cdf_f`. O argumento q deve ser um elemento de [0,1].

  Essa função não possui uma forma fechada e é calculada numericamante se a variável global `numer` for igual a `true`, de outra forma essa função retorna uma expressão nominal.

      (%i1) load (distrib)$
      (%i2) quantile_f(2/5,sqrt(3),5);
                                     2
      (%o2)               quantile_f(-, sqrt(3), 5)
                                     5
      (%i3) %,numer;
      (%o3)                   0.518947838573693

Função: mean_f (m,n)

  Retorna a média de uma variável aleatória F, F(m,n), com m>0, n>2. Para fazer uso dessa função, escreva primeiramente `load(distrib)`.

Função: var_f (m,n)

  Retorna a variância de uma variável aleatória F, F(m,n), com m>0, n>4. Para fazer uso dessa função, escreva primeiramente `load(distrib)`.

Função: std_f (m,n)

  Retorna o desvio padrão de uma variável aleatória F, F(m,n), com m>0, n>4. Para fazer uso dessa função, escreva primeiramente `load(distrib)`.

Função: skewness_f (m,n)

  Retorna o coeficiente de assimetria de uma variável aleatória F, F(m,n), com m>0, n>6. Para fazer uso dessa função, escreva primeiramente `load(distrib)`.

Função: kurtosis_f (m,n)

  Retorna o coeficiente de curtose de uma variável aleatória F, F(m,n), com m>0, n>8. Para fazer uso dessa função, escreva primeiramente `load(distrib)`.

Variável de opção: random_f_algorithm

  Valor 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: random_f (m,n)
Função: random_f (m,n,k)

  Retorna uma variável estatística pseudo-aleatória F, F(m,n), com m,n>0. Chamando `random_f` com um terceiro argumento k, uma amostra aleatória de tamanho k será simulada.

  Existem dois 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: pdf_exp (x,m)

  Retorna o valor em x da função densidade de probabilidade variável aleatória Exponential(m), com m>0.

  A variável aleatória Exponential(m) é equivalente a Weibull(1,1/m), embora quando Maxima não tiver informação disponível para pegar o resultado, uma forma nominal baseada na função de densidade de probabilidade de Weibull éretornada.

      (%i1) load (distrib)$
      (%i2) pdf_exp(x,m);
                                              1
      (%o2)                 pdf_weibull(x, 1, -)
                                              m
      (%i3) assume(x>0,m>0)$  pdf_exp(x,m);
                                      - m x
      (%o4)                       m %e

Função: cdf_exp (x,m)

  Retorna o valor em x da função distribuição de probabilidade variável aleatória Exponential(m), com m>0.

  A variável aleatória Exponential(m) é equivalente a Weibull(1,1/m), embora quando Maxima não tiver informação disponível para pegar o resultado, uma forma nominal baseada na distribuição de Weibull é retornada.

      (%i1) load (distrib)$
      (%i2) cdf_exp(x,m);
                                              1
      (%o2)                 cdf_weibull(x, 1, -)
                                              m
      (%i3) assume(x>0,m>0)$  cdf_exp(x,m);
                                       - m x
      (%o4)                      1 - %e

Função: quantile_exp (q,m)

  Retorna o q-quantil variável aleatória Exponential(m), com m>0; em outras palavras, essa função é inversa da função `cdf_exp`. O argumento q deve ser um elemento de [0,1].

  A variável aleatória Exponential(m) é equivalente a Weibull(1,1/m), embora quando Maxima não tiver informação disponível para pegar o resultado, uma forma nominal baseada no qualtil de Weibull é retornada.

      (%i1) load (distrib)$
      (%i2) quantile_exp(0.56,5);
      (%o2)                   .1641961104139661
      (%i3) quantile_exp(0.56,m);
                                                  1
      (%o3)             quantile_weibull(0.56, 1, -)
                                                  m

Função: mean_exp (m)

  Retorna a média de uma variável aleatória Exponential(m), com m>0.

  A variável aleatória Exponential(m) é equivalente a Weibull(1,1/m), embora quando Maxima não tiver informação disponível para pegar o resultado, uma forma nominal baseada na média de Weibull é reornada.

      (%i1) load (distrib)$
      (%i2) mean_exp(m);
                                             1
      (%o2)                  mean_weibull(1, -)
                                             m
      (%i3) assume(m>0)$  mean_exp(m);
                                      1
      (%o4)                           -
                                      m

Função: var_exp (m)

  Retorna a variância de uma variável aleatória Exponential(m), com m>0.

  A variável aleatória Exponential(m) é equivalente a Weibull(1,1/m), embora quando Maxima não tiver informação disponível para pegar o resultado, uma forma nominal baseada na variância de Weibull é retornada.

      (%i1) load (distrib)$
      (%i2) var_exp(m);
                                             1
      (%o2)                   var_weibull(1, -)
                                             m
      (%i3) assume(m>0)$  var_exp(m);
                                     1
      (%o4)                          --
                                      2
                                     m

Função: std_exp (m)

  Retorna o desvio padrão de uma variável aleatória Exponential(m), com m>0.

  A variável aleatória Exponential(m) é equivalente a Weibull(1,1/m), embora quando Maxima não tiver informação disponível para pegar o resultado, uma forma nominal baseada no desvio padrão de Weibull é retornada.

      (%i1) load (distrib)$
      (%i2) std_exp(m);
                                             1
      (%o2)                   std_weibull(1, -)
                                             m
      (%i3) assume(m>0)$  std_exp(m);
                                      1
      (%o4)                           -
                                      m

Função: skewness_exp (m)

  Retorna o coeficiente de assimetria de uma variável aleatória Exponential(m), com m>0.

  A variável aleatória Exponential(m) é equivalente a Weibull(1,1/m), embora quando Maxima não tiver informação disponível para pegar o resultado, uma forma nominal baseada no coeficiente de assimetria de Weibull é retornada.

      (%i1) load (distrib)$
      (%i2) skewness_exp(m);
                                               1
      (%o2)                skewness_weibull(1, -)
                                               m
      (%i3) assume(m>0)$  skewness_exp(m);
      (%o4)                           2

Função: kurtosis_exp (m)

  Retorna o coeficiente de curtose de uma variável aleatória Exponential(m), com m>0.

  A variável aleatória Exponential(m) é equivalente a Weibull(1,1/m), embora quando Maxima não tiver informação disponível para pegar o resultado, uma forma nominal baseada no coeficiente de curtose de Weibull é retornada.

      (%i1) load (distrib)$
      (%i2) kurtosis_exp(m);
                                               1
      (%o2)                kurtosis_weibull(1, -)
                                               m
      (%i3) assume(m>0)$  kurtosis_exp(m);
      (%o4)                           6

Variável de opção: random_exp_algorithm

  Valor 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: random_exp (m)
Função: random_exp (m,k)

  Retorna uma variável estatística pseudo-aleatória Exponential(m), com m>0. Chamando `random_exp` com um segundo argumento k, uma amostra aleatória de tamanho k será simulada.

  Existem três 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: pdf_lognormal (x,m,s)

  Retorna o valor em x da função densidade de probabilidade de uma variável aleatória Lognormal(m,s), com s>0. Para fazer uso dessa função, escreva primeiramente `load(distrib)`.

Função: cdf_lognormal (x,m,s)

  Retorna o valor em x da função distribuição de probabilidade de uma variável aleatória Lognormal(m,s), com s>0. Essa função é definida em termos de funções `erf`de erro internas do Maxima.

      (%i1) load (distrib)$
      (%i2) assume(x>0, s>0)$  cdf_lognormal(x,m,s);
                                 log(x) - m
                             erf(----------)
                                 sqrt(2) s     1
      (%o3)                  --------------- + -
                                    2          2

  Veja também `erf`.

Função: quantile_lognormal (q,m,s)

  Retorna o q-quantil de uma variável aleatória Lognormal(m,s), com s>0; em outras palavras, essa função é a inversa da função `cdf_lognormal`. O argumento q deve ser um elemento de [0,1]. Para fazer uso dessa função, escreva primeiramente `load(distrib)`.

Função: mean_lognormal (m,s)

  Retorna a média de uma variável aleatória Lognormal(m,s), com s>0. Para fazer uso dessa função, escreva primeiramente `load(distrib)`.

Função: var_lognormal (m,s)

  Retorna a variância de uma variável aleatória Lognormal(m,s), com s>0. Para fazer uso dessa função, escreva primeiramente `load(distrib)`.

Função: std_lognormal (m,s)

  Retorna o desvio padrão de uma variável aleatória Lognormal(m,s), com s>0. Para fazer uso dessa função, escreva primeiramente `load(distrib)`.

Função: skewness_lognormal (m,s)

  Retorna o coeficiente de assimetria de uma variável aleatória Lognormal(m,s), com s>0. Para fazer uso dessa função, escreva primeiramente `load(distrib)`.

Função: kurtosis_lognormal (m,s)

  Retorna o coeficiente de curtose de uma variável aleatória Lognormal(m,s), com s>0. Para fazer uso dessa função, escreva primeiramente `load(distrib)`.

Função: random_lognormal (m,s)
Função: random_lognormal (m,s,n)

  Retorna uma variável estatística pseudo-aleatória Lognormal(m,s), com s>0. Chamando `random_lognormal` com um terceiro argumento n, uma amostra aleatória de tamanho n será simulada.

  Variáveis Log-normal são simuladas por meio de variáveis estatísticas normais pseudo-aleatórias. Existem dois 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: pdf_gamma (x,a,b)

  Retorna o valor em x da função densidade de probabilidade de uma variável aleatória Gamma(a,b), com a,b>0. Para fazer uso dessa função, escreva primeiramente `load(distrib)`.

Função: cdf_gamma (x,a,b)

  Retorna o valor em x da função distribuição de probabilidade de uma variável aleatória Gamma(a,b), com a,b>0.

  Essa função não possui uma forma fechada e é calculada numericamante se a variável global `numer` for igual a `true`, de outra forma essa função retorna uma expressão nominal.

      (%i1) load (distrib)$
      (%i2) cdf_gamma(3,5,21);
      (%o2)                  cdf_gamma(3, 5, 21)
      (%i3) %,numer;
      (%o3)                 4.402663157135039E-7

Função: quantile_gamma (q,a,b)

  Retorna o q-quantil de uma variável aleatória Gamma(a,b), com a,b>0; em outras palavras, essa função é a inversa da função `cdf_gamma`. O argumento q deve ser um elemento de [0,1]. Para fazer uso dessa função, escreva primeiramente `load(distrib)`.

Função: mean_gamma (a,b)

  Retorna a média de uma variável aleatória Gamma(a,b), com a,b>0. Para fazer uso dessa função, escreva primeiramente `load(distrib)`.

Função: var_gamma (a,b)

  Retorna a variância de uma variável aleatória Gamma(a,b), com a,b>0. Para fazer uso dessa função, escreva primeiramente `load(distrib)`.

Função: std_gamma (a,b)

  Retorna o desvio padrão de uma variável aleatória Gamma(a,b), com a,b>0. Para fazer uso dessa função, escreva primeiramente `load(distrib)`.

Função: skewness_gamma (a,b)

  Retorna o coeficiente de assimetria de uma variável aleatória Gamma(a,b), com a,b>0. Para fazer uso dessa função, escreva primeiramente `load(distrib)`.

Função: kurtosis_gamma (a,b)

  Retorna o coeficiente de curtose de uma variável aleatória Gamma(a,b), com a,b>0. Para fazer uso dessa função, escreva primeiramente `load(distrib)`.

Variável de opção: random_gamma_algorithm

  Valor 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: random_gamma (a,b)
Função: random_gamma (a,b,n)

  Retorna uma variável estatística pseudo-aleatória Gamma(a,b), com a,b>0. Chamando `random_gamma` com um terceiro argumento n, uma amostra aleatória de tamanho n será simulada.

  Existem dois 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: pdf_beta (x,a,b)

  Retorna o valor em x da função densidade de probabilidade de uma variável aleatória Beta(a,b), com a,b>0. Para fazer uso dessa função, escreva primeiramente `load(distrib)`.

Função: cdf_beta (x,a,b)

  Retorna o valor em x da função distribuição de probabilidade de uma variável aleatória Beta(a,b), com a,b>0.

  Essa função não possui uma forma fechada e é calculada numericamante se a variável global `numer` for igual a `true`, de outra forma essa função retorna uma expressão nominal.

      (%i1) load (distrib)$
      (%i2) cdf_beta(1/3,15,2);
                                       1
      (%o2)                   cdf_beta(-, 15, 2)
                                       3
      (%i3) %,numer;
      (%o3)                 7.666089131388224E-7

Função: quantile_beta (q,a,b)

  Retorna o q-quantil de uma variável aleatória Beta(a,b), com a,b>0; em outras palavras, essa função é a inversa da função `cdf_beta`. O argumento q deve ser um elemento de [0,1]. Para fazer uso dessa função, escreva primeiramente `load(distrib)`.

Função: mean_beta (a,b)

  Retorna a média de uma variável aleatória Beta(a,b), com a,b>0. Para fazer uso dessa função, escreva primeiramente `load(distrib)`.

Função: var_beta (a,b)

  Retorna a variância de uma variável aleatória Beta(a,b), com a,b>0. Para fazer uso dessa função, escreva primeiramente `load(distrib)`.

Função: std_beta (a,b)

  Retorna o desvio padrão de uma variável aleatória Beta(a,b), com a,b>0. Para fazer uso dessa função, escreva primeiramente `load(distrib)`.

Função: skewness_beta (a,b)

  Retorna o coeficiente de assimetria de uma variável aleatória Beta(a,b), com a,b>0. Para fazer uso dessa função, escreva primeiramente `load(distrib)`.

Função: kurtosis_beta (a,b)

  Retorna o coeficiente de curtose de uma variável aleatória Beta(a,b), com a,b>0. Para fazer uso dessa função, escreva primeiramente `load(distrib)`.

Variável de opção: random_beta_algorithm

  Valor 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: random_beta (a,b)
Função: random_beta (a,b,n)

  Retorna uma variável estatística pseudo-aleatória Beta(a,b), com a,b>0. Chamando `random_beta` com um terceiro argumento n, uma amostra aleatória de tamanho n será simulada.

  Existem três 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: pdf_continuous_uniform (x,a,b)

  Retorna o valor em x da função densidade de probabilidade de uma variável aleatória Continuous Uniform(a,b), com a<b. Para fazer uso dessa função, escreva primeiramente `load(distrib)`.

Função: cdf_continuous_uniform (x,a,b)

  Retorna o valor em x da função distribuição de probabilidade de uma variável aleatória Continuous Uniform(a,b), com a<b. Para fazer uso dessa função, escreva primeiramente `load(distrib)`.

Função: quantile_continuous_uniform (q,a,b)

  Retorna o q-quantil de uma variável aleatória Continuous Uniform(a,b), com a<b; em outras palavras, essa função é a inversa da função `cdf_continuous_uniform`. O argumento q deve ser um elemento de [0,1]. Para fazer uso dessa função, escreva primeiramente `load(distrib)`.

Função: mean_continuous_uniform (a,b)

  Retorna a média de uma variável aleatória Continuous Uniform(a,b), com a<b. Para fazer uso dessa função, escreva primeiramente `load(distrib)`.

Função: var_continuous_uniform (a,b)

  Retorna a variância de uma variável aleatória Continuous Uniform(a,b), com a<b. Para fazer uso dessa função, escreva primeiramente `load(distrib)`.

Função: std_continuous_uniform (a,b)

  Retorna o desvio padrão de uma variável aleatória Continuous Uniform(a,b), com a<b. Para fazer uso dessa função, escreva primeiramente `load(distrib)`.

Função: skewness_continuous_uniform (a,b)

  Retorna o coeficiente de assimetria de uma variável aleatória Continuous Uniform(a,b), com a<b. Para fazer uso dessa função, escreva primeiramente `load(distrib)`.

Função: kurtosis_continuous_uniform (a,b)

  Retorna o coeficiente de curtose de uma variável aleatória Continuous Uniform(a,b), com a<b. Para fazer uso dessa função, escreva primeiramente `load(distrib)`.

Função: random_continuous_uniform (a,b)
Função: random_continuous_uniform (a,b,n)

  Retorna uma variável estatística pseudo-aleatória Continuous Uniform(a,b), com a<b. Chamando `random_continuous_uniform` com um terceiro argumento n, uma amostra aleatória de tamanho n será simulada.

  Essa é uma aplicação directa da função `random` interna do Maxima.

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

Função: pdf_logistic (x,a,b)

  Retorna o valor em x da função densidade de probabilidade de uma variável aleatória Logistic(a,b) , com b>0. Para fazer uso dessa função, escreva primeiramente `load(distrib)`.

Função: cdf_logistic (x,a,b)

  Retorna o valor em x da função distribuição de probabilidade de uma variável aleatória Logistic(a,b), com b>0. Para fazer uso dessa função, escreva primeiramente `load(distrib)`.

Função: quantile_logistic (q,a,b)

  Retorna o q-quantil de uma variável aleatória Logistic(a,b) , com b>0; em outras palavras, essa função é a inversa da função `cdf_logistic`. O argumento q deve ser um elemento de [0,1]. Para fazer uso dessa função, escreva primeiramente `load(distrib)`.

Função: meanlog (a,b)

  Retorna a média de uma Logistic(a,b) variável aleatória , com b>0. Para fazer uso dessa função, escreva primeiramente `load(distrib)`.

Função: var_logistic (a,b)

  Retorna a variância de uma variável aleatória Logistic(a,b) , com b>0. Para fazer uso dessa função, escreva primeiramente `load(distrib)`.

Função: std_logistic (a,b)

  Retorna o desvio padrão de uma variável aleatória Logistic(a,b) , com b>0. Para fazer uso dessa função, escreva primeiramente `load(distrib)`.

Função: skewness_logistic (a,b)

  Retorna o coeficiente de assimetria de uma variável aleatória Logistic(a,b) , com b>0. Para fazer uso dessa função, escreva primeiramente `load(distrib)`.

Função: kurtosis_logistic (a,b)

  Retorna o coeficiente de curtose de uma variável aleatória Logistic(a,b) , com b>0. Para fazer uso dessa função, escreva primeiramente `load(distrib)`.

Função: random_logistic (a,b)
Função: random_logistic (a,b,n)

  Retorna uma variável estatística pseudo-aleatória Logistic(a,b), com b>0. Chamando `random_logistic` com um terceiro argumento n, uma amostra aleatória de tamanho n será simulada.

  Somente o método inverso genérico está implementado. Para fazer uso dessa função, escreva primeiramente `load(distrib)`.

Função: pdf_pareto (x,a,b)

  Retorna o valor em x da função densidade de probabilidade de uma variável aleatória Pareto(a,b), com a,b>0. Para fazer uso dessa função, escreva primeiramente `load(distrib)`.

Função: cdf_pareto (x,a,b)

  Retorna o valor em x da função distribuição de probabilidade de uma variável aleatória Pareto(a,b), com a,b>0. Para fazer uso dessa função, escreva primeiramente `load(distrib)`.

Função: quantile_pareto (q,a,b)

  Retorna o q-quantile de uma variável aleatória Pareto(a,b), com a,b>0; em outras palavras, essa função é a inversa da função `cdf_pareto`. O argumento q deve ser um elemento de [0,1]. Para fazer uso dessa função, escreva primeiramente `load(distrib)`.

Função: mean_pareto (a,b)

  Retorna a média de uma variável aleatória Pareto(a,b), com a>1,b>0. Para fazer uso dessa função, escreva primeiramente `load(distrib)`.

Função: var_pareto (a,b)

  Retorna a variância de uma variável aleatória Pareto(a,b), com a>2,b>0. Para fazer uso dessa função, escreva primeiramente `load(distrib)`.

Função: std_pareto (a,b)

  Retorna o desvio padrão de uma variável aleatória Pareto(a,b), com a>2,b>0. Para fazer uso dessa função, escreva primeiramente `load(distrib)`.

Função: skewness_pareto (a,b)

  Retorna o coeficiente de assimetria de uma variável aleatória Pareto(a,b), com a>3,b>0. Para fazer uso dessa função, escreva primeiramente `load(distrib)`.

Função: kurtosis_pareto (a,b)

  Retorna o coeficiente de curtose de uma variável aleatória Pareto(a,b), com a>4,b>0. Para fazer uso dessa função, escreva primeiramente `load(distrib)`.

Função: random_pareto (a,b)
Função: random_pareto (a,b,n)

  Retorna uma variável estatística pseudo-aleatória Pareto(a,b), com a>0,b>0. Chamando `random_pareto` com um terceiro argumento n, uma amostra aleatória de tamanho n será simulada.

  Somente o método inverso genérico está implementado. Para fazer uso dessa função, escreva primeiramente `load(distrib)`.

Função: pdf_weibull (x,a,b)

  Retorna o valor em x da função densidade de probabilidade de uma variável aleatória Weibull(a,b), com a,b>0. Para fazer uso dessa função, escreva primeiramente `load(distrib)`.

Função: cdf_weibull (x,a,b)

  Retorna o valor em x da função distribuição de probabilidade de uma variável aleatória Weibull(a,b), com a,b>0. Para fazer uso dessa função, escreva primeiramente `load(distrib)`.

Função: quantile_weibull (q,a,b)

  Retorna o q-quantil de uma variável aleatória Weibull(a,b), com a,b>0; em outras palavras, essa função é a inversa da função `cdf_weibull`. O argumento q deve ser um elemento de [0,1]. Para fazer uso dessa função, escreva primeiramente `load(distrib)`.

Função: mean_weibull (a,b)

  Retorna a média de uma variável aleatória Weibull(a,b), com a,b>0. Para fazer uso dessa função, escreva primeiramente `load(distrib)`.

Função: var_weibull (a,b)

  Retorna a variância de uma variável aleatória Weibull(a,b), com a,b>0. Para fazer uso dessa função, escreva primeiramente `load(distrib)`.

Função: std_weibull (a,b)

  Retorna o desvio padrão de uma variável aleatória Weibull(a,b), com a,b>0. Para fazer uso dessa função, escreva primeiramente `load(distrib)`.

Função: skewness_weibull (a,b)

  Retorna o coeficiente de assimetria de uma variável aleatória Weibull(a,b), com a,b>0. Para fazer uso dessa função, escreva primeiramente `load(distrib)`.

Função: kurtosis_weibull (a,b)

  Retorna o coeficiente de curtose de uma variável aleatória Weibull(a,b), com a,b>0. Para fazer uso dessa função, escreva primeiramente `load(distrib)`.

Função: random_weibull (a,b)
Função: random_weibull (a,b,n)

  Retorna uma variável estatística pseudo-aleatória Weibull(a,b), com a,b>0. Chamando `random_weibull` com um terceiro argumento n, uma amostra aleatória de tamanho n será simulada.

  Somente o método inverso genérico está implementado. Para fazer uso dessa função, escreva primeiramente `load(distrib)`.

Função: pdf_rayleigh (x,b)

  Retorna o valor em x da função densidade de probabilidade de uma variável aleatória Rayleigh(b), com b>0.

  A variável aleatória Rayleigh(b) é equivalente a Weibull(2,1/b), embora quando Maxima não tiver informação disponível para pegar o resultado, uma forma nominal baseada na função densidade de probabilidade de Weibull é retornada.

      (%i1) load (distrib)$
      (%i2) pdf_rayleigh(x,b);
                                              1
      (%o2)                 pdf_weibull(x, 2, -)
                                              b
      (%i3) assume(x>0,b>0)$ pdf_rayleigh(x,b);
                                          2  2
                                 2     - b  x
      (%o4)                   2 b  x %e

Função: cdf_rayleigh (x,b)

  Retorna o valor em x da função distribuição de probabilidade de uma variável aleatória Rayleigh(b), com b>0.

  A variável aleatória Rayleigh(b) é equivalente a Weibull(2,1/b), embora quando Maxima não tiver informação disponível para pegar o resultado, uma forma nominal baseada na distribuição de Weibull é retornada.

      (%i1) load (distrib)$
      (%i2) cdf_rayleigh(x,b);
                                              1
      (%o2)                 cdf_weibull(x, 2, -)
                                              b
      (%i3) assume(x>0,b>0)$ cdf_rayleigh(x,b);
                                         2  2
                                      - b  x
      (%o4)                     1 - %e

Função: quantile_rayleigh (q,b)

  Retorna o q-quantil de uma variável aleatória Rayleigh(b), com b>0; em outras palavras, essa função é a inversa da função `cdf_rayleigh`. O argumento q deve ser um elemento de [0,1].

  A variável aleatória Rayleigh(b) é equivalente a Weibull(2,1/b), embora quando Maxima não tiver informação disponível para pegar o resultado, uma forma nominal baseada no quantil de Weibull é retornada.

      (%i1) load (distrib)$
      (%i2) quantile_rayleigh(0.99,b);
                                                  1
      (%o2)             quantile_weibull(0.99, 2, -)
                                                  b
      (%i3) assume(x>0,b>0)$ quantile_rayleigh(0.99,b);
                              2.145966026289347
      (%o4)                   -----------------
                                      b

Função: mean_rayleigh (b)

  Retorna a média de uma variável aleatória Rayleigh(b), com b>0.

  A variável aleatória Rayleigh(b) é equivalente a Weibull(2,1/b), embora quando Maxima não tiver informação disponível para pegar o resultado, uma forma nominal baseada na meia de Weibull é retornada.

      (%i1) load (distrib)$
      (%i2) mean_rayleigh(b);
                                             1
      (%o2)                  mean_weibull(2, -)
                                             b
      (%i3) assume(b>0)$ mean_rayleigh(b);
                                  sqrt(%pi)
      (%o4)                       ---------
                                     2 b

Função: var_rayleigh (b)

  Retorna a variância de uma variável aleatória Rayleigh(b), com b>0.

  A variável aleatória Rayleigh(b) é equivalente a Weibull(2,1/b), embora quando Maxima não tiver informação disponível para pegar o resultado, uma forma nominal baseada na variância de Weibull é retornada.

      (%i1) load (distrib)$
      (%i2) var_rayleigh(b);
                                             1
      (%o2)                   var_weibull(2, -)
                                             b
      (%i3) assume(b>0)$ var_rayleigh(b);
                                       %pi
                                   1 - ---
                                        4
      (%o4)                        -------
                                      2
                                     b

Função: std_rayleigh (b)

  Retorna o desvio padrão de uma variável aleatória Rayleigh(b), com b>0.

  A variável aleatória Rayleigh(b) é equivalente a Weibull(2,1/b), embora quando Maxima não tiver informação disponível para pegar o resultado, uma forma nominal baseada na Weibull desvio padrão é retornada.

      (%i1) load (distrib)$
      (%i2) std_rayleigh(b);
                                             1
      (%o2)                   std_weibull(2, -)
                                             b
      (%i3) assume(b>0)$ std_rayleigh(b);
                                         %pi
                                sqrt(1 - ---)
                                          4
      (%o4)                     -------------
                                      b

Função: skewness_rayleigh (b)

  Retorna o coeficiente de assimetria de uma variável aleatória Rayleigh(b), com b>0.

  A variável aleatória Rayleigh(b) é equivalente a Weibull(2,1/b), embora quando Maxima não tiver informação disponível para pegar o resultado, uma forma nominal baseada no coeficiente de assimetria de Weibull é retornada.

      (%i1) load (distrib)$
      (%i2) skewness_rayleigh(b);
                                               1
      (%o2)                skewness_weibull(2, -)
                                               b
      (%i3) assume(b>0)$ skewness_rayleigh(b);
                               3/2
                            %pi      3 sqrt(%pi)
                            ------ - -----------
                              4           4
      (%o4)                 --------------------
                                     %pi 3/2
                                (1 - ---)
                                      4

Função: kurtosis_rayleigh (b)

  Retorna o coeficiente de curtose de uma variável aleatória Rayleigh(b), com b>0.

  A variável aleatória Rayleigh(b) é equivalente a Weibull(2,1/b), embora quando Maxima não tiver informação disponível para pegar o resultado, uma forma nominal baseada no coeficiente de curtose de Weibull é retornada.

      (%i1) load (distrib)$
      (%i2) kurtosis_rayleigh(b);
                                               1
      (%o2)                kurtosis_weibull(2, -)
                                               b
      (%i3) assume(b>0)$ kurtosis_rayleigh(b);
                                        2
                                   3 %pi
                               2 - ------
                                     16
      (%o4)                    ---------- - 3
                                    %pi 2
                               (1 - ---)
                                     4

Função: random_rayleigh (b)
Função: random_rayleigh (b,n)

  Retorna uma variável estatística pseudo-aleatória Rayleigh(b), com b>0. Chamando `random_rayleigh` com um segundo argumento n, uma amostra aleatória de tamanho n será simulada.

  Somente o método inverso genérico está implementado. Para fazer uso dessa função, escreva primeiramente `load(distrib)`.

Função: pdf_laplace (x,a,b)

  Retorna o valor em x da função densidade de probabilidade de uma variável aleatória Laplace(a,b), com b>0. Para fazer uso dessa função, escreva primeiramente `load(distrib)`.

Função: cdf_laplace (x,a,b)

  Retorna o valor em x da função distribuição de probabilidade de uma variável aleatória Laplace(a,b), com b>0. Para fazer uso dessa função, escreva primeiramente `load(distrib)`.

Função: quantile_laplace (q,a,b)

  Retorna o q-quantil de uma variável aleatória Laplace(a,b), com b>0; em outras palavras, essa função é a inversa da função `cdf_laplace`. O argumento q deve ser um elemento de [0,1]. Para fazer uso dessa função, escreva primeiramente `load(distrib)`.

Função: mean_laplace (a,b)

  Retorna a média de uma variável aleatória Laplace(a,b), com b>0. Para fazer uso dessa função, escreva primeiramente `load(distrib)`.

Função: var_laplace (a,b)

  Retorna a variância de uma variável aleatória Laplace(a,b), com b>0. Para fazer uso dessa função, escreva primeiramente `load(distrib)`.

Função: std_laplace (a,b)

  Retorna o desvio padrão de uma variável aleatória Laplace(a,b), com b>0. Para fazer uso dessa função, escreva primeiramente `load(distrib)`.

Função: skewness_laplace (a,b)

  Retorna o coeficiente de assimetria de uma variável aleatória Laplace(a,b), com b>0. Para fazer uso dessa função, escreva primeiramente `load(distrib)`.

Função: kurtosis_laplace (a,b)

  Retorna o coeficiente de curtose de uma variável aleatória Laplace(a,b), com b>0. Para fazer uso dessa função, escreva primeiramente `load(distrib)`.

Função: random_laplace (a,b)
Função: random_laplace (a,b,n)

  Retorna uma variável estatística pseudo-aleatória Laplace(a,b), com b>0. Chamando `random_laplace` com um terceiro argumento n, uma amostra aleatória de tamanho n será simulada.

  Somente o método inverso genérico está implementado. Para fazer uso dessa função, escreva primeiramente `load(distrib)`.

Função: pdf_cauchy (x,a,b)

  Retorna o valor em x da função densidade de probabilidade de uma variável aleatória Cauchy(a,b), com b>0. Para fazer uso dessa função, escreva primeiramente `load(distrib)`.

Função: cdf_cauchy (x,a,b)

  Retorna o valor em x da função distribuição de probabilidade de uma variável aleatória Cauchy(a,b), com b>0. Para fazer uso dessa função, escreva primeiramente `load(distrib)`.

Função: quantile_cauchy (q,a,b)

  Retorna o q-quantil de uma variável aleatória Cauchy(a,b), com b>0; em outras palavras, essa função é a inversa da função `cdf_cauchy`. O argumento q deve ser um elemento de [0,1]. Para fazer uso dessa função, escreva primeiramente `load(distrib)`.

Função: random_cauchy (a,b)
Função: random_cauchy (a,b,n)

  Retorna uma variável estatística pseudo aleatória Cauchy(a,b), com b>0. Chamando `random_cauchy` com um terceiro argumento n, uma amostra aleatória de tamanho n será simulada.

  Somente o método inverso genérico está implementado. Para fazer uso dessa função, escreva primeiramente `load(distrib)`.

Função: pdf_gumbel (x,a,b)

  Retorna o valor em x da função densidade de probabilidade de uma variável aleatória Gumbel(a,b), com b>0. Para fazer uso dessa função, escreva primeiramente `load(distrib)`.

Função: cdf_gumbel (x,a,b)

  Retorna o valor em x da função distribuição de probabilidade de uma variável aleatória Gumbel(a,b), com b>0. Para fazer uso dessa função, escreva primeiramente `load(distrib)`.

Função: quantile_gumbel (q,a,b)

  Retorna o q-quantil de uma variável aleatória Gumbel(a,b), com b>0; em outras palavras, essa função é a inversa da função `cdf_gumbel`. O argumento q deve ser um elemento de [0,1]. Para fazer uso dessa função, escreva primeiramente `load(distrib)`.

Função: mean_gumbel (a,b)

  Retorna a média de uma variável aleatória Gumbel(a,b), com b>0.

      (%i1) load (distrib)$
      (%i2) assume(b>0)$  mean_gumbel(a,b);
      (%o3)                     %gamma b + a

  onde o símbolol `%gamma` representa a constante de Euler-Mascheroni. Veja também `%gamma`.

Função: var_gumbel (a,b)

  Retorna a variância de uma variável aleatória Gumbel(a,b), com b>0. Para fazer uso dessa função, escreva primeiramente `load(distrib)`.

Função: std_gumbel (a,b)

  Retorna o desvio padrão de uma variável aleatória Gumbel(a,b), com b>0. Para fazer uso dessa função, escreva primeiramente `load(distrib)`.

Função: skewness_gumbel (a,b)

  Retorna o coeficiente de assimetria de uma variável aleatória Gumbel(a,b), com b>0.

      (%i1) load (distrib)$
      (%i2) assume(b>0)$ skewness_gumbel(a,b);
                             12 sqrt(6) zeta(3)
      (%o3)                  ------------------
                                       3
                                    %pi
      (%i4) numer:true$ skewness_gumbel(a,b);
      (%o5)                   1.139547099404649

  onde `zeta` representa a função zeta de Riemann.

Função: kurtosis_gumbel (a,b)

  Retorna o coeficiente de curtose de uma variável aleatória Gumbel(a,b), com b>0. Para fazer uso dessa função, escreva primeiramente `load(distrib)`.

Função: random_gumbel (a,b)
Função: random_gumbel (a,b,n)

  Retorna uma variável estatística pseudo-aleatória Gumbel(a,b), com b>0. Chamando `random_gumbel` com um terceiro argumento n, uma amostra aleatória de tamanho n será simulada.

  Somente o método inverso genérico está implementado. Para fazer uso dessa função, escreva primeiramente `load(distrib)`.

[ < ] | [ > ] |  | [ << ] | [ Up ] | [ >> ] |  |  |  |  | [Top] | [Contents] | [Índice] | [ ? ]

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

Função: pdf_binomial (x,n,p)

  Retorna o valor em x da função de probabilidade de uma Binomial(n,p) variável aleatória, com 0<p<1 e n um inteiro positivo. Para fazer uso dessa função, escreva primeiramente `load(distrib)`.

Função: cdf_binomial (x,n,p)

  Retorna o valor em x da função distribuição de probabilidade de uma Binomial(n,p) variável aleatória, com 0<p<1 e n um inteiro positivo.

  `cdf_binomial` é calculada numéricamente se a variável global `numer` for igual a `true`, de outra forma `cdf_binomial` retorna uma expressão nominal.

      (%i1) load (distrib)$
      (%i2) cdf_binomial(5,7,1/6);
                                               1
      (%o2)                 cdf_binomial(5, 7, -)
                                               6
      (%i3) cdf_binomial(5,7,1/6), numer;
      (%o3)                   .9998713991769548

Função: quantile_binomial (q,n,p)

  Retorna o q-quantil de uma variável aleatória Binomial(n,p), com 0<p<1 e n um inteiro positivo; em outras palavras, essa função é a inversa da função `cdf_binomial`. O argumento q deve ser um elemento de [0,1]. Para fazer uso dessa função, escreva primeiramente `load(distrib)`.

Função: mean_binomial (n,p)

  Retorna a média de uma variável aleatória Binomial(n,p), com 0<p<1 e n um inteiro positivo. Para fazer uso dessa função, escreva primeiramente `load(distrib)`.

Função: var_binomial (n,p)

  Retorna a variância de uma variável aleatória Binomial(n,p), com 0<p<1 e n um inteiro positivo. Para fazer uso dessa função, escreva primeiramente `load(distrib)`.

Função: std_binomial (n,p)

  Retorna o desvio padrão de uma variável aleatória Binomial(n,p), com 0<p<1 e n um inteiro positivo. Para fazer uso dessa função, escreva primeiramente `load(distrib)`.

Função: skewness_binomial (n,p)

  Retorna o coeficiente de assimetria de uma variável aleatória Binomial(n,p), com 0<p<1 e n um inteiro positivo. Para fazer uso dessa função, escreva primeiramente `load(distrib)`.

Função: kurtosis_binomial (n,p)

  Retorna o coeficiente de curtose de uma variável aleatória Binomial(n,p), com 0<p<1 e n um inteiro positivo. Para fazer uso dessa função, escreva primeiramente `load(distrib)`.

Variável de opção: random_binomial_algorithm

  Valor 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: random_binomial (n,p)
Função: random_binomial (n,p,m)

  Retorna uma variável estatística pseudo-aleatória Binomial(n,p), com 0<p<1 e n um inteiro positivo. Chamando `random_binomial` com um terceiro argumento m, uma amostra aleatória de tamanho m será simulada.

  Existem três 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: pdf_poisson (x,m)

  Retorna o valor em x da função de probabilidade de uma variável aleatória Poisson(m), com m>0. Para fazer uso dessa função, escreva primeiramente `load(distrib)`.

Função: cdf_poisson (x,m)

  Retorna o valor em x da função distribuição de probabilidade de uma variável aleatória Poisson(m), com m>0.

  Essa função é calculada numéricamente se a variável global `numer` for igual a `true`, de outra forma essa função retorna uma expressão nominal.

      (%i1) load (distrib)$
      (%i2) cdf_poisson(3,5);
      (%o2)                   cdf_poisson(3, 5)
      (%i3) cdf_poisson(3,5), numer;
      (%o3)                   .2650259152973617

Função: quantile_poisson (q,m)

  Retorna o q-quantil de uma variável aleatória Poisson(m), com m>0; em outras palavras, essa função é a inversa da função `cdf_poisson`. O argumento q deve ser um elemento de [0,1]. Para fazer uso dessa função, escreva primeiramente `load(distrib)`.

Função: mean_poisson (m)

  Retorna a média de uma variável aleatória Poisson(m), com m>0. Para fazer uso dessa função, escreva primeiramente `load(distrib)`.

Função: var_poisson (m)

  Retorna a variância de uma variável aleatória Poisson(m), com m>0. Para fazer uso dessa função, escreva primeiramente `load(distrib)`.

Função: std_poisson (m)

  Retorna o desvio padrão de uma variável aleatória Poisson(m), com m>0. Para fazer uso dessa função, escreva primeiramente `load(distrib)`.

Função: skewness_poisson (m)

  Retorna o coeficiente de assimetria de uma variável aleatória Poisson(m), com m>0. Para fazer uso dessa função, escreva primeiramente `load(distrib)`.

Função: kurtosis_poisson (m)

  Retorna o coeficiente de curtose de uma Poisson variável aleatória Poi(m), com m>0. Para fazer uso dessa função, escreva primeiramente `load(distrib)`.

Variável de opção: random_poisson_algorithm

  Valor 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: random_poisson (m)
Função: random_poisson (m,n)

  Retorna uma variável estatística pseudo-aleatória Poisson(m), com m>0. Chamando `random_poisson` com um segundo argumento n, uma amostra aleatória de tamanho n será simulada.

  Existem dois 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: pdf_bernoulli (x,p)

  Retorna o valor em x da função de probabilidade de uma variável aleatória Bernoulli(p), com 0<p<1.

  A variável aleatória Bernoulli(p) é equivalente a Binomial(1,p), embora quando Maxima não tiver informação disponível para pegar o resultado, uma forma nominal baseada na função binomial de probabilidade é retornada.

      (%i1) load (distrib)$
      (%i2) pdf_bernoulli(1,p);
      (%o2)                 pdf_binomial(1, 1, p)
      (%i3) assume(0<p,p<1)$ pdf_bernoulli(1,p);
      (%o4)                           p

Função: cdf_bernoulli (x,p)

  Retorna o valor em x da função distribuição de probabilidade de uma variável aleatória Bernoulli(p), com 0<p<1. Para fazer uso dessa função, escreva primeiramente `load(distrib)`.

Função: quantile_bernoulli (q,p)

  Retorna o q-quantil de uma variável aleatória Bernoulli(p), com 0<p<1; em outras palavras, essa função é a inversa da função `cdf_bernoulli`. O argumento q deve ser um elemento de [0,1]. Para fazer uso dessa função, escreva primeiramente `load(distrib)`.

Função: mean_bernoulli (p)

  Retorna a média de uma variável aleatória Bernoulli(p), com 0<p<1.

  A variável aleatória Bernoulli(p) é equivalente a Binomial(1,p), embora quando Maxima não tiver informação disponível para pegar o resultado, uma forma nominal baseada na média binomial é retornada.

      (%i1) load (distrib)$
      (%i2) mean_bernoulli(p);
      (%o2)                  mean_binomial(1, p)
      (%i3) assume(0<p,p<1)$ mean_bernoulli(p);
      (%o4)                           p

Função: var_bernoulli (p)

  Retorna a variância de uma variável aleatória Bernoulli(p), com 0<p<1.

  A variável aleatória Bernoulli(p) é equivalente a Binomial(1,p), embora quando Maxima não tiver informação disponível para pegar o resultado, uma forma nominal baseada na variância binomial é retornada.

      (%i1) load (distrib)$
      (%i2) var_bernoulli(p);
      (%o2)                  var_binomial(1, p)
      (%i3) assume(0<p,p<1)$ var_bernoulli(p);
      (%o4)                       (1 - p) p

Função: std_bernoulli (p)

  Retorna o desvio padrão de uma variável aleatória Bernoulli(p), com 0<p<1.

  A variável aleatória Bernoulli(p) é equivalente a Binomial(1,p), embora quando Maxima não tiver informação disponível para pegar o resultado, uma forma nominal baseada no desvio padrão binomial é retornada.

      (%i1) load (distrib)$
      (%i2) std_bernoulli(p);
      (%o2)                  std_binomial(1, p)
      (%i3) assume(0<p,p<1)$ std_bernoulli(p);
      (%o4)                  sqrt(1 - p) sqrt(p)

Função: skewness_bernoulli (p)

  Retorna o coeficiente de assimetria de uma variável aleatória Bernoulli(p), com 0<p<1.

  A variável aleatória Bernoulli(p) é equivalente a Binomial(1,p), embora quando Maxima não tiver informação disponível para pegar o resultado, uma forma nominal baseada no coeficiente de assimetria binomial é retornada.

      (%i1) load (distrib)$
      (%i2) skewness_bernoulli(p);
      (%o2)                skewness_binomial(1, p)
      (%i3) assume(0<p,p<1)$ skewness_bernoulli(p);
                                   1 - 2 p
      (%o4)                  -------------------
                             sqrt(1 - p) sqrt(p)

Função: kurtosis_bernoulli (p)

  Retorna o coeficiente de curtose de uma variável aleatória Bernoulli(p), com 0<p<1.

  A variável aleatória Bernoulli(p) é equivalente a Binomial(1,p), embora quando Maxima não tiver informação disponível para pegar o resultado, uma forma nominal baseada no coeficiente de curtose binomial é retornada.

      (%i1) load (distrib)$
      (%i2) kurtosis_bernoulli(p);
      (%o2)                kurtosis_binomial(1, p)
      (%i3) assume(0<p,p<1)$ kurtosis_bernoulli(p);
                               1 - 6 (1 - p) p
      (%o4)                    ---------------
                                  (1 - p) p

Função: random_bernoulli (p)
Função: random_bernoulli (p,n)

  Retorna uma variável estatística pseudo-aleatória Bernoulli(p), com 0<p<1. Chamando `random_bernoulli` com um segundo argumento n, uma amostra aleatória de tamanho n será simulada.

  Essa é uma aplicação 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: pdf_geometric (x,p)

  Retorna o valor em x da função de probabilidade de uma variável aleatória Geometric(p), com 0<p<1. Para fazer uso dessa função, escreva primeiramente `load(distrib)`.

Função: cdf_geometric (x,p)

  Retorna o valor em x da função distribuição de probabilidade de uma variável aleatória Geometric(p), com 0<p<1. Para fazer uso dessa função, escreva primeiramente `load(distrib)`.

Função: quantile_geometric (q,p)

  Retorna o q-quantil de uma variável aleatória Geometric(p), com 0<p<1; em outras palavras, essa função é a inversa da função `cdf_geometric`. O argumento q deve ser um elemento de [0,1]. Para fazer uso dessa função, escreva primeiramente `load(distrib)`.

Função: mean_geometric (p)

  Retorna a média de uma variável aleatória Geometric(p), com 0<p<1. Para fazer uso dessa função, escreva primeiramente `load(distrib)`.

Função: var_geometric (p)

  Retorna a variância de uma variável aleatória Geometric(p), com 0<p<1. Para fazer uso dessa função, escreva primeiramente `load(distrib)`.

Função: std_geometric (p)

  Retorna o desvio padrão de uma variável aleatória Geometric(p), com 0<p<1. Para fazer uso dessa função, escreva primeiramente `load(distrib)`.

Função: skewness_geometric (p)

  Retorna o coeficiente de assimetria de uma variável aleatória Geometric(p), com 0<p<1. Para fazer uso dessa função, escreva primeiramente `load(distrib)`.

Função: kurtosis_geometric (p)

  Retorna o coeficiente de curtose de uma geometric variável aleatória Geo(p), com 0<p<1. Para fazer uso dessa função, escreva primeiramente `load(distrib)`.

Variável de opção: random_geometric_algorithm

  Valor 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: random_geometric (p)
Função: random_geometric (p,n)

  Retorna um Geometric(p) variável estatística pseudo-aleatória, com 0<p<1. Chamando `random_geometric` com um segundo argumento n, uma amostra aleatória de tamanho n será simulada.

  Existem três 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: pdf_discrete_uniform (x,n)

  Retorna o valor em x da função de probabilidade de uma variável aleatória Discrete Uniform(n), com n a strictly positive integer. Para fazer uso dessa função, escreva primeiramente `load(distrib)`.

Função: cdf_discrete_uniform (x,n)

  Retorna o valor em x da função distribuição de probabilidade de uma variável aleatória Discrete Uniform(n), com n inteiro estritamente positivo. Para fazer uso dessa função, escreva primeiramente `load(distrib)`.

Função: quantile_discrete_uniform (q,n)

  Retorna o q-quantil de uma variável aleatória Discrete Uniform(n), com n um inteiro estritamente positivo; em outras palavras, essa função é a inversa da função `cdf_discrete_uniform`. O argumento q deve ser um elemento de [0,1]. Para fazer uso dessa função, escreva primeiramente `load(distrib)`.

Função: mean_discrete_uniform (n)

  Retorna a média de uma variável aleatória Discrete Uniform(n), com n um inteiro estritamente positivo. Para fazer uso dessa função, escreva primeiramente `load(distrib)`.

Função: var_discrete_uniform (n)

  Retorna a variância de uma variável aleatória Discrete Uniform(n), com n um inteiro estritamente positivo. Para fazer uso dessa função, escreva primeiramente `load(distrib)`.

Função: std_discrete_uniform (n)

  Retorna o desvio padrão de uma variável aleatória Discrete Uniform(n), com n um inteiro estritamente positivo. Para fazer uso dessa função, escreva primeiramente `load(distrib)`.

Função: skewness_discrete_uniform (n)

  Retorna o coeficiente de assimetria de uma variável aleatória Discrete Uniform(n), com n um inteiro estritamente positivo. Para fazer uso dessa função, escreva primeiramente `load(distrib)`.

Função: kurtosis_discrete_uniform (n)

  Retorna o coeficiente de curtose de uma variável aleatória Discrete Uniform(n), com n um inteiro estritamente positivo. Para fazer uso dessa função, escreva primeiramente `load(distrib)`.

Função: random_discrete_uniform (n)
Função: random_discrete_uniform (n,m)

  Retorna uma variável estatística pseudo-aleatória Discrete Uniform(n), com n um inteiro estritamente positivo. Chamando `random_discrete_uniform` com um segundo argumento m, uma amostra aleatória de tamanho m será simulada.

  Isso é uma aplicação 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: pdf_hypergeometric (x,n1,n2,n)

  Retorna o valor em x da função de probabilidade de uma variável aleatória Hypergeometric(n1,n2,n), com n1, n2 e n inteiros não negativos e n<=n1+n2. Para fazer uso dessa função, escreva primeiramente `load(distrib)`.

Função: cdf_hypergeometric (x,n1,n2,n)

  Retorna o valor em x da função distribuição de probabilidade de uma variável aleatória Hypergeometric(n1,n2,n), com n1, n2 e n inteiros não negativos e n<=n1+n2. Para fazer uso dessa função, escreva primeiramente `load(distrib)`.

Função: quantile_hypergeometric (q,n1,n2,n)

  Retorna o q-quantil de uma variável aleatória Hypergeometric(n1,n2,n), com n1, n2 e n inteiros não negativos e n<=n1+n2; em outras palavras, essa função é a inversa da função `cdf_hypergeometric`. O argumento q deve ser um elemento de [0,1]. Para fazer uso dessa função, escreva primeiramente `load(distrib)`.

Função: mean_hypergeometric (n1,n2,n)

  Retorna a média de uma variável aleatória discreta univorme Hyp(n1,n2,n), com n1, n2 e n inteiros não negativos e n<=n1+n2. Para fazer uso dessa função, escreva primeiramente `load(distrib)`.

Função: var_hypergeometric (n1,n2,n)

  Retorna a variância de uma variável aleatória hipergeométrica Hyp(n1,n2,n), com n1, n2 e n inteiros não negativos e n<=n1+n2. Para fazer uso dessa função, escreva primeiramente `load(distrib)`.

Função: std_hypergeometric (n1,n2,n)

  Retorna o desvio padrão de uma variável aleatória Hypergeometric(n1,n2,n), com n1, n2 e n inteiros não negativos e n<=n1+n2. Para fazer uso dessa função, escreva primeiramente `load(distrib)`.

Função: skewness_hypergeometric (n1,n2,n)

  Retorna o coeficiente de assimetria de uma variável aleatória Hypergeometric(n1,n2,n), com n1, n2 e n inteiros não negativos e n<=n1+n2. Para fazer uso dessa função, escreva primeiramente `load(distrib)`.

Função: kurtosis_hypergeometric (n1,n2,n)

  Retorna o coeficiente de curtose de uma variável aleatória Hypergeometric(n1,n2,n), com n1, n2 e n inteiros não negativos e n<=n1+n2. Para fazer uso dessa função, escreva primeiramente `load(distrib)`.

Variável de opção: random_hypergeometric_algorithm

  Valor 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: random_hypergeometric (n1,n2,n)
Função: random_hypergeometric (n1,n2,n,m)

  Retorna uma variável estatística pseudo-aleatória Hypergeometric(n1,n2,n), com n1, n2 e n inteiros não negativos e n<=n1+n2. Chamando `random_hypergeometric` com um quarto argumento m, uma amostra aleatória de tamanho m será simulada.

  Existem dois 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: pdf_negative_binomial (x,n,p)

  Retorna o valor em x da função de probabilidade de uma variável aleatória Negative Binomial(n,p), com 0<p<1 e n um inteiro positivo. Para fazer uso dessa função, escreva primeiramente `load(distrib)`.

Função: cdf_negative_binomial (x,n,p)

  Retorna o valor em x da função distribuição de probabilidade de uma Negative Binomial(n,p) variável aleatória, com 0<p<1 e n um inteiro positivo.

  Essa função é calculada numéricamente se a variável global `numer` for igual a `true`, de outra forma essa função retorna uma expressão nominal.

      (%i1) load (distrib)$
      (%i2) cdf_negative_binomial(3,4,1/8);
                                                   1
      (%o2)            cdf_negative_binomial(3, 4, -)
                                                   8
      (%i3) cdf_negative_binomial(3,4,1/8), numer;
      (%o3)                  .006238937377929698

Função: quantile_negative_binomial (q,n,p)

  Retorna o q-quantil de uma variável aleatória Negative Binomial(n,p), com 0<p<1 e n um inteiro positivo; em outras palavras, essa função é a inversa da função `cdf_negative_binomial`. O argumento q deve ser um elemento de [0,1]. Para fazer uso dessa função, escreva primeiramente `load(distrib)`.

Função: mean_negative_binomial (n,p)

  Retorna a média de uma variável aleatória Negative Binomial(n,p), com 0<p<1 e n um inteiro positivo. Para fazer uso dessa função, escreva primeiramente `load(distrib)`.

Função: var_negative_binomial (n,p)

  Retorna a variância de uma variável aleatória Negative Binomial(n,p), com 0<p<1 e n um inteiro positivo. Para fazer uso dessa função, escreva primeiramente `load(distrib)`.

Função: std_negative_binomial (n,p)

  Retorna o desvio padrão de uma variável aleatória Negative Binomial(n,p), com 0<p<1 e n um inteiro positivo. Para fazer uso dessa função, escreva primeiramente `load(distrib)`.

Função: skewness_negative_binomial (n,p)

  Retorna o coeficiente de assimetria de uma variável aleatória Negative Binomial(n,p), com 0<p<1 e n um inteiro positivo. Para fazer uso dessa função, escreva primeiramente `load(distrib)`.

Função: kurtosis_negative_binomial (n,p)

  Retorna o coeficiente de curtose de uma variável aleatória Negative Binomial(n,p), com 0<p<1 e n um inteiro positivo. Para fazer uso dessa função, escreva primeiramente `load(distrib)`.

Variável de opção: random_negative_binomial_algorithm

  Valor 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: random_negative_binomial (n,p)
Função: random_negative_binomial (n,p,m)

  Retorna uma variável estatística pseudo-aleatória Negative Binomial(n,p), com 0<p<1 e n um inteiro positivo. Chamando `random_negative_binomial` com um terceiro argumento m, uma amostra aleatória de tamanho m será simulada.

  Existem três 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)`.

[ << ] | [ >> ] |  |  |  |  |  | [Top] | [Contents] | [Índice] | [ ? ]

This document was generated by Viktor T. Toth on Setembro, 27 2018 using texi2html 1.76.