Distribuição Estatística no MQL5 - tirando o melhor de R e o fazendo mais rápido

7 novembro 2016, 09:39
MetaQuotes Software Corp.
0
1 291

Consideremos as funções para trabalhar com as distribuições estatísticas básicas implementadas na linguagem R.

As distribuições de Cauchy, Weibull, normal, log-normal, logistic, exponential, uniform, gamma, beta central e não-central, qui-quadrado, F de Fisher-Snedecor, t de Student, assim como as distribuições binomiais discretas e binomiais negativas, distribuições geométricas, hipergeométricas e de Poisson. Além disso, existem funções para o cálculo de momentos teóricos de distribuições, que permitem avaliar o grau de conformidade da distribuição real com a modelada.

A biblioteca padrão MQL5 foi complementada com inúmeras funções matemáticas de R. Além disso, um aumento na velocidade de operação de 3 a 7 vezes foi alcançado, em comparação com as versões iniciais na linguagem R. Ao mesmo tempo, erros na implementação de certas funções em R foram encontrados.

Conteúdos

  1. Funções para o cálculo das características estatísticas dos elementos de array


  2. Funções para trabalhar com distribuições estatísticas

    2.1. Distribuição normal

    2.2. Distribuição do Log-normal

    2.3. Distribuição beta

    2.4. Distribuição beta não-central

    2.5. Distribuição Gama

    2.6. Distribuição Qui-quadrado

    2.7. Distribuição do qui-quadrado não-central

    2.8. Distribuição exponencial

    2.9. Distribuição F

    2.10. Distribuição F não-central

    2.11. Distribuição t

    2.12 Distribuição t não-central

    2.13. Distribuição logística

    2.14. Distribuição cauchy

    2.15. Distribuição uniforme

    2.16. Distribuição Weibull

    2.17. Distribuição binomial

    2.18. Distribuição binomial negativa

    2.19. Distribuição geométrica

    2.20. Distribuição Hipergeometrica

    2.21. Distribuição de Poisson

  3. Tabela de correspondência com as funções estatísticas em R

  4. Um exemplo de uso das funções

  5. Comparação da velocidade do cálculo

  6. Erros de cálculo detectados em R

  7. Referências


Introdução

A linguagem R é uma das melhores ferramentas de processamento estatístico e análise de dados.

Graças à disponibilidade e suporte de múltiplas distribuições estatísticas, se tornaram possível a análise e processamento de vários dados. Ao usar um aparelho de teoria da probabilidade e estatísticas matemáticas, podemos dar uma nova visão nos dados do mercado financeiro e fornecer novas oportunidades para o desenvolvimento de estratégias de negociação. Com a biblioteca de estatísticas, todos esses recursos estão agora disponíveis no MQL5.

A biblioteca de estatísticas contém funções para o cálculo das características estatísticas dos dados, bem como funções para trabalhar com distribuições estatísticas.

Este artigo considera as principais funções da biblioteca e um exemplo de seu uso prático.


1. Funções para o cálculo das características estatísticas dos elementos de array

Este grupo de funções calcula as características padrões (média, variância, assimetria, curtose, mediana, valor quadrático médio e desvios padrão) dos elementos do array.

1.1. MathMean

Calcula a média (primeiro momento) dos elementos do array. Em caso de erro, retorna NaN (não um número). Análoga da função mean() em R.

double MathMean(
  const double   &array[]         // [in] Array com dados
);

1.2. MathVariance

Calcula a variação (segundo momento) dos elementos do array. Em caso de erro, retorna NaN. Análoga da var() em R.

double MathVariance(
  const double   &array[]         // [in] Array com dados
);


1.3. MathSkewness

Calcula a assimetria (terceiro momento) dos elementos do array. Em caso de erro, retorna NaN. Análoga da skewness() em R (biblioteca 1071).

double MathSkewness(
  const double   &array[]         // [in] Array com dados
);


1.4. MathKurtosis

Calcula a curtose (quarto momento) dos elementos do array. Em caso de erro, retorna NaN. Análoga da kurtosis() em R (biblioteca e1071).

double MathKurtosis(
  const double   &array[]         // [in] Array com dados
);


1.5. MathMoments

Calcula os primeiros 4 momentos (média, variância, assimetria, curtose) dos elementos do array. Retorna verdadeiro se os momentos foram calculados com sucesso, caso contrário falso.

bool MathMoments(
  const double   &array[],         // [in]  Array com dados
  double         &mean,            // [out] Variável para a média(1º momento)
  double         &variance,        // [out] Variável para a variância (2º momento)
  double         &skewness,        // [out] Variável para a assimetria (3º momento)
  double         &kurtosis,        // [out] Variável para a curtose (4º momento)
  const int      start=0,          // [in]  Número inicial para calcular
  const int      count=WHOLE_ARRAY // [in]  O número de elementos para calcular
);


1.6. MathMedian

Calcula o valor médio dos elementos do array. Em caso de erro, retorna NaN. Análoga da median() em R.

double MathMedian(
  double         &array[]         // [in] Array com dados
);


1.7. MathStandardDeviation

Calcula o desvio padrão dos elementos do array. Em caso de erro, retorna NaN. Análoga da sd() em R.

double MathStandardDeviation(
  const double   &array[]         // [in] Array com dados
);


1.8. MathAverageDeviation

Calcula o desvio médio absoluto dos elementos do array. Em caso de erro, retorna NaN. Análoga da aad() em R.

double MathAverageDeviation(
  const double   &array[]         // [in] Array com dados
);


Todas as funções que calculam a curtose usam o excesso da mesma em torno da distribuição normal (excesso da curtose=curtose-3), isto é, o excesso de curtose de uma distribuição normal é zero.

É positivo se o pico da distribuição em torno do valor esperado é íngreme, e negativo se o pico for achatado.


2. Distribuição estatística

A biblioteca estatística MQL5 contém 5 funções para trabalhar com as distribuições estatísticas:

  1. Cálculo da probabilidade de densidade - as funções MathProbabilityDensityX();
  2. Cálculo de probabilidades - as funções MathCumulativeDistributionX();
    A probabilidade da função de distribuição é igual à probabilidade de uma variável aleatória dentro do intervalo (-inf; x]).
  3. Cálculo de quantil de distribuição - as funções MathQuantileX();
    O quantil x de uma distribuição corresponde a um valor aleatório que está dentro do intervalo (-inf, x] com a probabilidade específica aos parâmetros de distribuição.
  4. Cálculo de números aleatórios com a distribuição específica - as funções MathRandomX();
  5. Cálculo dos momentos teóricos das distribuições - as funções MathMomentsX();


2.1. Distribuição Normal

2.1.1. MathProbabilityDensityNormal

Calcula o valor da probabilidade função de densidade distribuição normal com os parâmetros mu e sigma para uma variável aleatória x. Em caso de erro, retorna NaN.
double MathProbabilityDensityNormal(
  const double   x,           // [in]  Valor de uma variável aleatória
  const double   mu,          // [in]  Parâmetro médio (valor esperado) da distribuição
  const double   sigma,       // [in]  Sigma (valor quadrático médio) da distribuição
  const bool     log_mode,    // [in]  Flag Para calcular o logaritmo do valor, se log_mode = true, então o logaritmo natural da densidade de probabilidade é retornado
  int            &error_code  // [out] Variável para o código de erro
);

Calcula o valor da probabilidade função de densidade distribuição normal com os parâmetros mu e sigma para uma variável aleatória x. Em caso de erro, retorna NaN.

double MathProbabilityDensityNormal(
  const double   x,           // [in]  Valor de uma variável aleatória
  const double   mu,          // [in]  Parâmetro médio (valor esperado) da distribuição
  const double   sigma,       // [in]  Sigma (valor quadrático médio) da distribuição
  int            &error_code  // [out] Variável para o código de erro
);

Calcula os valores da função de densidade de probabilidade da distribuição normal com os parâmetros mu e sigma para um array de variáveis aleatórias x[]. Em caso de erro ele retorna falso. Analoga da dnorm() em R.

bool MathProbabilityDensityNormal(
  const double   &x[],        // [in]  Array com os valores da variável aleatória
  const double   mu,          // [in]  Parâmetro médio (valor esperado) da distribuição
  const double   sigma,       // [in]  Sigma (valor quadrático médio) da distribuição
  const bool     log_mode,    // [in]  Flag Para calcular o logaritmo do valor, se log_mode=true, então o logaritmo natural da densidade de probabilidade é calculado
  double         &result[]    // [out] Array para valores da função de densidade de probabilidade
);

Calcula os valores da função de densidade de probabilidade da distribuição normal com os parâmetros mu e sigma para um array de variáveis aleatórias x[]. Em caso de erro ele retorna falso.

bool MathProbabilityDensityNormal(
  const double   &x[],        // [in]  Array com os valores da variável aleatória
  const double   mu,          // [in]  Parâmetro médio (valor esperado) da distribuição
  const double   sigma,       // [in]  Sigma (valor quadrático médio) da distribuição
  double         &result[]    // [out] Array para valores da função de densidade de probabilidade
);


2.1.2. MathCumulativeDistributionNormal

Calcula o valor da função de distribuição normal com os parâmetros mu e sigma para uma variável aleatória x. Em caso de erro, retorna NaN.

double MathCumulativeDistributionNormal(
  const double   x,           // [in]  Valor de uma variável aleatória
  const double   mu,          // [in]  Valor esperado
  const double   sigma,       // [in]  Desvio do valor quadrático médio
  const bool     tail,        // [in]  Flag de cálculo, se for verdadeira, então a probabilidade da variável aleatória não excedendo x é calculada
  const bool     log_mode,    // [in]  Flag para calcular o logaritmo do valor, se log_mode=true, então o logaritmo natural da probabilidade é calculado
  int            &error_code  // [out] Variável para o código de erro
);

Calcula o valor da função de distribuição normal com os parâmetros mu e sigma para uma variável aleatória x. Em caso de erro, retorna NaN.

double MathCumulativeDistributionNormal(
  const double   x,           // [in]  Valor de uma variável aleatória
  const double   mu,          // [in]  Valor esperado
  const double   sigma,       // [in]  Desvio do valor quadrático médio
  int            &error_code  // [out] Variável para o código de erro
);
Calcula o valor da função de distribuição normal com os parâmetros mu e sigma para um array de variáveis aleatórias x[]. Em caso de erro ele retorna falso. Analoga da pnorm() em R.
bool MathCumulativeDistributionNormal(
  const double   &x[],        // [in]  Array com os valores da variável aleatória
  const double   mu,          // [in]  Valor esperado
  const double   sigma,       // [in]  Desvio do valor quadrático médio
  const bool     tail,        // [in]  Flag de cálculo, se for verdadeira, então a probabilidade da variável aleatória não excedendo x é calculada
  const bool     log_mode,    // [in]  Flag para calcular o logaritmo do valor, se log_mode=true, então o logaritmo natural da probabilidade é calculado
  double         &result[]    // [out] Array para valores da função de probabilidade
);

Calcula o valor da função de distribuição normal com os parâmetros mu e sigma para um array de variáveis aleatórias x[]. Em caso de erro ele retorna falso.

bool MathCumulativeDistributionNormal(
  const double   &x[],        // [in]  Array com os valores da variável aleatória
  const double   mu,          // [in]  Valor esperado
  const double   sigma,       // [in]  Desvio do valor quadrático médio
  double         &result[]    // [out] Array para valores da função de probabilidade
);


2.1.3. MathQuantileNormal

Para a probabilidade específica, calcula o valor da função de distribuição inversa normal com os parâmetros mu e sigma. Em caso de erro, retorna NaN.

double MathQuantileNormal(
  const double   probability, // [in]  Valor de probabilidade da variável aleatória
  const double   mu,          // [in]  Valor esperado
  const double   sigma,       // [in]  desvio do valor quadrático médio
  const bool     tail,        // [in]  Flag de cálculo, se for falsa, então o cálculo é realizado pela probabilidade 1.0
  const bool     log_mode,    // [in]  Flag do cálculo, se log_mode=true, o cálculo é realizado para Exp(probabilidade)
  int            &error_code  // [out] Variável para o código de erro
);

Para a probabilidade específica, calcula o valor da função de distribuição inversa normal com os parâmetros mu e sigma. Em caso de erro, retorna NaN.

double MathQuantileNormal(
  const double   probability, // [in]  Valor de probabilidade da variável aleatória
  const double   mu,          // [in]  Valor esperado
  const double   sigma,       // [in]  desvio do valor quadrático médio
  int            &error_code  // [out] Variável para o código de erro
);
Para o array especificado de valores de probabilidade 'probability[]', é calculado os valores da função de distribuição normal inversa com os parâmetros mu e sigma. Em caso de erro ele retorna falso. Analoga da qnorm() em R.
bool MathQuantileNormal(
  const double   &probability[],// [in]  Array com valores de probabilidade de variável aleatória
  const double   mu,            // [in]  Valor esperado
  const double   sigma,         // [in]  desvio do valor quadrático médio
  const bool     tail,          // [in]  Bandeira de cálculo, se for falsa, então o cálculo é realizado pela probabilidade 1.0
  const bool     log_mode,      // [in]  Flag de cálculo, se log_mode=true, o cálculo é realizado pelo Exp(probabilidade)
  double         &result[]      // [out] Array com valor de quantis
);

Para o array especificado de valores de probabilidade 'probability[]', é calculado os valores da função de distribuição normal inversa com os parâmetros mu e sigma. Em caso de erro ele retorna falso.

bool MathQuantileNormal(
  const double   &probability[],// [in]  Array com valores de probabilidade de variável aleatória
  const double   mu,            // [in]  Valor sperado
  const double   sigma,         // [in]  desvio do valor quadrático médio
  double         &result[]      // [out] Array com valor de quantis
);


2.1.4. MathRandomNormal

A função gera uma variável pseudo-aleatória, distribuída de acordo com a lei normal, com os parâmetros mu e sigma. Em caso de erro, retorna NaN.

double MathRandomNormal(
  const double   mu,          // [in]  Valor esperado
  const double   sigma,       // [in]  Desvio do valor quadrático médio
  int            &error_code  // [out] Variável para o código de erro
);

A função gera variáveis pseudo-aleatórias distribuídas de acordo com a lei normal com os parâmetros mu e sigma. Em caso de erro ele retorna falso. Análoga da rnorm() em R.

bool MathRandomNormal(
  const double   mu,          // [in]  Valor esperado
  const double   sigma,       // [in]  Desvio do valor quadrático médio
  const int      data_count,  // [in]  Quantidade de dados requeridos
  double         &result[]    // [out] Array Com valores de variáveis pseudo-aleatórias
);


2.1.5. MathMomentsNormal

Calcula os valores numéricos teóricos dos primeiros 4 momentos da distribuição normal. Retorna verdadeiro se o cálculo do momento for bem-sucedido, caso contrário, falso.

bool MathMomentsNormal(
  const double   mu,          // [in]  Valor esperado
  const double   sigma,       // [in]  desvio do valor quadrático médio
  double         &mean,       // [out] Variável para a média(1º momento)
  double         &variance,   // [out] Variável para a variância (2º momento)
  double         &skewness,   // [out] Variável para a assimetria (3º momento)
  double         &kurtosis,   // [out] Variável para a curtose (4º momento)
  int            &error_code  // [out] Variável para o código de erro
);


2.2. Distribuição do Log-normal

2.2.1. MathProbabilityDensityLognormal

Calcula o valor da probabilidade da função de densidade da distribuição log-normal com os parâmetros mu e sigma para uma variável x aleatória. Em caso de erro, retorna NaN.

double MathProbabilityDensityLognormal(
  const double   x,           // [in]  Valor de uma variável aleatória
  const double   mu,          // [in]  Logaritmo do valor esperado (log médio)
  const double   sigma,       // [in]  Logaritmo do desvio quadrático-médio (log do desvio padrão)
  const bool     log_mode,    // [in]  Flag Para calcular o logaritmo do valor, se log_mode = true, então o logaritmo natural da densidade de probabilidade é retornado
  int            &error_code  // [out] Variável para o código de erro
);

Calcula o valor da probabilidade da função de densidade da distribuição log-normal com os parâmetros mu e sigma para uma variável x aleatória. Em caso de erro, retorna NaN.

double MathProbabilityDensityLognormal(
  const double   x,           // [in]  Valor de uma variável aleatória
  const double   mu,          // [in]  Logaritmo do valor esperado (log médio)
  const double   sigma,       // [in]  Logaritmo do desvio quadrático-médio (log do desvio padrão)
  int            &error_code  // [out] Variável para o código de erro
);

Calcula o valor da função de densidade de probabilidade da distribuição log-normal com os parâmetros mu e sigma para um array de variáveis aleatórias x[]. Em caso de erro, retorna NaN. Análoga da dlnorm() em R.

bool MathProbabilityDensityLognormal(
  const double   &x[],        // [in]  Array com os valores da variável aleatória
  const double   mu,          // [in]  Logaritmo do valor esperado (log médio)
  const double   sigma,       // [in]  Logaritmo do desvio quadrático-médio (log do desvio padrão)
  const bool     log_mode,    // [in]  Flag Para calcular o logaritmo do valor, se log_mode=true, então o logaritmo natural da densidade de probabilidade é calculado
  double         &result[]    // [out] Array para valores da função de densidade de probabilidade
);

Calcula o valor da função de densidade de probabilidade da distribuição log-normal com os parâmetros mu e sigma para um array de variáveis aleatórias x[]. Em caso de erro ele retorna falso.

bool MathProbabilityDensityLognormal(
  const double   &x[],        // [in]  Array com os valores da variável aleatória
  const double   mu,          // [in]  Logaritmo do valor esperado (log médio)
  const double   sigma,       // [in]  Logaritmo do desvio quadrático-médio (log do desvio padrão)
  double         &result[]    // [out] Array para valores da função de densidade de probabilidade
);


2.2.2. MathCumulativeDistributionLognormal

Calcula o valor da função de distribuição log-normal com os parâmetros mu e sigma para uma variável x aleatória. Em caso de erro, retorna NaN.

double MathCumulativeDistributionLognormal(
  const double   x,           // [in]  Valor de uma variável aleatória
  const double   mu,          // [in]  Logaritmo do valor esperado (log médio)
  const double   sigma,       // [in]  Logaritmo do desvio quadrático-médio (log do desvio padrão)
  const bool     tail,        // [in]  Flag do cálculo, se true, então a probabilidade de variável aleatória não excedendo x é calculada
  const bool     log_mode,    // [in]  Flag para calcular o logaritmo do valor, se log_mode=true, então o logaritmo natural da probabilidade é calculado
  int            &error_code  // [out] Variável para o código de erro
);

Calcula o valor da função de distribuição log-normal com os parâmetros mu e sigma para uma variável x aleatória. Em caso de erro, retorna NaN.

double MathCumulativeDistributionLognormal(
  const double   x,           // [in]  Valor de uma variável aleatória
  const double   mu,          // [in]  Logaritmo do valor esperado (log médio)
  const double   sigma,       // [in]  Logaritmo do desvio quadrático-médio (log do desvio padrão)
  int            &error_code  // [out] Variável para o código de erro
);

Calcula o valor da função de distribuição log-normal com os parâmetros mu e sigma para um array de variáveis aleatórias x[]. Em caso de erro ele retorna falso. Análoga da plnorm() em R.

bool MathCumulativeDistributionLognormal(
  const double   &x[],        // [in]  Array com os valores da variável aleatória
  const double   mu,          // [in]  Logaritmo do valor esperado (log médio)
  const double   sigma,       // [in]  Logaritmo do desvio quadrático-médio (log do desvio padrão)
  const bool     tail,        // [in]  Flag do cálculo, se true, então a probabilidade de variável aleatória não excedendo x é calculada
  const bool     log_mode,    // [in]  Flag para calcular o logaritmo do valor, se log_mode=true, então o logaritmo natural da probabilidade é calculado
  double         &result[]    // [out] Array para valores da função de probabilidade
);

Calcula o valor da função de distribuição log-normal com os parâmetros mu e sigma para um array de variáveis aleatórias x[]. Em caso de erro ele retorna falso.

bool MathCumulativeDistributionLognormal(
  const double   &x[],        // [in]  Array com os valores da variável aleatória
  const double   mu,          // [in]  Logaritmo do valor esperado (log médio)
  const double   sigma,       // [in]  Logaritmo do desvio quadrático-médio (log do desvio padrão)
  double         &result[]    // [out] Array para valores da função de probabilidade
);


2.2.3. MathQuantileLognormal

Calcula o valor da função de distribuição log-normal inversa com os parâmetros mu e sigma para a probabilidade específica. Em caso de erro, retorna NaN.

double MathQuantileLognormal(
  const double   probability, // [in]  O valor de probabilidade da ocorrência da variável aleatória
  const double   mu,          // [in]  Logaritmo do valor esperado (log médio)
  const double   sigma,       // [in]  Logaritmo do desvio quadrático-médio (log do desvio padrão)
  const bool     tail,        // [in]  Flag de cálculo, se for falsa, então o cálculo é realizado pela probabilidade 1.0
  const bool     log_mode,    // [in]  Flag do cálculo, se log_mode=true, o cálculo é realizado para Exp(probabilidade)
  int            &error_code  // [out] Variável para o código de erro
);

Calcula o valor da função de distribuição log-normal inversa com os parâmetros mu e sigma para a probabilidade específica. Em caso de erro, retorna NaN.

double MathQuantileLognormal(
  const double   probability, // [in]  O valor de probabilidade da ocorrência da variável aleatória
  const double   mu,          // [in]  Logaritmo do valor esperado (log médio)
  const double   sigma,       // [in]  Logaritmo do desvio quadrático-médio (log do desvio padrão)
  int            &error_code  // [out] Variável para o código de erro
);

Para o array especifico de valores de probabilidade 'probability[]', é calculado os valores da função de distribuição log-normal inversa com os parâmetros mu e sigma. Em caso de erro ele retorna falso. Analoga da qlnorm() em R.

bool MathQuantileLognormal(
  const double   &probability[], // [in]  Array com valores de probabilidade da variável aleatória
  const double   mu,             // [in]  Logaritmo do valor esperado (log médio)
  const double   sigma,          // [in]  Logaritmo de desvio do valor quadrático médio (desvio do log padrão)
  const bool     tail,           // [in]  Flag de cálculo, se for falsa, então o cálculo é realizado pela probabilidade 1.0
  const bool     log_mode,       // [in]  Flag do cálculo, se false, então o cálculo é executado pela Exp(probabilidade)
  double         &result[]       // [out] Array com valores de quantis
);

Para o array especifico de valores de probabilidade 'probability[]', é calculado os valores da função de distribuição log-normal inversa com os parâmetros mu e sigma. Em caso de erro ele retorna falso.

bool MathQuantileLognormal(
  const double   &probability[], // [in]  Array com valores de probabilidade da variável aleatória
  const double   mu,             // [in]  Logaritmo do valor esperado (log médio)
  const double   sigma,          // [in]  Logaritmo do desvio do valor quadrático médio (desvio padrão do log)
  double         &result[]       // [out] Array com valores de quantis
);


2.2.4. MathRandomLognormal

A função gera uma variável pseudo-aleatória distribuída de acordo com a lei do log-normal com os parâmetros mu e sigma. Em caso de erro, retorna NaN.

double MathRandomLognormal(
  const double   mu,          // [in]  Logaritmo do valor esperado (log médio)
  const double   sigma,       // [in]  Logaritmo do valor quadrático médio (log do desvio padrão)
  int            &error_code  // [out] Variável para o código de erro
);

A função gera variáveis pseudo-aleatórias distribuídas de acordo com a lei log-normal com os parâmetros mu e sigma. Em caso de erro ele retorna falso. Analoga da rlnorm() em R.

bool MathRandomLognormal(
  const double   mu,          // [in]  Logaritmo do valor esperado (log médio)
  const double   sigma,       // [in]  Logaritmo do valor quadrático médio (log do desvio padrão)
  const int      data_count,  // [in]  Quantidade de dados requeridos
  double         &result[]    // [out] Array Com valores de variáveis pseudo-aleatórias
);


2.2.5. MathMomentsLognormal

Calcula os valores numéricos teóricos dos primeiros 4 momentos da distribuição do log-normal. Retorna verdadeiro se o cálculo do momento for bem-sucedido, caso contrário, falso.

bool MathMomentsLognormal(
  const double   mu,          // [in]  Logaritmo do valor esperado (log médio)
  const double   sigma,       // [in]  Logaritmo do valor quadrático médio (log do desvio padrão)
  double         &mean,       // [out] Variável para a média(1º momento)
  double         &variance,   // [out] Variável para a variância (2º momento)
  double         &skewness,   // [out] Variável para a assimetria (3º momento)
  double         &kurtosis,   // [out] Variável para a curtose (4º momento)
  int            &error_code  // [out] Variável para o código de erro
);


2.3. Distribuição beta

2.3.1. MathProbabilityDensityBeta

Calcula o valor da probabilidade da função de densidade da distribuição beta com os parâmetros "a" e "b" para uma variável aleatória x. Em caso de erro, retorna NaN.

double MathProbabilityDensityBeta(
  const double   x,           // [in]  Valor de uma variável aleatória
  const double   a,           // [in]  O primeiro parâmetro da distribuição beta (shape1)
  const double   b,           // [in]  O segundo parâmetro da distribuição beta (shape2)
  const bool     log_mode,    // [in]  Flag Para calcular o logaritmo do valor, se log_mode = true, então o logaritmo natural da densidade de probabilidade é retornado
  int            &error_code  // [out] Variável para o código de erro
);

Calcula o valor da probabilidade da função de densidade da distribuição beta com os parâmetros "a" e "b" para uma variável aleatória x. Em caso de erro, retorna NaN.

double MathProbabilityDensityBeta(
  const double   x,           // [in]  Valor de uma variável aleatória
  const double   a,           // [in]  O primeiro parâmetro da distribuição beta (shape1)
  const double   b,           // [in]  O segundo parâmetro da distribuição beta (shape2)
  int            &error_code  // [out] Variável para o código de erro
);

Calcula o valor da função de densidade de probabilidade da distribuição beta com os parâmetros a e b para um array de variáveis aleatórias x[]. Em caso de erro ele retorna falso. Analoga da dbeta() em R.

bool MathProbabilityDensityBeta(
  const double   &x[],        // [in]  Valor da variavel aleatória
  const double   a,           // [in]  O primeiro parâmetro da distribuição beta (shape1)
  const double   b,           // [in]  O segundo parâmetro da distribuição beta (shape2)
  const bool     log_mode,    // [in]  Flag Para calcular o logaritmo do valor, se log_mode=true, então o logaritmo natural da densidade de probabilidade é calculado
  double         &result[]    // [out] Array para valores da função de densidade de probabilidade
);

Calcula o valor da função de densidade de probabilidade da distribuição beta com os parâmetros a e b para um array de variáveis aleatórias x[]. Em caso de erro ele retorna falso.

bool MathProbabilityDensityBeta(
  const double   &x[],        // [in]  Valor da variavel aleatória
  const double   a,           // [in]  O primeiro parâmetro da distribuição beta (shape1)
  const double   b,           // [in]  O segundo parâmetro da distribuição beta (shape2)
  double         &result[]    // [out] Array para valores da função de densidade de probabilidade
);


2.3.2. MathCumulativeDistributionlBeta

Calcula o valor de probabilidade da função de distribuição beta com os parâmetros "a" e "b" para uma variável aleatória x. Em caso de erro, retorna NaN.

double MathCumulativeDistributionBeta(
  const double   x,           // [in]  Valor da variável aleatória
  const double   a,           // [in]  O primeiro parâmetro da distribuição beta (shape1)
  const double   b,           // [in]  O segundo parâmetro da distribuição beta (shape2)
  const bool     tail,        // [in]  Flag do cálculo, se true, então a probabilidade de variável aleatória não excedendo x é calculada
  const bool     log_mode,    // [in]  Flag para calcular o logaritmo do valor, se log_mode=true, então o logaritmo natural da probabilidade é calculado
  int            &error_code  // [out] Variável para o código de erro
);

Calcula o valor de probabilidade da função de distribuição beta com os parâmetros "a" e "b" para uma variável aleatória x. Em caso de erro, retorna NaN.

double MathCumulativeDistributionBeta(
  const double   x,           // [in]  Valor da variável aleatória
  const double   a,           // [in]  O primeiro parâmetro da distribuição beta (shape1)
  const double   b,           // [in]  O segundo parâmetro da distribuição beta (shape2)
  int            &error_code  // [out] Variável para o código de erro
);

Calcula o valor da função de distribuição de probabilidade da distribuição beta com os parâmetros a e b para um array de variáveis aleatórias x[]. Em caso de erro ele retorna falso. Análoga da pbeta() em R.

bool MathCumulativeDistributionBeta(
  const double   &x[],        // [in]  Array com os valores da variável aleatória
  const double   a,           // [in]  O primeiro parâmetro da distribuição beta (shape1)
  const double   b,           // [in]  O segundo parâmetro da distribuição beta (shape2)
  const bool     tail,        // [in]  Flag do cálculo, se true, então a probabilidade de variável aleatória não excedendo x é calculada
  const bool     log_mode,    // [in]  Flag para calcular o logaritmo do valor, se log_mode=true, então o logaritmo natural da probabilidade é calculado
  double         &result[]    // [out] Array para valores da função de probabilidade
);

Calcula o valor da função de distribuição de probabilidade da distribuição beta com os parâmetros a e b para um array de variáveis aleatórias x[]. Em caso de erro ele retorna falso.

bool MathCumulativeDistributionBeta(
  const double   &x[],        // [in]  Array com os valores da variável aleatória
  const double   a,           // [in]  O primeiro parâmetro da distribuição beta (shape1)
  const double   b,           // [in]  O segundo parâmetro da distribuição beta (shape2)
  double         &result[]    // [out] Array para valores da função de probabilidade
);


2.3.3. MathQuantileBeta

Para a probabilidade específica, calcula o valor da função de distribuição beta inversa com os parâmetros "a" e "b". Em caso de erro, retorna NaN.

double MathQuantileBeta(
  const double   probability,   // [in]  O valor de probabilidade da ocorrência da variável aleatória
  const double   a,             // [in]  O primeiro parâmetro da distribuição beta (shape1)
  const double   b,             // [in]  O segundo parâmetro da distribuição beta (shape2)
  const bool     tail,          // [in]  Bandeira de cálculo, se for falsa, então o cálculo é realizado pela probabilidade 1.0
  const bool     log_mode,      // [in]  Flag de cálculo, se log_mode=true, o cálculo é realizado pelo Exp(probabilidade)
  int            &error_code    // [out] Variável para o código de erro
);

Para a probabilidade específica, calcula o valor da função de distribuição beta inversa com os parâmetros "a" e "b". Em caso de erro, retorna NaN.

double MathQuantileBeta(
  const double   probability,   // [in]  O valor de probabilidade da ocorrência da variável aleatória
  const double   a,             // [in]  O primeiro parâmetro da distribuição beta (shape1)
  const double   b,             // [in]  O segundo parâmetro da distribuição beta (shape2)
  int            &error_code    // [out] Variável para o código de erro
);

Para o array especifico de valores de probabilidade 'probability[]', é calculado os valores da função de distribuição beta inversa com os parâmetros a e b. Em caso de erro ele retorna falso. Análoga da qbeta() em1 R.

bool MathQuantileBeta(
  const double   &probability[],// [in]  Array com valores de probabilidade de variável aleatória
  const double   a,             // [in]  O primeiro parâmetro da distribuição beta (shape1)
  const double   b,             // [in]  O segundo parâmetro da distribuição beta (shape2)
  const bool     tail,          // [in]  Bandeira de cálculo, se for falsa, então o cálculo é realizado pela probabilidade 1.0
  const bool     log_mode,      // [in]  Flag de cálculo, se log_mode=true, o cálculo é realizado pelo Exp(probabilidade)
  double         &result[]      // [out] Array com valor de quantis
);

Para o array especifico de valores de probabilidade 'probability[]', é calculado os valores da função de distribuição beta inversa com os parâmetros a e b. Em caso de erro ele retorna falso.

bool MathQuantileBeta(
  const double   &probability[],// [in]  Array com valores de probabilidade de variável aleatória
  const double   a,             // [in]  O primeiro parâmetro da distribuição beta (shape1)
  const double   b,             // [in]  O segundo parâmetro da distribuição beta (shape2)
  double         &result[]      // [out] Array com valor de quantis
);


2.3.4. MathRandomBeta

A função gera uma variável pseudo-aleatória distribuída de acordo com a lei de distribuição beta com os parâmetros "a" e "b". Em caso de erro, retorna NaN.

double MathRandomBeta(
  const double   a,           // [in]  O primeiro parâmetro da distribuição beta (shape1)
  const double   b,           // [in]  O segundo parâmetro da distribuição beta (shape2)
  int            &error_code  // [out] Variável do codigo de erro
);

A função gera variáveis pseudo-aleatórias distribuídas de acordo com a lei de distribuição beta com os parâmetros a e b. Em caso de erro ele retorna falso. Análoga da rbeta() em R.

bool MathRandomBeta(
  const double   a,           // [in]  O primeiro parâmetro da distribuição beta (shape1)
  const double   b,           // [in]  O segundo parâmetro da distribuição beta (shape2)
  const int      data_count,  // [in]  Quantidade de dados requeridos
  double         &result[]    // [out] Array Com valores de variáveis pseudo-aleatórias
);


2.3.5. MathMomentsBeta

Calcula os valores numéricos teóricos dos primeiros 4 momentos da distribuição beta. Retorna verdadeiro se o cálculo do momento for bem-sucedido, caso contrário, falso.

bool MathMomentsBeta(
  const double   a,           // [in]  O primeiro parâmetro da distribuição beta (shape1)
  const double   b,           // [in]  O segundo parâmetro da distribuição beta (shape2)
  double         &mean,       // [out] Variável para a média(1º momento)
  double         &variance,   // [out] Variável para a variância (2º momento)
  double         &skewness,   // [out] Variável para a assimetria (3º momento)
  double         &kurtosis,   // [out] Variável para a curtose (4º momento)
  int            &error_code  // [out] Variável para o código de erro
);


2.4. Distribuição beta não-central

2.4.1. MathProbabilityDensityNoncentralBeta

Calcula o valor da probabilidade da função de densidade da distribuição beta não central com os parâmetros "a", "b" e lambda para uma variável aleatória x. Em caso de erro, retorna NaN.
double MathProbabilityDensityNoncentralBeta(
  const double   x,           // [in]  Valor da variável aleatória
  const double   a,           // [in]  O primeiro parâmetro da distribuição beta (shape1)
  const double   b,           // [in]  O segundo parâmetro da distribuição beta (shape2)
  const double   lambda,      // [in]  Parâmetro não centralizado
  const bool     log_mode,    // [in]  Flag Para calcular o logaritmo do valor, se log_mode = true, então o logaritmo natural da densidade de probabilidade é retornado
  int            &error_code  // [out] Variável para o código de erro
);

Calcula o valor da probabilidade da função de densidade da distribuição beta não central com os parâmetros "a", "b" e lambda para uma variável aleatória x. Em caso de erro, retorna NaN.

double MathProbabilityDensityNoncentralBeta(
  const double   x,           // [in]  Valor da variável aleatória
  const double   a,           // [in]  O primeiro parâmetro da distribuição beta (shape1)
  const double   b,           // [in]  O segundo parâmetro da distribuição beta (shape2)
  const double   lambda,      // [in]  Parâmetro não centralizado
  int            &error_code  // [out] Variável para o código de erro
);

Calcula o valor da função de densidade de probabilidade da distribuição beta não central com os parâmetros a, b e lambda para um array de variáveis aleatórias x[]. Em caso de erro ele retorna falso. Analoga da dbeta() em R.

bool MathProbabilityDensityNoncentralBeta(
  const double   &x[],        // [in]  Array com os valores da variável aleatória
  const double   a,           // [in]  O primeiro parâmetro da distribuição beta (shape1)
  const double   b,           // [in]  O segundo parâmetro da distribuição beta (shape2)
  const double   lambda,      // [in]  Parâmetro não centralizado
  const bool     log_mode,    // [in]  Flag Para calcular o logaritmo do valor, se log_mode = true, então o logaritmo natural da densidade de probabilidade é retornado
  double         &result[]    // [out] Array para valores da função de densidade de probabilidade
);

Calcula o valor da função de densidade de probabilidade da distribuição beta não central com os parâmetros a, b e lambda para um array de variáveis aleatórias x[]. Em caso de erro ele retorna falso.

bool MathProbabilityDensityNoncentralBeta(
  const double   &x[],        // [in]  Array com os valores da variável aleatória
  const double   a,           // [in]  O primeiro parâmetro da distribuição beta (shape1)
  const double   b,           // [in]  O segundo parâmetro da distribuição beta (shape2)
  const double   lambda,      // [in]  Parâmetro não centralizado
  double         &result[]    // [out] Array para valores da função de densidade de probabilidade
);


2.4.2. MathCumulativeDistributionNoncentralBeta

Calcula o valor da probabilidade da função de distribuição beta não central com os parâmetros "a" e "b" para uma variável aleatória x. Em caso de erro, retorna NaN.

double MathCumulativeDistributionNoncentralBeta(
  const double   x,           // [in]  Valor da variável aleatória
  const double   a,           // [in]  O primeiro parâmetro da distribuição beta (shape1)
  const double   b,           // [in]  O segundo parâmetro da distribuição beta (shape2)
  const double   lambda,      // [in]  Parâmetro não centralizado
  const bool     tail,        // [in]  Flag do cálculo, se true, então a probabilidade de variável aleatória não excedendo x é calculada
  const bool     log_mode,    // [in]  Flag para calcular o logaritmo do valor, se log_mode=true, então o logaritmo natural da probabilidade é calculado
  int            &error_code  // [out] Variável para o código de erro
);

Calcula o valor da probabilidade da função de distribuição beta não central com os parâmetros "a" e "b" para uma variável aleatória x. Em caso de erro, retorna NaN.

double MathCumulativeDistributionNoncentralBeta(
  const double   x,           // [in]  Valor da variável aleatória
  const double   a,           // [in]  O primeiro parâmetro da distribuição beta (shape1)
  const double   b,           // [in]  O segundo parâmetro da distribuição beta (shape2)
  const double   lambda,      // [in]  Parâmetro não centralizado
  int            &error_code  // [out] Variável para o código de erro
);

Calcula o valor da função de distribuição de probabilidade da distribuição beta não central com os parâmetros a e b para um conjunto de variáveis aleatórias x[]. Em caso de erro ele retorna falso. Análoga da pbeta() em R.

bool MathCumulativeDistributionNoncentralBeta(
  const double   &x[],        // [in]  Array com os valores da variável aleatória
  const double   a,           // [in]  O primeiro parâmetro da distribuição beta (shape1)
  const double   b,           // [in]  O segundo parâmetro da distribuição beta (shape2)
  const double   lambda,      // [in]  Parâmetro não centralizado
  const bool     tail,        // [in]  Flag do cálculo, se true, então a probabilidade de variável aleatória não excedendo x é calculada
  const bool     log_mode,    // [in]  Flag para calcular o logaritmo do valor, se log_mode=true, então o logaritmo natural da probabilidade é calculado
  double         &result[]    // [out] Array para valores da função de probabilidade
);

Calcula o valor da função de distribuição de probabilidade da distribuição beta não central com os parâmetros a e b para um conjunto de variáveis aleatórias x[]. Em caso de erro ele retorna falso.

bool MathCumulativeDistributionNoncentralBeta(
  const double   &x[],        // [in]  Array com os valores da variável aleatória
  const double   a,           // [in]  O primeiro parâmetro da distribuição beta (shape1)
  const double   b,           // [in]  O segundo parâmetro da distribuição beta (shape2)
  const double   lambda,      // [in]  Parâmetro não centralizado
  double         &result[]    // [out] Array para valores da função de probabilidade
);


2.4.3. MathQuantileNoncentralBeta

Calcula o valor da probabilidade inversa da função de distribuição beta não central com os parâmetros "a", "b" e lambda para a ocorrência de uma variável aleatória x. Em caso de erro, retorna NaN.

double MathQuantileNoncentralBeta(
  const double   probability,   // [in]  O valor de probabilidade da ocorrência da variável aleatória
  const double   a,             // [in]  O primeiro parâmetro da distribuição beta (shape1)
  const double   b,             // [in]  O segundo parâmetro da distribuição beta (shape2)
  const double   lambda,        // [in]  Parametro não centralizado
  const bool     tail,          // [in]  Bandeira de cálculo, se for falsa, então o cálculo é realizado pela probabilidade 1.0
  const bool     log_mode,      // [in]  Flag de cálculo, se log_mode=true, o cálculo é realizado pelo Exp(probabilidade)
  int            &error_code    // [out] Variável para o código de erro
);

Calcula o valor da probabilidade inversa da função de distribuição beta não central com os parâmetros "a", "b" e lambda para a ocorrência de uma variável aleatória x. Em caso de erro, retorna NaN.

double MathQuantileNoncentralBeta(
  const double   probability,   // [in]  O valor de probabilidade da ocorrência da variável aleatória
  const double   a,             // [in]  O primeiro parâmetro da distribuição beta (shape1)
  const double   b,             // [in]  O segundo parâmetro da distribuição beta (shape2)
  const double   lambda,        // [in]  Parâmetro não centralizado
  int            &error_code    // [out] Variável para o código de erro
);

Para o array especificado de valores de probabilidade 'probability[]', é calculado o valor da função de distribuição de probabilidade inversa da distribuição beta não central com os parâmetros a, b e lambda. Em caso de erro ele retorna falso. Análoga da qbeta() em1 R.

bool MathQuantileNoncentralBeta(
  const double   &probability[],// [in]  Array com valores de probabilidade de variável aleatória
  const double   a,             // [in]  O primeiro parâmetro da distribuição beta (shape1)
  const double   b,             // [in]  O segundo parâmetro da distribuição beta (shape2)
  const double   lambda,        // [in]  Parâmetro não centralizado
  const bool     tail,          // [in]  Bandeira de cálculo, se for falsa, então o cálculo é realizado pela probabilidade 1.0
  const bool     log_mode,      // [in]  Flag de cálculo, se log_mode=true, o cálculo é realizado pelo Exp(probabilidade)
  double         &result[]      // [out] Array com valor de quantis
);

Para o array especificado de valores de probabilidade 'probability[]', é calculado o valor da função de distribuição de probabilidade inversa da distribuição beta não central com os parâmetros a, b e lambda. Em caso de erro ele retorna falso.

bool MathQuantileNoncentralBeta(
  const double   &probability[],// [in]  Array com valores de probabilidade de variável aleatória
  const double   a,             // [in]  O primeiro parâmetro da distribuição beta (shape1)
  const double   b,             // [in]  O segundo parâmetro da distribuição beta (shape2)
  const double   lambda,        // [in]  Parâmetro não centralizado
  double         &result[]      // [out] Array com valor de quantis
);


2.4.4. MathRandomNoncentralBeta

A função gera uma variável pseudo-aleatória distribuída de acordo com a lei da distribuição beta não central os parâmetros "a", "b" e lambda. Em caso de erro, retorna NaN.

double MathRandomNoncentralBeta(
  const double   a,           // [in]  O primeiro parâmetro da distribuição beta (shape1)
  const double   b,           // [in]  O segundo parâmetro da distribuição beta (shape2)
  const double   lambda,      // [in]  Parâmetro não centralizado
  int            &error_code  // [out] Variável para o código de erro
);

A função gera variáveis pseudo-aleatórias distribuídas de acordo com a lei da distribuição beta não central dos parâmetros a, b e lambda. Em caso de erro ele retorna falso. Análoga da rbeta() em R.

bool MathRandomNoncentralBeta(
  const double   a,           // [in]  O primeiro parâmetro da distribuição beta (shape1)
  const double   b,           // [in]  O segundo parâmetro da distribuição beta (shape2)
  const double   lambda,      // [in]  Parâmetro não centralizado
  const int      data_count,  // [in]  Quantidade de dados requeridos
  double         &result[]    // [out] Array Com valores de variáveis pseudo-aleatórias
);


2.4.5. MathMomentsNoncentralBeta

Calcula os valores numéricos teóricos dos primeiros 4 momentos da distribuição beta não central com os parâmetros "a", "b" e lambda. Retorna verdadeiro se o cálculo do momento for bem-sucedido, caso contrário, falso.

double MathMomentsNoncentralBeta(
  const double   a,           // [in]  O primeiro parâmetro da distribuição beta (shape1)
  const double   b,           // [in]  O segundo parâmetro da distribuição beta (shape2)
  const double   lambda,      // [in]  Parâmetro não centralizado
  double         &mean,       // [out] Variável para a média(1º momento)
  double         &variance,   // [out] Variável para a variância (2º momento)
  double         &skewness,   // [out] Variável para a assimetria (3º momento)
  double         &kurtosis,   // [out] Variável para a curtose (4º momento)
  int            &error_code  // [out] Variável para o código de erro
);


2.5. Distribuição Gama

2.5.1. MathProbabilityDensityGamma

Calcula o valor da probabilidade da função de densidade da distribuição gama com os parâmetros "a" e "b" para uma variável aleatória x. Em caso de erro, retorna NaN.
double MathProbabilityDensityGamma(
  const double   x,           // [in]  Valor da variável aleatória
  const double   a,           // [in]  O primeiro parâmetro da distribuição (shape)
  const double   b,           // [in]  O segundo parâmetro da distribuição (scale)
  const bool     log_mode,    // [in]  Flag para calcular o logaritmo do valor, se log_mode=true, então o logaritmo natural da densidade de probabilidade é calculado
  int            &error_code  // [out] Variável para o código de erro
);

Calcula o valor da probabilidade da função de densidade da distribuição gama com os parâmetros "a" e "b" para uma variável aleatória x. Em caso de erro, retorna NaN.

double MathProbabilityDensityGamma(
  const double   x,           // [in]  Valor da variável aleatória
  const double   a,           // [in]  O primeiro parâmetro da distribuição (shape)
  const double   b,           // [in]  O segundo parâmetro da distribuição (scale)
  int            &error_code  // [out] Variável para o código de erro
);

A função calcula o valor da função de densidade de probabilidade da distribuição gama com os parâmetros a e b para um array de variáveis aleatórias x[]. Em caso de erro ele retorna falso. Análoga da dgamma() em R.

bool MathProbabilityDensityGamma(
  const double   &x[],        // [in]  Array com os valores da variável aleatória
  const double   a,           // [in]  O primeiro parâmetro da distribuição (shape)
  const double   b,           // [in]  O segundo parâmetro da distribuição (scale)
  const bool     log_mode,    // [in]  Flag para calcular o logaritmo do valor, se log_mode=true, então o logaritmo natural da densidade de probabilidade é calculado
  double         &result[]    // [out] Array para valores da função de densidade de probabilidade
);

A função calcula o valor da função de densidade de probabilidade da distribuição gama com os parâmetros a e b para um array de variáveis aleatórias x[]. Em caso de erro ele retorna falso.

bool MathProbabilityDensityGamma(
  const double   &x[],        // [in]  Array com os valores da variável aleatória
  const double   a,           // [in]  O primeiro parâmetro da distribuição (shape)
  const double   b,           // [in]  O segundo parâmetro da distribuição (scale)
  double         &result[]    // [out] Array para valores da função de densidade de probabilidade
);


2.5.2. MathCumulativeDistributionGamma

Calcula o valor da função de distribuição gama com os parâmetros "a" e "b" para uma variável aleatória x. Em caso de erro, retorna NaN.

double MathCumulativeDistributionGamma(
  const double   x,           // [in]  Valor da variável aleatória
  const double   a,           // [in]  O primeiro parâmetro da distribuição (shape)
  const double   b,           // [in]  O segundo parâmetro da distribuição (scale)
  const bool     tail,        // [in]  Flag de cálculo, se for verdadeira, então a probabilidade da variável aleatória não excedendo x é calculada
  const bool     log_mode,    // [in]  Flag para calcular o logaritmo do valor, se log_mode=true, então o logaritmo natural da probabilidade é calculado
  int            &error_code  // [out] Variável para o código de erro
);

Calcula o valor da função de distribuição gama com os parâmetros "a" e "b" para uma variável aleatória x. Em caso de erro, retorna NaN.

double MathCumulativeDistributionGamma(
  const double   x,           // [in]  Valor da variável aleatória
  const double   a,           // [in]  O primeiro parâmetro da distribuição (shape)
  const double   b,           // [in]  O segundo parâmetro da distribuição (scale)
  int            &error_code  // [out] Variável para o código de erro
);

Calcula o valor da função de distribuição gama com os parâmetros a e b para um array de variáveis aleatórias x[]. Em caso de erro ele retorna falso. Análoga da pgamma() em R.

bool MathCumulativeDistributionGamma(
  const double   &x[],        // [in]  Array com os valores da variável aleatória
  const double   a,           // [in]  O primeiro parâmetro da distribuição (shape)
  const double   b,           // [in]  O segundo parâmetro da distribuição (scale)
  const bool     tail,        // [in]  Flag de cálculo, se for verdadeira, então a probabilidade da variável aleatória não excedendo x é calculada
  const bool     log_mode,    // [in]  Flag para calcular o logaritmo do valor, se log_mode=true, então o logaritmo natural da probabilidade é calculado
  double         &result[]    // [out] Array para valores da função de probabilidade
);

Calcula o valor da função de distribuição gama com os parâmetros a e b para um array de variáveis aleatórias x[]. Em caso de erro ele retorna falso.

bool MathCumulativeDistributionGamma(
  const double   &x[],        // [in]  Array com os valores da variável aleatória
  const double   a,           // [in]  O primeiro parâmetro da distribuição (shape)
  const double   b,           // [in]  O segundo parâmetro da distribuição (scale)
  double         &result[]    // [out] Array para valores da função de probabilidade
);


2.5.3. MathQuantileGamma

Para a probabilidade específica, calcula o valor da função de distribuição gama com os parâmetros "a" e "b". Em caso de erro, retorna NaN.

double MathQuantileGamma(
  const double   probability,   // [in]  O valor de probabilidade da ocorrência da variável aleatória
  const double   a,             // [in]  O primeiro parâmetro de distribuição (forma)
  const double   b,             // [in]  O segundo parâmetro de distribuição (scale)
  const bool     tail,          // [in]  Flag de cálculo, se for falsa, então o cálculo é realizado pela probabilidade 1.0
  const bool     log_mode,      // [in]  Flag de cálculo, se log_mode=true, o cálculo é realizado pelo Exp(probabilidade)
  int            &error_code    // [out] Variável para o código de erro
);

Para a probabilidade específica, calcula o valor da função de distribuição gama com os parâmetros "a" e "b". Em caso de erro, retorna NaN.

double MathQuantileGamma(
  const double   probability,   // [in]  O valor de probabilidade da ocorrência da variável aleatória
  const double   a,             // [in]  O primeiro parâmetro de distribuição (forma)
  const double   b,             // [in]  O segundo parâmetro de distribuição (scale)
  int            &error_code    // [out] Variável para o código de erro
);

Para o array especificado de valores de probabilidade 'probability[]', é calculado o valor da função de distribuição de gama inversa com os parâmetros a e b. Em caso de erro ele retorna falso. Análoga da qgamma() em R.

bool MathQuantileGamma(
  const double   &probability[],// [in]  Array com valores de probabilidade de variável aleatória
  const double   a,             // [in]  O primeiro parâmetro de distribuição (forma)
  const double   b,             // [in]  O segundo parâmetro de distribuição (scale)
  const bool     tail,          // [in]  Bandeira de cálculo, se for falsa, então o cálculo é realizado pela probabilidade 1.0
  const bool     log_mode,      // [in]  Flag do cálculo, se false, então o cálculo é executado pela Exp(probabilidade)
  double         &result[]      // [out] Array com valor de quantis
);

Para o array especificado de valores de probabilidade 'probability[]', é calculado o valor da função de distribuição de gama inversa com os parâmetros a e b. Em caso de erro ele retorna falso.

bool MathQuantileGamma(
  const double   &probability[],// [in]  Array com valores de probabilidade de variável aleatória
  const double   a,             // [in]  O primeiro parâmetro de distribuição (forma)
  const double   b,             // [in]  O segundo parâmetro de distribuição (scale)
  double         &result[]      // [out] Array com valor de quantis
);


2.5.4. MathRandomGamma

A função gera uma variável pseudo-aleatória distribuída de acordo com a lei de distribuição gama com os parâmetros "a" e "b". Em caso de erro, retorna NaN.

double MathRandomGamma(
  const double   a,           // [in]  O primeiro parâmetro de distribuição (shape)
  const double   b,           // [in]  O segundo parâmetro da distribuição (scale)
  int            &error_code  // [out] Variável para o código de erro
);

A função gera variáveis pseudo-aleatórias distribuídas de acordo com a lei da distribuição gama com os parâmetros a e b. Em caso de erro ele retorna falso. Análoga da rgamma() em R.

bool MathRandomGamma(
  const double   a,           // [in]  O primeiro parâmetro de distribuição (shape)
  const double   b,           // [in]  O segundo parâmetro da distribuição (scale)
  const int      data_count,  // [in]  Quantidade de dados requeridos
  double         &result[]    // [out] Array Com valores de variáveis pseudo-aleatórias
);


2.5.5. MathMomentsGamma

Calcula os valores numéricos teóricos dos primeiros 4 momentos da distribuição gama com os parâmetros"a" e "b". Retorna verdadeiro se o cálculo do momento for bem-sucedido, caso contrário, falso.

bool MathMomentsGamma(
  const double   a,           // [in]  O primeiro parâmetro da distribuição (shape)
  const double   b,           // [in]  O segundo parâmetro da distribuição (scale)
  double         &mean,       // [out] Variável para a média(1º momento)
  double         &variance,   // [out] Variável para a variância (2º momento)
  double         &skewness,   // [out] Variável para a assimetria (3º momento)
  double         &kurtosis,   // [out] Variável para a curtose (4º momento)
  int            &error_code  // [out] Variável para o código de erro
);


2.6. Distribuição Qui-quadrado

2.6.1. MathProbabilityDensityChiSquare

Calcula o valor da probabilidade da função de densidade da distribuição do qui-quadrado com o parâmetro nu para uma variável aleatória x. Em caso de erro, retorna NaN.

double MathProbabilityDensityChiSquare(
  const double   x,           // [in]  Valor da variável aleatória
  const double   nu,          // [in]  Parâmetro de distribuição (número de graus livres)
  const bool     log_mode,    // [in]  Flag Para calcular o logaritmo do valor, se log_mode = true, então o logaritmo natural da densidade de probabilidade é retornado
  int            &error_code  // [out] Variável para o código de erro
);
Calcula o valor da probabilidade da função de densidade da distribuição do qui-quadrado com o parâmetro nu para uma variável aleatória x. Em caso de erro, retorna NaN.
double MathProbabilityDensityChiSquare(
  const double   x,           // [in]  Valor da variável aleatória
  const double   nu,          // [in]  Parâmetro da distribuição (número de graus livres)
  int            &error_code  // [out] Variável para o código de erro
);

Calcula o valor da função de densidade de probabilidade da distribuição do qui-quadrado com o parâmetro nu para um array de variáveis aleatórias x[]. Em caso de erro ele retorna falso. Análoga da dchisq() em R.

bool MathProbabilityDensityChiSquare(
  const double   &x[],        // [in]  Array com os valores da variável aleatória
  const double   nu,          // [in]  Parâmetro da distribuição (número de graus livres)
  const bool     log_mode,    // [in]  Flag Para calcular o logaritmo do valor, se log_mode = true, então o logaritmo natural da densidade de probabilidade é retornado
  double         &result[]    // [out] Array para valores da função de densidade de probabilidade
);

Calcula o valor da função de densidade de probabilidade da distribuição do qui-quadrado com o parâmetro nu para um array de variáveis aleatórias x[]. Em caso de erro ele retorna falso.

bool MathProbabilityDensityChiSquare(
  const double   &x[],        // [in]  Array com os valores da variável aleatória
  const double   nu,          // [in]  Parâmetro da distribuição (número de graus livres)
  double         &result[]    // [out] Array para valores da função de densidade de probabilidade
);


2.6.2. MathCumulativeDistributionChiSquare

Calcula o valor probabilidade da função de distribuição do qui-quadrado com o parâmetro nu para uma variável aleatória x. Em caso de erro, retorna NaN.

double MathCumulativeDistributionChiSquare(
  const double   x,           // [in]  Valor da variável aleatória
  const double   nu,          // [in]  Parâmetro da distribuição (número de graus livres)
  const bool     tail,        // [in]  Flag de cálculo, se for verdadeira, então a probabilidade da variável aleatória não excedendo x é calculada
  const bool     log_mode,    // [in]  Flag para calcular o logaritmo do valor, se log_mode=true, então o logaritmo natural da probabilidade é calculado
  int            &error_code  // [out] Variável para o código de erro
);

Calcula o valor probabilidade da função de distribuição do qui-quadrado com o parâmetro nu para uma variável aleatória x. Em caso de erro, retorna NaN.

double MathCumulativeDistributionChiSquare(
  const double   x,           // [in]  Valor da variável aleatória
  const double   nu,          // [in]  Parâmetro da distribuição (número de graus livres)
  int            &error_code  // [out] Variável para o código de erro
);

Calcula o valor da função de distribuição de probabilidade da distribuição de qui-quadrado com o parâmetro nu para um array de variáveis aleatórias x[]. Em caso de erro ele retorna falso. Análoga da pchisq() em R.

bool MathCumulativeDistributionChiSquare(
  const double   &x[],        // [in]  Array com os valores da variável aleatória
  const double   nu,          // [in]  Parâmetro da distribuição (número de graus livres)
  const bool     tail,        // [in]  Flag de cálculo, se for verdadeira, então a probabilidade da variável aleatória não excedendo x é calculada
  const bool     log_mode,    // [in]  Flag para calcular o logaritmo do valor, se log_mode=true, então o logaritmo natural da probabilidade é calculado
  double         &result[]    // [out] Array para valores da função de probabilidade
);

Calcula o valor da função de distribuição de probabilidade da distribuição de qui-quadrado com o parâmetro nu para um array de variáveis aleatórias x[]. Em caso de erro ele retorna falso.

bool MathCumulativeDistributionChiSquare(
  const double   &x[],        // [in]  Array com os valores da variável aleatória
  const double   nu,          // [in]  Parâmetro da distribuição (número de graus livres)
  double         &result[]    // [out] Array para valores da função de probabilidade
);


2.6.3. MathQuantileChiSquare

Para a probabilidade específica, calcula o valor da função de distribuição do qui-quadrado inverso. Em caso de erro, retorna NaN.

double MathQuantileChiSquare(  
  const double   probability,   // [in]  O valor de probabilidade da ocorrência da variável aleatória
  const double   nu,            // [in]  Parâmetro de distribuição (número de graus livres)
  const bool     tail,          // [in]  Flag de cálculo, se for falsa, então o cálculo é realizado pela probabilidade 1.0
  const bool     log_mode,      // [in]  Flag do cálculo, se false, então o cálculo é executado pela Exp(probabilidade)
  int            &error_code    // [out] Variável para o código de erro
);

Para a probabilidade específica, calcula o valor da função de distribuição do qui-quadrado inverso. Em caso de erro, retorna NaN.

double MathQuantileChiSquare(  
  const double   probability,   // [in]  O valor de probabilidade da ocorrência da variável aleatória
  const double   nu,            // [in]  Parâmetro de distribuição (número de graus livres)
  int            &error_code    // [out] Variável para o código de erro
);

Para o array especificado de valores de probabilidade probability[], é calculado o valor da função de distribuição de chi-quadrado inversa. Em caso de erro ele retorna falso. Análoga da qchisq() em R.

bool MathQuantileChiSquare(  
  const double   &probability[],// [in]  Array com valores de probabilidade de variável aleatória
  const double   nu,            // [in]  Parâmetro de distribuição (número de graus livres)
  const bool     tail,          // [in]  Bandeira de cálculo, se for falsa, então o cálculo é realizado pela probabilidade 1.0
  const bool     log_mode,      // [in]  Flag de cálculo, se log_mode=true, o cálculo é realizado pelo Exp(probabilidade)
  double         &result[]      // [out] Array com valor de quantis
);

Para o array especificado de valores de probabilidade probability[], é calculado o valor da função de distribuição de chi-quadrado inversa. Em caso de erro ele retorna falso.

bool MathQuantileChiSquare(  
  const double   &probability[],// [in]  Array com valores de probabilidade de variável aleatória
  const double   nu,            // [in]  Parâmetro de distribuição (número de graus livres)
  double         &result[]      // [out] Array com valor de quantis
);


2.6.4. MathRandomChiSquare

A função gera uma variável pseudo-aleatória distribuída de acordo com a lei da distribuição do qui-quadrado com o parâmetro nu. Em caso de erro, retorna NaN.

double MathRandomChiSquare(
  const double   nu,          // [in]  Parâmetro da distribuição (número de graus livres)
  int            &error_code  // [out] Variável para o código de erro
);

A função gera variáveis pseudo-aleatórias distribuídas de acordo com a lei da distribuição do qui-quadrado com o parâmetro nu. Em caso de erro ele retorna falso. Análoga da rchisq() em R.

bool MathRandomChiSquare(
  const double   nu,          // [in]  Parâmetro da distribuição (número de graus livres)
  const int      data_count,  // [in]  Quantidade de dados requeridos
  double         &result[]    // [out] Array Com valores de variáveis pseudo-aleatórias
);


2.6.5. MathMomentsChiSquare

Calcula os valores numéricos teóricos dos primeiros 4 momentos da distribuição do qui-quadrado com o parâmetro nu. Retorna verdadeiro se o cálculo do momento for bem-sucedido, caso contrário, falso.

bool MathMomentsChiSquare(
  const double   nu,          // [in]  Parâmetro da distribuição (número de graus livres)
  double         &mean,       // [out] Variável para a média(1º momento)
  double         &variance,   // [out] Variável para a variância (2º momento)
  double         &skewness,   // [out] Variável para a assimetria (3º momento)
  double         &kurtosis,   // [out] Variável para a curtose (4º momento)
  int            &error_code  // [out] Variável para o código de erro
);


2.7. Distribuição do qui-quadrado não-central

2.7.1. MathProbabilityDensityNoncentralChiSquare

Calcula o valor da probabilidade da função de densidade da distribuição não-central do qui-quadrado com os parâmetros nu e sigma para uma variável aleatória x. Em caso de erro, retorna NaN.

double MathProbabilityDensityNoncentralChiSquare(
  const double   x,           // [in]  Valor da variável aleatória
  const double   nu,          // [in]  Parâmetro da distribuição (número de graus livres)
  const double   sigma,       // [in]  Parâmetro não centralizado
  const bool     log_mode,    // [in]  Flag Para calcular o logaritmo do valor, se log_mode = true, então o logaritmo natural da densidade de probabilidade é retornado
  int            &error_code  // [out] Variável para o código de erro
);

Calcula o valor da probabilidade da função de densidade da distribuição não-central do qui-quadrado com os parâmetros nu e sigma para uma variável aleatória x. Em caso de erro, retorna NaN.

double MathProbabilityDensityNoncentralChiSquare(
  const double   x,           // [in]  Valor da variável aleatória
  const double   nu,          // [in]  Parâmetro da distribuição (número de graus livres)
  const double   sigma,       // [in]  Parâmetro não centralizado
  int            &error_code  // [out] Variável para o código de erro
);

Calcula o valor da função de densidade de probabilidade da distribuição não-central do qui-quadrado com os parâmetros nu e sigma para uma matriz de variáveis aleatórias x[]. Em caso de erro ele retorna falso. Análoga da dchisq() em R.

bool MathProbabilityDensityNoncentralChiSquare(
  const double   &x[],        // [in]  Array com os valores da variável aleatória
  const double   nu,          // [in]  Parâmetro da distribuição (número de graus livres)
  const double   sigma,       // [in]  Parâmetro não centralizado
  const bool     log_mode,    // [in]  Flag Para calcular o logaritmo do valor, se log_mode = true, então o logaritmo natural da densidade de probabilidade é retornado
  double         &result[]    // [out] Array para valores da função de densidade de probabilidade
);

Calcula o valor da função de densidade de probabilidade da distribuição não-central do qui-quadrado com os parâmetros nu e sigma para uma matriz de variáveis aleatórias x[]. Em caso de erro ele retorna falso.

bool MathProbabilityDensityNoncentralChiSquare(
  const double   &x[],        // [in]  Array com os valores da variável aleatória
  const double   nu,          // [in]  Parâmetro da distribuição (número de graus livres)
  const double   sigma,       // [in]  Parâmetro não centralizado
  double         &result[]    // [out] Array para valores da função de densidade de probabilidade
);


2.7.2. MathCumulativeDistributionNoncentralChiSquare

Calcula o valor da probabilidade da função de distribuição não-central do qui-quadrado com os parâmetros nu e sigma para uma variável aleatória x. Em caso de erro, retorna NaN.

double MathCumulativeDistributionNoncentralChiSquare(
  const double   x,           // [in]  Valor da variável aleatória
  const double   nu,          // [in]  Parâmetro da distribuição (número de graus livres)
  const double   sigma,       // [in]  Parâmetro não centralizado
  const bool     tail,        // [in]  Flag de cálculo, se for verdadeira, então a probabilidade da variável aleatória não excedendo x é calculada
  const bool     log_mode,    // [in]  Flag para calcular o logaritmo do valor, se log_mode=true, então o logaritmo natural da probabilidade é calculado
  int            &error_code  // [out] Variável do codigo de erro
);

Calcula o valor da probabilidade da função de distribuição não-central do qui-quadrado com os parâmetros nu e sigma para uma variável aleatória x. Em caso de erro, retorna NaN.

double MathCumulativeDistributionNoncentralChiSquare(
  const double   x,           // [in]  Valor da variável aleatória
  const double   nu,          // [in]  Parâmetro da distribuição (número de graus livres)
  const double   sigma,       // [in]  Parâmetro não centralizado
  int            &error_code  // [out] Variável do codigo de erro
);

Calcula o valor da função de distribuição de probabilidade da distribuição não-central do qui-quadrado com os parâmetros nu e sigma para um array de variáveis aleatórias x[]. Em caso de erro ele retorna falso. Análoga da pchisq() em R.

bool MathCumulativeDistributionNoncentralChiSquare(
  const double   &x[],        // [in]  Array com os valores da variável aleatória
  const double   nu,          // [in]  Parâmetro da distribuição (número de graus livres)
  const double   sigma,       // [in]  Parâmetro não centralizado
  const bool     tail,        // [in]  Flag de cálculo, se for verdadeira, então a probabilidade da variável aleatória não excedendo x é calculada
  const bool     log_mode,    // [in]  Flag para calcular o logaritmo do valor, se log_mode=true, então o logaritmo natural da probabilidade é calculado
  double         &result[]    // [out] Array para valores da função de probabilidade
);

Calcula o valor da função de distribuição de probabilidade da distribuição não-central do qui-quadrado com os parâmetros nu e sigma para um array de variáveis aleatórias x[]. Em caso de erro ele retorna falso.

bool MathCumulativeDistributionNoncentralChiSquare(
  const double   &x[],        // [in]  Array com os valores da variável aleatória
  const double   nu,          // [in]  Parâmetro da distribuição (número de graus livres)
  const double   sigma,       // [in]  Parâmetro não centralizado
  double         &result[]    // [out] Array para valores da função de probabilidade
);


2.7.3. MathQuantileNoncentralChiSquare

Para a probabilidade específica, calcula o valor da função de distribuição do qui-quadrado inversa não central com os parâmetros nu e sigma. Em caso de erro, retorna NaN.

double MathQuantileNoncentralChiSquare(
  const double   probability,   // [in]  O valor de probabilidade da ocorrência da variável aleatória
  const double   nu,            // [in]  Parâmetro de distribuição (número de graus livres)
  const double   sigma,         // [in]  Parâmetro não centralizado
  const bool     tail,          // [in]  Bandeira de cálculo, se for falsa, então o cálculo é realizado pela probabilidade 1.0
  const bool     log_mode,      // [in]  Flag de cálculo, se log_mode=true, o cálculo é realizado pelo Exp(probabilidade)
  int            &error_code    // [out] Variável para o código de erro
);

Para a probabilidade específica, calcula o valor da função de distribuição do qui-quadrado inversa não central com os parâmetros nu e sigma. Em caso de erro, retorna NaN.

double MathQuantileNoncentralChiSquare(
  const double   probability,   // [in]  O valor de probabilidade da ocorrência da variável aleatória
  const double   nu,            // [in]  Parâmetro de distribuição (número de graus livres)
  const double   sigma,         // [in]  Parâmetro não centralizado
  int            &error_code    // [out] Variável para o código de erro
);

Para o array especificado de valores de probabilidade 'probability[]', é calculado o valor da função de distribuição não central do qui-quadrado com os parâmetros nu e sigma. Em caso de erro ele retorna falso. Análoga da qchisq() em R.

bool MathQuantileNoncentralChiSquare(
  const double   &probability[],// [in]  Array com valores de probabilidade de variável aleatória
  const double   nu,            // [in]  Parâmetro de distribuição (número de graus livres)
  const double   sigma,         // [in]  Parâmetro não centralizado
  const bool     tail,          // [in]  Bandeira de cálculo, se for falsa, então o cálculo é realizado pela probabilidade 1.0
  const bool     log_mode,      // [in]  Flag de cálculo, se log_mode=true, o cálculo é realizado pelo Exp(probabilidade)
  double         &result[]      // [out] Array com valor de quantis
);

Para o array especificado de valores de probabilidade 'probability[]', é calculado o valor da função de distribuição não central do qui-quadrado com os parâmetros nu e sigma. Em caso de erro, ele retorna falso.

bool MathQuantileNoncentralChiSquare(
  const double   &probability[],// [in]  Array com valores de probabilidade de variável aleatória
  const double   nu,            // [in]  Parâmetro de distribuição (número de graus livres)
  const double   sigma,         // [in]  Parâmetro não centralizado
  double         &result[]      // [out] Array com valor de quantis
);


2.7.4. MathRandomNoncentralChiSquare

A função gera uma variável pseudo-aleatória distribuída de acordo com a lei da distribuição do qui-quadrado não central com os parâmetros nu e sigma. Em caso de erro, retorna NaN.

double MathRandomNoncentralChiSquare(
  const double   nu,          // [in]  Parâmetro da distribuição (número de graus livres)
  const double   sigma,       // [in]  Parâmetro não centralizado
  int            &error_code  // [out] Variável para o código de erro
);

A função gera variáveis pseudo-aleatórias distribuídas de acordo com a lei da distribuição do qui-quadrado não central com os parâmetros nu e sigma. Em caso de erro ele retorna falso. Análoga da rchisq() em R.

bool MathRandomNoncentralChiSquare(
  const double   nu,          // [in]  Parâmetro da distribuição (número de graus livres)
  const double   sigma,       // [in]  Parâmetro não centralizado
  const int      data_count,  // [in]  Quantidade de dados requeridos
  double         &result[]    // [out] Array Com valores de variáveis pseudo-aleatórias
);


2.7.5. MathMomentsNoncentralChiSquare

Calcula os valores numéricos teóricos dos primeiros 4 momentos da distribuição do qui-quadrado não central com os parâmetros nu e sigma. Retorna verdadeiro se o cálculo do momento for bem-sucedido, caso contrário, falso.

bool MathMomentsNoncentralChiSquare(
  const double   nu,          // [in]  Parâmetro da distribuição (número de graus livres)
  const double   sigma,       // [in]  Parâmetro não centralizado
  double         &mean,       // [out] Variável para a média(1º momento)
  double         &variance,   // [out] Variável para a variância (2º momento)
  double         &skewness,   // [out] Variável para a assimetria (3º momento)
  double         &kurtosis,   // [out] Variável para a curtose (4º momento)
  int            &error_code  // [out] Variável para o código de erro
);


2.8. Distribuição exponencial

2.8.1. MathProbabilityDensityExponential

Calcula o valor da probabilidade da função de densidade da distribuição exponencial com o parâmetro mu para uma variável aleatória x. Em caso de erro, retorna NaN.

double MathProbabilityDensityExponential(
  const double   x,           // [in]  Valor da variável aleatória
  const double   mu,          // [in]  Parâmetro da distribuição (valor esperado)
  const bool     log_mode,    // [in]  Flag para calcular o logaritmo do valor, se log_mode=true, então o logaritmo natural da probabilidade de densidade é retornado
  int            &error_code  // [out] Variável para o código de erro
);

Calcula o valor da probabilidade da função de densidade da distribuição exponencial com o parâmetro mu para uma variável aleatória x. Em caso de erro, retorna NaN.

double MathProbabilityDensityExponential(
  const double   x,           // [in]  Valor da variável aleatória
  const double   mu,          // [in]  Parâmetro da distribuição (valor esperado)
  int            &error_code  // [out] Variável para o código de erro
);

Calcula o valor da probabilidade da função de densidade da distribuição exponencial com o parâmetro mu para um array de variavel aleatória x[]. Em caso de erro ele retorna falso. Análoga da dexp() em R.

bool MathProbabilityDensityExponential(
  const double   &x[],        // [in]  Array com os valores da variável aleatória
  const double   mu,          // [in]  Parâmetro de distribuição (valor esperado)
  const bool     log_mode,    // [in]  Flag Para calcular o logaritmo do valor, se log_mode=true, então o logaritmo natural da densidade de probabilidade é calculado
  double         &result[]    // [out] Array para valores da função de densidade de probabilidade
);

Calcula o valor da probabilidade da função de densidade da distribuição exponencial com o parâmetro mu para um array de variavel aleatória x[]. Em caso de erro ele retorna falso.

bool MathProbabilityDensityExponential(
  const double   &x[],        // [in]  Array com os valores da variável aleatória
  const double   mu,          // [in]  Parâmetro da distribuição (valor esperado)
  double         &result[]    // [out] Array para valores da função de densidade de probabilidade
);


2.8.2. MathCumulativeDistributionExponential

Calcula o valor da função de distribuição exponencial das probabilidades com o parâmetro mu para uma variável aleatória x. Em caso de erro, retorna NaN.

double MathCumulativeDistributionExponential(
  const double   x,           // [in]  Valor da variável aleatória
  const double   mu,          // [in]  Parâmetro da distribuição (valor esperado)
  const bool     tail,        // [in]  Flag de cálculo, se for verdadeira, então a probabilidade da variável aleatória não excedendo x é calculada
  const bool     log_mode,    // [in]  Flag para calcular o logaritmo do valor, se log_mode=true, então o logaritmo natural da probabilidade é calculado
  int            &error_code  // [out] Variável para o código de erro
);

Calcula o valor da função de distribuição exponencial das probabilidades com o parâmetro mu para uma variável aleatória x. Em caso de erro, retorna NaN.

double MathCumulativeDistributionExponential(
  const double   x,           // [in]  Valor da variável aleatória
  const double   mu,          // [in]  Parâmetro da distribuição (valor esperado)
  int            &error_code  // [out] Variável para o código de erro
);

Calcula o valor da função de distribuição exponencial das probabilidades com o parâmetro mu para uma variável aleatória x. Em caso de erro ele retorna falso. Análoga da pexp() em R.

bool MathCumulativeDistributionExponential(
  const double   &x[],        // [in]  Array com os valores da variável aleatória
  const double   mu,          // [in]  Parâmetro de distribuição (valor esperado)
  const bool     tail,        // [in]  Flag de cálculo, se for verdadeira, então a probabilidade da variável aleatória não excedendo x é calculada
  const bool     log_mode,    // [in]  Flag para calcular o logaritmo do valor, se log_mode=true, então o logaritmo natural da probabilidade é calculado
  double         &result[]    // [out] Array para valores da função de probabilidade
);

Calcula o valor da função de distribuição exponencial das probabilidades com o parâmetro mu para uma variável aleatória x. Em caso de erro ele retorna falso.

bool MathCumulativeDistributionExponential(
  const double   &x[],        // [in]  Array com os valores da variável aleatória
  const double   mu,          // [in]  Parâmetro da distribuição (valor esperado)
  double         &result[]    // [out] Array para valores da função de probabilidade
);


2.8.3. MathQuantileExponential

Para a probabilidade específica, calcula o valor da função de distribuição exponencial inversa com o parâmetro mu. Em caso de erro, retorna NaN.

double MathQuantileExponential(
  const double   probability,   // [in]  O valor de probabilidade da ocorrência da variável aleatória
  const double   mu,            // [in]  Parâmetro de distribuição (valor esperado)
  const bool     tail,          // [in]  Bandeira de cálculo, se for falsa, então o cálculo é realizado pela probabilidade 1.0
  const bool     log_mode,      // [in]  Flag de cálculo, se log_mode=true, o cálculo é realizado pelo Exp(probabilidade)
  int            &error_code    // [out] Variável para o código de erro
);

Para a probabilidade específica, calcula o valor da função de distribuição exponencial inversa com o parâmetro mu. Em caso de erro, retorna NaN.

double MathQuantileExponential(
  const double   probability,   // [in]  O valor de probabilidade da ocorrência da variável aleatória
  const double   mu,            // [in]  Parâmetro de distribuição (valor esperado)
  int            &error_code    // [out] Variável para o código de erro
);

Para o array especificado de valores de probabilidade 'probability[]', é calculado o valor da função de distribuição exponencial inversa com o parâmetro mu. Em caso de erro ele retorna falso. Análoga da qexp() em R.

bool MathQuantileExponential(
  const double   &probability[],// [in]  Array com valores de probabilidade de variável aleatória
  const double   mu,            // [in]  Parâmetro de distribuição (valor esperado)
  const bool     tail,          // [in]  Bandeira de cálculo, se for falsa, então o cálculo é realizado pela probabilidade 1.0
  const bool     log_mode,      // [in]  Flag de cálculo, se log_mode=true, o cálculo é realizado pelo Exp(probabilidade)
  double         &result[]      // [out] Array com valor de quantis
);

Para o array especificado de valores de probabilidade 'probability[]', é calculado o valor da função de distribuição exponencial inversa com o parâmetro mu. Em caso de erro ele retorna falso.

bool MathQuantileExponential(
  const double   &probability[],// [in]  Array com valores de probabilidade de variável aleatória
  const double   mu,            // [in]  Parâmetro de distribuição (valor esperado)
  double         &result[]      // [out] Array com valor de quantis
);


2.8.4. MathRandomExponential

A função gera uma variável pseudo-aleatória distribuída de acordo com a lei de distribuição exponencial com o parâmetro mu. Em caso de erro, retorna NaN.

double MathRandomExponential(
  const double   mu,          // [in]  Parâmetro da distribuição (valor esperado)
  int            &error_code  // [out] Variável para o código de erro
);

A função gera variáveis pseudo-aleatórias distribuídas de acordo com a lei da distribuição exponencial com o parâmetro mu. Em caso de erro ele retorna falso. Análoga da rexp() em R.

bool MathRandomExponential(
  const double   mu,          // [in]  Parâmetro da distribuição (valor esperado)
  const int      data_count,  // [in]  Quantidade de dados requeridos
  double         &result[]    // [out] Array Com valores de variáveis pseudo-aleatórias
);


2.8.5. MathMomentsExponential

Calcula os valores numéricos teóricos dos primeiros 4 momentos da distribuição exponencial com o parâmetro mu. Retorna verdadeiro se o cálculo do momento for bem-sucedido, caso contrário, falso.

bool MathMomentsExponential(
  const double   mu,          // [in]  Parâmetro da distribuição (valor esperado)
  double         &mean,       // [out] Variável para a média(1º momento)
  double         &variance,   // [out] Variável para a variância (2º momento)
  double         &skewness,   // [out] Variável para a assimetria (3º momento)
  double         &kurtosis,   // [out] Variável para a curtose (4º momento)
  int            &error_code  // [out] Variável para o código de erro
);


2.9. Distribuição F

2.9.1. MathProbabilityDensityF

Calcula o valor da probabilidade da função de densidade da distribuição-F de Fisher com os parâmetros nu1 e nu2 para uma variável aleatória x. Em caso de erro, retorna NaN.

double MathProbabilityDensityF(
  const double   x,           // [in]  Valor da variável aleatória
  const double   nu1,         // [in]  O primeiro parâmetro da distribuição (número de graus livres)
  const double   nu2,         // [in]  O segundo parâmetro da distribuição (número de graus livres)
  const bool     log_mode,    // [in]  Flag Para calcular o logaritmo do valor, se log_mode = true, então o logaritmo natural da densidade de probabilidade é retornado
  int            &error_code  // [out] Variável para o código de erro
);

Calcula o valor da probabilidade da função de densidade da distribuição-F de Fisher com os parâmetros nu1 e nu2 para uma variável aleatória x. Em caso de erro, retorna NaN.

double MathProbabilityDensityF(
  const double   x,           // [in]  Valor da variável aleatória
  const double   nu1,         // [in]  O primeiro parâmetro da distribuição (número de graus livres)
  const double   nu2,         // [in]  O segundo parâmetro da distribuição (número de graus livres)
  int            &error_code  // [out] Variável para o código de erro
);

Calcula o valor da probabilidade da função de densidade da distribuição F de Fisher com os parâmetros nu1 e nu2 para um array de variáveis aleatórias x[]. Em caso de erro ele retorna falso. Análoga da df() em R.

bool MathProbabilityDensityF(
  const double   &x[],        // [in]  Array com os valores da variável aleatória
  const double   nu1,         // [in]  O primeiro parâmetro da distribuição (número de graus livres)
  const double   nu2,         // [in]  O segundo parâmetro da distribuição (número de graus livres)
  const bool     log_mode,    // [in]  Flag Para calcular o logaritmo do valor, se log_mode = true, então o logaritmo natural da densidade de probabilidade é retornado
  double         &result[]    // [out] Array para valores da função de densidade de probabilidade
);

Calcula o valor da probabilidade da função de densidade da distribuição F de Fisher com os parâmetros nu1 e nu2 para um array de variáveis aleatórias x[]. Em caso de erro ele retorna falso.

bool MathProbabilityDensityF(
  const double   &x[],        // [in]  Array com os valores da variável aleatória
  const double   nu1,         // [in]  O primeiro parâmetro da distribuição (número de graus livres)
  const double   nu2,         // [in]  O segundo parâmetro da distribuição (número de graus livres)
  double         &result[]    // [out] Array para valores da função de densidade de probabilidade
);


2.9.2. MathCumulativeDistributionF

Calcula o valor da probabilidade da função de distribuição-F de Fisher com os parâmetros nu1 e nu2 para uma variável aleatória x. Em caso de erro, retorna NaN.

double MathCumulativeDistributionF(
  const double   x,           // [in]  Valor da variável aleatória
  const double   nu1,         // [in]  O primeiro parâmetro da distribuição (número de graus livres)
  const double   nu2,         // [in]  O segundo parâmetro da distribuição (número de graus livres)
  const bool     tail,        // [in]  Flag de cálculo, se for verdadeira, então a probabilidade da variável aleatória não excedendo x é calculada
  const bool     log_mode,    // [in]  Flag para calcular o logaritmo do valor, se log_mode=true, então o logaritmo natural da probabilidade é calculado
  int            &error_code  // [out] Variável para o código de erro
);

Calcula o valor da probabilidade da função de distribuição-F de Fisher com os parâmetros nu1 e nu2 para uma variável aleatória x. Em caso de erro, retorna NaN.

double MathCumulativeDistributionF(
  const double   x,           // [in]  Valor de uma variável aleatória
  const double   nu1,         // [in]  O primeiro parâmetro de distribuição (número de graus livres)
  const double   nu2,         // [in]  O segundo parâmetro de distribuição (número de graus livres)
  int            &error_code  // [out] Variável para o código de erro
);

Calcula o valor da função de distribuição de probabilidade da distribuição F de Fisher com os parâmetros nu1 e nu2 para um array de variáveis aleatórias x[]. Em caso de erro ele retorna falso. Análoga da pf() em R.

bool MathCumulativeDistributionF(
  const double   &x[],        // [in]  Array com os valores da variável aleatória
  const double   nu1,         // [in]  O primeiro parâmetro da distribuição (número de graus livres)
  const double   nu2,         // [in]  O segundo parâmetro da distribuição (número de graus livres)
  const bool     tail,        // [in]  Flag de cálculo, se for verdadeira, então a probabilidade da variável aleatória não excedendo x é calculada
  const bool     log_mode,    // [in]  Flag para calcular o logaritmo do valor, se log_mode=true, então o logaritmo natural da probabilidade é calculado
  double         &result[]    // [out] Array para valores da função de probabilidade
);

Calcula o valor da função de distribuição de probabilidade da distribuição F de Fisher com os parâmetros nu1 e nu2 para um array de variáveis aleatórias x[]. Em caso de erro ele retorna falso.

bool MathCumulativeDistributionF(
  const double   &x[],        // [in]  Array com os valores da variável aleatória
  const double   nu1,         // [in]  O primeiro parâmetro de distribuição (número de graus livres)
  const double   nu2,         // [in]  O segundo parâmetro da distribuição (número de graus livres)
  double         &result[]    // [out] Array para valores da função de probabilidade
);


2.9.3. MathQuantileF

Para a probabilidade específica, calcula o valor da função de distribuição F de Fisher inversa com os parâmetros nu1 e nu2. Em caso de erro, retorna NaN.

double MathQuantileF(
  const double   probability,   // [in]  O valor de probabilidade da ocorrência da variável aleatória
  const double   nu1,           // [in]  O primeiro parâmetro de distribuição (número de graus livres)
  const double   nu2,           // [in]  O segundo parâmetro de distribuição (número de graus livres)
  const bool     tail,          // [in]  Flag de cálculo, se for falsa, então o cálculo é realizado pela probabilidade 1.0
  const bool     log_mode,      // [in]  Flag de cálculo, se log_mode=true, o cálculo é realizado pelo Exp(probabilidade)
  int            &error_code    // [out] Variável para o código de erro
);

Para a probabilidade específica, calcula o valor da função de distribuição F de Fisher inversa com os parâmetros nu1 e nu2. Em caso de erro, retorna NaN.

double MathQuantileF(
  const double   probability,   // [in]  O valor de probabilidade da ocorrência da variável aleatória
  const double   nu1,           // [in]  O primeiro parâmetro de distribuição (número de graus livres)
  const double   nu2,           // [in]  O segundo parâmetro de distribuição (número de graus livres)
  int            &error_code    // [out] Variável para o código de erro
);

Para a probabilidade específica, calcula o valor da função de distribuição F de Fisher inversa com os parâmetros nu1 e nu2. Em caso de erro ele retorna falso. Análoga da qf() em R.

bool MathQuantileF(
  const double   &probability[],// [in]  Array com valores de probabilidade de variável aleatória
  const double   nu1,           // [in]  O primeiro parâmetro de distribuição (número de graus livres)
  const double   nu2,           // [in]  O segundo parâmetro de distribuição (número de graus livres)
  const bool     tail,          // [in]  Flag de cálculo, se for falsa, então o cálculo é realizado pela probabilidade 1.0
  const bool     log_mode,      // [in]  Flag do cálculo, se false, então o cálculo é executado pela Exp(probabilidade)
  double         &result[]      // [out] Array com valores de quantis
);

Para a probabilidade específica, calcula o valor da função de distribuição F de Fisher inversa com os parâmetros nu1 e nu2. Em caso de erro ele retorna falso.

bool MathQuantileF(
  const double   &probability[],// [in]  Array com valores de probabilidade de variável aleatória
  const double   nu1,           // [in]  O primeiro parâmetro de distribuição (número de graus livres)
  const double   nu2,           // [in]  O segundo parâmetro de distribuição (número de graus livres)
  double         &result[]      // [out] Array com valores de quantis
);


2.9.4. MathRandomF

A função gera uma variável pseudo-aleatória distribuída de acordo com a lei da distribuição F de Fisher com os parâmetros nu1 e nu2. Em caso de erro, retorna NaN.

double MathRandomF(
  const double   nu1,         // [in]  O primeiro parâmetro da distribuição (número de graus livres)
  const double   nu2,         // [in]  O segundo parâmetro da distribuição (número de graus livres)
  int            &error_code  // [out] Variável para o código de erro
);

A função gera variáveis pseudo-aleatórias distribuídas de acordo com a lei da distribuição F de Fisher com os parâmetros nu1 e nu2. Em caso de erro ele retorna falso. Análoga da rf() em R.

bool MathRandomF(
  const double   nu1,         // [in]  O primeiro parâmetro da distribuição (número de graus livres)
  const double   nu2,         // [in]  O segundo parâmetro da distribuição (número de graus livres)
  const int      data_count,  // [in]  Quantidade de dados requeridos
  double         &result[]    // [out] Array Com valores de variáveis pseudo-aleatórias
);


2.9.5. MathMomentsF

Calcula os valores numéricos teóricos dos primeiros 4 momentos da distribuição F de Fisher com os parâmetros nu1 e nu2. Retorna verdadeiro se o cálculo do momento for bem-sucedido, caso contrário, falso.

bool MathMomentsF(
  const double   nu1,         // [in]  O primeiro parâmetro da distribuição (número de graus livres)
  const double   nu2,         // [in]  O segundo parâmetro da distribuição (número de graus livres)
  double         &mean,       // [out] Variável para a média(1º momento)
  double         &variance,   // [out] Variável para a variância (2º momento)
  double         &skewness,   // [out] Variável para a assimetria (3º momento)
  double         &kurtosis,   // [out] Variável para a curtose (4º momento)
  int            &error_code  // [out] Variável para o código de erro
);


2.10. Distribuição F não-central

2.10.1. MathProbabilityDensityNoncentralF

Calcula o valor da probabilidade da função de densidade da distribuição F de Fisher não central com os parâmetros nu1, nu2 e sigma para uma variável aleatória x. Em caso de erro, retorna NaN.

double MathProbabilityDensityNoncentralF(
  const double   x,           // [in]  Valor da variável aleatória
  const double   nu1,         // [in]  O primeiro parâmetro da distribuição (número de graus livres)
  const double   nu2,         // [in]  O segundo parâmetro da distribuição (número de graus livres)
  const double   sigma,       // [in]  Parâmetro não centralizado
  const bool     log_mode,    // [in]  Flag Para calcular o logaritmo do valor, se log_mode = true, então o logaritmo natural da densidade de probabilidade é retornado
  int            &error_code  // [out] Variável para o código de erro
);

Calcula o valor da probabilidade da função de densidade da distribuição F de Fisher não central com os parâmetros nu1, nu2 e sigma para uma variável aleatória x. Em caso de erro, retorna NaN.

double MathProbabilityDensityNoncentralF(
  const double   x,           // [in]  Valor da variável aleatória
  const double   nu1,         // [in]  O primeiro parâmetro da distribuição (número de graus livres)
  const double   nu2,         // [in]  O segundo parâmetro da distribuição (número de graus livres)
  const double   sigma,       // [in]  Parâmetro não centralizado
  int            &error_code  // [out] Variável para o código de erro
);

Calcula o valor da probabilidade da função de densidade da distribuição F de Fisher nãocentral com os parâmetros nu1, nu2 e sigma para um array de variáveis aleatórias x[]. Em caso de erro ele retorna falso. Análoga da df() em R.

double MathProbabilityDensityNoncentralF(
  const double   &x[],        // [in]  Array com os valores da variável aleatória
  const double   nu1,         // [in]  O primeiro parâmetro da distribuição (número de graus livres)
  const double   nu2,         // [in]  O segundo parâmetro da distribuição (número de graus livres)
  const double   sigma,       // [in]  Parâmetro não centralizado
  const bool     log_mode,    // [in]  Flag Para calcular o logaritmo do valor, se log_mode = true, então o logaritmo natural da densidade de probabilidade é retornado
  double         &result[]    // [out] Array para valores da função de densidade de probabilidade
);

Calcula o valor da probabilidade da função de densidade da distribuição F de Fisher nãocentral com os parâmetros nu1, nu2 e sigma para um array de variáveis aleatórias x[]. Em caso de erro ele retorna falso.

double MathProbabilityDensityNoncentralF(
  const double   &x[],        // [in]  Array com os valores da variável aleatória
  const double   nu1,         // [in]  O primeiro parâmetro da distribuição (número de graus livres)
  const double   nu2,         // [in]  O segundo parâmetro da distribuição (número de graus livres)
  const double   sigma,       // [in]  Parâmetro não centralizado
  double         &result[]    // [out] Array para valores da função de densidade de probabilidade
);


2.10.2. MathCumulativeDistributionlNoncentralF

Calcula o valor da probabilidade da função de distribuição F de Fisher não central com os parâmetros nu1, nu2 e sigma para uma variável aleatória x. Em caso de erro, retorna NaN.

double MathCumulativeDistributionNoncentralF(
  const double   x,           // [in]  Valor da variável aleatória
  const double   nu1,         // [in]  O primeiro parâmetro da distribuição (número de graus livres)
  const double   nu2,         // [in]  O segundo parâmetro da distribuição (número de graus livres)
  const double   sigma,       // [in]  Parâmetro não centralizado
  const bool     tail,        // [in]  Flag de cálculo, se for verdadeira, então a probabilidade da variável aleatória não excedendo x é calculada
  const bool     log_mode,    // [in]  Flag para calcular o logaritmo do valor, se log_mode=true, então o logaritmo natural da probabilidade é calculado
  int            &error_code  // [out] Variável para o código de erro
);

Calcula o valor da probabilidade da função de distribuição F de Fisher não central com os parâmetros nu1, nu2 e sigma para uma variável aleatória x. Em caso de erro, retorna NaN.

double MathCumulativeDistributionNoncentralF(
  const double   x,           // [in]  Valor da variável aleatória
  const double   nu1,         // [in]  O primeiro parâmetro da distribuição (número de graus livres)
  const double   nu2,         // [in]  O segundo parâmetro da distribuição (número de graus livres)
  const double   sigma,       // [in]  Parâmetro não centralizado
  int            &error_code  // [out] Variável para o código de erro
);

Calcula o valor da probabilidade da função de distribuição F de Fisher não central com os parâmetros nu1, nu2 e sigma para uma variável aleatória x. Em caso de erro ele retorna falso. Análoga da pf() em R.

bool MathCumulativeDistributionNoncentralF(
  const double   &x[],        // [in]  Array com os valores da variável aleatória
  const double   nu1,         // [in]  O primeiro parâmetro da distribuição (número de graus livres)
  const double   nu2,         // [in]  O segundo parâmetro da distribuição (número de graus livres)
  const double   sigma,       // [in]  Parâmetro não centralizado
  const bool     tail,        // [in]  Flag de cálculo, se for verdadeira, então a probabilidade da variável aleatória não excedendo x é calculada
  const bool     log_mode,    // [in]  Flag para calcular o logaritmo do valor, se log_mode=true, então o logaritmo natural da probabilidade é calculado
  double         &result[]    // [out] Array para valores da função de probabilidade
);

Calcula o valor da probabilidade da função de distribuição F de Fisher não central com os parâmetros nu1, nu2 e sigma para uma variável aleatória x. Em caso de erro, retorna NaN.

bool MathCumulativeDistributionNoncentralF(
  const double   &x[],        // [in]  Array com os valores da variável aleatória
  const double   nu1,         // [in]  O primeiro parâmetro da distribuição (número de graus livres)
  const double   nu2,         // [in]  O segundo parâmetro da distribuição (número de graus livres)
  const double   sigma,       // [in]  Parâmetro não centralizado
  double         &result[]    // [out] Array para valores da função de probabilidade
);


2.10.3. MathQuantileNoncentralF

Para a probabilidade específica, calcula o valor da função de distribuição F de Fisher inversa não central com os parâmetros nu1, nu2 e sigma. Em caso de erro, retorna NaN.

double MathQuantileNoncentralF(
  const double   probability,   // [in]  O valor de probabilidade da ocorrência da variável aleatória
  const double   nu1,           // [in]  O primeiro parâmetro de distribuição (número de graus livres)
  const double   nu2,           // [in]  O segundo parâmetro de distribuição (número de graus livres)
  const double   sigma,         // [in]  Parâmetro não centralizado
  const bool     tail,          // [in]  Bandeira de cálculo, se for falsa, então o cálculo é realizado pela probabilidade 1.0
  const bool     log_mode,      // [in]  Flag de cálculo, se log_mode=true, o cálculo é realizado pelo Exp(probabilidade)
  int            &error_code    // [out] Variável para o código de erro
);

Para a probabilidade específica, calcula o valor da função de distribuição F de Fisher inversa não central com os parâmetros nu1, nu2 e sigma. Em caso de erro, retorna NaN.

double MathQuantileNoncentralF(
  const double   probability,   // [in]  O valor de probabilidade da ocorrência da variável aleatória
  const double   nu1,           // [in]  O primeiro parâmetro de distribuição (número de graus livres)
  const double   nu2,           // [in]  O segundo parâmetro de distribuição (número de graus livres)
  const double   sigma,         // [in]  Parâmetro não centralizado
  int            &error_code    // [out] Variável para o código de erro
);

Para a probabilidade específica, calcula o valor da função de distribuição F de Fisher inversa não central com os parâmetros nu1, nu2 e sigma. Em caso de erro ele retorna falso. Análoga da qf() em R.

bool MathQuantileNoncentralF(
  const double   &probability[],// [in]  Array com valores de probabilidade de variável aleatória
  const double   nu1,           // [in]  O primeiro parâmetro de distribuição (número de graus livres)
  const double   nu2,           // [in]  O segundo parâmetro de distribuição (número de graus livres)
  const double   sigma,         // [in]  Parâmetro não centralizado
  const bool     tail,          // [in]  Bandeira de cálculo, se for falsa, então o cálculo é realizado pela probabilidade 1.0
  const bool     log_mode,      // [in]  Flag de cálculo, se log_mode=true, o cálculo é realizado pelo Exp(probabilidade)
  double         &result[]      // [out] Array com valor de quantis
);

Para a probabilidade específica, calcula o valor da função de distribuição F de Fisher inversa não central com os parâmetros nu1, nu2 e sigma. Em caso de erro ele retorna falso.

bool MathQuantileNoncentralF(
  const double   &probability[],// [in]  Array com valores de probabilidade de variável aleatória
  const double   nu1,           // [in]  O primeiro parâmetro de distribuição (número de graus livres)
  const double   nu2,           // [in]  O segundo parâmetro de distribuição (número de graus livres)
  const double   sigma,         // [in]  Parâmetro não centralizado
  double         &result[]      // [out] Array com valor de quantis
);


2.10.4. MathRandomNoncentralF

A função gera uma variável pseudo-aleatória distribuída de acordo com a lei da distribuição F de Fisher não central com os parâmetros nu1, nu2 e sigma. Em caso de erro, retorna NaN.

double MathRandomNoncentralF(
  const double   nu1,           // [in]  O primeiro parâmetro de distribuição (número de graus livres)
  const double   nu2,           // [in]  O segundo parâmetro de distribuição (número de graus livres)
  const double   sigma,         // [in]  Parâmetro não centralizado
  int            &error_code    // [out] Variável para o código de erro
);

A função gera variáveis pseudo-aleatórias distribuídas de acordo com a lei da distribuição F não-central de Fisher com os parâmetros nu1, nu2 e sigma. Em caso de erro ele retorna falso. Análoga da rf() em R.

bool MathRandomNoncentralF(
  const double   nu1,           // [in]  O primeiro parâmetro de distribuição (número de graus livres)
  const double   nu2,           // [in]  O segundo parâmetro de distribuição (número de graus livres)
  const double   sigma,         // [in]  Parâmetro não centralizado
  double         &result[]      // [out] Array com valor de quantis
);


2.10.5. MathMomentsNoncentralF

Calcula os valores numéricos teóricos dos primeiros 4 momentos da distribuição F de Fisher não central com os parâmetros nu1, nu2 e sigma. Retorna verdadeiro se o cálculo do momento for bem-sucedido, caso contrário, falso.

bool MathMomentsNoncentralF(
  const double   nu1,         // [in]  O primeiro parâmetro da distribuição (número de graus livres)
  const double   nu2,         // [in]  O segundo parâmetro da distribuição (número de graus livres)
  const double   sigma,       // [in]  Parâmetro não centralizado
  double         &mean,       // [out] Variável para a média(1º momento)
  double         &variance,   // [out] Variável para a variância (2º momento)
  double         &skewness,   // [out] Variável para a assimetria (3º momento)
  double         &kurtosis,   // [out] Variável para a curtose (4º momento)
  int            &error_code  // [out] Variável para o código de erro
e.)


2.11. Distribuição t

2.11.1. MathProbabilityDensityT

Calcula o valor probabilidade da função de densidade da distribuição t de Student com o parâmetro nu para uma variável aleatória x. Em caso de erro, retorna NaN.

double MathProbabilityDensityT(
  const double   x,             // [in]  Valor de uma variável aleatória
  const double   nu,            // [in]  Parâmetro de distribuição (número de graus livres)
  const bool     log_mode,      // [in]  Flag para calcular o logaritmo do valor, se log_mode=true, então o logaritmo natural da probabilidade de densidade e calculado
  int            &error_code    // [out] Variável para o código de erro
);

Calcula o valor probabilidade da função de densidade da distribuição t de Student com o parâmetro nu para uma variável aleatória x. Em caso de erro, retorna NaN.

double MathProbabilityDensityT(
  const double   x,             // [in]  Valor de uma variável aleatória
  const double   nu,            // [in]  Parâmetro de distribuição (número de graus livres)
  int            &error_code    // [out] Variável para o código de erro
);

Calcula o valor da probabilidade da função de densidade da distribuição t de Student com o parâmetro nu para um array de variáveis aleatórias x[]. Em caso de erro ele retorna falso. Análoga da dt() em R.

bool MathProbabilityDensityT(
  const double   &x[],          // [in]  Array com os valores da variável aleatória
  const double   nu,            // [in]  Parâmetro de distribuição (número de graus livres)
  const bool     log_mode,      // [in]  Flag para calcular o logaritmo do valor, se log_mode=true, então o logaritmo natural da probabilidade de densidade e calculado
  double         &result[]      // [out] Array para valores da função de densidade de probabilidade
);

Calcula o valor da probabilidade da função de densidade da distribuição t de Student com o parâmetro nu para um array de variáveis aleatórias x[]. Em caso de erro ele retorna falso.

bool MathProbabilityDensityT(
  const double   &x[],          // [in]  Array com os valores da variável aleatória
  const double   nu,            // [in]  Parâmetro de distribuição (número de graus livres)
  double         &result[]      // [out] Array para valores da função de densidade de probabilidade
);


2.11.2. MathCumulativeDistributionT

Calcula o valor da função de distribuição t de Student com o parâmetro nu para uma variável aleatória x. Em caso de erro, retorna NaN.

double MathCumulativeDistributionT(
  const double   x,           // [in]  Valor da variável aleatória
  const double   nu,          // [in]  Parâmetro da distribuição (número de graus livres)
  const bool     tail,        // [in]  Flag de cálculo, se for verdadeira, então a probabilidade da variável aleatória não excedendo x é calculada
  const bool     log_mode,    // [in]  Flag para calcular o logaritmo do valor, se log_mode=true, então o logaritmo natural da probabilidade é calculado
  int            &error_code  // [out] Variável para o código de erro
);

Calcula o valor da função de distribuição t de Student com o parâmetro nu para uma variável aleatória x. Em caso de erro, retorna NaN.

double MathCumulativeDistributionT(
  const double   x,           // [in]  Valor da variável aleatória
  const double   nu,          // [in]  Parâmetro da distribuição (número de graus livres)
  int            &error_code  // [out] Variável para o código de erro
);

Calcula o valor da função de distribuição t de Student com o parâmetro nu para um array de variável aleatória x[]. Em caso de erro ele retorna falso. Análoga da pt() em R.

bool MathCumulativeDistributionT(
  const double   &x[],        // [in]  Array com os valores da variável aleatória
  const double   nu,          // [in]  Parâmetro de distribuição (número de graus livres)
  const bool     tail,        // [in]  Flag de cálculo, se for verdadeira, então a probabilidade da variável aleatória não excedendo x é calculada
  const bool     log_mode,    // [in]  Flag para calcular o logaritmo do valor, se log_mode=true, então o logaritmo natural da probabilidade é calculado
  double         &result[]    // [out] Array para valores da função de probabilidade
);

Calcula o valor da função de distribuição t de Student com o parâmetro nu para um array de variável aleatória x[]. Em caso de erro ele retorna falso.

bool MathCumulativeDistributionT(
  const double   &x[],        // [in]  Array com os valores da variável aleatória
  const double   nu,          // [in]  Parâmetro da distribuição (número de graus livres)
  double         &result[]    // [out] Array para valores da função de probabilidade
);


2.11.3. MathQuantileT

Para a probabilidade específica, calcula o valor da função de distribuição t de Student inversa com o parâmetro nu. Em caso de erro, retorna NaN.

double MathQuantileT(
  const double   probability,   // [in]  O valor de probabilidade da ocorrência da variável aleatória
  const double   nu,            // [in]  Parâmetro de distribuição (número de graus livres)
  const bool     tail,          // [in]  Bandeira de cálculo, se for falsa, então o cálculo é realizado pela probabilidade 1.0
  const bool     log_mode,      // [in]  Flag de cálculo, se log_mode=true, o cálculo é realizado pelo Exp(probabilidade)
  int            &error_code    // [out] Variável para o código de erro
);

Para a probabilidade específica, calcula o valor da função de distribuição t de Student inversa com o parâmetro nu. Em caso de erro, retorna NaN.

double MathQuantileT(
  const double   probability,   // [in]  O valor de probabilidade da ocorrência da variável aleatória
  const double   nu,            // [in]  Parâmetro de distribuição (número de graus livres)
  int            &error_code    // [out] Variável para o código de erro
);

Para o array especificado de valores de probabilidade 'probability[]', é calculado o valor da função de distribuição t de Student inversa com o parâmetro nu. Em caso de erro ele retorna falso. Análoga da qt() em R.

bool MathQuantileT(
  const double   &probability[],// [in]  Array com valores de probabilidade de variável aleatória
  const double   nu,            // [in]  Parâmetro de distribuição (número de graus livres)
  const bool     tail,          // [in]  Bandeira de cálculo, se for falsa, então o cálculo é realizado pela probabilidade 1.0
  const bool     log_mode,      // [in]  Flag de cálculo, se log_mode=true, o cálculo é realizado pelo Exp(probabilidade)
  double         &result[]      // [out] Array com valor de quantis
);

Para o array especificado de valores de probabilidade 'probability[]', é calculado o valor da função de distribuição t de Student inversa com o parâmetro nu. Em caso de erro ele retorna falso.

bool MathQuantileT(
  const double   &probability[],// [in]  Array com valores de probabilidade de variável aleatória
  const double   nu,            // [in]  Parâmetro de distribuição (número de graus livres)
  double         &result[]      // [out] Array com valor de quantis
);


2.11.4. MathRandomT

A função gera uma variável pseudo-aleatória distribuída de acordo com a lei da distribuição t de Student com o parâmetro nu. Em caso de erro, retorna NaN.

double MathRandomT(
  const double   nu,          // [in]  Parâmetro da distribuição (número de graus livres)
  int            &error_code  // [out] Variável para o código de erro
);

A função gera variáveis pseudo-aleatórias distribuídas de acordo com a lei da distribuição t de Student com o parâmetro nu. Em caso de erro ele retorna falso. Análoga da rt() em R.

bool MathRandomT(
  const double   nu,          // [in]  Parâmetro da distribuição (número de graus livres)
  const int      data_count,  // [in]  Quantidade de dados requeridos
  double         &result[]    // [out] Array Com valores de variáveis pseudo-aleatórias
);


2.11.5. MathMomentsT

Calcula os valores numéricos teóricos dos primeiros 4 momentos da distribuição t de Student com o parâmetro nu. Retorna verdadeiro se o cálculo do momento for bem-sucedido, caso contrário, falso.

double MathMomentsT(
  const double   nu,          // [in]  Parâmetro da distribuição (número de graus livres)
  double         &mean,       // [out] Variável para a média(1º momento)
  double         &variance,   // [out] Variável para a variância (2º momento)
  double         &skewness,   // [out] Variável para a assimetria (3º momento)
  double         &kurtosis,   // [out] Variável para a curtose (4º momento)
  int            &error_code  // [out] Variável para o código de erro
);


2.12. Distribuição t não-central

2.12.1. MathProbabilityDensityNoncentralT

Calcula o valor da probabilidade função de densidade da distribuição t de Student não central com o parâmetro nu para uma variável aleatória x. Em caso de erro, retorna NaN.

double MathProbabilityDensityNoncentralT(
  const double   x,           // [in]  Valor da variável aleatória
  const double   nu,          // [in]  Parâmetro da distribuição (número de graus livres)
  const double   delta,       // [in]  Parâmetro não centralizado
  const bool     log_mode,    // [in]  Flag Para calcular o logaritmo do valor, se log_mode = true, então o logaritmo natural da densidade de probabilidade é retornado
  int            &error_code  // [out] Variável para o código de erro
);

Calcula o valor da probabilidade função de densidade da distribuição t de Student não central com o parâmetro nu para uma variável aleatória x. Em caso de erro, retorna NaN.

double MathProbabilityDensityNoncentralT(
  const double   x,           // [in]  Valor da variável aleatória
  const double   nu,          // [in]  Parâmetro da distribuição (número de graus livres)
  const double   delta,       // [in]  Parâmetro não centralizado
  int            &error_code  // [out] Variável para o código de erro
);

Calcula o valor da probabilidade da função de densidade da distribuição T não-central de Student com o parâmetro nu para um array de variáveis aleatórias x[]. Em caso de erro ele retorna falso. Análoga da dt() em R.

bool MathProbabilityDensityNoncentralT(
  const double   &x[],        // [in]  Array com os valores da variável aleatória
  const double   nu,          // [in]  Parâmetro da distribuição (número de graus livres)
  const double   delta,       // [in]  Parâmetro não centralizado
  const bool     log_mode,    // [in]  Flag Para calcular o logaritmo do valor, se log_mode=true, então o logaritmo natural da densidade de probabilidade é calculado
  double         &result[]    // [out] Array para valores da função de densidade de probabilidade
);

Calcula o valor da probabilidade da função de densidade da distribuição T não-central de Student com o parâmetro nu para um array de variáveis aleatórias x[]. Em caso de erro ele retorna falso.

bool MathProbabilityDensityNoncentralT(
  const double   &x[],        // [in]  Array com os valores da variável aleatória
  const double   nu,          // [in]  Parâmetro da distribuição (número de graus livres)
  const double   delta,       // [in]  Parâmetro não centralizado
  double         &result[]    // [out] Array para valores da função de densidade de probabilidade
);


2.12.2. MathCumulativeDistributionlNoncentralT

Calcula o valor da probabilidade da função de distribuição t de Student não central com os parâmetros nu e delta para uma variável aleatória x. Em caso de erro, retorna NaN.

double MathCumulativeDistributionNoncentralT(
  const double   x,           // [in]  Valor da variável aleatória
  const double   nu,          // [in]  Parâmetro da distribuição (número de graus livres)
  const double   delta,       // [in]  Parâmetro não centralizado
  const bool     tail,        // [in]  Flag de cálculo, se for verdadeira, então a probabilidade da variável aleatória não excedendo x é calculada
  const bool     log_mode,    // [in]  Flag para calcular o logaritmo do valor, se log_mode=true, então o logaritmo natural da probabilidade é calculado
  int            &error_code  // [out] Variável para o código de erro
);

Calcula o valor da probabilidade da função de distribuição t de Student não central com os parâmetros nu e delta para uma variável aleatória x. Em caso de erro, retorna NaN.

double MathCumulativeDistributionNoncentralT(
  const double   x,           // [in]  Valor da variável aleatória
  const double   nu,          // [in]  Parâmetro da distribuição (número de graus livres)
  const double   delta,       // [in]  Parâmetro não centralizado
  int            &error_code  // [out] Variável para o código de erro
);

Calcula o valor da função de distribuição de probabilidade da distribuição t nao central de Student com os parâmetros nu e delta para um array de variáveis aleatórias x[]. Em caso de erro ele retorna falso. Análoga da pt() em R.

bool MathCumulativeDistributionNoncentralT(
  const double   &x[],        // [in]  Array com os valores da variável aleatória
  const double   nu,          // [in]  Parâmetro da distribuição (número de graus livres)
  const double   delta,       // [in]  Parâmetro não centralizado
  const bool     tail,        // [in]  Flag de cálculo, se for verdadeira, então a probabilidade da variável aleatória não excedendo x é calculada
  const bool     log_mode,    // [in]  Flag para calcular o logaritmo do valor, se log_mode=true, então o logaritmo natural da probabilidade é calculado
  double         &result[]    // [out] Array para valores da função de probabilidade
);

Calcula o valor da função de distribuição de probabilidade da distribuição t nao central de Student com os parâmetros nu e delta para um array de variáveis aleatórias x[]. Em caso de erro ele retorna falso.

bool MathCumulativeDistributionNoncentralT(
  const double   &x[],        // [in]  Array com os valores da variável aleatória
  const double   nu,          // [in]  Parâmetro da distribuição (número de graus livres)
  const double   delta,       // [in]  Parâmetro não centralizado
  double         &result[]    // [out] Array para valores da função de probabilidade
);


2.12.3. MathQuantileNoncentralT

Para a probabilidade específica, calcula o valor da função de distribuição t de Student inversa não central com os parâmetros nu e delta. Em caso de erro, retorna NaN.

double MathQuantileNoncentralT(
  const double   probability,   // [in]  O valor de probabilidade da ocorrência da variável aleatória
  const double   nu,            // [in]  Parâmetro de distribuição (número de graus livres)
  const double   delta,         // [in]  Parâmetro não centralizado
  const bool     tail,          // [in]  Flag de cálculo, se for falsa, então o cálculo é realizado pela probabilidade 1.0
  const bool     log_mode,      // [in]  Flag do cálculo, se false, então o cálculo é executado pela Exp(probabilidade)
  int            &error_code    // [out] Variável para o código de erro
);

Para a probabilidade específica, calcula o valor da função de distribuição t de Student inversa não central com os parâmetros nu e delta. Em caso de erro, retorna NaN.

double MathQuantileNoncentralT(
  const double   probability,   // [in]  O valor de probabilidade da ocorrência da variável aleatória
  const double   nu,            // [in]  Parâmetro de distribuição (número de graus livres)
  const double   delta,         // [in]  Parâmetro não centralizado
  int            &error_code    // [out] Variável para o código de erro
);

Para o array especificado de valores de probabilidade 'probability[]', é calculado o valor da função de distribuição t de Student inversa não central com os parâmetros nu e delta. Em caso de erro ele retorna falso. Análoga da qt() em R.

bool MathQuantileNoncentralT(
  const double   &probability[],// [in]  Array com valores de probabilidade de variável aleatória
  const double   nu,            // [in]  Parâmetro de distribuição (número de graus livres)
  const double   delta,         // [in]  Parâmetro não centralizado
  const bool     tail,          // [in]  Bandeira de cálculo, se for falsa, então o cálculo é realizado pela probabilidade 1.0
  const bool     log_mode,      // [in]  Flag de cálculo, se log_mode=true, o cálculo é realizado pelo Exp(probabilidade)
  double         &result[]      // [out] Array com valor de quantis
);

Para o array especificado de valores de probabilidade 'probability[]', é calculado o valor da função de distribuição t de Student inversa não central com os parâmetros nu e delta. Em caso de erro ele retorna falso.

bool MathQuantileNoncentralT(
  const double   &probability[],// [in]  Array com valores de probabilidade de variável aleatória
  const double   nu,            // [in]  Parâmetro de distribuição (número de graus livres)
  const double   delta,         // [in]  Parâmetro não centralizado
  double         &result[]      // [out] Array com valor de quantis
);


2.12.4. MathRandomNoncentralT

A função gera uma variável pseudo-aleatória distribuída de acordo com a lei da distribuição t de Student não central com os parâmetros nu e delta. Em caso de erro, retorna NaN.

double MathRandomNoncentralT(
  const double   nu,            // [in]  Parâmetro de distribuição (número de graus livres)
  const double   delta,         // [in]  Parâmetro não centralizado
  int            &error_code    // [out] Variável para o código de erro
);

A função gera variáveis pseudo-aleatórias distribuídas de acordo com a lei da distribuição T não-central de Student com os parâmetros nu e delta. Em caso de erro ele retorna falso. Análoga da rt() em R.

bool MathRandomNoncentralT(
  const double   nu,            // [in]  Parâmetro de distribuição (número de graus livres)
  const double   delta,         // [in]  Parâmetro não centralizado
  const int      data_count,    // [in]  Quantidade de dados requeridos
  double         &result[]      // [out] Array Com valores de variáveis pseudo-aleatórias
);


2.12.5. MathMomentsNoncentralT

Calcula os valores numéricos teóricos dos primeiros 4 momentos da distribuição t de Student nãocentral com os parâmetros nu e delta. Retorna verdadeiro se o cálculo do momento for bem-sucedido, caso contrário, falso.

double MathMomentsNoncentralT(
  const double   nu,          // [in]  Parâmetro da distribuição (número de graus livres)
  const double   delta,       // [in]  Parâmetro não centralizado
  double         &mean,       // [out] Variável para a média(1º momento)
  double         &variance,   // [out] Variável para a variância (2º momento)
  double         &skewness,   // [out] Variável para a assimetria (3º momento)
  double         &kurtosis,   // [out] Variável para a curtose (4º momento)
  int            &error_code  // [out] Variável para o código de erro
);


2.13. Distribuição logística

2.13.1. MathProbabilityDensityLogistic

Calcula o valor da probabilidade da função de densidade da distribuição logística com os parâmetros mu e sigma para uma variável aleatória x. Em caso de erro, retorna NaN.

double MathProbabilityDensityLogistic(
  const double   x,           // [in]  Valor da variável aleatória
  const double   mu,          // [in]  parâmetro médio da distribuição
  const double   sigma,       // [in]  Parâmetro scale da distribuição
  const bool     log_mode,    // [in]  Flag Para calcular o logaritmo do valor, se log_mode = true, então o logaritmo natural da densidade de probabilidade é retornado
  int            &error_code  // [out] Variável para o código de erro
);

Calcula o valor da probabilidade da função de densidade da distribuição logística com os parâmetros mu e sigma para uma variável aleatória x. Em caso de erro, retorna NaN.

double MathProbabilityDensityLogistic(
  const double   x,           // [in]  Valor da variável aleatória
  const double   mu,          // [in]  parâmetro médio da distribuição
  const double   sigma,       // [in]  Parâmetro scale da distribuição
  int            &error_code  // [out] Variável para o código de erro
);

Calcula o valor da função de densidade de probabilidade da distribuição logística com os parâmetros mu e sigma para um array de variáveis aleatórias x[]. Em caso de erro ele retorna falso. Análoga da dlogis() em R.

bool MathProbabilityDensityLogistic(
  const double   &x[],        // [in]  Array com os valores da variável aleatória
  const double   mu,          // [in]  parâmetro médio da distribuição
  const double   sigma,       // [in]  Parâmetro scale da distribuição
  const bool     log_mode,    // [in]  Flag Para calcular o logaritmo do valor, se log_mode=true, então o logaritmo natural da densidade de probabilidade é calculado
  double         &result[]    // [out] Array para valores da função de densidade de probabilidade
);

Calcula o valor da função de densidade de probabilidade da distribuição logística com os parâmetros mu e sigma para um array de variáveis aleatórias x[]. Em caso de erro ele retorna falso.

bool MathProbabilityDensityLogistic(
  const double   &x[],        // [in]  Array com os valores da variável aleatória
  const double   mu,          // [in]  parâmetro médio da distribuição
  const double   sigma,       // [in]  Parâmetro scale da distribuição
  double         &result[]    // [out] Array para valores da função de densidade de probabilidade
);


2.13.2. MathCumulativeDistributionlLogistic

Calcula o valor da função de distribuição logística com os parâmetros mu e sigma para uma variável aleatória x. Em caso de erro, retorna NaN.

double MathCumulativeDistributionLogistic(
  const double   x,           // [in]  Valor da variável aleatória
  const double   mu,          // [in]  parâmetro médio da distribuição
  const double   sigma,       // [in]  Parâmetro scale da distribuição
  const bool     tail,        // [in]  Flag de cálculo, se for verdadeira, então a probabilidade da variável aleatória não excedendo x é calculada
  const bool     log_mode,    // [in]  Flag para calcular o logaritmo do valor, se log_mode=true, então o logaritmo natural da probabilidade é calculado
  int            &error_code  // [out] Variável para o código de erro
);

Calcula o valor da função de distribuição logística com os parâmetros mu e sigma para uma variável aleatória x. Em caso de erro, retorna NaN.

double MathCumulativeDistributionLogistic(
  const double   x,           // [in]  Valor da variável aleatória
  const double   mu,          // [in]  parâmetro médio da distribuição
  const double   sigma,       // [in]  Parâmetro scale da distribuição
  int            &error_code  // [out] Variável para o código de erro
);

Calcula o valor da função de distribuição logística com os parâmetros mu e sigma para um array de variável aleatória x[]. Em caso de erro ele retorna falso. Análoga da plogis() em R.

bool MathCumulativeDistributionLogistic(
  const double   &x[],        // [in]  Array com os valores da variável aleatória
  const double   mu,          // [in]  parâmetro médio da distribuição
  const double   sigma,       // [in]  Parâmetro scale da distribuição
  const bool     tail,        // [in]  Flag de cálculo, se for verdadeira, então a probabilidade da variável aleatória não excedendo x é calculada
  const bool     log_mode,    // [in]  Flag para calcular o logaritmo do valor, se log_mode=true, então o logaritmo natural da probabilidade é calculado
  double         &result[]    // [out] Array para valores da função de probabilidade
);

Calcula o valor da função de distribuição logística com os parâmetros mu e sigma para um array de variável aleatória x[]. Em caso de erro ele retorna falso. Análoga da plogis() em R.

bool MathCumulativeDistributionLogistic(
  const double   &x[],        // [in]  Array com os valores da variável aleatória
  const double   mu,          // [in]  parâmetro médio da distribuição
  const double   sigma,       // [in]  Parâmetro scale da distribuição
  double         &result[]    // [out] Array para valores da função de probabilidade
);


2.13.3. MathQuantileLogistic

Para a probabilidade específica, calcula o valor da função de distribuição logística inversa com os parâmetros mu e sigma. Em caso de erro, retorna NaN.

double MathQuantileLogistic(
  const double   probability,   // [in]  O valor de probabilidade da ocorrência da variável aleatória
  const double   mu,            // [in]  parâmetro médio de distribuição
  const double   sigma,         // [in]  parâmetro de escala da distribuição
  const bool     tail,          // [in]  Bandeira de cálculo, se for falsa, então o cálculo é realizado pela probabilidade 1.0
  const bool     log_mode,      // [in]  Flag de cálculo, se log_mode=true, o cálculo é realizado pelo Exp(probabilidade)
  int            &error_code    // [out] Variável para o código de erro
);

Para a probabilidade específica, calcula o valor da função de distribuição logística inversa com os parâmetros mu e sigma. Em caso de erro, retorna NaN.

double MathQuantileLogistic(
  const double   probability,   // [in]  O valor de probabilidade da ocorrência da variável aleatória
  const double   mu,            // [in]  parâmetro médio de distribuição
  const double   sigma,         // [in]  parâmetro de escala da distribuição
  int            &error_code    // [out] Variável para o código de erro
);

Para o array especificado de valores de probabilidade 'probability[]', é calculado o valor da função de distribuição logística inversa com os parâmetros mu e sigma. Em caso de erro ele retorna falso. Análoga da qlogis() em R.

bool MathQuantileLogistic(
  const double   &probability[],// [in]  Array com valores de probabilidade de variável aleatória
  const double   mu,            // [in]  parâmetro médio de distribuição
  const double   sigma,         // [in]  Parâmetro scale da distribuição
  const bool     tail,          // [in]  Bandeira de cálculo, se for falsa, então o cálculo é realizado pela probabilidade 1.0
  const bool     log_mode,      // [in]  Flag de cálculo, se log_mode=true, o cálculo é realizado pelo Exp(probabilidade)
  double         &result[]      // [out] Array com valor de quantis
);

Para o array especificado de valores de probabilidade 'probability[]', é calculado o valor da função de distribuição logística inversa com os parâmetros mu e sigma. Em caso de erro ele retorna falso.

bool MathQuantileLogistic(
  const double   &probability[],// [in]  Array com valores de probabilidade de variável aleatória
  const double   mu,            // [in]  parâmetro médio de distribuição
  const double   sigma,         // [in]  parâmetro de escala da distribuição
  double         &result[]      // [out] Array com valor de quantis
);


2.13.4. MathRandomLogistic

A função gera uma variável pseudo aleatória distribuída de acordo com a lei de distribuição logística com os parâmetros mu e sigma. Em caso de erro, retorna NaN.

double MathRandomLogistic(
  const double   mu,          // [in]  parâmetro médio da distribuição
  const double   sigma,       // [in]  Parâmetro scale da distribuição
  int            &error_code  // [out] Variável para o código de erro
);

A função gera variáveis pseudo-aleatórias distribuídas de acordo com a lei da distribuição logística com os parâmetros mu e sigma Em caso de erro ele retorna falso. Análoga da rlogis() em R.

bool MathRandomLogistic(
  const double   mu,          // [in]  parâmetro médio da distribuição
  const double   sigma,       // [in]  Parâmetro scale da distribuição
  const int      data_count,  // [in]  Quantidade de dados requeridos
  double         &result[]    // [out] Array Com valores de variáveis pseudo-aleatórias
);


2.13.5. MathMomentsLogistic

Calcula os valores numéricos teóricos dos primeiros 4 momentos da distribuição logística com os parâmetros mu e sigma. Retorna verdadeiro se o cálculo do momento for bem-sucedido, caso contrário, falso.

bool MathMomentsLogistic(
  const double   mu,          // [in]  parâmetro médio da distribuição
  const double   sigma,       // [in]  Parâmetro scale da distribuição
  double         &mean,       // [out] Variável para a média(1º momento)
  double         &variance,   // [out] Variável para a variância (2º momento)
  double         &skewness,   // [out] Variável para a assimetria (3º momento)
  double         &kurtosis,   // [out] Variável para a curtose (4º momento)
  int            &error_code  // [out] Variável para o código de erro
);


2.14. Distribuição cauchy

2.14.1. MathProbabilityDensityCauchy

Calcula o valor da probabilidade da função de densidade da distribuição de Cauchy com os parâmetros "a" e "b" para uma variável aleatória x. Em caso de erro, retorna NaN.

double MathProbabilityDensityCauchy(
  const double   x,           // [in]  Valor da variável aleatória
  const double   a,           // [in]  parâmetro médio da distribuição
  const double   b,           // [in]  parâmetro de escala da distribuição
  const bool     log_mode,    // [in]  Flag Para calcular o logaritmo do valor, se log_mode = true, então o logaritmo natural da densidade de probabilidade é retornado
  int            &error_code  // [out] Variável para o código de erro
);

Calcula o valor da probabilidade da função de densidade da distribuição de Cauchy com os parâmetros "a" e "b" para uma variável aleatória x. Em caso de erro, retorna NaN.

double MathProbabilityDensityCauchy(
  const double   x,           // [in]  Valor da variável aleatória
  const double   a,           // [in]  parâmetro médio da distribuição
  const double   b,           // [in]  parâmetro de escala da distribuição
  int            &error_code  // [out] Variável para o código de erro
);

Calcula o valor da função de densidade de probabilidade da distribuição de Cauchy com os parâmetros a e b para um array de variáveis aleatórias x[]. Em caso de erro ele retorna falso. Análoga da dcauchy() em R.

bool MathProbabilityDensityCauchy(
  const double   &x[],        // [in]  Array com os valores da variável aleatória
  const double   a,           // [in]  parâmetro médio da distribuição
  const double   b,           // [in]  parâmetro de escala da distribuição
  const bool     log_mode,    // [in]  Flag Para calcular o logaritmo do valor, se log_mode=true, então o logaritmo natural da densidade de probabilidade é calculado
  double         &result[]    // [out] Array para valores da função de densidade de probabilidade
);

Calcula o valor da função de densidade de probabilidade da distribuição de Cauchy com os parâmetros a e b para um array de variáveis aleatórias x[]. Em caso de erro ele retorna falso.

bool MathProbabilityDensityCauchy(
  const double   &x[],        // [in]  Array com os valores da variável aleatória
  const double   a,           // [in]  parâmetro médio da distribuição
  const double   b,           // [in]  parâmetro de escala da distribuição
  double         &result[]    // [out] Array para valores da função de densidade de probabilidade
);


2.14.2. MathCumulativeDistributionCauchy

Calcula o valor da probabilidade da função de distribuição de Cauchy com os parâmetros "a" e "b" para uma variável aleatória x. Em caso de erro, retorna NaN.

double MathCumulativeDistributionCauchy(
  const double   x,           // [in]  Valor da variável aleatória
  const double   a,           // [in]   parâmetro médio da distribuição
  const double   b,           // [in]  parâmetro de escala da distribuição
  const bool     tail,        // [in]  Flag de cálculo, se for verdadeira, então a probabilidade da variável aleatória não excedendo x é calculada
  const bool     log_mode,    // [in]  Flag para calcular o logaritmo do valor, se log_mode=true, então o logaritmo natural da probabilidade é calculado
  int            &error_code  // [out] Variável para o código de erro
);

Calcula o valor da probabilidade da função de distribuição de Cauchy com os parâmetros "a" e "b" para uma variável aleatória x. Em caso de erro, retorna NaN.

double MathCumulativeDistributionCauchy(
  const double   x,           // [in]  Valor da variável aleatória
  const double   a,           // [in]   parâmetro médio da distribuição
  const double   b,           // [in]  parâmetro de escala da distribuição
  int            &error_code  // [out] Variável para o código de erro
);

Calcula o valor da função de distribuição de probabilidade da distribuição de Cauchy com os parâmetros a e b para um array de variáveis aleatórias x[]. Em caso de erro ele retorna falso. Análoga da pcauchy() em R.

bool MathCumulativeDistributionCauchy(
  const double   &x[],        // [in]  Array com os valores da variável aleatória
  const double   a,           // [in]   parâmetro médio da distribuição
  const double   b,           // [in]  parâmetro de escala da distribuição
  const bool     tail,        // [in]  Flag de cálculo, se for verdadeira, então a probabilidade da variável aleatória não excedendo x é calculada
  const bool     log_mode,    // [in]  Flag para calcular o logaritmo do valor, se log_mode=true, então o logaritmo natural da probabilidade é calculado
  double         &result[]    // [out] Array para valores da função de densidade de probabilidade
);

Calcula o valor da função de distribuição de probabilidade da distribuição de Cauchy com os parâmetros a e b para um array de variáveis aleatórias x[]. Em caso de erro ele retorna falso.

bool MathCumulativeDistributionCauchy(
  const double   &x[],        // [in]  Array com os valores da variável aleatória
  const double   a,           // [in]   parâmetro médio da distribuição
  const double   b,           // [in]  parâmetro de escala da distribuição
  double         &result[]    // [out] Array para valores da função de densidade de probabilidade
);


2.14.3. MathQuantileCauchy

Para a probabilidade específica, calcula o valor da função de distribuição de Cauchy inversa com os parâmetros "a" e "b". Em caso de erro, retorna NaN.

double MathQuantileCauchy(
  const double   probability,   // [in]  O valor de probabilidade da ocorrência da variável aleatória
  const double   a,             // [in]  parametro medio da distribuição
  const double   b,             // [in]  parâmetro de escala da distribuição
  const bool     tail,          // [in]  Flag de cálculo, se for falsa, então o cálculo é realizado pela probabilidade 1.0
  const bool     log_mode,      // [in]  Flag do cálculo, se false, então o cálculo é executado pela Exp(probabilidade)
  int            &error_code    // [out] Variável para o código de erro
);

Para a probabilidade específica, calcula o valor da função de distribuição de Cauchy inversa com os parâmetros "a" e "b". Em caso de erro, retorna NaN.

double MathQuantileCauchy(
  const double   probability,   // [in]  O valor de probabilidade da ocorrência da variável aleatória
  const double   a,             // [in]  parametro medio da distribuição
  const double   b,             // [in]  parâmetro de escala da distribuição
  int            &error_code    // [out] Variável para o código de erro
);

Para o array especificado de valores de probabilidade 'probability[]', é calculado o valor da função de distribuição de Cauchy inversa com os parâmetros a e b. Em caso de erro ele retorna falso. Análoga da qcauchy() em R.

bool MathQuantileCauchy(
  const double   &probability[],// [in]  Array com valores de probabilidade de variável aleatória
  const double   a,             // [in]  parametro medio da distribuição
  const double   b,             // [in]  parâmetro de escala da distribuição
  const bool     tail,          // [in]  Flag de cálculo, se for falsa, então o cálculo é realizado pela probabilidade 1.0
  const bool     log_mode,      // [in]  Flag de cálculo, se log_mode=true, o cálculo é realizado pelo Exp(probabilidade)
  double         &result[]      // [out] Array com valor de quantis
);

Para o array especificado de valores de probabilidade 'probability[]', é calculado o valor da função de distribuição de Cauchy inversa com os parâmetros a e b. Em caso de erro ele retorna falso.

bool MathQuantileCauchy(
  const double   &probability[],// [in]  Array com valores de probabilidade de variável aleatória
  const double   a,             // [in]  parametro medio da distribuição
  const double   b,             // [in]  parâmetro de escala da distribuição
  double         &result[]      // [out] Array com valor de quantis
);


2.14.4. MathRandomCauchy

A função gera uma variável pseudo-aleatória distribuída de acordo com a lei de distribuição de Cauchy com os parâmetros "a" e "b". Em caso de erro, retorna NaN.

double MathRandomCauchy(
  const double   a,           // [in]   parâmetro médio da distribuição
  const double   b,           // [in]  parâmetro de escala da distribuição
  int            &error_code  // [out] Variável para o código de erro
);

A função gera variáveis pseudo-aleatórias distribuídas de acordo com a lei da distribuição de Cauchy com os parâmetros a e b. Em caso de erro ele retorna falso. Análoga da rcauchy() em R.

double MathRandomCauchy(
  const double   a,           // [in]   parâmetro médio da distribuição
  const double   b,           // [in]  parâmetro de escala da distribuição
  const int      data_count,  // [in]  Quantidade de dados requeridos
  double         &result[]    // [out] Array Com valores de variáveis pseudo-aleatórias
);


2.14.5. MathMomentsCauchy

Calcula os valores numéricos teóricos dos primeiros 4 momentos da distribuição de Cauchy. Retorna verdadeiro se o cálculo do momento for bem-sucedido, caso contrário, falso.

bool MathMomentsCauchy(
  const double   a,           // [in]   parâmetro médio da distribuição
  const double   b,           // [in]  parâmetro de escala da distribuição
  double         &mean,       // [out] Variável para a média(1º momento)
  double         &variance,   // [out] Variável para a variância (2º momento)
  double         &skewness,   // [out] Variável para a assimetria (3º momento)
  double         &kurtosis,   // [out] Variável para a curtose (4º momento)
  int            &error_code  // [out] Variável para o código de erro
);


2.15. Distribuição uniforme

2.15.1. MathProbabilityDensityUniform

Calcula o valor da probabilidade da função de densidade da distribuição uniforme com os parâmetros "a" e "b" para uma variável aleatória x. Em caso de erro, retorna NaN.

double MathProbabilityDensityUniform(
  const double   x,           // [in]  Valor da variável aleatória
  const double   a,           // [in]  Parâmetro da distribuição a (limite inferior)
  const double   b,           // [in]  Parâmetro da distribuição b (limite superior)
  const bool     log_mode,    // [in]  Flag Para calcular o logaritmo do valor, se log_mode = true, então o logaritmo natural da densidade de probabilidade é retornado
  int            &error_code  // [out] Variável para o código de erro
);

Calcula o valor da probabilidade da função de densidade da distribuição uniforme com os parâmetros "a" e "b" para uma variável aleatória x. Em caso de erro, retorna NaN.

double MathProbabilityDensityUniform(
  const double   x,           // [in]  Valor da variável aleatória
  const double   a,           // [in]  Parâmetro da distribuição a (limite inferior)
  const double   b,           // [in]  Parâmetro da distribuição b (limite superior)
  int            &error_code  // [out] Variável para o código de erro
);

Calcula o valor da função de densidade de probabilidade da distribuição uniforme com os parâmetros a e b para um array de variáveis aleatórias x[]. Em caso de erro ele retorna falso. Análoga da dunif() em R.

bool MathProbabilityDensityUniform(
  const double   &x[],        // [in]  Array com os valores da variável aleatória
  const double   a,           // [in]  Parâmetro da distribuição a (limite inferior)
  const double   b,           // [in]  Parâmetro da distribuição b (limite superior)
  const bool     log_mode,    // [in]  Flag Para calcular o logaritmo do valor, se log_mode = true, então o logaritmo natural da densidade de probabilidade é retornado
  double         &result[]    // [out] Array para valores da função de densidade de probabilidade
);

Calcula o valor da função de densidade de probabilidade da distribuição uniforme com os parâmetros a e b para um array de variáveis aleatórias x[]. Em caso de erro ele retorna falso.

bool MathProbabilityDensityUniform(
  const double   &x[],        // [in]  Array com os valores da variável aleatória
  const double   a,           // [in]  Parâmetro da distribuição a (limite inferior)
  const double   b,           // [in]  Parâmetro da distribuição b (limite superior)
  double         &result[]    // [out] Array para valores da função de densidade de probabilidade
);


2.15.2. MathCumulativeDistributionUniform

Calcula o valor da função de distribuição uniforme com os parâmetros "a" e "b" para uma variável aleatória x. Em caso de erro, retorna NaN.

double MathCumulativeDistributionUniform(
  const double   x,           // [in]  Valor da variável aleatória
  const double   a,           // [in]  Parâmetro da distribuição a (limite inferior)
  const double   b,           // [in]  Parâmetro da distribuição b (limite superior)
  const bool     tail,        // [in]  Flag de cálculo, se for verdadeira, então a probabilidade da variável aleatória não excedendo x é calculada
  const bool     log_mode,    // [in]  Flag para calcular o logaritmo do valor, se log_mode=true, então o logaritmo natural da probabilidade é calculado
  int            &error_code  // [out] Variável para o código de erro
);

Calcula o valor da função de distribuição uniforme com os parâmetros "a" e "b" para uma variável aleatória x. Em caso de erro, retorna NaN.

double MathCumulativeDistributionUniform(
  const double   x,           // [in]  Valor da variável aleatória
  const double   a,           // [in]  Parâmetro da distribuição a (limite inferior)
  const double   b,           // [in]  Parâmetro da distribuição b (limite superior)
  int            &error_code  // [out] Variável para o código de erro
);

Calcula o valor da função de distribuição uniforme com os parâmetros "a" e "b" para um array de variável aleatória x[]. Em caso de erro ele retorna falso. Análoga da punif() em R.

bool MathCumulativeDistributionUniform(
  const double   &x[],        // [in]  Array com os valores da variável aleatória
  const double   a,           // [in]  Parâmetro da distribuição a (limite inferior)
  const double   b,           // [in]  Parâmetro da distribuição b (limite superior)
  const bool     tail,        // [in]  Flag de cálculo, se for verdadeira, então a probabilidade da variável aleatória não excedendo x é calculada
  const bool     log_mode,    // [in]  Flag para calcular o logaritmo do valor, se log_mode=true, então o logaritmo natural da probabilidade é calculado
  double         &result[]    // [out] Array para valores da função de densidade de probabilidade
);

Calcula o valor da função de distribuição uniforme com os parâmetros "a" e "b" para um array de variável aleatória x[]. Em caso de erro ele retorna falso.

bool MathCumulativeDistributionUniform(
  const double   &x[],        // [in]  Array com os valores da variável aleatória
  const double   a,           // [in]  Parâmetro da distribuição a (limite inferior)
  const double   b,           // [in]  Parâmetro da distribuição b (limite superior)
  double         &result[]    // [out] Array para valores da função de densidade de probabilidade
);


2.15.3. MathQuantileUniform

Para a probabilidade específica, calcula o valor da função de distribuição uniforme inversa com os parâmetros "a" e "b". Em caso de erro, retorna NaN.

double MathQuantileUniform(
  const double   probability,   // [in]  O valor de probabilidade da ocorrência da variável aleatória
  const double   a,             // [in]  Parâmetro da distribuição a (limite inferior)
  const double   b,             // [in]  Parâmetro da distribuição b (limite superior)
  const bool     tail,          // [in]  Flag de cálculo, se for falsa, então o cálculo é realizado pela probabilidade 1.0
  const bool     log_mode,      // [in]  Flag do cálculo, se false, então o cálculo é executado pela Exp(probabilidade)
  int            &error_code    // [out] Variável para o código de erro
);

Para a probabilidade específica, calcula o valor da função de distribuição uniforme inversa com os parâmetros "a" e "b". Em caso de erro, retorna NaN.

double MathQuantileUniform(
  const double   probability,   // [in]  O valor de probabilidade da ocorrência da variável aleatória
  const double   a,             // [in]  Parâmetro da distribuição a (limite inferior)
  const double   b,             // [in]  Parâmetro da distribuição b (limite superior)
  int            &error_code    // [out] Variável para o código de erro
);

Para o array especificado de valores de probabilidade 'probability[]', é calculado o valor da função de distribuição uniforme inversa com os parâmetros a e b. Em caso de erro ele retorna falso. Análoga da qunif() em R.

bool MathQuantileUniform(
  const double   &probability[],// [in]  Array com valores de probabilidade de variável aleatória
  const double   a,             // [in]  Parâmetro da distribuição a (limite inferior)
  const double   b,             // [in]  Parâmetro da distribuição b (limite superior)
  const bool     tail,          // [in]  Bandeira de cálculo, se for falsa, então o cálculo é realizado pela probabilidade 1.0
  const bool     log_mode,      // [in]  Flag de cálculo, se log_mode=true, o cálculo é realizado pelo Exp(probabilidade)
  double         &result[]      // [out] Array com valor de quantis
);

Para o array especificado de valores de probabilidade 'probability[]', é calculado o valor da função de distribuição uniforme inversa com os parâmetros a e b. Em caso de erro ele retorna falso.

bool MathQuantileUniform(
  const double   &probability[],// [in]  Array com valores de probabilidade de variável aleatória
  const double   a,             // [in]  Parâmetro da distribuição a (limite inferior)
  const double   b,             // [in]  Parâmetro da distribuição b (limite superior)
  double         &result[]      // [out] Array com valor de quantis
);


2.15.4. MathRandomUniform

A função gera uma variável pseudo-aleatória distribuída de acordo com a lei da distribuição uniforme com os parâmetros "a" e "b". Em caso de erro, retorna NaN.

double MathRandomUniform(
  const double   a,           // [in]  Parâmetro da distribuição a (limite inferior)
  const double   b,           // [in]  Parâmetro da distribuição b (limite superior)
  int            &error_code  // [out] Variável para o código de erro
);

A função gera variáveis pseudo-aleatórias distribuídas de acordo com a lei da distribuição uniforme com os parâmetros a e b. Em caso de erro ele retorna falso. Análoga da runif() em R.

bool MathRandomUniform(
  const double   a,           // [in]  Parâmetro da distribuição a (limite inferior)
  const double   b,           // [in]  Parâmetro da distribuição b (limite superior)
  const int      data_count,  // [in]  Quantidade de dados requeridos
  double         &result[]    // [out] Array Com valores de variáveis pseudo-aleatórias
);


2.15.5. MathMomentsUniform

Calcula os valores numéricos teóricos dos primeiros 4 momentos para a distribuição uniforme. Retorna verdadeiro se o cálculo do momento for bem-sucedido, caso contrário, falso.

bool MathMomentsUniform(
  const double   a,           // [in]  Parâmetro da distribuição a (limite inferior)
  const double   b,           // [in]  Parâmetro da distribuição b (limite superior)
  double         &mean,       // [out] Variável para a média(1º momento)
  double         &variance,   // [out] Variável para a variância (2º momento)
  double         &skewness,   // [out] Variável para a assimetria (3º momento)
  double         &kurtosis,   // [out] Variável para a curtose (4º momento)
  int            &error_code  // [out] Variável para o código de erro
);


2.16. Distribuição Weibull

2.16.1. MathProbabilityDensityWeibull

Calcula o valor da probabilidade da função de densidade da distribuição Weibull com os parâmetros "a" e "b" para uma variável aleatória x. Em caso de erro, retorna NaN.

double MathProbabilityDensityWeibull(
  const double   x,           // [in]  Valor da variável aleatória
  const double   a,           // [in]  Parâmetro da distribuição (shape)
  const double   b,           // [in]  Parâmetro da distribuição (scale)
  const bool     log_mode,    // [in]  Flag Para calcular o logaritmo do valor, se log_mode = true, então o logaritmo natural da densidade de probabilidade é retornado
  int            &error_code  // [out] Variável para o código de erro
);

Calcula o valor da probabilidade da função de densidade da distribuição Weibull com os parâmetros "a" e "b" para uma variável aleatória x. Em caso de erro, retorna NaN.

double MathProbabilityDensityWeibull(
  const double   x,           // [in]  Valor da variável aleatória
  const double   a,           // [in]  Parâmetro da distribuição (shape)
  const double   b,           // [in]  Parâmetro da distribuição (scale)
  int            &error_code  // [out] Variável para o código de erro
);

Calcula o valor da função de densidade de probabilidade da distribuição de Weibull com os parâmetros a e b para um array de variáveis aleatórias x[]. Em caso de erro ele retorna falso. Análoga da dweibull() em R.

bool MathProbabilityDensityWeibull(
  const double   &x[],        // [in]  Array com os valores da variável aleatória
  const double   a,           // [in]  Parâmetro da distribuição (shape)
  const double   b,           // [in]  Parâmetro da distribuição (scale)
  const bool     log_mode,    // [in]  Flag Para calcular o logaritmo do valor, se log_mode = true, então o logaritmo natural da densidade de probabilidade é retornado
  double         &result[]    // [out] Array para valores da função de densidade de probabilidade
);

Calcula o valor da função de densidade de probabilidade da distribuição de Weibull com os parâmetros a e b para um array de variáveis aleatórias x[]. Em caso de erro ele retorna falso.

bool MathProbabilityDensityWeibull(
  const double   &x[],        // [in]  Array com os valores da variável aleatória
  const double   a,           // [in]  Parâmetro da distribuição (shape)
  const double   b,           // [in]  Parâmetro da distribuição (scale)
  double         &result[]    // [out] Array para valores da função de densidade de probabilidade
);


2.16.2. MathCumulativeDistributionWeibull

Calcula o valor da função de distribuição Weibull com os parâmetros "a" e "b" para uma variável aleatória x. Em caso de erro, retorna NaN.
double MathCumulativeDistributionWeibull(
  const double   x,           // [in]  Valor da variável aleatória
  const double   a,           // [in]  Parâmetro da distribuição (shape)
  const double   b,           // [in]  Parâmetro scale da distribuição 
  const bool     tail,        // [in]  Flag de cálculo, se for verdadeira, então a probabilidade da variável aleatória não excedendo x é calculada
  const bool     log_mode,    // [in]  Flag para calcular o logaritmo do valor, se log_mode=true, então o logaritmo natural da probabilidade é calculado
  int            &error_code  // [out] Variável para o código de erro
);

Calcula o valor da função de distribuição Weibull com os parâmetros "a" e "b" para uma variável aleatória x. Em caso de erro, retorna NaN.

double MathCumulativeDistributionWeibull(
  const double   x,           // [in]  Valor da variável aleatória
  const double   a,           // [in]  Parâmetro da distribuição (shape)
  const double   b,           // [in]  Parâmetro scale da distribuição 
  int            &error_code  // [out] Variável para o código de erro
);

Calcula o valor da função de distribuição Weibull com os parâmetros "a" e "b" para uma variável aleatória x. Em caso de erro ele retorna falso. Análoga da pweibull() em R.

bool MathCumulativeDistributionWeibull(
  const double   &x[],        // [in]  Array com os valores da variável aleatória
  const double   a,           // [in]  Parâmetro da distribuição (shape)
  const double   b,           // [in]  Parâmetro de distribuição (scale)
  const bool     tail,        // [in]  Flag de cálculo, se for verdadeira, então a probabilidade da variável aleatória não excedendo x é calculada
  const bool     log_mode,    // [in]  Flag para calcular o logaritmo do valor, se log_mode=true, então o logaritmo natural da probabilidade é calculado
  double         &result[]    // [out] Array para valores da função de densidade de probabilidade
);

Calcula o valor da função de distribuição Weibull com os parâmetros "a" e "b" para uma variável aleatória x. Em caso de erro ele retorna falso.

bool MathCumulativeDistributionWeibull(
  const double   &x[],        // [in]  Array com os valores da variável aleatória
  const double   a,           // [in]  Parâmetro da distribuição (shape)
  const double   b,           // [in]  Parâmetro scale da distribuição 
  double         &result[]    // [out] Array para valores da função de densidade de probabilidade
);


2.16.3. MathQuantileWeibull

Para a probabilidade específica, calcula o valor da função de distribuição Weibull inversa com os parâmetros "a" e "b". Em caso de erro, retorna NaN.

double MathQuantileWeibull(
  const double   probability,   // [in]  O valor de probabilidade da ocorrência da variável aleatória
  const double   a,             // [in]  Parâmetro de distribuição (shape)
  const double   b,             // [in]  Parâmetro de distribuição (scale)
  const bool     tail,          // [in]  Bandeira de cálculo, se for falsa, então o cálculo é realizado pela probabilidade 1.0
  const bool     log_mode,      // [in]  Flag de cálculo, se log_mode=true, o cálculo é realizado pelo Exp(probabilidade)
  int            &error_code    // [out] Variável para o código de erro
);

Para a probabilidade específica, calcula o valor da função de distribuição Weibull inversa com os parâmetros "a" e "b". Em caso de erro, retorna NaN.

double MathQuantileWeibull(
  const double   probability,   // [in]  O valor de probabilidade da ocorrência da variável aleatória
  const double   a,             // [in]  Parâmetro de distribuição (shape)
  const double   b,             // [in]  Parâmetro de distribuição (scale)
  int            &error_code    // [out] Variável para o código de erro
);

Para o array especificado de valores de probabilidade 'probability[]', é calculado o valor da função de distribuição Weibull inversa com os parâmetros a e b. Em caso de erro ele retorna falso. Análoga da qweibull() em R.

bool MathQuantileWeibull(
  const double   &probability[],// [in]  Array com valores de probabilidade de variável aleatória
  const double   a,             // [in]  Parâmetro de distribuição (shape)
  const double   b,             // [in]  Parâmetro de distribuição (scale)
  const bool     tail,          // [in]  Bandeira de cálculo, se for falsa, então o cálculo é realizado pela probabilidade 1.0
  const bool     log_mode,      // [in]  Flag de cálculo, se log_mode=true, o cálculo é realizado pelo Exp(probabilidade)
  double         &result[]      // [out] Array com valor de quantis
);

Para o array especificado de valores de probabilidade 'probability[]', é calculado o valor da função de distribuição Weibull inversa com os parâmetros a e b. Em caso de erro ele retorna falso.

bool MathQuantileWeibull(
  const double   &probability[],// [in]  Array com valores de probabilidade de variável aleatória
  const double   a,             // [in]  Parâmetro de distribuição (shape)
  const double   b,             // [in]  Parâmetro de distribuição (scale)
  double         &result[]      // [out] Array com valor de quantis
);


2.16.4. MathRandomWeibull

A função gera uma variável pseudo-aleatória distribuída de acordo com a lei da distribuição Weibull com os parâmetros "a" e "b". Em caso de erro, retorna NaN.

double MathRandomWeibull(
  const double   a,           // [in]  Parâmetro da distribuição (shape)
  const double   b,           // [in]  Parâmetro da distribuição (scale)
  int            &error_code  // [out] Variável do codigo de erro
);

A função gera variáveis pseudo-aleatórias distribuídas de acordo com a lei da distribuição de Weibull com os parâmetros a e b. Em caso de erro ele retorna falso. Análoga da rweibull() em R.

bool MathRandomWeibull(
  const double   a,           // [in]  Parâmetro da distribuição (shape)
  const double   b,           // [in]  Parâmetro da distribuição (scale)
  const int      data_count,  // [in]  Quantidade de dados requeridos
  double         &result[]    // [out] Array Com valores de variáveis pseudo-aleatórias
);


2.16.5. MathMomentsWeibull

Calcula os valores numéricos teóricos dos primeiros 4 momentos da distribuição Weibull. Retorna verdadeiro se o cálculo do momento for bem-sucedido, caso contrário, falso.

bool MathMomentsWeibull(
  const double   a,           // [in]  Parâmetro da distribuição (shape)
  const double   b,           // [in]  Parâmetro da distribuição (scale)
  double         &mean,       // [out] Variável para a média(1º momento)
  double         &variance,   // [out] Variável para a variância (2º momento)
  double         &skewness,   // [out] Variável para a assimetria (3º momento)
  double         &kurtosis,   // [out] Variável para a curtose (4º momento)
  int            &error_code  // [out] Variável para o código de erro
);


2.17. Distribuição binomial

2.17.1. MathProbabilityDensityBinomial

Calcula o valor da probabilidade da função de massa da distribuição binomial com os parâmetros "n" e "p" para uma variável aleatória x. Em caso de erro, retorna NaN.

double MathProbabilityDensityBinomial(
  const double   x,           // [in]  Valor da variável aleatória (inteira)
  const double   n,           // [in]  Parâmetro da distribuição (número de testes)
  const double   p,           // [in]  Parâmetro de distribuição (probabilidade de sucesso para cada teste)
  const bool     log_mode,    // [in]  Flag Para calcular o logaritmo do valor, se log_mode = true, então o logaritmo natural da densidade de probabilidade é retornado
  int            &error_code  // [out] Variável para o código de erro
);

Calcula o valor da probabilidade da função de massa da distribuição binomial com os parâmetros "n" e "p" para uma variável aleatória x. Em caso de erro, retorna NaN.

double MathProbabilityDensityBinomial(
  const double   x,           // [in]  Valor da variável aleatória (inteira)
  const double   n,           // [in]  Parâmetro da distribuição (número de testes)
  const double   p,           // [in]  Parâmetro de distribuição (probabilidade de sucesso para cada teste)
  int            &error_code  // [out] Variável para o código de erro
);

Calcula o valor da probabilidade da função de massa da distribuição binomial com os parâmetros n e p para um array de variável aleatória x[]. Em caso de erro ele retorna falso. Análoga da dbinom() em R.

bool MathProbabilityDensityBinomial(
  const double   &x[],        // [in]  Array with the values of random variable
  const double   n,           // [in]  Parâmetro da distribuição (número de testes)
  const double   p,           // [in]  Parâmetro de distribuição (probabilidade de sucesso para cada teste)
  const bool     log_mode,    // [in]  Flag Para calcular o logaritmo do valor, se log_mode = true, então o logaritmo natural da densidade de probabilidade é retornado
  double         &result[]    // [out] Array para valores da função de densidade de probabilidade
);

Calcula o valor da probabilidade da função de massa da distribuição binomial com os parâmetros n e p para um array de variável aleatória x[]. Em caso de erro ele retorna falso.

bool MathProbabilityDensityBinomial(
  const double   &x[],        // [in]  Array with the values of random variable
  const double   n,           // [in]  Parâmetro da distribuição (número de testes)
  const double   p,           // [in]  Parâmetro de distribuição (probabilidade de sucesso para cada teste)
  double         &result[]    // [out] Array para valores da função de densidade de probabilidade
);


2.17.2. MathCumulativeDistributionBinomial

Calcula o valor da probabilidade da função de distribuição para a lei binomial com os parâmetros "n" e "p" para uma variável aleatória x. Em caso de erro, retorna NaN.

double MathCumulativeDistributionBinomial(
  const double   x,           // [in]  Valor da variável aleatória (inteiro)
  const double   n,           // [in]  Parâmetro da distribuição (número de testes)
  const double   p,           // [in]  Parâmetro de distribuição (probabilidade de sucesso para cada teste)
  const bool     tail,        // [in]  Flag de cálculo, se for verdadeira, então a probabilidade da variável aleatória não excedendo x é calculada
  const bool     log_mode,    // [in]  Flag para calcular o logaritmo do valor, se log_mode=true, então o logaritmo natural da probabilidade é calculado
  int            &error_code  // [out] Variável do codigo de erro
);

Calcula o valor da probabilidade da função de distribuição para a lei binomial com os parâmetros "n" e "p" para uma variável aleatória x. Em caso de erro, retorna NaN.

double MathCumulativeDistributionBinomial(
  const double   x,           // [in]  Valor da variável aleatória (inteiro)
  const double   n,           // [in]  Parâmetro da distribuição (número de testes)
  const double   p,           // [in]  Parâmetro de distribuição (probabilidade de sucesso para cada teste)
  int            &error_code  // [out] Variável do codigo de erro
);

Calcula o valor da probabilidade da função de distribuição para a lei binomial com os parâmetros n e p para um array de variável aleatória x[]. Em caso de erro ele retorna falso. Análoga da pbinom() em R.

bool MathCumulativeDistributionBinomial(
  const double   &x[],        // [in]  Array com os valores da variável aleatória
  const double   n,           // [in]  Parâmetro da distribuição (número de testes)
  const double   p,           // [in]  Parâmetro de distribuição (probabilidade de sucesso para cada teste)
  const bool     tail,        // [in]  Flag de cálculo, se for verdadeira, então a probabilidade da variável aleatória não excedendo x é calculada
  const bool     log_mode,    // [in]  Flag para calcular o logaritmo do valor, se log_mode=true, então o logaritmo natural da probabilidade é calculado
  double         &result[]    // [out] Array para valores da função de densidade de probabilidade
);

Calcula o valor da probabilidade da função de distribuição para a lei binomial com os parâmetros n e p para um array de variável aleatória x[]. Em caso de erro ele retorna falso.

bool MathCumulativeDistributionBinomial(
  const double   &x[],        // [in]  Array com os valores da variável aleatória
  const double   n,           // [in]  Parâmetro da distribuição (número de testes)
  const double   p,           // [in]  Parâmetro de distribuição (probabilidade de sucesso para cada teste)
  double         &result[]    // [out] Array para valores da função de densidade de probabilidade
);


2.17.3. MathQuantileBinomial

Para a probabilidade específica, calcula o valor inverso da função de distribuição para a lei binomial com os parâmetros "n" e "p" . Em caso de erro, retorna NaN.

double MathQuantileBinomial(
  const double   probability,   // [in]  O valor de probabilidade da ocorrência da variável aleatória
  const double   n,             // [in]  Parâmetro de distribuição (número de testes)
  const double   p,             // [in]  Parâmetro de distribuição (probabilidade de sucesso para cada teste)
  const bool     tail,          // [in]  Flag de cálculo, se for falsa, então o cálculo é realizado pela probabilidade 1.0
  const bool     log_mode,      // [in]  Flag de cálculo, se log_mode=true, o cálculo é realizado pelo Exp(probabilidade)
  int            &error_code    // [out] Variável para o código de erro
);

Para a probabilidade específica, calcula o valor inverso da função de distribuição para a lei binomial com os parâmetros "n" e "p" . Em caso de erro, retorna NaN.

double MathQuantileBinomial(
  const double   probability,   // [in]  O valor de probabilidade da ocorrência da variável aleatória
  const double   n,             // [in]  Parâmetro de distribuição (número de testes)
  const double   p,             // [in]  Parâmetro de distribuição (probabilidade de sucesso para cada teste)
  int            &error_code    // [out] Variável para o código de erro
);

Para o array especificado de valores de probabilidade 'probability[]', é calculado o valor inverso de distribuição da função para a lei binomial com os parâmetros n e p. Em caso de erro ele retorna falso. Análoga da qbinom() em R.

bool MathQuantileBinomial(
  const double   &probability[],// [in]  Array com valores de probabilidade de variável aleatória
  const double   n,             // [in]  Parâmetro de distribuição (número de testes)
  const double   p,             // [in]  Parâmetro de distribuição (probabilidade de sucesso para cada teste)
  const bool     tail,          // [in]  Flag de cálculo, se for falsa, então o cálculo é realizado pela probabilidade 1.0
  const bool     log_mode,      // [in]  Flag do cálculo, se false, então o cálculo é executado pela Exp(probabilidade)
  double         &result[]      // [out] Array com valor de quantis
);

Para o array especificado de valores de probabilidade 'probability[]', é calculado o valor inverso de distribuição da função para a lei binomial com os parâmetros n e p. Em caso de erro ele retorna falso.

bool MathQuantileBinomial(
  const double   &probability[],// [in]  Array com valores de probabilidade de variável aleatória
  const double   n,             // [in]  Parâmetro de distribuição (número de testes)
  const double   p,             // [in]  Parâmetro de distribuição (probabilidade de sucesso para cada teste)
  double         &result[]      // [out] Array com valor de quantis
);


2.17.4. MathRandomBinomial

A função gera uma variável pseudo-aleatória distribuída de acordo com a lei de distribuição binomial com os parâmetros "n" e "p". Em caso de erro, retorna NaN.

double MathRandomBinomial(
  const double   n,           // [in]  Parâmetro da distribuição (número de testes)
  const double   p,           // [in]  Parâmetro de distribuição (probabilidade de sucesso para cada teste)
  int            &error_code  // [out] Variável do codigo de erro
);

A função gera variáveis pseudo-aleatórias distribuídas de acordo com a lei da distribuição binomial com os parâmetros n e p. Em caso de erro ele retorna falso. Análoga da rbinom() em R.

bool MathRandomBinomial(
  const double   n,           // [in]  Parâmetro da distribuição (número de testes)
  const double   p,           // [in]  Parâmetro de distribuição (probabilidade de sucesso para cada teste)
  const int      data_count,  // [in]  Quantidade de dados requeridos
  double         &result[]    // [out] Array Com valores de variáveis pseudo-aleatórias
);


2.17.5. MathMomentsBinomial

Calcula os valores numéricos teóricos dos primeiros 4 momentos da distribuição binomial com os parâmetros "n" e "p". Retorna verdadeiro se o cálculo do momento for bem-sucedido, caso contrário, falso.

bool MathMomentsBinomial(
  const double   n,           // [in]  Número de testes
  const double   p,           // [in]  Probabilidade de sucesso em cada teste
  double         &mean,       // [out] Variável para a média(1º momento)
  double         &variance,   // [out] Variável para a variância (2º momento)
  double         &skewness,   // [out] Variável para a assimetria (3º momento)
  double         &kurtosis,   // [out] Variável para a curtose (4º momento)
  int            &error_code  // [out] Variável para o código de erro
);


2.18. Distribuição binomial negativa

2.18.1. MathProbabilityDensityNegativeBinomial

Calcula o valor da probabilidade da função de massa da distribuição binomial negativa com os parâmetros r e p para uma variável aleatória x. Em caso de erro, retorna NaN.

double MathProbabilityDensityNegativeBinomial(
  const double   x,           // [in]  Valor da variável aleatória (inteiro)
  const double   r,           // [in]  Número de testes bem sucedidos
  double         p,           // [in]  Probabilidade de sucesso
  const bool     log_mode,    // [in]  Flag Para calcular o logaritmo do valor, se log_mode = true, então o logaritmo natural da densidade de probabilidade é retornado
  int            &error_code  // [out] Variável para o código de erro
);

Calcula o valor da probabilidade da função de massa da distribuição binomial negativa com os parâmetros r e p para uma variável aleatória x. Em caso de erro, retorna NaN.

double MathProbabilityDensityNegativeBinomial(
  const double   x,           // [in]  Valor da variável aleatória (inteiro)
  const double   r,           // [in]  Número de testes bem sucedidos
  double         p,           // [in]  Probabilidade de sucesso
  int            &error_code  // [out] Variável para o código de erro
);

Calcula o valor da probabilidade da função de massa da distribuição binomial negativa com os parâmetros r e p para uma variável aleatória x[]. Em caso de erro ele retorna falso. Análoga da dnbinom() em R.

bool MathProbabilityDensityNegativeBinomial(
  const double   &x[],        // [in]  Array com os valores da variável aleatória
  const double   r,           // [in]  Número de testes bem sucedidos
  double         p,           // [in]  Probabilidade de successo
  const bool     log_mode,    // [in]  Flag Para calcular o logaritmo do valor, se log_mode = true, então o logaritmo natural da densidade de probabilidade é retornado
  double         &result[]    // [out] Array para valores da função de densidade de probabilidade
);

Calcula o valor da probabilidade da função de massa da distribuição binomial negativa com os parâmetros r e p para uma variável aleatória x[]. Em caso de erro ele retorna falso.

bool MathProbabilityDensityNegativeBinomial(
  const double   &x[],        // [in]  Array com os valores da variável aleatória
  const double   r,           // [in]  Número de testes bem sucedidos
  double         p,           // [in]  Probabilidade de sucesso
  double         &result[]    // [out] Array para valores da função de densidade de probabilidade
);


2.18.2. MathCumulativeDistributionNegativeBinomial

Calcula o valor da probabilidade da função de distribuição para a lei binomial negativa com os parâmetros r e p para uma variável aleatória x. Em caso de erro, retorna NaN.

double MathCumulativeDistributionNegativeBinomial(
  const double   x,           // [in]  Valor da variável aleatória (inteiro)
  const double   r,           // [in]  Número de testes bem sucedidos
  double         p,           // [in]  Probabilidade de sucesso
  const bool     tail,        // [in]  Flag de cálculo, se for verdadeira, então a probabilidade da variável aleatória não excedendo x é calculada
  const bool     log_mode,    // [in]  Flag para calcular o logaritmo do valor, se log_mode=true, então o logaritmo natural da probabilidade é calculado
  int            &error_code  // [out] Variável para o código de erro
);

Calcula o valor da probabilidade da função de distribuição para a lei binomial negativa com os parâmetros r e p para uma variável aleatória x. Em caso de erro, retorna NaN.

double MathCumulativeDistributionNegativeBinomial(
  const double   x,           // [in]  Valor da variável aleatória (inteiro)
  const double   r,           // [in]  Número de testes bem sucedidos
  double         p,           // [in]  Probabilidade de sucesso
  int            &error_code  // [out] Variável para o código de erro
);

Calcula o valor da função de distribuição de probabilidade para a lei binomial negativa com os parâmetros r e p para um array de variáveis aleatórias x[]. Em caso de erro ele retorna falso. Análoga da pnbinom() em R.

bool MathCumulativeDistributionNegativeBinomial(
  const double   &x[],        // [in]  Array com os valores da variável aleatória
  const double   r,           // [in]  Número de testes bem sucedidos
  double         p,           // [in]  Probabilidade de sucesso
  const bool     tail,        // [in]  Flag de cálculo, se for verdadeira, então a probabilidade da variável aleatória não excedendo x é calculada
  const bool     log_mode,    // [in]  Flag para calcular o logaritmo do valor, se log_mode=true, então o logaritmo natural da probabilidade é calculado
  double         &result[]    // [out] Array para valores da função de probabilidade
);

Calcula o valor da função de distribuição de probabilidade para a lei binomial negativa com os parâmetros r e p para um array de variáveis aleatórias x[]. Em caso de erro ele retorna falso.

bool MathCumulativeDistributionNegativeBinomial(
  const double   &x[],        // [in]  Array com os valores da variável aleatória
  const double   r,           // [in]  Número de testes bem sucedidos
  double         p,           // [in]  Probabilidade de sucesso
  double         &result[]    // [out] Array para valores da função de probabilidade
);


2.18.3. MathQuantileNegativeBinomial

Para a probabilidade específica, calcula o valor inverso da função de distribuição para a lei binomial negativa com os parâmetros r e p. Em caso de erro, retorna NaN.

double MathQuantileNegativeBinomial(
  const double   probability,   // [in]  O valor de probabilidade da ocorrência da variável aleatória 
  const double   r,             // [in]  Número de testes bem sucedidos
  double         p,             // [in]  Probabilidade de successo
  const bool     tail,          // [in]  Flag de cálculo, se false, entao o calculo é executado pela probabilidade 1.0
  const bool     log_mode,      // [in]  Flag de cálculo, se log_mode=true, o cálculo é realizado pelo Exp(probabilidade)
  int            &error_code    // [out] Variável para o código de erro
);

Para a probabilidade específica, calcula o valor inverso da função de distribuição para a lei binomial negativa com os parâmetros r e p. Em caso de erro, retorna NaN.

double MathQuantileNegativeBinomial(
  const double   probability,   // [in]  O valor de probabilidade da ocorrência da variável aleatória 
  const double   r,             // [in]  Número de testes bem sucedidos
  double         p,             // [in]  Probabilidade de successo
  int            &error_code    // [out] Variável para o código de erro
);

Para o array especificado de valores de probabilidade 'probability[]', é calculado o valor inverso da distribuição da função para a lei binomial negativa com os parâmetros r e p. Em caso de erro ele retorna falso. Análoga da qnbinom() em R.

bool MathQuantileNegativeBinomial(
  const double   &probability[],// [in]  Array com valores de probabilidade de variável aleatória
  const double   r,             // [in]  Número de testes bem sucedidos
  double         p,             // [in]  Probabilidade de successo
  const bool     tail,          // [in]  Flag de cálculo, se false, entao o calculo é executado pela probabilidade 1.0
  const bool     log_mode,      // [in]  Flag de cálculo, se log_mode=true, o cálculo é realizado pelo Exp(probabilidade)
  double         &result[]      // [out] Array com valor de quantis
);

Para o array especificado de valores de probabilidade 'probability[]', é calculado o valor inverso da distribuição da função para a lei binomial negativa com os parâmetros r e p. Em caso de erro ele retorna falso.

bool MathQuantileNegativeBinomial(
  const double   &probability[],// [in]  Array com valores de probabilidade de variável aleatória
  const double   r,             // [in]  Número de testes bem sucedidos
  double         p,             // [in]  Probabilidade de successo
  double         &result[]      // [out] Array com valor de quantis
);


2.18.4. MathRandomNegativeBinomial

A função gera uma variável pseudo aleatória distribuída de acordo com a lei de distribuição binomial negativa com os parâmetros r e p. Em caso de erro, retorna NaN.

double MathRandomNegativeBinomial(
  const double   r,           // [in]  Número de testes bem sucedidos
  double         p,           // [in]  Probabilidade de successo
  int            &error_code  // [out] Variável para o código de erro
);

A função gera variáveis pseudo-aleatórias distribuídas de acordo com a lei da distribuição binomial negativa com os parâmetros r e p. Em caso de erro ele retorna falso. Análoga da rnbinom() em R.

bool MathRandomNegativeBinomial(
  const double   r,           // [in]  Número de testes bem sucedidos
  double         p,           // [in]  Probabilidade de successo
  const int      data_count,  // [in]  Quantidade de dados requeridos
  double         &result[]    // [out] Array Com valores de variáveis pseudo-aleatórias
);


2.18.5. MathMomentsNegativeBinomial

Calcula os valores numéricos teóricos dos primeiros 4 momentos da distribuição binomial negativa com os parâmetros r e p. Retorna verdadeiro se o cálculo do momento for bem-sucedido, caso contrário, falso.

bool MathMomentsNegativeBinomial(
  const double   r,           // [in]  Número de testes bem sucedidos
  double         p,           // [in]  Probabilidade de successo
  double         &mean,       // [out] Variável para a média(1º momento)
  double         &variance,   // [out] Variável para a variância (2º momento)
  double         &skewness,   // [out] Variável para a assimetria (3º momento)
  double         &kurtosis,   // [out] Variável para a curtose (4º momento)
  int            &error_code  // [out] Variável para o código de erro
);

2.19. Distribuição geométrica

2.19.1. MathProbabilityDensityGeometric

Calcula o valor da probabilidade da função de massa da distribuição geométrica com o parâmetro p para uma variável aleatória x. Em caso de erro, retorna NaN.

double MathProbabilityDensityGeometric(
  const double   x,           // [in]  Valor da variável aleatória
  const double   p,           // [in]  Parâmetro de distribuição (probabilidade de ocorrência do evento para cada teste)
  const bool     log_mode,    // [in]  Flag Para calcular o logaritmo do valor, se log_mode = true, então o logaritmo natural da densidade de probabilidade é retornado
  int            &error_code  // [out] Variável para o código de erro
);

Calcula o valor da probabilidade da função de massa da distribuição geométrica com o parâmetro p para uma variável aleatória x. Em caso de erro, retorna NaN.

double MathProbabilityDensityGeometric(
  const double   x,           // [in]  Valor da variável aleatória
  const double   p,           // [in]  Parâmetro de distribuição (probabilidade de ocorrência do evento para cada teste)
  int            &error_code  // [out] Variável para o código de erro
);

Calcula o valor da probabilidade da função de massa da distribuição geométrica com o parâmetro p para uma variável aleatória x[]. Em caso de erro ele retorna falso. Análoga da dgeom() em R.

bool MathProbabilityDensityGeometric(
  const double   &x[],        // [in]  Array com os valores da variável aleatória
  const double   p,           // [in]  Parâmetro de distribuição (probabilidade de ocorrência do evento para cada teste)
  const bool     log_mode,    // [in]  Flag Para calcular o logaritmo do valor, se log_mode = true, então o logaritmo natural da densidade de probabilidade é retornado
  double         &result[]    // [out] Array para valores da função de densidade de probabilidade
);

Calcula o valor da probabilidade da função de massa da distribuição geométrica com o parâmetro p para uma variável aleatória x[]. Em caso de erro ele retorna falso.

bool MathProbabilityDensityGeometric(
  const double   &x[],        // [in]  Array com os valores da variável aleatória
  const double   p,           // [in]  Parâmetro de distribuição (probabilidade de ocorrência do evento para cada teste)
  double         &result[]    // [out] Array para valores da função de densidade de probabilidade
);


2.19.2. MathCumulativeDistributionGeometric

Calcula o valor da probabilidade da função de distribuição para a lei geométrica com o parâmetro p para uma variável aleatória x. Em caso de erro, retorna NaN.

double MathCumulativeDistributionGeometric(
  const double   x,           // [in]  Valor da variável aleatória
  const double   p,           // [in]  Parâmetro de distribuição (probabilidade de ocorrência do evento para cada teste)
  const bool     tail,        // [in]  Flag de cálculo, se for falsa, então o cálculo é realizado pela probabilidade 1.0
  const bool     log_mode,    // [in]  Flag do cálculo, se false, então o cálculo é executado pela Exp(probabilidade)
  int            &error_code  // [out] Variável para o código de erro
);

Calcula o valor da probabilidade da função de distribuição para a lei geométrica com o parâmetro p para uma variável aleatória x. Em caso de erro, retorna NaN.

double MathCumulativeDistributionGeometric(
  const double   x,           // [in]  Valor da variável aleatória
  const double   p,           // [in]  Parâmetro de distribuição (probabilidade de ocorrência do evento para cada teste)
  int            &error_code  // [out] Variável para o código de erro
);

Calcula o valor da função de distribuição de probabilidade para a lei geométrica com o parâmetro p para um array de variáveis aleatórias x[]. Em caso de erro ele retorna falso. Análoga da pgeom() em R.

bool MathCumulativeDistributionGeometric(
  const double   &x[],        // [in]  Array com os valores da variável aleatória
  const double   p,           // [in]  Parâmetro de distribuição (probabilidade de ocorrência do evento para cada teste)
  const bool     tail,        // [in]  Flag de cálculo, se for falsa, então o cálculo é realizado pela probabilidade 1.0
  const bool     log_mode,    // [in]  Flag do cálculo, se false, então o cálculo é executado pela Exp(probabilidade)
  double         &result[]    // [out] Array para valores da função de densidade de probabilidade
);

Calcula o valor da função de distribuição de probabilidade para a lei geométrica com o parâmetro p para um array de variáveis aleatórias x[]. Em caso de erro ele retorna falso.

bool MathCumulativeDistributionGeometric(
  const double   &x[],        // [in]  Array com os valores da variável aleatória
  const double   p,           // [in]  Parâmetro de distribuição (probabilidade de ocorrência do evento para cada teste)
  double         &result[]    // [out] Array para valores da função de densidade de probabilidade
);


2.19.3. MathQuantileGeometric

Para a probabilidade específica, calcula o valor inverso da função de distribuição para a lei geométrica com o parâmetro p. Em caso de erro, retorna NaN.

double MathQuantileGeometric(
  const double   probability,   // [in]  O valor de probabilidade da ocorrência da variável aleatória
  const double   p,             // [in]  Parâmetro de distribuição (probabilidade de ocorrência do evento em um teste)
  const bool     tail,          // [in]  Bandeira de cálculo, se for falsa, então o cálculo é realizado pela probabilidade 1.0
  const bool     log_mode,      // [in]  Flag de cálculo, se log_mode=true, o cálculo é realizado pelo Exp(probabilidade)
  int            &error_code    // [out] Variável para o código de erro
);

Para a probabilidade específica, calcula o valor inverso da função de distribuição para a lei geométrica com o parâmetro p. Em caso de erro, retorna NaN.

double MathQuantileGeometric(
  const double   probability,   // [in]  O valor de probabilidade da ocorrência da variável aleatória
  const double   p,             // [in]  Parâmetro de distribuição (probabilidade de ocorrência do evento em um teste)
  int            &error_code    // [out] Variável para o código de erro
);

Para o array especificado de valores de probabilidade 'probability[]', é calculado o valor inverso da distribuição da função para a lei geométrica com o parâmetro p. Em caso de erro ele retorna falso. Análoga da qgeom() em R.

bool MathQuantileGeometric(
  const double   &probability[],// [in]  Array com valores de probabilidade de variável aleatória
  const double   p,             // [in]  Parâmetro de distribuição (probabilidade de ocorrência do evento em um teste)
  const bool     tail,          // [in]  Bandeira de cálculo, se for falsa, então o cálculo é realizado pela probabilidade 1.0
  const bool     log_mode,      // [in]  Flag de cálculo, se log_mode=true, o cálculo é realizado pelo Exp(probabilidade)
  double         &result[]      // [out] Array com valor de quantis
);

Para o array especificado de valores de probabilidade 'probability[]', é calculado o valor inverso da distribuição da função para a lei geométrica com o parâmetro p. Em caso de erro ele retorna falso.

bool MathQuantileGeometric(
  const double   &probability[],// [in]  Array com valores de probabilidade de variável aleatória
  const double   p,             // [in]  Parâmetro de distribuição (probabilidade de ocorrência do evento em um teste)
  double         &result[]      // [out] Array com valor de quantis
);


2.19.4. MathRandomGeometric

A função gera uma variável pseudo aleatória distribuída de acordo com a lei de distribuição geométrica com o parâmetro p. Em caso de erro, retorna NaN.

double MathRandomGeometric(
  const double   p,           // [in]  Parâmetro de distribuição (probabilidade de ocorrência do evento para cada teste)
  int            &error_code  // [out] Variável para o código de erro
);

A função gera variáveis pseudo-aleatórias distribuídas de acordo com a lei da distribuição geométrica com o parâmetro p. Em caso de erro ele retorna falso. Análogo do rgeom() em R.

bool MathRandomGeometric(
  const double   p,           // [in]  Parâmetro de distribuição (probabilidade de ocorrência do evento para cada teste)
  const int      data_count,  // [in]  Quantidade de dados requeridos
  double         &result[]    // [out] Array Com valores de variáveis pseudo-aleatórias
);


2.19.5. MathMomentsGeometric

Calcula os valores numéricos teóricos dos primeiros 4 momentos da distribuição geométrica com o parâmetro p. Retorna verdadeiro se o cálculo do momento for bem-sucedido, caso contrário, falso.

bool MathMomentsGeometric(
  const double   p,           // [in]  Parâmetro de distribuição (probabilidade de ocorrência do evento para cada teste)
  double         &mean,       // [out] Variável para a média(1º momento)
  double         &variance,   // [out] Variável para a variância (2º momento)
  double         &skewness,   // [out] Variável para a assimetria (3º momento)
  double         &kurtosis,   // [out] Variável para a curtose (4º momento)
  int            &error_code  // [out] Variável para o código de erro
);


2.20. Distribuição Hipergeometrica

2.20.1. MathProbabilityDensityHypergeometric

Calcula o valor da probabilidade da função de massa da distribuição hipergeométrica com os parâmetros m, k e n para uma variável aleatória x. Em caso de erro, retorna NaN.

double MathProbabilityDensityHypergeometric(
  const double   x,           // [in]  Valor da variável aleatória (inteiro)
  const double   m,           // [in]  Número total de objetos (inteiros)
  const double   k,           // [in]  Número de objetos com a característica desejada (inteiros)
  const double   n,           // [in]  Número de objetos desenhados(inteiros)
  const bool     log_mode,    // [in]  Flag Para calcular o logaritmo do valor, se log_mode = true, então o logaritmo natural da densidade de probabilidade é retornado
  int            &error_code  // [out] Variável para o código de erro
);

Calcula o valor da probabilidade da função de massa da distribuição hipergeométrica com os parâmetros m, k e n para uma variável aleatória x. Em caso de erro, retorna NaN.

double MathProbabilityDensityHypergeometric(
  const double   x,           // [in]  Valor da variável aleatória (inteiro)
  const double   m,           // [in]  Número total de objetos (inteiros)
  const double   k,           // [in]  Número de objetos com a característica desejada (inteiros)
  const double   n,           // [in]  Número de objetos desenhados(inteiros)
  int            &error_code  // [out] Variável para o código de erro
);

Calcula o valor da probabilidade da função de massa da distribuição hipergeométrica com os parâmetros m, k e n para um array de variável aleatória x[]. Em caso de erro ele retorna falso. Análoga da dhyper() em R.

bool MathProbabilityDensityHypergeometric(
  const double   &x[],        // [in]  Array com os valores da variável aleatória
  const double   m,           // [in]  Número total de objetos (inteiros)
  const double   k,           // [in]  Número de objetos com a característica desejada (inteiros)
  const double   n,           // [in]  Número de objetos desenhados(inteiros)
  const bool     log_mode,    // [in]  Flag Para calcular o logaritmo do valor, se log_mode = true, então o logaritmo natural da densidade de probabilidade é retornado
  double         &result[]    // [out] Array para valores da função de probabilidade
);

Calcula o valor da probabilidade da função de massa da distribuição hipergeométrica com os parâmetros m, k e n para um array de variável aleatória x[]. Em caso de erro ele retorna falso.

bool MathProbabilityDensityHypergeometric(
  const double   &x[],        // [in]  Array com os valores da variável aleatória
  const double   m,           // [in]  Número total de objetos (inteiros)
  const double   k,           // [in]  Número de objetos com a característica desejada (inteiros)
  const double   n,           // [in]  Número de objetos desenhados(inteiros)
  double         &result[]    // [out] Array para valores da função de probabilidade
);


2.20.2. MathCumulativeDistributionHypergeometric

Calcula o valor da probabilidade da função de distribuição para a lei hipergeométrica com os parâmetros m, k e n para uma variável aleatória x. Em caso de erro, retorna NaN.

double MathCumulativeDistributionHypergeometric(
  const double   x,           // [in]  Valor da variável aleatória (inteiro)
  const double   m,           // [in]  Número total de objetos (inteiros)
  const double   k,           // [in]  Número de objetos com a característica desejada (inteiro)
  const double   n,           // [in]  Número de objetos desenhados(inteiros)
  const bool     tail,        // [in]  Flag de cálculo, se for falsa, então o cálculo é realizado pela probabilidade 1.0
  const bool     log_mode,    // [in]  Flag do cálculo, se false, então o cálculo é executado pela Exp(probabilidade)
  int            &error_code  // [out] Variável para o código de erro
);

Calcula o valor da probabilidade da função de distribuição para a lei hipergeométrica com os parâmetros m, k e n para uma variável aleatória x. Em caso de erro, retorna NaN.

double MathCumulativeDistributionHypergeometric(
  const double   x,           // [in]  Valor da variável aleatória (inteiro)
  const double   m,           // [in]  Número total de objetos (inteiros)
  const double   k,           // [in]  Número de objetos com a característica desejada (inteiro)
  const double   n,           // [in]  Número de objetos desenhados(inteiros)
  int            &error_code  // [out] Variável para o código de erro
);

Calcula o valor da função de distribuição de probabilidade para a lei hipergeométrica com os parâmetros m, k e n para um array de variáveis aleatórias x[]. Em caso de erro ele retorna falso. Análoga da phyper() em R.

bool MathCumulativeDistributionHypergeometric(
  const double   &x[],        // [in]  Array com os valores da variável aleatória
  const double   m,           // [in]  Número total de objetos (inteiros)
  const double   k,           // [in]  Número de objetos com a característica desejada (inteiro)
  const double   n,           // [in]  Número de objetos desenhados(inteiros)
  const bool     tail,        // [in]  Flag de cálculo, se for falsa, então o cálculo é realizado pela probabilidade 1.0
  const bool     log_mode,    // [in]  Flag do cálculo, se false, então o cálculo é executado pela Exp(probabilidade)
  double         &result[]    // [out] Array para valores da função de distribuição
);

Calcula o valor da função de distribuição de probabilidade para a lei hipergeométrica com os parâmetros m, k e n para um array de variáveis aleatórias x[]. Em caso de erro ele retorna falso.

bool MathCumulativeDistributionHypergeometric(
  const double   &x[],        // [in]  Array com os valores da variável aleatória
  const double   m,           // [in]  Número total de objetos (inteiros)
  const double   k,           // [in]  Número de objetos com a característica desejada (inteiro)
  const double   n,           // [in]  Número de objetos desenhados(inteiros)
  double         &result[]    // [out] Array para valores da função de distribuição
);


2.20.3. MathQuantileHypergeometric

Para a probabilidade específica, calcula o valor inverso da função de distribuição para lei hipergeométrica com os parâmetros m, k e n. Em caso de erro, retorna NaN.

double MathQuantileHypergeometric(
  const double   probability,   // [in]  O valor de probabilidade da ocorrência da variável aleatória
  const double   m,             // [in]  Numero total de objetos (número inteiro)
  const double   k,             // [in]  Número de objetos com a característica desejada (inteiro)
  const double   n,             // [in]  Número de objetos desenhados (inteiro)
  const bool     tail,          // [in]  Flag do cálculo, se for falso, então o cálculo é realizado pela probabilidade 1.0
  const bool     log_mode,      // [in]  Flag do cálculo, se false, então o cálculo é executado pela Exp(probabilidade)
  int            &error_code    // [out] Variável para o código de erro
);

Para a probabilidade específica, calcula o valor inverso da função de distribuição para lei hipergeométrica com os parâmetros m, k e n. Em caso de erro, retorna NaN.

double MathQuantileHypergeometric(
  const double   probability,   // [in]  O valor de probabilidade da ocorrência da variável aleatória
  const double   m,             // [in]  Número total de objetos (inteiro)
  const double   k,             // [in]  Número de objetos com a característica desejada (inteiro)
  const double   n,             // [in]  Número de objetos desenhados (inteiro)
  int            &error_code    // [out] Variável para o código de erro
);

Para o array especificado de valores de probabilidade 'probability[]', é calculado o valor inverso da distribuição da função para lei hipergeométrica com os parâmetros m, k e n. Em caso de erro ele retorna falso. Análoga da qhyper() em R.

bool MathQuantileHypergeometric(
  const double   &probability[],// [in]  Array com valores de probabilidade de variável aleatória
  const double   m,             // [in]  Número total de objetos (inteiro)
  const double   k,             // [in]  Número de objetos com a característica desejada (inteiro)
  const double   n,             // [in]  Número de objetos desenhados (inteiro)
  const bool     tail,          // [in]  Flag do cálculo, se for falso, então o cálculo é realizado pela probabilidade 1.0
  const bool     log_mode,      // [in]  Flag do cálculo, se false, então o cálculo é executado pela Exp(probabilidade)
  double         &result[]      // [out] Array com valor de quantis
);

Para o array especificado de valores de probabilidade 'probability[]', é calculado o valor inverso da distribuição da função para lei hipergeométrica com os parâmetros m, k e n. Em caso de erro ele retorna falso.

bool MathQuantileHypergeometric(
  const double   &probability[],// [in]  Array com valores de probabilidade de variável aleatória
  const double   m,             // [in]  Número total de objetos (inteiro)
  const double   k,             // [in]  Número de objetos com a característica desejada (inteiro)
  const double   n,             // [in]  Número de objetos desenhados (inteiro)
  double         &result[]      // [out] Array com valor de quantis
);


2.20.4. MathRandomHypergeometric

A função gera uma variável pseudo-aleatória distribuída de acordo com a lei da distribuição hipergeométrica com os parâmetros m, n e k. Em caso de erro, retorna NaN.

double MathRandomHypergeometric(
  const double   m,           // [in]  Número total de objetos (inteiros)
  const double   k,           // [in]  Número de objetos com a característica desejada (inteiro)
  const double   n,           // [in]  Número de objetos desenhados(inteiros)
  int            &error_code  // [out] Variável para o código de erro
);

A função gera variáveis pseudo-aleatórias distribuídas de acordo com a lei da distribuição hipergeométrica com os parâmetros m, n e k. Em caso de erro ele retorna falso. Análoga da rhyper() in R.

bool MathRandomHypergeometric(
  const double   m,           // [in]  Número total de objetos (inteiros)
  const double   k,           // [in]  Número de objetos com a característica desejada (inteiro)
  const double   n,           // [in]  Número de objetos desenhados(inteiros)
  const int      data_count,  // [in]  Quantidade de dados requeridos
  double         &result[]    // [out] Array Com valores de variáveis pseudo-aleatórias
);


2.20.5. MathMomentsHypergeometric

Calcula os valores numéricos teóricos dos primeiros 4 momentos da distribuição hipergeométrica com os parâmetros m, n e k. Retorna verdadeiro se o cálculo do momento for bem-sucedido, caso contrário, falso.

bool MathMomentsHypergeometric(
  const double   m,           // [in]  Número total de objetos (inteiros)
  const double   k,           // [in]  Número de objetos com a característica desejada (inteiro)
  const double   n,           // [in]  Número de objetos desenhados(inteiros)
  double         &mean,       // [out] Variável para a média(1º momento)
  double         &variance,   // [out] Variável para a variância (2º momento)
  double         &skewness,   // [out] Variável para a assimetria (3º momento)
  double         &kurtosis,   // [out] Variável para a curtose (4º momento)
  int            &error_code  // [out] Variável para o código de erro
);


2.21. Distribuição de Poisson

2.21.1. MathProbabilityDensityPoisson

Calcula o valor da probabilidade da função de massa da distribuição de Poisson com o parâmetro lambda para uma variável aleatória x. Em caso de erro, retorna NaN.

double MathProbabilityDensityPoisson(
  const double   x,           // [in]  Valor da variável aleatória
  const double   lambda,      // [in]  Parâmetro da distribuição (médio)
  const bool     log_mode,    // [in]  Flag Para calcular o logaritmo do valor, se log_mode = true, então o logaritmo natural da densidade de probabilidade é retornado
  int            &error_code  // [out] Variável para o código de erro
);

Calcula o valor da probabilidade da função de massa da distribuição de Poisson com o parâmetro lambda para uma variável aleatória x. Em caso de erro, retorna NaN.

double MathProbabilityDensityPoisson(
  const double   x,           // [in]  Valor da variável aleatória
  const double   lambda,      // [in]  Parâmetro da distribuição (médio)
  int            &error_code  // [out] Variável para o código de erro
);

Calcula o valor da probabilidade da função de massa da distribuição de Poisson com o parâmetro lambda para um array de variável aleatória x[]. Em caso de erro ele retorna falso. Análoga da dpois() em R.

bool MathProbabilityDensityPoisson(
  const double   &x[],        // [in]  Array com os valores da variável aleatória
  const double   lambda,      // [in]  Parâmetro da distribuição (médio)
  const bool     log_mode,    // [in]  Flag Para calcular o logaritmo do valor, se log_mode = true, então o logaritmo natural da densidade de probabilidade é retornado
  double         &result[]    // [out] Array para valores da função de densidade de probabilidade
);

Calcula o valor da probabilidade da função de massa da distribuição de Poisson com o parâmetro lambda para um array de variável aleatória x[]. Em caso de erro ele retorna falso.

bool MathProbabilityDensityPoisson(
  const double   &x[],        // [in]  Array com os valores da variável aleatória
  const double   lambda,      // [in]  Parâmetro da distribuição (médio)
  double         &result[]    // [out] Array para valores da função de densidade de probabilidade
);


2.21.2. MathCumulativeDistributionPoisson

Calcula o valor da função de distribuição de Poisson com o parâmetro lambda para uma variável aleatória x. Em caso de erro, retorna NaN.

double MathCumulativeDistributionPoisson(
  const double   x,           // [in]  Valor da variável aleatória
  const double   lambda,      // [in]  Parâmetro da distribuição (médio)
  const bool     tail,        // [in]  Flag de cálculo, se for verdadeira, então a probabilidade da variável aleatória não excedendo x é calculada
  const bool     log_mode,    // [in]  Flag para calcular o logaritmo do valor, se log_mode=true, então o logaritmo natural da probabilidade é calculado
  int            &error_code  // [out] Variável para o código de erro
);

Calcula o valor da função de distribuição de Poisson com o parâmetro lambda para uma variável aleatória x. Em caso de erro, retorna NaN.

double MathCumulativeDistributionPoisson(
  const double   x,           // [in]  Valor da variável aleatória
  const double   lambda,      // [in]  Parâmetro da distribuição (médio)
  int            &error_code  // [out] Variável para o código de erro
);

Calcula o valor da função de distribuição de Poisson com o parâmetro lambda para um array de variável aleatória x[]. Em caso de erro ele retorna falso. Análoga da ppois() em R.

bool MathCumulativeDistributionPoisson(
  const double   &x[],        // [in]  Array com os valores da variável aleatória
  const double   lambda,      // [in]  Parâmetro da distribuição (médio)
  const bool     tail,        // [in]  Flag de cálculo, se for verdadeira, então a probabilidade da variável aleatória não excedendo x é calculada
  const bool     log_mode,    // [in]  Flag para calcular o logaritmo do valor, se log_mode=true, então o logaritmo natural da probabilidade é calculado
  double         &result[]    // [out] Array para valores da função de probabilidade
);

Calcula o valor da função de distribuição de Poisson com o parâmetro lambda para um array de variável aleatória x[]. Em caso de erro ele retorna falso.

bool MathCumulativeDistributionPoisson(
  const double   &x[],        // [in]  Array com os valores da variável aleatória
  const double   lambda,      // [in]  Parâmetro da distribuição (médio)
  double         &result[]    // [out] Array para valores da função de probabilidade
);


2.21.3. MathQuantilePoisson

Para a probabilidade específica, calcula o valor inverso da função de distribuição de Poisson com o parâmetro lambda. Em caso de erro, retorna NaN.

double MathQuantilePoisson(
  const double   probability,   // [in]  O valor de probabilidade da ocorrência da variável aleatória
  const double   lambda,        // [in]  Parâmetro de distribuição (medio)
  const bool     tail,          // [in]  Bandeira de cálculo, se for falsa, então o cálculo é realizado pela probabilidade 1.0
  const bool     log_mode,      // [in]  Flag de cálculo, se log_mode=true, o cálculo é realizado pelo Exp(probabilidade)
  int            &error_code    // [out] Variável para o código de erro
);

Para a probabilidade específica, calcula o valor inverso da função de distribuição de Poisson com o parâmetro lambda. Em caso de erro, retorna NaN.

double MathQuantilePoisson(
  const double   probability,   // [in]  O valor de probabilidade da ocorrência da variável aleatória
  const double   lambda,        // [in]  Parâmetro de distribuição (medio)
  int            &error_code    // [out] Variável para o código de erro
);

Para o array especificado de valores de probabilidade 'probability[]', é calculado o valor inverso da função de distribuição de Poisson com o parâmetro lambda. Em caso de erro ele retorna falso. Análoga da qpois() em R.

double MathQuantilePoisson(
  const double   &probability[],// [in]  Array com valores de probabilidade de variável aleatória
  const double   lambda,        // [in]  Parâmetro de distribuição (medio)
  const bool     tail,          // [in]  Flag de cálculo, se for falsa, então o cálculo é realizado pela probabilidade 1.0
  const bool     log_mode,      // [in]  Flag do cálculo, se false, então o cálculo é executado pela Exp(probabilidade)
  double         &result[]      // [out] Array com valor de quantis
);

Para o array especificado de valores de probabilidade 'probability[]', é calculado o valor inverso da função de distribuição de Poisson com o parâmetro lambda. Em caso de erro ele retorna falso.

double MathQuantilePoisson(
  const double   &probability[],// [in]  Array com valores de probabilidade de variável aleatória
  const double   lambda,        // [in]  Parâmetro de distribuição (medio)
  double         &result[]      // [out] Array com valor de quantis
);


2.21.4. MathRandomPoisson

A função gera uma variável pseudo-aleatória distribuída de acordo com a lei de distribuição de Poisson com o parâmetro lambda. Em caso de erro, retorna NaN.

double MathRandomPoisson(
  const double   lambda,      // [in]  Parâmetro da distribuição(médio)
  int            &error_code  // [out] Variável para o código de erro
);

A função gera variáveis pseudo-aleatórias distribuídas de acordo com a lei da distribuição de Poisson com o parâmetro lambda. Em caso de erro ele retorna falso. Análoga da rpois() em R.

double MathRandomPoisson(
  const double   lambda,      // [in]  Parâmetro da distribuição(médio)
  int            &error_code  // [out] Variável para o código de erro
);


2.21.5. MathMomentsPoisson

Calcula os valores numéricos teóricos dos primeiros 4 momentos da distribuição de Poisson com o parâmetro lambda. Retorna verdadeiro se o cálculo do momento for bem-sucedido, caso contrário, falso.

bool MathMomentsPoisson(
  const double   lambda,      // [in]  Parâmetro da distribuição (médio)
  double         &mean,       // [out] Variável para a média(1º momento)
  double         &variance,   // [out] Variável para a variância (2º momento)
  double         &skewness,   // [out] Variável para a assimetria (3º momento)
  double         &kurtosis,   // [out] Variável para a curtose (4º momento)
  int            &error_code  // [out] Variável para o código de erro
);


3. Tabela de correspondência com as funções estatísticas em R

Por praticidade, as tabelas 1-2 contêm as funções da biblioteca estatística e as funções correspondentes da linguagem R.


Valor calculado
Funções no MQL5
Funções em R
1
 Media
MathMean
mean
2
 Variância
MathVariance
var
3
 Assimetria
MathSkewness
skewness
60
 Curtose
MathKurtosis
kurtosis
5
 Valor médio
MathMedian
median
6
 Desvio padrão
MathStandardDeviation
sd
7
 Desvio médio
MathAverageDeviation
aad

Tabela 1. Funções para o cálculo das características estatísticas dos dados do array.



Distribuição
Função de densidade
Funções no MQL5
Funções em R
 1Normal Probabilidade da Função de densidade da distribuição normal
MathProbabilityDensityNormal
MathCumulativeDistributionNormal
MathQuantileNormal
MathRandomNormal

dnorm
pnorm
qnorm
rnorm
 2Beta Probabilidade da função de densidade da distribuição beta
MathProbabilityDensityBeta
MathCumulativeDistributionBeta
MathQuantileBeta
MathRandomBeta

dbeta
pbeta
qbeta
rbeta
3Binomial
 Probabilidade da função de massa da distribuição binomial
MathProbabilityDensityBinomial
MathCumulativeDistributionBinomial
MathQuantileBinomial
MathRandomBinomial

dbinom
pbinom
qbinom
rbinom
60
Cauchy
 Probabilidade da função de densidade da distribuição de Cauchy
MathProbabilityDensityCauchy
MathCumulativeDistributionCauchy
MathQuantileCauchy
MathRandomCauchy

dcauchy
pcauchy
qcauchy
rcauchy
5Qui-quadrado
 Probabilidade da Função de densidade da distribuição do qui-quadrado
MathProbabilityDensityChiSquare
MathCumulativeDistributionChiSquare
MathQuantileChiSquare
MathRandomChiSquare

dchisq
pchisq
qchisq
rchisq
6Exponencial Probabilidade da Função de densidade da distribuição exponencial
MathProbabilityDensityExponential
MathCumulativeDistributionExponential
MathQuantileExponential
MathRandomExponential

dexp
pexp
qexp
rexp
7Distribuição F
 Probabilidade da função de densidade da distribuição F de Fisher
MathProbabilityDensityF
MathCumulativeDistributionF
MathQuantileF
MathRandomF

df
pf
qf
rf
8Gamma Probabilidade da função de densidade da distribuição gama
MathProbabilityDensityGamma
MathCumulativeDistributionGamma
MathQuantileGamma
MathRandomGamma

dgamma
pgamma
qgamma
rgamma
9Geometrico Função da massa de probabilidade da distribuição geométrica
MathProbabilityDensityGeometric
MathCumulativeDistributionGeometric
MathQuantileGeometric
MathRandomGeometric

dgeom
pgeom
qgeom
rgeom
10Hipergeometrico Função da massa de probabilidade da distribuição hipergeométrica
MathProbabilityDensityHypergeometric
MathCumulativeDistributionHypergeometric
MathQuantileHypergeometric
MathRandomHypergeometric

dhyper
phyper
qhyper
rhyper
11
Logística Função de massa de probabilidade da distribuição logística
MathProbabilityDensityLogistic
MathCumulativeDistributionLogistic
MathQuantileLogistic
MathRandomLogistic

dlogis
plogis
qlogis
rlogis
12Log-normal Probabilidade da Função de densidade da distribuição log-normal
MathProbabilityDensityLognormal
MathCumulativeDistributionLognormal
MathQuantileLognormal
MathRandomLognormal

dlnorm
plnorm
qlnorm
rlnorm
13 Binomial negativa
 Função de massa de probabilidade da distribuição binomial negativa
MathProbabilityDensityNegativeBinomial
MathCumulativeDistributionNegativeBinomial
MathQuantileNegativeBinomial
MathRandomNegativeBinomial

dnbinom
pnbinom
qnbinom
rnbinom
 14Beta não central
 Probabilidade da função de densidade da distribuição beta não central
MathProbabilityDensityNoncentralBeta
MathCumulativeDistributionNoncentralBeta
MathQuantileNoncentralBeta
MathRandomNoncentralBeta

dbeta
pbeta
qbeta
rbeta
15Qui-quadrado não central
 Probabilidade da Função de densidade da distribuição não-central do qui-quadrado
MathProbabilityDensityNoncentralChiSquare
MathCumulativeDistributionNoncentralChiSquare
MathQuantileNoncentralChiSquare
MathRandomNoncentralChiSquare

dchisq
pchisq
qchisq
rchisq
16
Distribuição F não-central
 Probabilidade da Função de densidade da distribuição F não central
MathProbabilityDensityNoncentralF()
MathCumulativeDistributionNoncentralF()
MathQuantileNoncentralF()
MathRandomNoncentralF()

df
pf
qf
rf
17Distribuição t não-central
 Distribuição t não-central
MathProbabilityDensityNoncentralT
MathCumulativeDistributionNoncentralT
MathQuantileNoncentralT
MathRandomNoncentralT

dt
pt
qt
rt
18Poisson
 Probabilidade da função de massa da distribuição de Poisson
MathProbabilityDensityPoisson
MathCumulativeDistributionPoisson
MathQuantilePoisson
MathRandomPoisson

dpois
ppois
qpois
rpois
19Distribuição t
 Probabilidade da função de densidade da distribuição t de Student
MathProbabilityDensityT
MathCumulativeDistributionT
MathQuantileT
MathRandomT

dt
pt
qt
rt
20
Uniforme
 Probabilidade da Função de densidade da distribuição uniforme
MathProbabilityDensityUniform
MathCumulativeDistributionUniform
MathQuantileUniform
MathRandomUniform

dunif
punif
qunif
runif
21Weibull Probabilidade da função de densidade da distribuição Weibull
MathProbabilityDensityWeibull
MathCumulativeDistributionWeibull
MathQuantileWeibull
MathRandomWeibull

dweibull
pweibull
qweibull
rweibull

Tabela 2. Funções de trabalho com distribuições estatísticas


A biblioteca estatística do MQL5 também fornece funções para o cálculo das funções matemáticas em arrays, que estão listadas abaixo na Tabela 3.

Descrição
MQL5
 R
 Gernando uma sequência de valores
bool MathSequence(const double from,const double to,const double step,double &result[])
bool MathSequenceByCount(const double from,const double to,const int count,double &result[])
bool MathSequence(const int from,const int to,const int step,int &result[])
bool MathSequenceByCount(const int from,const int to,const int count,int &result[])
 seq()
 Gera uma sequência repetitiva
bool MathReplicate(const double &array[],const int count,double &result[])
bool MathReplicate(const int &array[],const int count,int &result[])
 rep()
 Gera um array com ordem inversa de elementos
bool MathReverse(const double &array[],double &result[])
bool MathReverse(const int &array[],int &result[])
 rev(x)
 Compara arrays e retorna verdadeiro se todos os elementos correspondem
bool MathIdentical(const double &array1[],const double &array2[])
bool MathIdentical(const int &array1[],const int &array2[])
 identical()
 Gera um array apenas com valores únicos
bool MathUnique(const double &array[],double &result[])
bool MathUnique(const int &array[],int &result[])
 unique()
 Gera um array inteiro com permutação de acordo com a ordem dos elementos do array após sua classificação
bool MathOrder(const double &array[],int &result[])
bool MathOrder(const int &array[],int &result[])
 order()
 Gera uma amostra aleatória dos elementos do array. O argumento replace=true permite realizar uma amostragem aleatória dos elementos com a substituição de volta para a sequência original. O array probabilities[] define as probabilidades de amostragem dos elementos.
bool MathSample(const double &array[],const int count,double &result[])
bool MathSample(const double &array[],const int count,const bool replace,double &result[])
bool MathSample(const double &array[],double &probabilities[],const int count,double &result[])
bool MathSample(const double &array[],double &probabilities[],const int count,const bool replace,double &result[])
bool MathSample(const int &array[],const int count,int &result[])
bool MathSample(const int &array[],const int count,const bool replace,int &result[])
bool MathSample(const int &array[],double &probabilities[],const int count,int &result[])
bool MathSample(const int &array[],double &probabilities[],const int count,const bool replace,int &result[])
 sample()

 Retorna a soma dos elementos do array
double MathSum(const double &array[])
 sum()
 Retorna o produto dos elementos do array
double MathProduct(const double &array[])
 prod()
 Gera um array com as somas cumulativas
bool MathCumulativeSum(const double &array[],double &result[])
bool MathCumulativeSum(double &array[])
 cumsum()
 Gera um array com os produtos cumulativos
bool MathCumulativeProduct(const double &array[],double &result[])
bool MathCumulativeProduct(double &array[])
 cumprod()
 Gera um array com os mínimos cumulativos
bool MathCumulativeMin(const double &array[],double &result[])
bool MathCumulativeMin(double &array[])
 cummin()
 Gera um array com os maximos cumulativos
bool MathCumulativeMax(const double &array[],double &result[])
bool MathCumulativeMax(double &array[])
 cummax()
 Gera um array com diferenças doselementos de y[i]=x[i+lag]-x[i]
bool MathDifference(const double &array[],const int lag,double &result[])
bool MathDifference(const double &array[],const int lag,const int differences,double &result[])
bool MathDifference(const int &array[],const int lag,int &result[])
bool MathDifference(const int &array[],const int lag,const int differences,int &result[])
 diff()
 Retorna os mínimos dos elementos do array
double MathMin(const double &array[])
 min()
 Retorna o máximo de elementos do array
double MathMax(const double &array[])
 max()
 Calcula os mínimos e máximos dos elementos do array
bool MathRange(const double &array[],double &min,double &max)
 range()
 Calcula os valores médios dos elementos do array
double MathMean(const double &array[])
 mean()
 Calcula os desvios padrão dos elementos do array
double MathStandardDeviation(const double &array[])
 sd()
 Calcula os valores medianos dos elementos do array
double MathMedian(double &array[])
 median()
 Calcula as fileiras dos elementos do array
bool MathRank(const int &array[],double &rank[])
bool MathRank(const double &array[],double &rank[])
 rank()
 Calcula os coeficientes de correlação de Pearson, Spearman e Kendall
bool MathCorrelationPearson(const double &array1[],const double &array2[],double &r)
bool MathCorrelationPearson(const int &array1[],const int &array2[],double &r)
bool MathCorrelationSpearman(const double &array1[],const double &array2[],double &r)
bool MathCorrelationSpearman(const int &array1[],const int &array2[],double &r)
bool MathCorrelationKendall(const double &array1[],const double &array2[],double &tau)
bool MathCorrelationKendall(const int &array1[],const int &array2[],double &tau)
 corr()
 Calcula os quantis de amostra correspondentes às probabilidades especificadas
bool MathQuantile(const double &array[],const double &probs[],double &quantile[])
 qunatile()
 Calcula o resumo de cinco números de Tukey (mínimo, dobradiça inferior, mediana, dobradiça superior, máximo) para elementos do arrar
bool MathTukeySummary(const double &array[],const bool removeNAN,double &minimum,double &lower_hinge,double &median,double &upper_hinge,double &maximum)
 fivenum()
 Calcula logaritmos de elementos do array (naturais e para uma dada base)
bool MathLog(const double &array[],double &result[])
bool MathLog(const double &array[],const double base,double &result[])
bool MathLog(double &array[])
bool MathLog(double &array[],const double base)
 log()
 Calcula logaritmos de elementos do array para base 2
bool MathLog2(const double &array[],double &result[])
bool MathLog2(double &array[])
 log2()
 Calcula logaritmos de elementos do array para base 10
bool MathLog10(const double &array[],double &result[])
bool MathLog10(double &array[])
 log10()
 Calcula os valores da função log(1+x) para elementos do array
bool MathLog1p(const double &array[], double &result[])
bool MathLog1p(double &array[])
 log1p()
 Calcula os valores da função exp(x) para elementos do array
bool MathExp(const double &array[], double &result[])
bool MathExp(double &array[])
 exp()
 Calcula os valores da função exp(x)-1 para elementos do array
bool MathExpm1(const double &array[], double &result[])
bool MathExpm1(double &array[])
 expm1()
 Calcula os valores da função sin(x) para elementos do array
bool MathSin(const double &array[], double &result[])
bool MathSin(double &array[])
 sin()
 Calcula os valores da função cos(x) para elementos do array
bool MathCos(const double &array[], double &result[])
bool MathCos(double &array[])
 cos()
 Calcula os valores da função tan(x) para elementos do array
bool MathTan(const double &array[], double &result[])
bool MathTan(double &array[])
 tan()
 Calcula os valores da função arcsin(x) para elementos do array
bool MathArcsin(const double &array[], double &result[])
bool MathArcsin(double &array[])
 arcsin()
 Calcula os valores da função arccos(x) para elementos do array
bool MathArccos(const double &array[], double &result[])
bool MathArccos(double &array[])
 arccos()
 Calcula os valores da função arctan(x) para elementos do array
bool MathArctan(const double &array[], double &result[])
bool MathArctan(double &array[])
 arctan()
 Calcula os valores da função arctan(y/x) para elementos do array
bool MathArctan2(const double &array1[], const double &array2[], double &result[])
 arctan2()
 Calcula os valores da função sin(pi*x) para elementos do array
bool MathSinPi(const double &array[], double &result[])
bool MathSinPi(double &array[])
 sinpi()
 Calcula os valores da função cos(pi*x) para elementos do arrays
bool MathCosPi(const double &array[], double &result[])
bool MathCosPi(const double &array[])
 cospi()
 Calcula os valores da função tan(pi*x) para elementos do array
bool MathTanPi(const double &array[], double &result[])
bool MathTanPi(double &array[])
 tanpi()
  Calcula os valores absolutos dos elementos do array
bool MathAbs(const double &array[], double &result[])
bool MathAbs(double &array[])
 abs()
  Calcula as raízes quadradas dos elementos do array
bool MathSqrt(const double &array[], double &result[])
bool MathSqrt(double &array[])
 sqrt()
 Retorna os inteiros maiores mais próximos para elementos do array
bool MathCeil(const double &array[], double &result[])
bool MathCeil(double &array[])
 ceil()
 Retorna os inteiros menores mais próximos para elementos do array
bool MathFloor(const double &array[], double &result[])
bool MathFloor(double &array[])
 floor()
 Calcula as partes inteiras dos elementos do array
bool MathTrunc(const double &array[], const int digits, double &result[])
bool MathTrunc(double &array[])
 trunc()
 Calcula os valores arredondados de elementos do array
bool MathRound(const double &array[], const int digits, double &result[])
bool MathRound(double &array[],int digits)
 round()
 Para elementos do array, é calculado o valor arredondado do número especificado de dígitos na mantissa
bool MathSignif(const double &array[], const int digits, double &result[])
bool MathSignif(double &array[], const int digits)
 signinf()
 Calcula os valores da função sinh(x) para elementos do array
bool MathSinh(const double &array[],double &result[])
bool MathSinh(double &array[])
 sinh()
 Calcula os valores da função cosh(x) para elementos do array
bool MathCosh(const double &array[],double &result[])
bool MathCosh(double &array[])
 cosh()
 Calcula os valores da função tanh(x) para elementos do array
bool MathTanh(const double &array[],double &result[])
bool MathTanh(double &array[])
 tanh()
 Calcula os valores da função arcsinh(x) para elementos do array
bool MathArcsinh(const double &array[],double &result[])
bool MathArcsinh(double &array[])
 asinh()
 Calcula os valores da função arccosh(x) para elementos do array 
bool MathArccosh(const double &array[],double &result[])
bool MathArccosh(double &array[])
 acosh()
 Calcula os valores da função arctanh(x) para elementos do array  
bool MathArctanh(const double &array[],double &result[])
bool MathArctanh(double &array[])
 atanh()
 Calcula o resultado da operação NOT bit a bit por elementos do array
bool MathBitwiseNot(const int &array[],int &result[])
bool MathBitwiseNot(int &array[])
 bitwNot()
 Calcula o resultado da operação AND bit a bit para arrays especificados
bool MathBitwiseAnd(const int &array1[],const int &array2[],int &result[])
 bitwAnd()
 Calcula o resultado da operação OR bit a bit para arrays especificadas
bool MathBitwiseOr(const int &array1[],const int &array2[],int &result[])
 bitwOr()
 Calcula o resultado da operação XOR bit a bit para arrays especificadas
bool MathBitwiseXor(const int &array1[],const int &array2[],int &result[])
 bitwXor()
 Calcula o resultado da operação SHL bit a bit para arrays especificadas
bool MathBitwiseShiftL(const int &array[],const int n,int &result[])
bool MathBitwiseShiftL(int &array[],const int n)
 bitwShiftL()
  Calcula o resultado da operação SHR bit a bit para arrays especificadas
bool MathBitwiseShiftR(const int &array[],const int n,int &result[])
bool MathBitwiseShiftR(int &array[],const int n)
 bitwShiftR()

Tabela 3. Funções matemáticas para calcular valores em arrays



4. Um exemplo de uso das funções

Consideremos a aplicação prática de funções estatísticas no exemplo de uma distribuição normal.

Suponha que os seguintes problemas precisam ser resolvidos:

  1. Calcular a probabilidade de uma variável aleatória, distribuída de acordo com a lei normal com os parâmetros mu e sigma, dentro do intervalo de [mu-sigma,mu+sigma].
  2. Encontre o intervalo de valores da variável aleatória x, distribuído de acordo com a lei normal com os parâmetros mu e sigma, o qual é simétrico a mu e que corresponde a 95% da probabilidade de confiança.
  3. Gerar 1000000 números aleatórios, distribuídos de acordo com a lei normal e com os parâmetros mu e sigma, calcular o histograma dos valores obtidos, os primeiros 4 momentos e comparar com os valores teóricos.

Exemplo de solução no script NormalExample:

//+------------------------------------------------------------------+
//|                                                NormalExample.mq5 |
//|                        Copyright 2016, MetaQuotes Software Corp. |
//|                                             https://www.mql5.com |
//+------------------------------------------------------------------+
#property copyright "Copyright 2016, MetaQuotes Software Corp."
#property link      "https://www.mql5.com"
#property version   "1.00"
//--- Incluem as funções para o cálculo da distribuição normal
#include <Math\Stat\Normal.mqh>
//+------------------------------------------------------------------+
//| Cálculo do Histograma                                            |
//+------------------------------------------------------------------+
void CalculateHistogram(double &data[],const int ncells=200,const string filename="normal.csv")
  {
   if(ArraySize(data)<=0)
      return;

   int n=ArraySize(data);
//--- Encontre os valores dos dados mínimo e máximo no array 'data'
   double minv,maxv,range;
   minv=data[0];
   maxv=data[0];
   for(int i=1; i<n; i++)
     {
      minv=MathMin(minv,data[i]);
      maxv=MathMax(maxv,data[i]);
     }
//--- Calcular o intervalo
   range=maxv-minv;
//   Print("Min=",minv," Max=",maxv," range=",range," size=",n);
   if(range==0)
      return;
//--- Arrays para o cálculo do histograma
   double x[];
   double y[];
//--- Definir os valores do histograma
   ArrayResize(x,ncells);
   ArrayResize(y,ncells);
   for(int i=0; i<ncells; i++)
     {
      x[i]=minv+i*range/(ncells-1);
      y[i]=0;
     }
//--- Calcular o histograma
   for(int i=0; i<n; i++)
     {
      double v=(maxv-data[i])/range;
      int ind=int((v*(ncells-1)));
      y[ind]++;
     }
//--- Verificar o nome do arquivo
   if(filename=="")
      return;
//--- Abrir o arquivo para escrever
   ResetLastError();
   int filehandle=FileOpen(filename,FILE_WRITE|FILE_TXT|FILE_ANSI);
//--- Gravar dados no arquivo
   if(filehandle!=INVALID_HANDLE)
     {
      for(int i=0; i<ncells; i++)
        {
         string str=StringFormat("%6.20f;%6.20f",x[i],y[i]);
         FileWrite(filehandle,str);
        }
      FileClose(filehandle);
      PrintFormat("Histogram saved to file %s",filename);
     }
   else
      PrintFormat("Error calling FileOpen, error code=%d",GetLastError());
  }
//+------------------------------------------------------------------+
//| Função de início do programa do script                          |
//+------------------------------------------------------------------+
void OnStart()
  {
//--- 1. Calcular a probabilidade de uma variável aleatória, 
//--- Distribuídos de acordo com a lei normal e com os parâmetros mu e sigma, dentro do intervalo [mu-sigma,mu+sigma]
//--- Definir os parâmetros de distribuição
   double mu=5.0;
   double sigma=1.0;
//--- definir o intervalo
   double x1=mu-sigma;
   double x2=mu+sigma;
//--- Variáveis para cálculo da probabilidade
   double cdf1,cdf2,probability;
//--- Variáveis para códigos de erro
   int error_code1,error_code2;
//--- Calcular os valores das funções de distribuição
   cdf1=MathCumulativeDistributionNormal(x1,mu,sigma,error_code1);
   cdf2=MathCumulativeDistributionNormal(x2,mu,sigma,error_code2);
//--- Verificar os códigos de erro
   if(error_code1==ERR_OK && error_code2==ERR_OK)
     {
      //--- calcular a probabilidade
      probability=cdf2-cdf1;
      //--- exibir o resultado
      PrintFormat("x1=%5.8f, x2=%5.8f, Probability=%5.8f",x1,x2,probability);
     }
//--- 2. Encontre o intervalo de valores da variável aleatória x, distribuído de acordo com a lei normal e com os parâmetros mu e sigma, 
//--- O qual é simétrico a mu e que corresponde a 95% da probabilidade de confiança.
//--- Definir a probabilidade de confiança
   probability=0.95;
//--- Definir as probabilidade nos limites do intervalo
   double p1=(1.0-probability)*0.5;
   double p2=probability+(1.0-probability)*0.5;
//--- Calcular os limites do intervalo
   x1=MathQuantileNormal(p1,mu,sigma,error_code1);
   x2=MathQuantileNormal(p2,mu,sigma,error_code2);
//--- Verificar os códigos de erro
   if(error_code1==ERR_OK && error_code2==ERR_OK)
     {
      //--- exibir o resultado  
      PrintFormat("x1=%5.8f, x2=%5.8f",x1,x2);
     }
//--- 3. Gerar 1000000 números aleatórios, distribuídos de acordo com a lei normal e com os parâmetros mu e sigma,
//--- Calcular o histograma dos valores obtidos, os primeiros 4 momentos e comparar com os valores teóricos
//--- Definir o número de valores e preparar um array
   int data_count=1000000;
   double data[];
   ArrayResize(data,data_count);
//--- Gerar valores aleatórios e armazená-los no array
   for(int i=0; i<data_count; i++)
     {
      data[i]=MathRandomNormal(mu,sigma,error_code1);
     }
//--- Definir o índice do valor inicial e a quantidade de dados para o cálculo
   int start=0;
   int count=data_count;
//--- Calcular os primeiros 4 momentos dos valores gerados
   double mean=MathMean(data,start,count);
   double variance=MathVariance(data,start,count);
   double skewness=MathSkewness(data,start,count);
   double kurtosis=MathKurtosis(data,start,count);
//--- Variáveis para os momentos teóricos
   double normal_mean=0;
   double normal_variance=0;
   double normal_skewness=0;
   double normal_kurtosis=0;
//--- Exibir os valores dos momentos calculados
   PrintFormat("              mean=%.10f,         variance=%.10f         skewness=%.10f         kurtosis=%.10f",mean,variance,skewness,kurtosis);
//--- Calcular os valores teóricos dos momentos e compará-los com os valores obtidos
   if(MathMomentsNormal(mu,sigma,normal_mean,normal_variance,normal_skewness,normal_kurtosis,error_code1))
     {
      PrintFormat("Normal mean=%.10f,  Normal variance=%.10f  Normal skewness=%.10f  Normal kurtosis=%.10f",normal_mean,normal_variance,normal_skewness,normal_kurtosis);
      PrintFormat("delta mean=%.4f, delta variance=%.4f  delta skewness=%.4f  delta kurtosis=%.4f",mean-normal_mean,variance-normal_variance,skewness-normal_skewness,kurtosis-normal_kurtosis);
     }
//--- Calcular o histograma de distribuição e salver como o arquivo normal.csv
   int ncells=50;
   CalculateHistogram(data,ncells,"normal.csv");
  }

Resultados da execução de scripts:

Fig. Resultado da operação do script TestNormal.mq5

Fig. 1. Resultado da operação do script TestNormal.mq5

Observe que todos os cálculos do valor do parâmetro 'kurtosis' usam "excess kurtosis=kurtosis-3", ou seja, para que uma distribuição normal seja igual a zero.

O histograma calculado é salvo no arquivo normal.csv (fig. 2)

Histograma da distribuição de números aleatórios, gerados de acordo com a distribuição normal e com os parâmetros mu=5 e sigma=1

Fig. 2. Histograma da distribuição de números aleatórios, gerados de acordo com a distribuição normal e com os parâmetros mu=5 e sigma=1



5. Comparação da velocidade do cálculo

Para comparar a velocidade de cálculo das funções estatísticas, foram preparados scripts para medir os tempos de cálculo para as funções de densidade de probabilidade (pdf), funções de distribuição cumulativa (cdf), funções de cálculo quantil e funções de geração de números pseudo-aleatórios.

Os cálculos foram realizados em um array de 51 valores. Para distribuições contínuas, o cálculo dos valores das funções foi realizado na faixa de 0 a 1; Para distribuições discretas - de 0 a 50. O tempo de cálculo das funções estatísticas da linguagem R foi realizado utilizando a biblioteca microbenchmark. O tempo de cálculo das funções MQL5 foi medido com a função GetMicrosecondCount(). O script de cálculo TestStatBenchmark.mq5 pode ser encontrado em terminal_data_folder\MQL5\Scripts\UnitTests\Stat. O script para o R e os resultados das medições de velocidade de cálculo são fornecidos no Appendix.

Os cálculos foram feitos num computador Intel Core i7-4790, CPU 3.6 Ghz, 16 GB RAM, Windows 10 x64.

Os resultados das medições do tempo de cálculo (em microsegundos, μs) são mostrados na Tabela 3.


Distribuição
Tempo do MQL5 para calcular
o PDF (µs)
 Tempo R para calcular
o PDF (µs)
PDF
R/MQL5 
Tempo do MQL5 para calcular
o CDF (µs)
Tempo R para calcular
o CDF (µs)
CDF
R/MQL5
Tempo do MQL5 para calcular
os quantis (µs)
 Tempo R para calcular
os quantis (µs)
Quantil
R/MQL5
 Tempo do MQL5 para gerar
números aleatórios (µs)
Tempo R para gerar
números aleatórios (µs)  
Aleatorio
R/MQL5
1
 Binomial
4.39
11.663
2.657
13.65
25.316
1.855
50.18
66.845
1.332
318.73
1816.463
5.699
2
 Beta
1.74
17.352
9.972
4.76
15.076
3.167
48.72
129.992
2.668
688.81
1723.45
2.502
3
 Gamma
1.31
8.251
6.347
8.09
14.792
1.828
50.83
64.286
1.265
142.84
1281.707
8.973
60
 Cauchy
0.45
1.423
3.162
1.33
15.078
11.34
1.37
2.845
2.077
224.19
588.517
2.625
5
 Exponencial
0.85
3.13
3.682
0.77
2.845
3.695
0.53
2.276
4.294
143.18
389.406
2.72
6
 Uniforme
0.42
2.561
6.098
0.45
1.423
3.162
0.18
2.846
15.81
40.3
247.467
6.141
7
 Geometrico
2.3
5.121
2.227
2.12
4.552
2.147
0.81
5.407
6.675
278
1078.045
3.879
8
 Hipergeometrico
1.8511.095
5.997
0.9
8.819
9.799
0.75
9.957
13.28
302.55
880.356
2.91
9
 Logística
1.27
4.267
3.36
1.11
4.267
3.844
0.71
3.13
4.408
178.65
626.632
3.508
10
 Weibull
2.99
5.69
1.903
2.74
4.268
1.558
2.64
6.828
2.586
536.37
1558.472
2.906
11
 Poisson
