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
   
   
   • 1.1. MathMean()
   • 1.2. MathVariance()
   • 1.3. MathSkewness()
   • 1.4. MathKurtosis()
   • 1.5. MathMoments()
   • 1.6. MathMedian()
   • 1.7. MathStandardDeviation()
   • 1.8. MathAverageDeviation()


2. Funções para trabalhar com distribuições estatísticas
   
   2.1. Distribuição normal
   
   • 2.1.1. MathProbabilityDensityNormal()
   • 2.1.2. MathCumulativeDistributionNormal()
   • 2.1.3. MathQuantileNormal()
   • 2.1.4. MathRandomNormal()
   • 2.1.5. MathMomentsNormal()
   
   2.2. Distribuição do Log-normal
   
   • 2.2.1. MathProbabilityDensityLognormal()
   • 2.2.2. MathCumulativeDistributionLognormal()
   • 2.2.3. MathQuantileLognormal()
   • 2.2.4. MathRandomLognormal()
   • 2.2.5. MathMomentsLognormal()
   
   2.3. Distribuição beta
   
   • 2.3.1. MathProbabilityDensityBeta()
   • 2.3.2. MathCumulativeDistributionBeta()
   • 2.3.3. MathQuantileBeta()
   • 2.3.4. MathRandomBeta()
   • 2.3.5. MathMomentsBeta()
   
   2.4. Distribuição beta não-central
   
   • 2.4.1. MathProbabilityDensityNoncentralBeta()
   • 2.4.2. MathCumulativeDistributionNoncentralBeta()
   • 2.4.3. MathQuantileNoncentralBeta()
   • 2.4.4. MathRandomNoncentralBeta()
   • 2.4.5. MathMomentsNoncentralBeta()
   
   2.5. Distribuição Gama
   
   • 2.5.1. MathProbabilityDensityGamma()
   • 2.5.2. MathCumulativeDistributionGamma()
   • 2.5.3. MathQuantileGamma()
   • 2.5.4. MathRandomGamma()
   • 2.5.5. MathMomentsGamma()
   
   2.6. Distribuição Qui-quadrado
   
   • 2.6.1. MathProbabilityDensityChiSquare()
   • 2.6.2. MathCumulativeDistributionChiSquare()
   • 2.6.3. MathQuantileChiSquare()
   • 2.6.4. MathRandomChiSquare()
   • 2.6.5. MathMomentsChiSquare()
   
   2.7. Distribuição do qui-quadrado não-central
   
   • 2.7.1. MathProbabilityDensityNoncentralChiSquare()
   • 2.7.2. MathCumulativeDistributionNoncentralChiSquare()
   • 2.7.3. MathQuantileNoncentralChiSquare()
   • 2.7.4. MathRandomNoncentralChiSquare()
   • 2.7.5. MathMomentsNoncentralChiSquare()
   
   2.8. Distribuição exponencial
   
   • 2.8.1. MathProbabilityDensityExponential()
   • 2.8.2. MathCumulativeDistributionExponential()
   • 2.8.3. MathQuantileExponential()
   • 2.8.4. MathRandomExponential()
   • 2.8.5. MathMomentsExponential()
   
   2.9. Distribuição F
   
   • 2.9.1. MathProbabilityDensityF()
   • 2.9.2. MathCumulativeDistributionF()
   • 2.9.3. MathQuantileF()
   • 2.9.4. MathRandomF()
   • 2.9.5. MathMomentsF()
   
   2.10. Distribuição F não-central
   
   • 2.10.1. MathProbabilityDensityNoncentralF()
   • 2.10.2. MathCumulativeDistributionNoncentralF()
   • 2.10.3. MathQuantileNoncentralF()
   • 2.10.4. MathRandomNoncentralF()
   • 2.10.5. MathMomentsNoncentralF()
   
   2.11. Distribuição t
   
   • 2.11.1. MathProbabilityDensityT()
   • 2.11.2. MathCumulativeDistributionT()
   • 2.11.3. MathQuantileT()
   • 2.11.4. MathRandomT()
   • 2.11.5. MathMomentsT()
   
   2.12 Distribuição t não-central
   
   • 2.12.1. MathProbabilityDensityNoncentralT()
   • 2.12.2. MathCumulativeDistributionNoncentralT()
   • 2.12.3. MathQuantileNoncentralT()
   • 2.12.4. MathRandomNoncentralT()
   • 2.12.5. MathMomentsNoncentralT()
   
   2.13. Distribuição logística
   
   • 2.13.1. MathProbabilityDensityLogistic()
   • 2.13.2. MathCumulativeDistributionLogistic()
   • 2.13.3. MathQuantileLogistic()
   • 2.13.4. MathRandomLogistic()
   • 2.13.5. MathMomentsLogistic()
   
   2.14. Distribuição cauchy
   
   • 2.14.1. MathProbabilityDensityCauchy()
   • 2.14.2. MathCumulativeDistributionCauchy()
   • 2.14.3. MathQuantileCauchy()
   • 2.14.4. MathRandomCauchy()
   • 2.14.5. MathMomentsCauchy()
   
   2.15. Distribuição uniforme
   
   • 2.15.1. MathProbabilityDensityUniform()
   • 2.15.2. MathCumulativeDistributionUniform()
   • 2.15.3. MathQuantileUniform()
   • 2.15.4. MathRandomUniform()
   • 2.15.5. MathMomentsUniform()
   
   2.16. Distribuição Weibull
   
   • 2.16.1. MathProbabilityDensityWeibull()
   • 2.16.2. MathCumulativeDistributionWeibull()
   • 2.16.3. MathQuantileWeibull()
   • 2.16.4. MathRandomWeibull()
   • 2.16.5. MathMomentsWeibull()
   
   2.17. Distribuição binomial
   
   • 2.17.1. MathProbabilityDensityBinomial()
   • 2.17.2. MathCumulativeDistributionBinomial()
   • 2.17.3. MathQuantileBinomial()
   • 2.17.4. MathRandomBinomial()
   • 2.17.5. MathMomentsBinomial()
   
   2.18. Distribuição binomial negativa
   
   • 2.18.1. MathProbabilityDensityNegativeBinomial()
   • 2.18.2. MathCumulativeDistributionNegativeBinomial()
   • 2.18.3. MathQuantileNegativeBinomial()
   • 2.18.4. MathRandomNegativeBinomial()
   • 2.18.5. MathMomentsNegativeBinomial()
   
   2.19. Distribuição geométrica
   
   • 2.19.1. MathProbabilityDensityGeometric()
   • 2.19.2. MathCumulativeDistributionGeometric()
   • 2.19.3. MathQuantileGeometric()
   • 2.19.4. MathRandomGeometric()
   • 2.19.5. MathMomentsGeometric()
   
   2.20. Distribuição Hipergeometrica
   
   • 2.20.1. MathProbabilityDensityHypergeometric()
   • 2.20.2. MathCumulativeDistributionHypergeometric()
   • 2.20.3. MathQuantileHypergeometric()
   • 2.20.4. MathRandomHypergeometric()
   • 2.20.5. MathMomentsHypergeometric()
   
   2.21. Distribuição de Poisson
   
   • 2.21.1. MathProbabilityDensityPoisson()
   • 2.21.2. MathCumulativeDistributionPoisson()
   • 2.21.3. MathQuantilePoisson()
   • 2.21.4. MathRandomPoisson()
   • 2.21.5. MathMomentsPoisson()
   
   
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
);

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.