2.91
5.974
2.053
6.26
8.534
1.363
3.43
13.085
3.815
153.59
303.219
1.974
12
 F
3.86
10.241
2.653
9.94
22.472
2.261
65.47
135.396
2.068
1249.22
1801.955
1.442
13
 Qui Quadrado
2.47
5.974
2.419
7.71
13.37
1.734
44.11
61.725
1.399
210.24
1235.059
5.875
14
 Qui Quadrado Noncentral
8.05
14.223
1.767
45.61
209.068
4.584
220.66
10342.96
46.873
744.45
1997.653
2.683
15
 Noncentral F
19.1
28.446
1.489
14.67
46.935
3.199
212.21
2561.991
12.073
1848.9
2912.141
1.575
16
 Noncentral Beta
16.3
26.739
1.64
10.48
43.237
4.126
153.66
2290.915
14.909
2686.82
2839.893
1.057
17
 Binomial Negativo
6.13
11.094
1.81
12.21
19.627
1.607
14.05
60.019
4.272
1130.39
1936.498
1.713
18
 Normal
1.15
4.267
3.71
0.81
3.983
4.917
0.7
2.277
3.253
293.7
696.321
2.371
19
 Lognormal
1.99
5.406
2.717
3.19
8.819
2.765
3.18
6.259
1.968
479.75
1269.761
2.647
20
 T
2.32
11.663
5.027
8.01
19.059
2.379
50.23
58.596
1.167
951.58
1425.92
1.498
21
 Noncentral T
38.47
86.757
2.255
27.75
39.823
1.435
1339.51
1930.524
1.441
1550.27
1699.84
1.096
   <PDF R/MQL5>
3.474   <CDF R/MQL5>
3.465
    <Quantil R/MQL5>
7.03
    <R Aleatorio/MQL5>
3.13

Tabela 4. Os tempos de cálculo das funções estatísticas no R e MQL5 (em microssegundos)

Os valores mínimos de tempo foram tomados por R, e os valores médios (pdf_mean, cdf_mean, quantile_mean, random_mean) foram tomadas pelo MQL5.

A Tabela 3 mostra que, mesmo sob tais condições, os cálculos das funções de biblioteca estatística no MQL5 são realizados várias vezes mais rápido do que aqueles em R. Em média, o MQL5 calcula 3 a 7 vezes mais rápido que R, mesmo levando em consideração que as versões comparadas as funções R são realmente escritas em C++.

Na prática, o compilador MQL5 acabou por ser muito mais rápido do que implementaçõescdo C++ nas funções em R, o que mostra a alta qualidade de nossos desenvolvimentos. A tradução de programas de R para MQL5 pode dar um aumento significativo na velocidade, e não haverá necessidade de usar um DLL de terceiros.


6. Erros de cálculo detectados em R

Durante o teste de R, um erro no cálculo de quantis da distribuição t não central foi detectado.

Por exemplo:

> n <- 10
> k <- seq(0,1,by=1/n)
> nt_pdf<-dt(k, 10,8, log = FALSE)
> nt_cdf<-pt(k, 10,8, log = FALSE)
> nt_quantile<-qt(nt_cdf, 10,8, log = FALSE)
> nt_pdf
 [1] 4.927733e-15 1.130226e-14 2.641608e-14 6.281015e-14 1.516342e-13 3.708688e-13 9.166299e-13
 [8] 2.283319e-12 5.716198e-12 1.433893e-11 3.593699e-11
> nt_cdf
 [1] 6.220961e-16 1.388760e-15 3.166372e-15 7.362630e-15 1.742915e-14 4.191776e-14 1.021850e-13
 [8] 2.518433e-13 6.257956e-13 1.563360e-12 3.914610e-12
> k
 [1] 0.0 0.1 0.2 0.3 0.4 0.5 0.6 0.7 0.8 0.9 1.0
> nt_quantile
 [1]           -Inf -1.340781e+154 -1.340781e+154 -1.340781e+154 -1.340781e+154 -1.340781e+154
 [7] -1.340781e+154   7.000000e-01   8.000000e-01   9.000000e-01   1.000000e+00

Para calcular a distribuição t de Student, a linguagem R usa o algoritmo AS 243, proposto por Lenth [6]. A vantagem deste método é uma computação recursiva rápida de membros de série infinitos com uma função beta incompleta. Mas o artigo [7] mostrou que, devido a um erro na estimativa de precisão durante a soma dos membros da série, este algoritmo leva a erros (tabela 2 no artigo [7]), especialmente para grandes valores do parâmetro delta para os não centralizados. Autores do artigo [7] propuseram um algoritmo corrigido para o cálculo recursivo da probabilidade da distribuição t não central.

A biblioteca de estatística do MQL5 utiliza o algoritmo correto para o cálculo das probabilidades sugeridas no artigo [7], que fornece resultados precisos.

Deve notar-se que, na linguagem R, a definição de densidade de probabilidade para distribuições Gama, qui-quadrado e não central do qui-quadrado no ponto x = 0 conduz a infinitas expressões:

> dgamma(0,0.5,1)
[1] Inf
> dchisq(0,df=0.5,ncp=1)
[1] Inf
> dchisq(0,df=0.5,ncp=0)
[1] Inf

Assim, na linguagem R, os valores-limite são utilizados na definição da densidade de probabilidade no ponto x=0. Apesar do infinito no ponto x=0, neste caso as divergências não ocorrem durante a integração e as integrais da densidade são finitas.

When calculating the probabilities (for example, for x=0.1), they match the values from Wolfram Alpha (Gamma, ChiSquare, NoncentralChiSquare).

> pgamma(0.1,0.5,1)
[1] 0.3452792
> pchisq(0.1,df=0.5,ncp=0)
[1] 0.5165553
> pchisq(0.1,df=0.5,ncp=1)
[1] 0.3194965

O Wolfram Alpha e o Matlab fazem uso de uma definição diferente da densidade no ponto x=0:

Fig. 3. Definição da densidade de probabilidade da distribuição Gamma no Wolfram Alpha

Fig. 3. Definição da densidade de probabilidade da distribuição Gamma no Wolfram Alpha


Fig. 4. Definição da densidade de probabilidade da distribuição do Qui-Quadrado no Wolfram Alpha

Fig. 4. Definição da densidade de probabilidade da distribuição do Qui-Quadrado no Wolfram Alpha


Fig. 5. Definição da densidade de probabilidade da distribuição Não-Central do Chi-Quadrado no Wolfram Alpha

Fig. 5. Definição da densidade de probabilidade da distribuição Não-Central do Chi-Quadrado no Wolfram Alpha


Na biblioteca de estatística do MQL5, as densidades dessas distribuições no ponto x=0 são consideradas iguais a zero por definição.

Para garantir a precisão do cálculo e permitir que desenvolvedores de terceiros testem a qualidade da biblioteca, vários scripts de teste de unidade estão incluídos na entrega padrão. Eles podem ser encontrados na pasta /Scripts/UnitTests/Stat.


Conclusão

O artigo considera as principais funções da Biblioteca Estatística MQL5.

Eles ermitem realizar o cálculo das características estatísticas dos dados e trabalhar com as distribuições estatísticas básicas implementadas na linguagem R. Além disso, a biblioteca também contém as funções para cálculo dos momentos teóricos das distribuições, permitindo a avaliação do grau de conformidade da distribuição real com a modelada.

Devido ao alto desempenho do novo compilador de 64 bits do MQL5, os cálculos matemáticos mais complexos são processados muitas vezes mais rápido do que em R, o que facilita significativamente o processo de pesquisa.


Referências

  1. The R Project for Statistical Computing.
  2. N. Balakrishnan, N. L. Johnson, S. Kotz  "Continuous Univariate Distributions: Volume 1." Wiley-Interscience, 1994.
  3. N. Balakrishnan, N. L. Johnson, S. Kotz  "Continuous Univariate Distributions: Volume 2." Wiley-Interscience, 2000.
  4. N. L. Johnson, S. Kotz, A. W. Kemp  "Univariate Discrete Distributions", Wiley-Interscience, 2005.
  5. Forbes C., Evans M., Hastings N., Peacock B., "Statistical Distributions", 4th Edition, John Wiley and Sons, 2011.
  6. Lenth, R.V., "Cumulative distribution function of the noncentral t distribution", Appled Statistics,  vol. 38 (1989), 185–189.
  7. D. Benton, K. Krishnamoorthy, "Computing discrete mixtures of continuous distributions: noncentral chisquare, noncentral t and the distribution of the square of the sample multiple correlation coefficient",  Computational Statistics & Data Analysis, 43, (2003), 249-267


Apêndice. Resultados da medição do tempo de cálculo das funções estatísticas

O script para avaliar o tempo de cálculo das funções estatísticas em R e seus resultados de operação são fornecidos no Apêndice, bem como os resultados da operação do script TestStatBenchmark.mq5.

Script em R:

library(microbenchmark)
n <- 50
k <- seq(0,n,by=1)
binomial_pdf <- microbenchmark(pdf<-dbinom(k, 50, 0.6, log = FALSE))
binomial_cdf <- microbenchmark(cdf<-pbinom(k, 50, 0.6, log = FALSE))
binomial_quantile <- microbenchmark(quantile<-qbinom(cdf, 50, 0.6, log = FALSE))
binomial_random <- microbenchmark(random<-rbinom(10000, 50, 0.6))
print(binomial_pdf)
print(binomial_cdf)
print(binomial_quantile)
print(binomial_random)

n <- 50
k <- seq(0,1,by=1/n)
beta_pdf <- microbenchmark(pdf<-dbeta(k, 2, 4, log = FALSE))
beta_cdf <- microbenchmark(cdf<-pbeta(k, 2, 4, log = FALSE))
beta_quantile <- microbenchmark(quantile<-qbeta(cdf, 2, 4, log = FALSE))
beta_random <- microbenchmark(random<-rbeta(10000, 2, 4,))
print(beta_pdf)
print(beta_cdf)
print(beta_quantile)
print(beta_random)

n <- 50
k <- seq(0,1,by=1/n)
gamma_pdf <- microbenchmark(pdf<-dgamma(k, 1,1, log = FALSE))
gamma_cdf <- microbenchmark(cdf<-pgamma(k, 1,1, log = FALSE))
gamma_quantile <- microbenchmark(quantile<-qgamma(cdf, 1, 1, log = FALSE))
gamma_random <- microbenchmark(random<-rgamma(10000, 1,1))
print(gamma_pdf)
print(gamma_cdf)
print(gamma_quantile)
print(gamma_random)

n <- 50
k <- seq(0,1,by=1/n)
cauchy_pdf <- microbenchmark(pdf<-dcauchy(k, 2,1, log = FALSE))
cauchy_cdf <- microbenchmark(cdf<-pgamma(k, 2,1, log = FALSE))
cauchy_quantile <- microbenchmark(quantile<-qcauchy(cdf, 2, 1, log = FALSE))
cauchy_random <- microbenchmark(random<-rcauchy(10000, 2, 1))
print(cauchy_pdf)
print(cauchy_cdf)
print(cauchy_quantile)
print(cauchy_random)

n <- 50
k <- seq(0,1,by=1/n)
exponential_pdf <- microbenchmark(pdf<-dexp(k, 2, log = FALSE))
exponential_cdf <- microbenchmark(cdf<-pexp(k, 2, log = FALSE))
exponential_quantile <- microbenchmark(quantile<-qexp(cdf, 2, log = FALSE))
exponential_random <- microbenchmark(random<-rexp(10000, 2))
print(exponential_pdf)
print(exponential_cdf)
print(exponential_quantile)
print(exponential_random)


n <- 50
k <- seq(0,1,by=1/n)
uniform_pdf <- microbenchmark(pdf<-dunif(k, 0, 10, log = FALSE))
uniform_cdf <- microbenchmark(cdf<-punif(k, 0, 10, log = FALSE))
uniform_quantile <- microbenchmark(quantile<-qunif(cdf, 0, 10, log = FALSE))
uniform_random <- microbenchmark(random<-runif(10000, 0, 10))
print(uniform_pdf)
print(uniform_cdf)
print(uniform_quantile)
print(uniform_random)


n <- 50
k <- seq(0,n,by=1)
geometric_pdf <- microbenchmark(pdf<-dgeom(k, 0.3, log = FALSE))
geometric_cdf <- microbenchmark(cdf<-pgeom(k, 0.3, log = FALSE))
geometric_quantile <- microbenchmark(quantile<-qgeom(cdf, 0.3, log = FALSE))
geometric_random <- microbenchmark(random<-rgeom(10000, 0.3))
print(geometric_pdf)
print(geometric_cdf)
print(geometric_quantile)
print(geometric_random)

n <- 50
k <- seq(0,n,by=1)
hypergeometric_pdf <- microbenchmark(pdf<-dhyper(k, 12,38,11, log = FALSE))
hypergeometric_cdf <- microbenchmark(cdf<-phyper(k, 12,38,11, log = FALSE))
hypergeometric_quantile <- microbenchmark(quantile<-qhyper(cdf, 12,38,11, log = FALSE))
hypergeometric_random <- microbenchmark(random<-rhyper(10000, 12,38,11))
print(hypergeometric_pdf)
print(hypergeometric_cdf)
print(hypergeometric_quantile)
print(hypergeometric_random)

n <- 50
k <- seq(0,1,by=1/n)
logistic_pdf <- microbenchmark(pdf<-dlogis(k, 1,2, log = FALSE))
logistic_cdf <- microbenchmark(cdf<-plogis(k, 1,2, log = FALSE))
logistic_quantile <- microbenchmark(quantile<-qlogis(cdf, 1,2, log = FALSE))
logistic_random <- microbenchmark(random<-rlogis(10000, 1,2))
print(logistic_pdf)
print(logistic_cdf)
print(logistic_quantile)
print(logistic_random)

n <- 50
k <- seq(0,1,by=1/n)
weibull_pdf <- microbenchmark(pdf<-dweibull(k, 5,1, log = FALSE))
weibull_cdf <- microbenchmark(cdf<-pweibull(k, 5,1, log = FALSE))
weibull_quantile <- microbenchmark(quantile<-qweibull(cdf, 5,1, log = FALSE))
weibull_random <- microbenchmark(random<-rweibull(10000, 5,1))
print(weibull_pdf)
print(weibull_cdf)
print(weibull_quantile)
print(weibull_random)

n <- 50
k <- seq(0,n,by=1)
poisson_pdf <- microbenchmark(pdf<-dpois(k, 1, log = FALSE))
poisson_cdf <- microbenchmark(cdf<-ppois(k, 1, log = FALSE))
poisson_quantile <- microbenchmark(quantile<-qpois(cdf, 1, log = FALSE))
poisson_random <- microbenchmark(random<-rpois(10000, 1))
print(poisson_pdf)
print(poisson_cdf)
print(poisson_quantile)
print(poisson_random)

n <- 50
k <- seq(0,1,by=1/n)
f_pdf <- microbenchmark(pdf<-df(k, 10,20, log = FALSE))
f_cdf <- microbenchmark(cdf<-pf(k, 10,20, log = FALSE))
f_quantile <- microbenchmark(quantile<-qf(cdf, 10,20,log = FALSE))
f_random <- microbenchmark(random<-rf(10000, 10,20))
print(f_pdf)
print(f_cdf)
print(f_quantile)
print(f_random)

n <- 50
k <- seq(0,1,by=1/n)
chisquare_pdf <- microbenchmark(pdf<-dchisq(k, 2,log = FALSE))
chisquare_cdf <- microbenchmark(cdf<-pchisq(k, 2, log = FALSE))
chisquare_quantile <- microbenchmark(quantile<-qchisq(cdf, 2, log = FALSE))
chisquare_random <- microbenchmark(random<-rchisq(10000, 2))
print(chisquare_pdf)
print(chisquare_cdf)
print(chisquare_quantile)
print(chisquare_random)

n <- 50
k <- seq(0,1,by=1/n)
nchisquare_pdf <- microbenchmark(pdf<-dchisq(k, 2,1, log = FALSE))
nchisquare_cdf <- microbenchmark(cdf<-pchisq(k, 2,1,log = FALSE))
nchisquare_quantile <- microbenchmark(quantile<-qchisq(cdf, 2,1, log = FALSE))
nchisquare_random <- microbenchmark(random<-rchisq(10000, 2,1))
print(nchisquare_pdf)
print(nchisquare_cdf)
print(nchisquare_quantile)
print(nchisquare_random)

n <- 50
k <- seq(0,1,by=1/n)
nf_pdf <- microbenchmark(pdf<-df(k, 10,20,2, log = FALSE))
nf_cdf <- microbenchmark(cdf<-pf(k, 10,20,2, log = FALSE))
nf_quantile <- microbenchmark(quantile<-qf(cdf, 10,20,2, log = FALSE))
nf_random <- microbenchmark(random<-rf(10000, 10,20,2))
print(nf_pdf)
print(nf_cdf)
print(nf_quantile)
print(nf_random)

n <- 50
k <- seq(0,1,by=1/n)
nbeta_pdf <- microbenchmark(pdf<-dbeta(k, 2,4,1, log = FALSE))
nbeta_cdf <- microbenchmark(cdf<-pbeta(k, 2,4,1, log = FALSE))
nbeta_quantile <- microbenchmark(quantile<-qbeta(cdf, 2,4,1, log = FALSE))
nbeta_random <- microbenchmark(random<-rbeta(10000, 2,4,1))
print(nbeta_pdf)
print(nbeta_cdf)
print(nbeta_quantile)
print(nbeta_random)

n <- 50
k <- seq(0,n,by=1)
nbinom_pdf <- microbenchmark(pdf<-dnbinom(k, 2, 0.5, log = FALSE))
nbinom_cdf <- microbenchmark(cdf<-pnbinom(k, 2, 0.5, log = FALSE))
nbinom_quantile <- microbenchmark(quantile<-qnbinom(cdf, 2, 0.5, log = FALSE))
nbinom_random <- microbenchmark(random<-rnbinom(10000, 2, 0.5))
print(nbinom_pdf)
print(nbinom_cdf)
print(nbinom_quantile)
print(nbinom_random)

n <- 50
k <- seq(0,1,by=1/n)
normal_pdf <- microbenchmark(pdf<-dnorm(k, 1, 1, log = FALSE))
normal_cdf <- microbenchmark(cdf<-pnorm(k, 1, 1, log = FALSE))
normal_quantile <- microbenchmark(quantile<-qnorm(cdf, 1,1, log = FALSE))
normal_random <- microbenchmark(random<-rnorm(10000, 1,1))
print(normal_pdf)
print(normal_cdf)
print(normal_quantile)
print(normal_random)

n <- 50
k <- seq(0,1,by=1/n)
lognormal_pdf <- microbenchmark(pdf<-dlnorm(k, 0.5,0.6, log = FALSE))
lognormal_cdf <- microbenchmark(cdf<-plnorm(k, 0.5,0.6, log = FALSE))
lognormal_quantile <- microbenchmark(quantile<-qlnorm(cdf, 0.5,0.6, log = FALSE))
lognormal_random <- microbenchmark(random<-rlnorm(10000, 0.5,0.6))
print(lognormal_pdf)
print(lognormal_cdf)
print(lognormal_quantile)
print(lognormal_random)

n <- 50
k <- seq(0,1,by=1/n)
t_pdf <- microbenchmark(pdf<-dt(k, 8, log = FALSE))
t_cdf <- microbenchmark(cdf<-pt(k, 8, log = FALSE))
t_quantile <- microbenchmark(quantile<-qt(cdf, 8, log = FALSE))
t_random <- microbenchmark(random<-rt(10000, 8))
print(t_pdf)
print(t_cdf)
print(t_quantile)
print(t_random)

n <- 50
k <- seq(0,1,by=1/n)
nt_pdf <- microbenchmark(pdf<-dt(k, 10,1, log = FALSE))
nt_cdf <- microbenchmark(cdf<-pt(k, 10,1, log = FALSE))
nt_quantile <- microbenchmark(quantile<-qt(cdf, 10,1, log = FALSE))
nt_random <- microbenchmark(random<-rt(10000, 10,1))
print(nt_pdf)
print(nt_cdf)
print(nt_quantile)
print(nt_random)

Resultado:

R version 3.2.5 (2016-04-14) -- "Very, Very Secure Dishes"
Copyright (C) 2016 The R Foundation for Statistical Computing
Platform: x86_64-w64-mingw32/x64 (64-bit)

R é um software livre e vem com ABSOLUTAMENTE SEM GARANTIA.
Você está convidado a repassa-lo sob certas condições.
Digite 'license()' ou 'license()' para detalhes de distribuição.

R é um projeto colaborativo com muitos colaboradores.
Digite 'contributors()' para obter mais informações e
'citation()' sobre como citar pacotes R ou R em publicações.

Digite 'demo()' para algumas demos, 'help()' para ajuda on-line ou
'Help.start()' para iniciar uma interface de navegador HTML para ajudar.
Digite 'q()' para sair R.

[Workspace loaded from ~/Test/111/.RData]

> library(microbenchmark)
> n <- 50
> k <- seq(0,n,by=1)
> binomial_pdf <- microbenchmark(pdf<-dbinom(k, 50, 0.6, log = FALSE))
> binomial_cdf <- microbenchmark(cdf<-pbinom(k, 50, 0.6, log = FALSE))
> binomial_quantile <- microbenchmark(quantile<-qbinom(cdf, 50, 0.6, log = FALSE))
> binomial_random <- microbenchmark(random<-rbinom(10000, 50, 0.6))
> print(binomial_pdf)
Unit: microseconds
                                   expr    min     lq     mean median     uq    max neval
 pdf <- dbinom(k, 50, 0.6, log = FALSE) 11.663 11.948 13.37888 12.233 12.233 47.503   100
> print(binomial_cdf)
Unit: microseconds
                                   expr    min     lq     mean median     uq    max neval
 cdf <- pbinom(k, 50, 0.6, log = FALSE) 25.316 25.602 29.63195 25.886 35.557 93.868   100
> print(binomial_quantile)
Unit: microseconds
                                          expr    min    lq     mean median     uq     max neval
 quantile <- qbinom(cdf, 50, 0.6, log = FALSE) 66.845 67.13 72.09098 67.699 73.672 130.276   100
> print(binomial_random)
Unit: milliseconds
                             expr      min      lq     mean   median       uq      max neval
 random <- rbinom(10000, 50, 0.6) 1.816463 1.89056 1.948185 1.929814 1.989262 2.308835   100
> 
> 
> n <- 50
> k <- seq(0,1,by=1/n)
> beta_pdf <- microbenchmark(pdf<-dbeta(k, 2, 4, log = FALSE))
> beta_cdf <- microbenchmark(cdf<-pbeta(k, 2, 4, log = FALSE))
> beta_quantile <- microbenchmark(quantile<-qbeta(cdf, 2, 4, log = FALSE))
> beta_random <- microbenchmark(random<-rbeta(10000, 2, 4,))
> print(beta_pdf)
Unit: microseconds
                               expr    min     lq     mean median     uq     max neval
 pdf <- dbeta(k, 2, 4, log = FALSE) 17.352 17.637 19.99512 17.638 18.206 109.797   100
> print(beta_cdf)
Unit: microseconds
                               expr    min     lq     mean median      uq    max neval
 cdf <- pbeta(k, 2, 4, log = FALSE) 15.076 15.361 16.83489 15.646 15.9295 75.379   100
> print(beta_quantile)
Unit: microseconds
                                      expr     min      lq     mean   median     uq     max neval
 quantile <- qbeta(cdf, 2, 4, log = FALSE) 129.992 130.277 140.8325 131.4145 143.93 201.672   100
> print(beta_random)
Unit: milliseconds
                           expr     min       lq     mean   median       uq      max neval
 random <- rbeta(10000, 2, 4, ) 1.72345 1.794132 1.862292 1.836515 1.901226 2.823963   100
> 
> n <- 50
> k <- seq(0,1,by=1/n)
> gamma_pdf <- microbenchmark(pdf<-dgamma(k, 1,1, log = FALSE))
> gamma_cdf <- microbenchmark(cdf<-pgamma(k, 1,1, log = FALSE))
> gamma_quantile <- microbenchmark(quantile<-qgamma(cdf, 1, 1, log = FALSE))
> gamma_random <- microbenchmark(random<-rgamma(10000, 1,1))
> print(gamma_pdf)
Unit: microseconds
                                expr   min     lq     mean median    uq     max neval
 pdf <- dgamma(k, 1, 1, log = FALSE) 8.251 8.8195 10.92684  9.104 9.389 122.312   100
> print(gamma_cdf)
Unit: microseconds
                                expr    min     lq     mean median     uq     max neval
 cdf <- pgamma(k, 1, 1, log = FALSE) 14.792 15.646 20.43306 20.055 21.334 106.099   100
> print(gamma_quantile)
Unit: microseconds
                                       expr    min     lq     mean median    uq     max neval
 quantile <- qgamma(cdf, 1, 1, log = FALSE) 64.286 64.854 70.09419 65.139 67.13 162.988   100
> print(gamma_random)
Unit: milliseconds
                          expr      min       lq     mean   median       uq      max neval
 random <- rgamma(10000, 1, 1) 1.281707 1.330347 1.410961 1.362631 1.421226 2.322204   100
> 
> n <- 50
> k <- seq(0,1,by=1/n)
> cauchy_pdf <- microbenchmark(pdf<-dcauchy(k, 2,1, log = FALSE))
> cauchy_cdf <- microbenchmark(cdf<-pgamma(k, 2,1, log = FALSE))
> cauchy_quantile <- microbenchmark(quantile<-qcauchy(cdf, 2, 1, log = FALSE))
> cauchy_random <- microbenchmark(random<-rcauchy(10000, 2, 1))
> print(cauchy_pdf)
Unit: microseconds
                                 expr   min    lq   mean median    uq    max neval
 pdf <- dcauchy(k, 2, 1, log = FALSE) 1.423 1.708 2.8431  1.709 2.278 67.415   100
> print(cauchy_cdf)
Unit: microseconds
                                expr    min     lq     mean median     uq    max neval
 cdf <- pgamma(k, 2, 1, log = FALSE) 15.078 15.646 16.51914  15.93 16.215 33.281   100
> print(cauchy_quantile)
Unit: microseconds
                                        expr   min   lq   mean median    uq    max neval
 quantile <- qcauchy(cdf, 2, 1, log = FALSE) 2.845 3.13 3.8044  3.131 3.415 56.606   100
> print(cauchy_random)
Unit: microseconds
                           expr     min      lq     mean   median      uq      max neval
 random <- rcauchy(10000, 2, 1) 588.517 615.823 663.8658 637.7255 674.845 1520.356   100
> 
> n <- 50
> k <- seq(0,1,by=1/n)
> exponential_pdf <- microbenchmark(pdf<-dexp(k, 2, log = FALSE))
> exponential_cdf <- microbenchmark(cdf<-pexp(k, 2, log = FALSE))
> exponential_quantile <- microbenchmark(quantile<-qexp(cdf, 2, log = FALSE))
> exponential_random <- microbenchmark(random<-rexp(10000, 2))
> print(exponential_pdf)
Unit: microseconds
                           expr  min    lq    mean median    uq    max neval
 pdf <- dexp(k, 2, log = FALSE) 3.13 3.414 4.08887  3.415 3.415 67.699   100
> print(exponential_cdf)
Unit: microseconds
                           expr   min   lq    mean median     uq    max neval
 cdf <- pexp(k, 2, log = FALSE) 2.845 3.13 4.38756  3.414 3.5565 58.597   100
> print(exponential_quantile)
Unit: microseconds
                                  expr   min    lq    mean median    uq    max neval
 quantile <- qexp(cdf, 2, log = FALSE) 2.276 2.561 3.80729 2.5615 2.846 44.659   100
> print(exponential_random)
Unit: microseconds
                     expr     min       lq     mean   median       uq      max neval
 random <- rexp(10000, 2) 389.406 408.8895 440.9583 418.4185 444.8715 1371.875   100
> 
> 
> n <- 50
> k <- seq(0,1,by=1/n)
> uniform_pdf <- microbenchmark(pdf<-dunif(k, 0, 10, log = FALSE))
> uniform_cdf <- microbenchmark(cdf<-punif(k, 0, 10, log = FALSE))
> uniform_quantile <- microbenchmark(quantile<-qunif(cdf, 0, 10, log = FALSE))
> uniform_random <- microbenchmark(random<-runif(10000, 0, 10))
> print(uniform_pdf)
Unit: microseconds
                                expr   min    lq    mean median    uq    max neval
 pdf <- dunif(k, 0, 10, log = FALSE) 2.561 2.846 3.78734   3.13 3.131 66.277   100
> print(uniform_cdf)
Unit: microseconds
                                expr   min    lq    mean median    uq    max neval
 cdf <- punif(k, 0, 10, log = FALSE) 1.423 1.708 2.41635  1.992 1.993 53.477   100
> print(uniform_quantile)
Unit: microseconds
                                       expr   min    lq    mean median     uq    max neval
 quantile <- qunif(cdf, 0, 10, log = FALSE) 2.846 3.131 5.13561  3.415 3.6995 82.774   100
> print(uniform_random)
Unit: microseconds
                          expr     min       lq     mean   median       uq      max neval
 random <- runif(10000, 0, 10) 247.467 258.7035 317.1567 279.6095 357.2635 1267.769   100
> 
> 
> n <- 50
> k <- seq(0,n,by=1)
> geometric_pdf <- microbenchmark(pdf<-dgeom(k, 0.3, log = FALSE))
> geometric_cdf <- microbenchmark(cdf<-pgeom(k, 0.3, log = FALSE))
> geometric_quantile <- microbenchmark(quantile<-qgeom(cdf, 0.3, log = FALSE))
> geometric_random <- microbenchmark(random<-rgeom(10000, 0.3))
> print(geometric_pdf)
Unit: microseconds
                              expr   min    lq    mean median    uq    max neval
 pdf <- dgeom(k, 0.3, log = FALSE) 5.121 5.122 6.14258  5.406 5.406 60.304   100
> print(geometric_cdf)
Unit: microseconds
                              expr   min    lq    mean median     uq    max neval
 cdf <- pgeom(k, 0.3, log = FALSE) 4.552 4.836 5.50548  4.837 5.1215 46.081   100
> print(geometric_quantile)
Unit: microseconds
                                     expr   min    lq    mean median    uq    max neval
 quantile <- qgeom(cdf, 0.3, log = FALSE) 5.407 5.974 7.12107  5.975 6.259 71.681   100
> print(geometric_random)
Unit: milliseconds
                        expr      min       lq     mean   median       uq      max neval
 random <- rgeom(10000, 0.3) 1.078045 1.127681 1.192608 1.156125 1.199361 1.604267   100
> 
> n <- 50
> k <- seq(0,n,by=1)
> hypergeometric_pdf <- microbenchmark(pdf<-dhyper(k, 12,38,11, log = FALSE))
> hypergeometric_cdf <- microbenchmark(cdf<-phyper(k, 12,38,11, log = FALSE))
> hypergeometric_quantile <- microbenchmark(quantile<-qhyper(cdf, 12,38,11, log = FALSE))
> hypergeometric_random <- microbenchmark(random<-rhyper(10000, 12,38,11))
> print(hypergeometric_pdf)
Unit: microseconds
                                      expr    min     lq     mean median     uq     max neval
 pdf <- dhyper(k, 12, 38, 11, log = FALSE) 11.095 13.939 17.07667 14.224 14.935 101.548   100
> print(hypergeometric_cdf)
Unit: microseconds
                                      expr   min    lq     mean median     uq   max neval
 cdf <- phyper(k, 12, 38, 11, log = FALSE) 8.819 9.387 12.60515  9.672 12.517 62.01   100
> print(hypergeometric_quantile)
Unit: microseconds
                                             expr   min      lq     mean median     uq    max neval
 quantile <- qhyper(cdf, 12, 38, 11, log = FALSE) 9.957 10.3835 13.00618  10.81 11.948 64.286   100
> print(hypergeometric_random)
Unit: microseconds
                                expr     min       lq     mean   median       uq      max neval
 random <- rhyper(10000, 12, 38, 11) 880.356 938.9515 993.8324 963.9835 996.8365 1375.289   100
> 
> n <- 50
> k <- seq(0,1,by=1/n)
> logistic_pdf <- microbenchmark(pdf<-dlogis(k, 1,2, log = FALSE))
> logistic_cdf <- microbenchmark(cdf<-plogis(k, 1,2, log = FALSE))
> logistic_quantile <- microbenchmark(quantile<-qlogis(cdf, 1,2, log = FALSE))
> logistic_random <- microbenchmark(random<-rlogis(10000, 1,2))
> print(logistic_pdf)
Unit: microseconds
                                expr   min    lq    mean median    uq    max neval
 pdf <- dlogis(k, 1, 2, log = FALSE) 4.267 4.552 5.94354  4.553 4.837 53.477   100
> print(logistic_cdf)
Unit: microseconds
                                expr   min    lq    mean median    uq    max neval
 cdf <- plogis(k, 1, 2, log = FALSE) 4.267 4.552 5.96056  4.837 4.837 96.428   100
> print(logistic_quantile)
Unit: microseconds
                                       expr  min    lq   mean median    uq    max neval
 quantile <- qlogis(cdf, 1, 2, log = FALSE) 3.13 3.415 4.1742  3.415 3.699 56.036   100
> print(logistic_random)
Unit: microseconds
                          expr     min      lq     mean   median      uq      max neval
 random <- rlogis(10000, 1, 2) 626.632 649.956 696.2128 675.2725 715.805 1589.191   100
> 
> n <- 50
> k <- seq(0,1,by=1/n)
> weibull_pdf <- microbenchmark(pdf<-dweibull(k, 5,1, log = FALSE))
> weibull_cdf <- microbenchmark(cdf<-pweibull(k, 5,1, log = FALSE))
> weibull_quantile <- microbenchmark(quantile<-qweibull(cdf, 5,1, log = FALSE))
> weibull_random <- microbenchmark(random<-rweibull(10000, 5,1))
> print(weibull_pdf)
Unit: microseconds
                                  expr  min    lq    mean median    uq    max neval
 pdf <- dweibull(k, 5, 1, log = FALSE) 5.69 5.974 7.21775  5.975 6.259 85.619   100
> print(weibull_cdf)
Unit: microseconds
                                  expr   min    lq    mean median    uq    max neval
 cdf <- pweibull(k, 5, 1, log = FALSE) 4.268 4.552 7.83782 4.8365 7.966 90.455   100
> print(weibull_quantile)
Unit: microseconds
                                         expr   min    lq    mean median    uq    max neval
 quantile <- qweibull(cdf, 5, 1, log = FALSE) 6.828 7.112 7.96587  7.113 7.397 48.641   100
> print(weibull_random)
Unit: milliseconds
                            expr      min      lq     mean   median       uq      max neval
 random <- rweibull(10000, 5, 1) 1.558472 1.59744 1.659753 1.632853 1.679502 2.616603   100
> 
> n <- 50
> k <- seq(0,n,by=1)
> poisson_pdf <- microbenchmark(pdf<-dpois(k, 1, log = FALSE))
> poisson_cdf <- microbenchmark(cdf<-ppois(k, 1, log = FALSE))
> poisson_quantile <- microbenchmark(quantile<-qpois(cdf, 1, log = FALSE))
> poisson_random <- microbenchmark(random<-rpois(10000, 1))
> print(poisson_pdf)
Unit: microseconds
                            expr   min    lq    mean median    uq    max neval
 pdf <- dpois(k, 1, log = FALSE) 5.974 6.543 7.30316  6.544 6.828 54.046   100
> print(poisson_cdf)
Unit: microseconds
                            expr   min    lq     mean median    uq    max neval
 cdf <- ppois(k, 1, log = FALSE) 8.534 8.819 10.25846  9.104 9.388 64.286   100
> print(poisson_quantile)
Unit: microseconds
                                   expr    min     lq     mean median     uq    max neval
 quantile <- qpois(cdf, 1, log = FALSE) 13.085 13.086 14.37438  13.37 13.654 61.157   100
> print(poisson_random)
Unit: microseconds
                      expr     min       lq     mean  median      uq     max neval
 random <- rpois(10000, 1) 303.219 314.8815 327.5787 324.552 341.335 373.477   100
> 
> n <- 50
> k <- seq(0,1,by=1/n)
> f_pdf <- microbenchmark(pdf<-df(k, 10,20, log = FALSE))
> f_cdf <- microbenchmark(cdf<-pf(k, 10,20, log = FALSE))
> f_quantile <- microbenchmark(quantile<-qf(cdf, 10,20,log = FALSE))
> f_random <- microbenchmark(random<-rf(10000, 10,20))
> print(f_pdf)
Unit: microseconds
                              expr    min    lq     mean median     uq    max neval
 pdf <- df(k, 10, 20, log = FALSE) 10.241 10.81 12.43159 10.811 11.095 71.112   100
> print(f_cdf)
Unit: microseconds
                              expr    min     lq     mean median      uq    max neval
 cdf <- pf(k, 10, 20, log = FALSE) 22.472 22.757 25.66972 23.041 23.3265 86.189   100
> print(f_quantile)
Unit: microseconds
                                     expr     min     lq     mean   median      uq     max neval
 quantile <- qf(cdf, 10, 20, log = FALSE) 135.396 136.25 166.7057 157.7255 186.171 255.717   100
> print(f_random)
Unit: milliseconds
                        expr      min       lq     mean   median      uq      max neval
 random <- rf(10000, 10, 20) 1.801955 1.889706 1.947645 1.929528 1.98272 2.725546   100
> 
> n <- 50
> k <- seq(0,1,by=1/n)
> chisquare_pdf <- microbenchmark(pdf<-dchisq(k, 2,log = FALSE))
> chisquare_cdf <- microbenchmark(cdf<-pchisq(k, 2, log = FALSE))
> chisquare_quantile <- microbenchmark(quantile<-qchisq(cdf, 2, log = FALSE))
> chisquare_random <- microbenchmark(random<-rchisq(10000, 2))
> print(chisquare_pdf)
Unit: microseconds
                             expr   min    lq    mean median    uq    max neval
 pdf <- dchisq(k, 2, log = FALSE) 5.974 6.259 7.06416 6.4015 6.544 52.339   100
> print(chisquare_cdf)
Unit: microseconds
                             expr   min     lq     mean median    uq    max neval
 cdf <- pchisq(k, 2, log = FALSE) 13.37 13.655 15.46392 13.655 13.94 99.841   100
> print(chisquare_quantile)
Unit: microseconds
                                    expr    min      lq     mean  median    uq     max neval
 quantile <- qchisq(cdf, 2, log = FALSE) 61.725 62.2945 68.40176 62.7215 72.25 132.553   100
> print(chisquare_random)
Unit: milliseconds
                       expr      min      lq    mean   median       uq      max neval
 random <- rchisq(10000, 2) 1.235059 1.29408 1.38993 1.333903 1.401743 2.205582   100
> 
> n <- 50
> k <- seq(0,1,by=1/n)
> nchisquare_pdf <- microbenchmark(pdf<-dchisq(k, 2,1, log = FALSE))
> nchisquare_cdf <- microbenchmark(cdf<-pchisq(k, 2,1,log = FALSE))
> nchisquare_quantile <- microbenchmark(quantile<-qchisq(cdf, 2,1, log = FALSE))
> nchisquare_random <- microbenchmark(random<-rchisq(10000, 2,1))
> print(nchisquare_pdf)
Unit: microseconds
                                expr    min     lq    mean median      uq    max neval
 pdf <- dchisq(k, 2, 1, log = FALSE) 14.223 14.509 17.3866 14.793 15.6455 37.548   100
> print(nchisquare_cdf)
Unit: microseconds
                                expr     min     lq     mean   median      uq     max neval
 cdf <- pchisq(k, 2, 1, log = FALSE) 209.068 210.49 231.6357 223.1475 240.499 309.193   100
> print(nchisquare_quantile)
Unit: milliseconds
                                       expr      min       lq     mean   median       uq      max neval
 quantile <- qchisq(cdf, 2, 1, log = FALSE) 10.34296 10.65955 10.90239 10.83733 11.02563 12.31558   100
> print(nchisquare_random)
Unit: milliseconds
                          expr      min       lq     mean   median       uq      max neval
 random <- rchisq(10000, 2, 1) 1.997653 2.073457 2.187417 2.114845 2.183111 3.134576   100
> 
> n <- 50
> k <- seq(0,1,by=1/n)
> nf_pdf <- microbenchmark(pdf<-df(k, 10,20,2, log = FALSE))
> nf_cdf <- microbenchmark(cdf<-pf(k, 10,20,2, log = FALSE))
> nf_quantile <- microbenchmark(quantile<-qf(cdf, 10,20,2, log = FALSE))
> nf_random <- microbenchmark(random<-rf(10000, 10,20,2))
> print(nf_pdf)
Unit: microseconds
                                 expr    min     lq     mean median     uq    max neval
 pdf <- df(k, 10, 20, 2, log = FALSE) 28.446 30.153 34.12338 30.438 31.291 68.836   100
> print(nf_cdf)
Unit: microseconds
                                 expr    min      lq     mean median     uq     max neval
 cdf <- pf(k, 10, 20, 2, log = FALSE) 46.935 61.8685 64.53899 63.433 65.708 106.953   100
> print(nf_quantile)
Unit: milliseconds
                                        expr      min       lq     mean  median       uq      max neval
 quantile <- qf(cdf, 10, 20, 2, log = FALSE) 2.561991 2.640355 2.719223 2.68999 2.744461 3.737598   100
> print(nf_random)
Unit: milliseconds
                           expr      min       lq     mean   median       uq      max neval
 random <- rf(10000, 10, 20, 2) 2.912141 2.989225 3.100073 3.035163 3.110825 4.062433   100
> 
> n <- 50
> k <- seq(0,1,by=1/n)
> nbeta_pdf <- microbenchmark(pdf<-dbeta(k, 2,4,1, log = FALSE))
> nbeta_cdf <- microbenchmark(cdf<-pbeta(k, 2,4,1, log = FALSE))
> nbeta_quantile <- microbenchmark(quantile<-qbeta(cdf, 2,4,1, log = FALSE))
> nbeta_random <- microbenchmark(random<-rbeta(10000, 2,4,1))
> print(nbeta_pdf)
Unit: microseconds
                                  expr    min     lq     mean median      uq    max neval
 pdf <- dbeta(k, 2, 4, 1, log = FALSE) 26.739 27.308 31.31301 27.592 30.5795 56.891   100
> print(nbeta_cdf)
Unit: microseconds
                                  expr    min     lq     mean median      uq     max neval
 cdf <- pbeta(k, 2, 4, 1, log = FALSE) 43.237 43.806 55.11814 56.321 57.7435 167.255   100
> print(nbeta_quantile)
Unit: milliseconds
                                         expr      min       lq     mean   median      uq      max neval
 quantile <- qbeta(cdf, 2, 4, 1, log = FALSE) 2.290915 2.375111 2.440959 2.431146 2.49927 2.644764   100
> print(nbeta_random)
Unit: milliseconds
                            expr      min       lq     mean   median       uq      max neval
 random <- rbeta(10000, 2, 4, 1) 2.839893 3.002737 3.143906 3.073848 3.150932 4.302789   100
> 
> n <- 50
> k <- seq(0,n,by=1)
> nbinom_pdf <- microbenchmark(pdf<-dnbinom(k, 2, 0.5, log = FALSE))
> nbinom_cdf <- microbenchmark(cdf<-pnbinom(k, 2, 0.5, log = FALSE))
> nbinom_quantile <- microbenchmark(quantile<-qnbinom(cdf, 2, 0.5, log = FALSE))
> nbinom_random <- microbenchmark(random<-rnbinom(10000, 2, 0.5))
> print(nbinom_pdf)
Unit: microseconds
                                   expr    min     lq     mean median     uq    max neval
 pdf <- dnbinom(k, 2, 0.5, log = FALSE) 11.094 11.379 13.37031 11.664 11.948 78.508   100
> print(nbinom_cdf)
Unit: microseconds
                                   expr    min     lq     mean median     uq     max neval
 cdf <- pnbinom(k, 2, 0.5, log = FALSE) 19.627 19.913 22.94469 20.197 20.482 130.277   100
> print(nbinom_quantile)
Unit: microseconds
                                          expr    min     lq     mean median     uq     max neval
 quantile <- qnbinom(cdf, 2, 0.5, log = FALSE) 60.019 60.588 69.73866 61.442 74.099 122.028   100
> print(nbinom_random)
Unit: milliseconds
                             expr      min       lq     mean   median       uq      max neval
 random <- rnbinom(10000, 2, 0.5) 1.936498 2.029226 2.086237 2.072035 2.125084 2.354061   100
> 
> n <- 50
> k <- seq(0,1,by=1/n)
> normal_pdf <- microbenchmark(pdf<-dnorm(k, 1, 1, log = FALSE))
> normal_cdf <- microbenchmark(cdf<-pnorm(k, 1, 1, log = FALSE))
> normal_quantile <- microbenchmark(quantile<-qnorm(cdf, 1,1, log = FALSE))
> normal_random <- microbenchmark(random<-rnorm(10000, 1,1))
> print(normal_pdf)
Unit: microseconds
                               expr   min    lq   mean median    uq    max neval
 pdf <- dnorm(k, 1, 1, log = FALSE) 4.267 4.552 5.7927  4.553 4.837 75.663   100
> print(normal_cdf)
Unit: microseconds
                               expr   min    lq    mean median    uq    max neval
 cdf <- pnorm(k, 1, 1, log = FALSE) 3.983 4.269 5.94911  4.553 4.979 50.632   100
> print(normal_quantile)
Unit: microseconds
                                      expr   min    lq    mean median    uq    max neval
 quantile <- qnorm(cdf, 1, 1, log = FALSE) 2.277 2.561 3.42042  2.845 2.846 45.227   100
> print(normal_random)
Unit: microseconds
                         expr     min      lq     mean   median       uq     max neval
 random <- rnorm(10000, 1, 1) 696.321 728.747 779.1994 749.7965 778.3835 1541.12   100
> 
> n <- 50
> k <- seq(0,1,by=1/n)
> lognormal_pdf <- microbenchmark(pdf<-dlnorm(k, 0.5,0.6, log = FALSE))
> lognormal_cdf <- microbenchmark(cdf<-plnorm(k, 0.5,0.6, log = FALSE))
> lognormal_quantile <- microbenchmark(quantile<-qlnorm(cdf, 0.5,0.6, log = FALSE))
> lognormal_random <- microbenchmark(random<-rlnorm(10000, 0.5,0.6))
> print(lognormal_pdf)
Unit: microseconds
                                    expr   min   lq    mean median    uq    max neval
 pdf <- dlnorm(k, 0.5, 0.6, log = FALSE) 5.406 5.69 6.89638  5.975 6.259 50.917   100
> print(lognormal_cdf)
Unit: microseconds
                                    expr   min    lq    mean median      uq    max neval
 cdf <- plnorm(k, 0.5, 0.6, log = FALSE) 8.819 9.387 12.3463 9.3885 12.6595 71.681   100
> print(lognormal_quantile)
Unit: microseconds
                                           expr   min    lq    mean median    uq    max neval
 quantile <- qlnorm(cdf, 0.5, 0.6, log = FALSE) 6.259 6.544 7.38277  6.544 6.828 58.881   100
> print(lognormal_random)
Unit: milliseconds
                              expr      min       lq     mean   median       uq      max neval
 random <- rlnorm(10000, 0.5, 0.6) 1.269761 1.329209 1.380386 1.362632 1.401743 2.247395   100
> 
> n <- 50
> k <- seq(0,1,by=1/n)
> t_pdf <- microbenchmark(pdf<-dt(k, 8, log = FALSE))
> t_cdf <- microbenchmark(cdf<-pt(k, 8, log = FALSE))
> t_quantile <- microbenchmark(quantile<-qt(cdf, 8, log = FALSE))
> t_random <- microbenchmark(random<-rt(10000, 8))
> print(t_pdf)
Unit: microseconds
                         expr    min     lq     mean median      uq    max neval
 pdf <- dt(k, 8, log = FALSE) 11.663 12.233 15.71413 12.517 16.0725 76.517   100
> print(t_cdf)
Unit: microseconds
                         expr    min      lq     mean median     uq     max neval
 cdf <- pt(k, 8, log = FALSE) 19.059 20.6235 23.23485  21.05 21.619 127.717   100
> print(t_quantile)
Unit: microseconds
                                expr    min     lq     mean median    uq     max neval
 quantile <- qt(cdf, 8, log = FALSE) 58.596 58.882 64.84339 59.166 62.01 151.611   100
> print(t_random)
Unit: milliseconds
                   expr     min       lq     mean  median       uq     max neval
 random <- rt(10000, 8) 1.42592 1.480676 1.553132 1.51424 1.569565 2.44679   100
> 
> n <- 50
> k <- seq(0,1,by=1/n)
> nt_pdf <- microbenchmark(pdf<-dt(k, 10,1, log = FALSE))
> nt_cdf <- microbenchmark(cdf<-pt(k, 10,1, log = FALSE))
> nt_quantile <- microbenchmark(quantile<-qt(cdf, 10,1, log = FALSE))
> nt_random <- microbenchmark(random<-rt(10000, 10,1))
> print(nt_pdf)
Unit: microseconds
                             expr    min     lq     mean median      uq     max neval
 pdf <- dt(k, 10, 1, log = FALSE) 86.757 88.037 92.88671 89.317 91.4505 130.276   100
> print(nt_cdf)
Unit: microseconds
                             expr    min      lq     mean  median     uq    max neval
 cdf <- pt(k, 10, 1, log = FALSE) 39.823 40.2505 44.51695 40.6765 49.352 70.829   100
> print(nt_quantile)
Unit: milliseconds
                                    expr      min       lq     mean median       uq      max neval
 quantile <- qt(cdf, 10, 1, log = FALSE) 1.930524 1.981866 2.038755 2.0224 2.079715 2.594987   100
> print(nt_random)
Unit: milliseconds
                       expr     min       lq     mean   median       uq      max neval
 random <- rt(10000, 10, 1) 1.69984 1.764693 1.867469 1.814044 1.893263 2.856959   100

Result of the TestStatBenchmark.mq5 operation script:

IG    0    13:06:15.252    TestStatBenchmark (EURUSD,H1)    Unit tests for Package Statistic Benchmark
PP    0    13:06:15.252    TestStatBenchmark (EURUSD,H1)   
KJ    0    13:06:15.639    TestStatBenchmark (EURUSD,H1)    Binomial time (microseconds):      pdf_mean=4.39,      pdf_median=4.00,      pdf_min=3.00,      pdf_max=40.00,       pdf_stddev=2.21,       pdf_avgdev=0.95
MS    0    13:06:15.639    TestStatBenchmark (EURUSD,H1)    Binomial time (microseconds):      cdf_mean=13.65,      cdf_median=12.00,      cdf_min=11.00,      cdf_max=54.00,       cdf_stddev=4.09,       cdf_avgdev=2.37
GF    0    13:06:15.639    TestStatBenchmark (EURUSD,H1)    Binomial time (microseconds): quantile_mean=50.18, quantile_median=45.00, quantile_min=43.00, quantile_max=108.00,  quantile_stddev=9.97,  quantile_avgdev=7.41
QO    0    13:06:15.639    TestStatBenchmark (EURUSD,H1)    Binomial time (microseconds):   random_mean=318.73,   random_median=312.00,   random_min=284.00,   random_max=478.00,    random_stddev=28.74,    random_avgdev=22.22
LP    0    13:06:16.384    TestStatBenchmark (EURUSD,H1)    Beta time (microseconds):      pdf_mean=1.74,      pdf_median=2.00,      pdf_min=1.00,      pdf_max=18.00,       pdf_stddev=1.07,       pdf_avgdev=0.53
EI    0    13:06:16.384    TestStatBenchmark (EURUSD,H1)    Beta time (microseconds):      cdf_mean=4.76,      cdf_median=4.00,      cdf_min=3.00,      cdf_max=68.00,       cdf_stddev=3.07,       cdf_avgdev=1.19
LM    0    13:06:16.384    TestStatBenchmark (EURUSD,H1)    Beta time (microseconds): quantile_mean=48.72, quantile_median=44.00, quantile_min=43.00, quantile_max=111.00,  quantile_stddev=10.21,  quantile_avgdev=6.96
QG    0    13:06:16.384    TestStatBenchmark (EURUSD,H1)    Beta time (microseconds):   random_mean=688.81,   random_median=680.00,   random_min=625.00,   random_max=976.00,    random_stddev=43.92,    random_avgdev=31.81
HE    0    13:06:16.587    TestStatBenchmark (EURUSD,H1)    Gamma time (microseconds):      pdf_mean=1.31,      pdf_median=1.00,      pdf_min=1.00,      pdf_max=13.00,       pdf_stddev=0.82,       pdf_avgdev=0.47
GL    0    13:06:16.587    TestStatBenchmark (EURUSD,H1)    Gamma time (microseconds):      cdf_mean=8.09,      cdf_median=7.00,      cdf_min=7.00,      cdf_max=92.00,       cdf_stddev=3.67,       cdf_avgdev=1.40
CF    0    13:06:16.587    TestStatBenchmark (EURUSD,H1)    Gamma time (microseconds): quantile_mean=50.83, quantile_median=46.00, quantile_min=45.00, quantile_max=106.00,  quantile_stddev=9.27,  quantile_avgdev=6.72
GR    0    13:06:16.587    TestStatBenchmark (EURUSD,H1)    Gamma time (microseconds):   random_mean=142.84,   random_median=132.00,   random_min=128.00,   random_max=260.00,    random_stddev=19.73,    random_avgdev=15.32
QD    0    13:06:16.815    TestStatBenchmark (EURUSD,H1)    Cauchy time (microseconds):      pdf_mean=0.45,      pdf_median=0.00,      pdf_min=0.00,      pdf_max=11.00,       pdf_stddev=0.85,       pdf_avgdev=0.54
QK    0    13:06:16.815    TestStatBenchmark (EURUSD,H1)    Cauchy time (microseconds):      cdf_mean=1.33,      cdf_median=1.00,      cdf_min=1.00,      cdf_max=12.00,       cdf_stddev=0.81,       cdf_avgdev=0.48
MR    0    13:06:16.815    TestStatBenchmark (EURUSD,H1)    Cauchy time (microseconds): quantile_mean=1.37, quantile_median=1.00, quantile_min=1.00, quantile_max=14.00,  quantile_stddev=0.89,  quantile_avgdev=0.51
IK    0    13:06:16.815    TestStatBenchmark (EURUSD,H1)    Cauchy time (microseconds):   random_mean=224.19,   random_median=215.00,   random_min=200.00,   random_max=352.00,    random_stddev=26.86,    random_avgdev=20.34
PQ    0    13:06:16.960    TestStatBenchmark (EURUSD,H1)    Exponential time (microseconds):      pdf_mean=0.85,      pdf_median=1.00,      pdf_min=0.00,      pdf_max=18.00,       pdf_stddev=1.40,       pdf_avgdev=0.54
GK    0    13:06:16.960    TestStatBenchmark (EURUSD,H1)    Exponential time (microseconds):      cdf_mean=0.77,      cdf_median=1.00,      cdf_min=0.00,      cdf_max=16.00,       cdf_stddev=0.94,       cdf_avgdev=0.47
HE    0    13:06:16.960    TestStatBenchmark (EURUSD,H1)    Exponential time (microseconds): quantile_mean=0.53, quantile_median=0.00, quantile_min=0.00, quantile_max=10.00,  quantile_stddev=0.78,  quantile_avgdev=0.54
HL    0    13:06:16.960    TestStatBenchmark (EURUSD,H1)    Exponential time (microseconds):   random_mean=143.18,   random_median=130.00,   random_min=128.00,   random_max=272.00,    random_stddev=21.58,    random_avgdev=16.98
LK    0    13:06:17.002    TestStatBenchmark (EURUSD,H1)    Uniform time (microseconds):      pdf_mean=0.42,      pdf_median=0.00,      pdf_min=0.00,      pdf_max=12.00,       pdf_stddev=0.82,       pdf_avgdev=0.52
CE    0    13:06:17.002    TestStatBenchmark (EURUSD,H1)    Uniform time (microseconds):      cdf_mean=0.45,      cdf_median=0.00,      cdf_min=0.00,      cdf_max=16.00,       cdf_stddev=0.96,       cdf_avgdev=0.55
LO    0    13:06:17.002    TestStatBenchmark (EURUSD,H1)    Uniform time (microseconds): quantile_mean=0.18, quantile_median=0.00, quantile_min=0.00, quantile_max=1.00,  quantile_stddev=0.38,  quantile_avgdev=0.29
GE    0    13:06:17.002    TestStatBenchmark (EURUSD,H1)    Uniform time (microseconds):   random_mean=40.30,   random_median=36.00,   random_min=35.00,   random_max=83.00,    random_stddev=7.61,    random_avgdev=5.41
OP    0    13:06:17.286    TestStatBenchmark (EURUSD,H1)    Geometric time (microseconds):      pdf_mean=2.30,      pdf_median=2.00,      pdf_min=1.00,      pdf_max=14.00,       pdf_stddev=1.30,       pdf_avgdev=0.52
DK    0    13:06:17.286    TestStatBenchmark (EURUSD,H1)    Geometric time (microseconds):      cdf_mean=2.12,      cdf_median=2.00,      cdf_min=1.00,      cdf_max=18.00,       cdf_stddev=1.69,       cdf_avgdev=0.53
NE    0    13:06:17.286    TestStatBenchmark (EURUSD,H1)    Geometric time (microseconds): quantile_mean=0.81, quantile_median=1.00, quantile_min=0.00, quantile_max=10.00,  quantile_stddev=0.68,  quantile_avgdev=0.39
IL    0    13:06:17.286    TestStatBenchmark (EURUSD,H1)    Geometric time (microseconds):   random_mean=278.00,   random_median=271.00,   random_min=251.00,   random_max=429.00,    random_stddev=28.23,    random_avgdev=21.62
PG    0    13:06:17.592    TestStatBenchmark (EURUSD,H1)    Hypergeometric time (microseconds):      pdf_mean=1.85,      pdf_median=2.00,      pdf_min=1.00,      pdf_max=15.00,       pdf_stddev=1.07,       pdf_avgdev=0.48
CM    0    13:06:17.592    TestStatBenchmark (EURUSD,H1)    Hypergeometric time (microseconds):      cdf_mean=0.90,      cdf_median=1.00,      cdf_min=0.00,      cdf_max=17.00,       cdf_stddev=0.85,       cdf_avgdev=0.32
NP    0    13:06:17.592    TestStatBenchmark (EURUSD,H1)    Hypergeometric time (microseconds): quantile_mean=0.75, quantile_median=1.00, quantile_min=0.00, quantile_max=12.00,  quantile_stddev=0.96,  quantile_avgdev=0.48
FE    0    13:06:17.592    TestStatBenchmark (EURUSD,H1)    Hypergeometric time (microseconds):   random_mean=302.55,   random_median=295.00,   random_min=272.00,   random_max=466.00,    random_stddev=30.20,    random_avgdev=22.99
ML    0    13:06:17.774    TestStatBenchmark (EURUSD,H1)    Logistic time (microseconds):      pdf_mean=1.27,      pdf_median=1.00,      pdf_min=0.00,      pdf_max=91.00,       pdf_stddev=3.04,       pdf_avgdev=0.56
DR    0    13:06:17.774    TestStatBenchmark (EURUSD,H1)    Logistic time (microseconds):      cdf_mean=1.11,      cdf_median=1.00,      cdf_min=0.00,      cdf_max=17.00,       cdf_stddev=1.34,       cdf_avgdev=0.40
IH    0    13:06:17.774    TestStatBenchmark (EURUSD,H1)    Logistic time (microseconds): quantile_mean=0.71, quantile_median=1.00, quantile_min=0.00, quantile_max=12.00,  quantile_stddev=0.79,  quantile_avgdev=0.47
GL    0    13:06:17.774    TestStatBenchmark (EURUSD,H1)    Logistic time (microseconds):   random_mean=178.65,   random_median=164.00,   random_min=162.00,   random_max=309.00,    random_stddev=24.09,    random_avgdev=17.94
MJ    0    13:06:18.319    TestStatBenchmark (EURUSD,H1)    Weibull time (microseconds):      pdf_mean=2.99,      pdf_median=3.00,      pdf_min=2.00,      pdf_max=17.00,       pdf_stddev=1.63,       pdf_avgdev=0.57
GD    0    13:06:18.319    TestStatBenchmark (EURUSD,H1)    Weibull time (microseconds):      cdf_mean=2.74,      cdf_median=3.00,      cdf_min=2.00,      cdf_max=19.00,       cdf_stddev=1.23,       cdf_avgdev=0.58
FO    0    13:06:18.319    TestStatBenchmark (EURUSD,H1)    Weibull time (microseconds): quantile_mean=2.64, quantile_median=2.00, quantile_min=2.00, quantile_max=19.00,  quantile_stddev=1.64,  quantile_avgdev=0.76
DJ    0    13:06:18.319    TestStatBenchmark (EURUSD,H1)    Weibull time (microseconds):   random_mean=536.37,   random_median=526.00,   random_min=483.00,   random_max=759.00,    random_stddev=46.99,    random_avgdev=34.40
HR    0    13:06:18.485    TestStatBenchmark (EURUSD,H1)    Poisson time (microseconds):      pdf_mean=2.91,      pdf_median=3.00,      pdf_min=2.00,      pdf_max=15.00,       pdf_stddev=1.40,       pdf_avgdev=0.58
IL    0    13:06:18.486    TestStatBenchmark (EURUSD,H1)    Poisson time (microseconds):      cdf_mean=6.26,      cdf_median=6.00,      cdf_min=5.00,      cdf_max=23.00,       cdf_stddev=2.38,       cdf_avgdev=1.07
HE    0    13:06:18.486    TestStatBenchmark (EURUSD,H1)    Poisson time (microseconds): quantile_mean=3.43, quantile_median=3.00, quantile_min=2.00, quantile_max=20.00,  quantile_stddev=1.48,  quantile_avgdev=0.68
DL    0    13:06:18.486    TestStatBenchmark (EURUSD,H1)    Poisson time (microseconds):   random_mean=153.59,   random_median=144.00,   random_min=138.00,   random_max=265.00,    random_stddev=18.57,    random_avgdev=13.99
IH    0    13:06:19.814    TestStatBenchmark (EURUSD,H1)    F time (microseconds):      pdf_mean=3.86,      pdf_median=4.00,      pdf_min=3.00,      pdf_max=21.00,       pdf_stddev=1.78,       pdf_avgdev=0.76
GS    0    13:06:19.814    TestStatBenchmark (EURUSD,H1)    F time (microseconds):      cdf_mean=9.94,      cdf_median=9.00,      cdf_min=7.00,      cdf_max=36.00,       cdf_stddev=3.82,       cdf_avgdev=2.15
OI    0    13:06:19.814    TestStatBenchmark (EURUSD,H1)    F time (microseconds): quantile_mean=65.47, quantile_median=59.00, quantile_min=57.00, quantile_max=147.00,  quantile_stddev=12.99,  quantile_avgdev=9.64
DE    0    13:06:19.814    TestStatBenchmark (EURUSD,H1)    F time (microseconds):   random_mean=1249.22,   random_median=1213.00,   random_min=1127.00,   random_max=1968.00,    random_stddev=117.69,    random_avgdev=72.17
EL    0    13:06:20.079    TestStatBenchmark (EURUSD,H1)    ChiSquare time (microseconds):      pdf_mean=2.47,      pdf_median=2.00,      pdf_min=2.00,      pdf_max=13.00,       pdf_stddev=1.32,       pdf_avgdev=0.65
JK    0    13:06:20.079    TestStatBenchmark (EURUSD,H1)    ChiSquare time (microseconds):      cdf_mean=7.71,      cdf_median=7.00,      cdf_min=7.00,      cdf_max=23.00,       cdf_stddev=1.91,       cdf_avgdev=0.88
KQ    0    13:06:20.079    TestStatBenchmark (EURUSD,H1)    ChiSquare time (microseconds): quantile_mean=44.11, quantile_median=41.00, quantile_min=40.00, quantile_max=120.00,  quantile_stddev=8.17,  quantile_avgdev=5.38
CL    0    13:06:20.079    TestStatBenchmark (EURUSD,H1)    ChiSquare time (microseconds):   random_mean=210.24,   random_median=196.00,   random_min=190.00,   random_max=437.00,    random_stddev=29.14,    random_avgdev=21.00
HD    0    13:06:21.098    TestStatBenchmark (EURUSD,H1)    Noncentral ChiSquare time (microseconds):      pdf_mean=8.05,      pdf_median=8.00,      pdf_min=7.00,      pdf_max=24.00,       pdf_stddev=2.41,       pdf_avgdev=1.09
MR    0    13:06:21.098    TestStatBenchmark (EURUSD,H1)    Noncentral ChiSquare time (microseconds):      cdf_mean=45.61,      cdf_median=42.00,      cdf_min=41.00,      cdf_max=97.00,       cdf_stddev=8.25,       cdf_avgdev=5.70
FN    0    13:06:21.098    TestStatBenchmark (EURUSD,H1)    Noncentral ChiSquare time (microseconds): quantile_mean=220.66, quantile_median=211.50, quantile_min=196.00, quantile_max=362.00,  quantile_stddev=24.71,  quantile_avgdev=19.45
LI    0    13:06:21.099    TestStatBenchmark (EURUSD,H1)    Noncentral ChiSquare time (microseconds):   random_mean=744.45,   random_median=728.00,   random_min=672.00,   random_max=1082.00,    random_stddev=62.42,    random_avgdev=43.24
RE    0    13:06:23.194    TestStatBenchmark (EURUSD,H1)    Noncentral F time (microseconds):      pdf_mean=19.10,      pdf_median=18.00,      pdf_min=16.00,      pdf_max=50.00,       pdf_stddev=4.67,       pdf_avgdev=2.64
FS    0    13:06:23.194    TestStatBenchmark (EURUSD,H1)    Noncentral F time (microseconds):      cdf_mean=14.67,      cdf_median=13.00,      cdf_min=12.00,      cdf_max=39.00,       cdf_stddev=3.94,       cdf_avgdev=2.44
EN    0    13:06:23.194    TestStatBenchmark (EURUSD,H1)    Noncentral F time (microseconds): quantile_mean=212.21, quantile_median=203.00, quantile_min=189.00, quantile_max=347.00,  quantile_stddev=24.37,  quantile_avgdev=19.30
EF    0    13:06:23.194    TestStatBenchmark (EURUSD,H1)    Noncentral F time (microseconds):   random_mean=1848.90,   random_median=1819.00,   random_min=1704.00,   random_max=2556.00,    random_stddev=118.75,    random_avgdev=78.66
EN    0    13:06:26.061    TestStatBenchmark (EURUSD,H1)    Noncentral Beta time (microseconds):      pdf_mean=16.30,      pdf_median=15.00,      pdf_min=14.00,      pdf_max=43.00,       pdf_stddev=4.32,       pdf_avgdev=2.43
EP    0    13:06:26.061    TestStatBenchmark (EURUSD,H1)    Noncentral Beta time (microseconds):      cdf_mean=10.48,      cdf_median=10.00,      cdf_min=8.00,      cdf_max=32.00,       cdf_stddev=3.02,       cdf_avgdev=1.72
ME    0    13:06:26.061    TestStatBenchmark (EURUSD,H1)    Noncentral Beta time (microseconds): quantile_mean=153.66, quantile_median=141.00, quantile_min=135.00, quantile_max=283.00,  quantile_stddev=20.83,  quantile_avgdev=16.16
QJ    0    13:06:26.061    TestStatBenchmark (EURUSD,H1)    Noncentral Beta time (microseconds):   random_mean=2686.82,   random_median=2649.00,   random_min=2457.00,   random_max=3753.00,    random_stddev=150.32,    random_avgdev=98.23
OO    0    13:06:27.225    TestStatBenchmark (EURUSD,H1)    Negative Binomial time (microseconds):      pdf_mean=6.13,      pdf_median=6.00,      pdf_min=5.00,      pdf_max=24.00,       pdf_stddev=2.38,       pdf_avgdev=1.22
DG    0    13:06:27.225    TestStatBenchmark (EURUSD,H1)    Negative Binomial time (microseconds):      cdf_mean=12.21,      cdf_median=11.00,      cdf_min=11.00,      cdf_max=33.00,       cdf_stddev=3.07,       cdf_avgdev=1.58
LJ    0    13:06:27.225    TestStatBenchmark (EURUSD,H1)    Negative Binomial time (microseconds): quantile_mean=14.05, quantile_median=13.00, quantile_min=12.00, quantile_max=82.00,  quantile_stddev=4.81,  quantile_avgdev=2.28
EM    0    13:06:27.225    TestStatBenchmark (EURUSD,H1)    Negative Binomial time (microseconds):   random_mean=1130.39,   random_median=1108.00,   random_min=1039.00,   random_max=1454.00,    random_stddev=69.41,    random_avgdev=51.70
GP    0    13:06:27.521    TestStatBenchmark (EURUSD,H1)    Normal time (microseconds):      pdf_mean=1.15,      pdf_median=1.00,      pdf_min=0.00,      pdf_max=19.00,       pdf_stddev=1.34,       pdf_avgdev=0.45
OI    0    13:06:27.521    TestStatBenchmark (EURUSD,H1)    Normal time (microseconds):      cdf_mean=0.81,      cdf_median=1.00,      cdf_min=0.00,      cdf_max=17.00,       cdf_stddev=1.16,       cdf_avgdev=0.49
CN    0    13:06:27.521    TestStatBenchmark (EURUSD,H1)    Normal time (microseconds): quantile_mean=0.70, quantile_median=1.00, quantile_min=0.00, quantile_max=13.00,  quantile_stddev=0.82,  quantile_avgdev=0.49
EG    0    13:06:27.521    TestStatBenchmark (EURUSD,H1)    Normal time (microseconds):   random_mean=293.70,   random_median=281.00,   random_min=256.00,   random_max=537.00,    random_stddev=43.28,    random_avgdev=31.62
FD    0    13:06:28.010    TestStatBenchmark (EURUSD,H1)    Lognormal time (microseconds):      pdf_mean=1.99,      pdf_median=2.00,      pdf_min=1.00,      pdf_max=18.00,       pdf_stddev=1.48,       pdf_avgdev=0.48
PN    0    13:06:28.010    TestStatBenchmark (EURUSD,H1)    Lognormal time (microseconds):      cdf_mean=3.19,      cdf_median=3.00,      cdf_min=2.00,      cdf_max=17.00,       cdf_stddev=1.61,       cdf_avgdev=0.64
DH    0    13:06:28.010    TestStatBenchmark (EURUSD,H1)    Lognormal time (microseconds): quantile_mean=3.18, quantile_median=3.00, quantile_min=2.00, quantile_max=19.00,  quantile_stddev=1.77,  quantile_avgdev=0.64
NR    0    13:06:28.010    TestStatBenchmark (EURUSD,H1)    Lognormal time (microseconds):   random_mean=479.75,   random_median=468.00,   random_min=428.00,   random_max=754.00,    random_stddev=48.26,    random_avgdev=34.30
FL    0    13:06:29.022    TestStatBenchmark (EURUSD,H1)    T time (microseconds):      pdf_mean=2.32,      pdf_median=2.00,      pdf_min=1.00,      pdf_max=15.00,       pdf_stddev=1.29,       pdf_avgdev=0.54
QE    0    13:06:29.022    TestStatBenchmark (EURUSD,H1)    T time (microseconds):      cdf_mean=8.01,      cdf_median=7.00,      cdf_min=6.00,      cdf_max=39.00,       cdf_stddev=3.13,       cdf_avgdev=1.73
MM    0    13:06:29.022    TestStatBenchmark (EURUSD,H1)    T time (microseconds): quantile_mean=50.23, quantile_median=45.00, quantile_min=44.00, quantile_max=113.00,  quantile_stddev=10.28,  quantile_avgdev=7.73
KG    0    13:06:29.022    TestStatBenchmark (EURUSD,H1)    T time (microseconds):   random_mean=951.58,   random_median=931.00,   random_min=859.00,   random_max=1439.00,    random_stddev=78.14,    random_avgdev=49.72
CQ    0    13:06:31.979    TestStatBenchmark (EURUSD,H1)    Noncentral T time (microseconds):      pdf_mean=38.47,      pdf_median=35.00,      pdf_min=32.00,      pdf_max=164.00,       pdf_stddev=9.66,       pdf_avgdev=6.38
OO    0    13:06:31.979    TestStatBenchmark (EURUSD,H1)    Noncentral T time (microseconds):      cdf_mean=27.75,      cdf_median=25.00,      cdf_min=24.00,      cdf_max=80.00,       cdf_stddev=7.02,       cdf_avgdev=4.63
PF    0    13:06:31.979    TestStatBenchmark (EURUSD,H1)    Noncentral T time (microseconds): quantile_mean=1339.51, quantile_median=1306.00, quantile_min=1206.00, quantile_max=2262.00,  quantile_stddev=128.18,  quantile_avgdev=74.83
OR    0    13:06:31.979    TestStatBenchmark (EURUSD,H1)    Noncentral T time (microseconds):   random_mean=1550.27,   random_median=1520.00,   random_min=1418.00,   random_max=2317.00,    random_stddev=112.08,    random_avgdev=73.74
LQ    0    13:06:31.979    TestStatBenchmark (EURUSD,H1)   
GH    0    13:06:31.979    TestStatBenchmark (EURUSD,H1)    21 of 21 passed

Traduzido do russo pela MetaQuotes Software Corp.
Artigo original: https://www.mql5.com/ru/articles/2742

Interfaces Gráficas IX: O Controle Seletor de Cores (Capítulo 1) Interfaces Gráficas IX: O Controle Seletor de Cores (Capítulo 1)

Com este artigo, nós começamos o capítulo nove da série de artigos dedicados à criação das interfaces gráficas nos terminais de negociação MetaTrader. Ele consiste de dois capítulos onde são apresentados os novos elementos do controle da interface, tais como o seletor de cores, o botão do seletor de cores, a barra de progresso e o gráfico de linha.

Interfaces Gráficas VIII: O Controle Navegador de Arquivos (Capítulo 3) Interfaces Gráficas VIII: O Controle Navegador de Arquivos (Capítulo 3)

Nos capítulos anteriores da oitava parte da série, nossa biblioteca foi reforçada por várias classes para o desenvolvimento de ponteiros para o cursor do mouse, calendários e as listas hierárquicas. O presente artigo lida com o controle navegador de arquivos que também pode ser utilizado como parte de uma interface gráfica na aplicação MQL.

Sistema de negociação 'Turtle Soup' e sua modificação 'Turtle Soup Plus One' Sistema de negociação 'Turtle Soup' e sua modificação 'Turtle Soup Plus One'

No artigo regras de estratégias de negociação formalizadas e programadas Turtle Soup e Turtle Soup Plus One a partir do livro de Linda Raschke e Laurence Connors Street Smarts: High Probability Short-Term Trading Strategies. As estratégias descritas no livro receberam uma ampla acolhida, no entanto é importante entender que os autores conceberam suas ideias com base no comportamento do mercado de há 15-20 anos.

Interfaces Gráficas IX: Os Controles Barra de Progresso e Gráfico de Linha (Capítulo 2) Interfaces Gráficas IX: Os Controles Barra de Progresso e Gráfico de Linha (Capítulo 2)

O segundo capítulo da parte nove é dedicado aos controles barra de progresso e gráfico de linha. Como sempre, teremos exemplos detalhados para revelar como esses controles podem ser utilizados nas aplicações MQL personalizadas.