Nº	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.

Nº	Distribuição	Função de densidade	Funções no MQL5	Funções em R
1	Normal		MathProbabilityDensityNormal MathCumulativeDistributionNormal MathQuantileNormal MathRandomNormal	dnorm pnorm qnorm rnorm
2	Beta		MathProbabilityDensityBeta MathCumulativeDistributionBeta MathQuantileBeta MathRandomBeta	dbeta pbeta qbeta rbeta
3	Binomial		MathProbabilityDensityBinomial MathCumulativeDistributionBinomial MathQuantileBinomial MathRandomBinomial	dbinom pbinom qbinom rbinom
60	Cauchy		MathProbabilityDensityCauchy MathCumulativeDistributionCauchy MathQuantileCauchy MathRandomCauchy	dcauchy pcauchy qcauchy rcauchy
5	Qui-quadrado		MathProbabilityDensityChiSquare MathCumulativeDistributionChiSquare MathQuantileChiSquare MathRandomChiSquare	dchisq pchisq qchisq rchisq
6	Exponencial		MathProbabilityDensityExponential MathCumulativeDistributionExponential MathQuantileExponential MathRandomExponential	dexp pexp qexp rexp
7	Distribuição F		MathProbabilityDensityF MathCumulativeDistributionF MathQuantileF MathRandomF	df pf qf rf
8	Gamma		MathProbabilityDensityGamma MathCumulativeDistributionGamma MathQuantileGamma MathRandomGamma	dgamma pgamma qgamma rgamma
9	Geometrico		MathProbabilityDensityGeometric MathCumulativeDistributionGeometric MathQuantileGeometric MathRandomGeometric	dgeom pgeom qgeom rgeom
10	Hipergeometrico		MathProbabilityDensityHypergeometric MathCumulativeDistributionHypergeometric MathQuantileHypergeometric MathRandomHypergeometric	dhyper phyper qhyper rhyper
11	Logística		MathProbabilityDensityLogistic MathCumulativeDistributionLogistic MathQuantileLogistic MathRandomLogistic	dlogis plogis qlogis rlogis
12	Log-normal		MathProbabilityDensityLognormal MathCumulativeDistributionLognormal MathQuantileLognormal MathRandomLognormal	dlnorm plnorm qlnorm rlnorm
13	Binomial negativa		MathProbabilityDensityNegativeBinomial MathCumulativeDistributionNegativeBinomial MathQuantileNegativeBinomial MathRandomNegativeBinomial	dnbinom pnbinom qnbinom rnbinom
14	Beta não central		MathProbabilityDensityNoncentralBeta MathCumulativeDistributionNoncentralBeta MathQuantileNoncentralBeta MathRandomNoncentralBeta	dbeta pbeta qbeta rbeta
15	Qui-quadrado não central		MathProbabilityDensityNoncentralChiSquare MathCumulativeDistributionNoncentralChiSquare MathQuantileNoncentralChiSquare MathRandomNoncentralChiSquare	dchisq pchisq qchisq rchisq
16	Distribuição F não-central		MathProbabilityDensityNoncentralF() MathCumulativeDistributionNoncentralF() MathQuantileNoncentralF() MathRandomNoncentralF()	df pf qf rf
17	Distribuição t não-central		MathProbabilityDensityNoncentralT MathCumulativeDistributionNoncentralT MathQuantileNoncentralT MathRandomNoncentralT	dt pt qt rt
18	Poisson		MathProbabilityDensityPoisson MathCumulativeDistributionPoisson MathQuantilePoisson MathRandomPoisson	dpois ppois qpois rpois
19	Distribuição t		MathProbabilityDensityT MathCumulativeDistributionT MathQuantileT MathRandomT	dt pt qt rt
20	Uniforme		MathProbabilityDensityUniform MathCumulativeDistributionUniform MathQuantileUniform MathRandomUniform	dunif punif qunif runif
21	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. 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)

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.

Nº	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.85	11.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:

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:

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

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

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:

Resultado:

Result of the TestStatBenchmark.mq5 operation script: