Distribution Normale Cumulative Fonction en C/C++

Je me demandais si il y avait des fonctions statistiques intégrées dans des bibliothèques mathématiques qui font partie du standard C++ bibliothèques comme cmath. Si non, pouvez-vous les gars, vous me recommander un bon stats de la bibliothèque qui aurait une distribution normale cumulative de la fonction? Merci à l'avance.

Plus précisément, je cherche à utiliser/créer une fonction de distribution cumulée.

Si le CDF de la distribution normale est tout ce dont vous avez besoin, pourquoi ne pas simplement mettre en œuvre vous-même? Il ne contient pas de magie donc, la mise en œuvre est simple.

InformationsquelleAutor Tyler Brock | 2010-02-24

c c++distribution math statistics

35

Theres est pas directement fonction. Mais depuis la gaussienne de la fonction d'erreur et de sa fonction complémentaire est liée à la normale de la fonction de distribution cumulée (voir ici, ou ici), nous pouvons utiliser la mise en œuvre de la c-fonction erfc (fonction d'erreur complémentaire):
```
double normalCDF(double value)
{
   return 0.5 * erfc(-value * M_SQRT1_2);
}
```
Qui considère la relation de erfc(x) = 1-erf(x) avec M_SQRT1_2 = √0,5.

Je l'utilise pour les calculs statistiques et il fonctionne très bien. Pas besoin de l'aide de coefficients.
- Notez que erfc() est dans <cmath> cplusplus.com/reference/cmath
- C'est le code, il y a la normale standard CDF?
- Oui, le code est pour le niveau normal de la CDF, veuillez consulter mon ajoutée deuxième lien avec plus de détails.
InformationsquelleAutor JFS

Voici un stand-alone C++ mise en œuvre de la distribution normale cumulative dans les 14 lignes de code.

http://www.johndcook.com/cpp_phi.html

#include <cmath>
double phi(double x)
{
//constants
double a1 =  0.254829592;
double a2 = -0.284496736;
double a3 =  1.421413741;
double a4 = -1.453152027;
double a5 =  1.061405429;
double p  =  0.3275911;
//Save the sign of x
int sign = 1;
if (x < 0)
sign = -1;
x = fabs(x)/sqrt(2.0);
//A&S formula 7.1.26
double t = 1.0/(1.0 + p*x);
double y = 1.0 - (((((a5*t + a4)*t) + a3)*t + a2)*t + a1)*t*exp(-x*x);
return 0.5*(1.0 + sign*y);
}
void testPhi()
{
//Select a few input values
double x[] = 
{
-3, 
-1, 
0.0, 
0.5, 
2.1 
};
//Output computed by Mathematica
//y = Phi[x]
double y[] = 
{ 
0.00134989803163, 
0.158655253931, 
0.5, 
0.691462461274, 
0.982135579437 
};
int numTests = sizeof(x)/sizeof(double);
double maxError = 0.0;
for (int i = 0; i < numTests; ++i)
{
double error = fabs(y[i] - phi(x[i]));
if (error > maxError)
maxError = error;
}
std::cout << "Maximum error: " << maxError << "\n";
}

Merci de fournir ce ainsi.
Viens de tomber sur ce à partir d'une recherche sur google. Très utile John, je vous remercie.
Pouvez-vous s'il vous plaît mettre le code dans la réponse, au lieu d'un lien externe?
Notez que c'est une simple précision de l'approximation, mais il y a un double précision de la mise en œuvre ci-dessous en parlait ainsi un.k. stackoverflow.com/a/23119456/190452

InformationsquelleAutor John D. Cook

9

Boost est aussi bon que le standard 😀 ici, vous allez: boost des mathématiques/statistiques.
- Est-il un standard intégré dans?
- Non, la bibliothèque standard n'a pas encore de.
- distribution normale, je pense que oui. Ou parlez-vous intégré dans la bibliothèque standard -- dans ce dernier cas, non.
- Merci, oui, la raison pour laquelle je demande, c'est parce que je veux utiliser autant de trucs standard que possible. Je suppose qu'il n'y a aucun moyen de l'éviter dans ce cas.
- 3 raisons d'utiliser boost: 1) Vous pouvez copier les bibliothèques de votre choix à l'aide d'un utilitaire qui vient avec boost. 2) les bibliothèques ont tendance à être en-tête uniquement. 3) la plupart des bibliothèques fonctionnent très bien et de travailler partout avec un compilateur C++.
- Non... Le boost page de documentation ne s'arrêtera jamais.
InformationsquelleAutor Hassan Syed
9

J'ai compris comment faire à l'aide de gsl, à la suggestion des gens qui ont répondu avant moi, mais un non-bibliothèque de la solution (j'espère que cela aide beaucoup de gens là-bas qui sont à la recherche pour elle, comme je l'étais):
```
#ifndef Pi 
#define Pi 3.141592653589793238462643 
#endif 
double cnd_manual(double x)
{
double L, K, w ;
/* constants */
double const a1 = 0.31938153, a2 = -0.356563782, a3 = 1.781477937;
double const a4 = -1.821255978, a5 = 1.330274429;
L = fabs(x);
K = 1.0 / (1.0 + 0.2316419 * L);
w = 1.0 - 1.0 / sqrt(2 * Pi) * exp(-L *L / 2) * (a1 * K + a2 * K *K + a3 * pow(K,3) + a4 * pow(K,4) + a5 * pow(K,5));
if (x < 0 ){
w= 1.0 - w;
}
return w;
}
```
- ouch... ne pas utiliser pow, utilisez la règle de Horner. Je downvote jusqu'à ce que ce problème est corrigé (merci de m'en informer).
- J'allais pour des raisons de lisibilité, demande refusée.
- ce code va perdre de la précision. Horner, la règle est plus stable (et aussi plus rapide).
- pourquoi ne pas simplement utiliser double pK3 = K*K*K et ainsi de suite?
- (Autant que je sache), Mais pow est définie comme une macro, je pense que pour permettre des implémentations pour optimiser commun de compétences, telles que 2 et 3. Afin de ne pas abandonner sur pow trop tôt!
- Merci pour le code! Je suppose que c'est un développement de Taylor de la Distribution Normale et l'intégration du polynôme obtenu. De toute façon, j'ai testé le code à l'encontre de bibliothèques Boost dans la gamme z de -3.8 à +3.8 avec un incrément de 0,01 et de la somme des différences absolues abs(boost-cnd_manul) est de l'ordre de 10^-6.
InformationsquelleAutor Tyler Brock
8

La mise en œuvre de la normale CDF donnés ici sont simple précision approximations qui ont eu float remplacé par double et donc ne sont précis à 7 ou 8 significative (décimal) chiffres.

Pour une VB de la mise en œuvre de Hart double précision rapprochement, voir la figure 2 de l'Occident Mieux des approximations cumul des fonctions normales.

Modifier: Ma traduction de l'Ouest de l'implémentation en C++:
```
double
phi(double x)
{
static const double RT2PI = sqrt(4.0*acos(0.0));
static const double SPLIT = 7.07106781186547;
static const double N0 = 220.206867912376;
static const double N1 = 221.213596169931;
static const double N2 = 112.079291497871;
static const double N3 = 33.912866078383;
static const double N4 = 6.37396220353165;
static const double N5 = 0.700383064443688;
static const double N6 = 3.52624965998911e-02;
static const double M0 = 440.413735824752;
static const double M1 = 793.826512519948;
static const double M2 = 637.333633378831;
static const double M3 = 296.564248779674;
static const double M4 = 86.7807322029461;
static const double M5 = 16.064177579207;
static const double M6 = 1.75566716318264;
static const double M7 = 8.83883476483184e-02;
const double z = fabs(x);
double c = 0.0;
if(z<=37.0)
{
const double e = exp(-z*z/2.0);
if(z<SPLIT)
{
const double n = (((((N6*z + N5)*z + N4)*z + N3)*z + N2)*z + N1)*z + N0;
const double d = ((((((M7*z + M6)*z + M5)*z + M4)*z + M3)*z + M2)*z + M1)*z + M0;
c = e*n/d;
}
else
{
const double f = z + 1.0/(z + 2.0/(z + 3.0/(z + 4.0/(z + 13.0/20.0))));
c = e/(RT2PI*f);
}
}
return x<=0.0 ? c : 1-c;
}
```
Remarque que j'ai réarrangé les expressions dans le sous des formes plus familières en série et en fraction continue des approximations. Le dernier numéro magique dans l'Ouest du code est la racine carrée de 2π, que j'ai reporté pour le compilateur sur la première ligne par l'exploitation de l'identité acos(0) = ½ π.

J'ai triple vérifié les numéros de magie, mais il ya toujours la chance que j'ai fait une faute de frappe quelque chose. Si vous repérez une faute de frappe, s'il vous plaît commentaire!

Les résultats pour les données de test John Cook utilisé dans sa réponse sont
```
 x               phi                Mathematica
-3     1.3498980316301150e-003    0.00134989803163
-1     1.5865525393145702e-001    0.158655253931
0     5.0000000000000000e-001    0.5
0.5    6.9146246127401301e-001    0.691462461274
2.1    9.8213557943718344e-001    0.982135579437
```
Je prends quelques petites réconfort dans le fait qu'ils sont d'accord pour que tous les chiffres donnés pour les Mathematica résultats.
- Comment cela se compare à erfc ?
- Ceci dépend de la précision des garanties de erfc. Il va certainement être un léger arrondi du produit de l'argument et de la racine carrée de la moitié.qui peut se propager jusqu'à la valeur finale. Hart algorithme est revendiquée pour être précis, double precision pour les tous argument, bien que je n'ai pas indépendamment vérifié que. En tout cas, les deux seront beaucoup, bien de mieux que de simple précision des approximations dans lequel le flotteur est remplacé par du simple au double!
- Est-il un moyen facile de modifier ce code pour tenir compte de degrés de liberté? Comme Scipy est t-test?
- Je doute fort qu'il existe un moyen simple de transformer la série et de la fraction continue approximations de la normale CDF dans celui de la distribution t, j'ai peur.
- Merci!!!! Je suppose que mon espoir pour rapidement le rapprochement ~1E6 p-valeurs, avec la même taille N était tout simplement imprudent.
InformationsquelleAutor thus spake a.k.

De NVIDIA CUDA échantillons:

static double CND(double d)
{
const double       A1 = 0.31938153;
const double       A2 = -0.356563782;
const double       A3 = 1.781477937;
const double       A4 = -1.821255978;
const double       A5 = 1.330274429;
const double RSQRT2PI = 0.39894228040143267793994605993438;
double
K = 1.0 / (1.0 + 0.2316419 * fabs(d));
double
cnd = RSQRT2PI * exp(- 0.5 * d * d) *
(K * (A1 + K * (A2 + K * (A3 + K * (A4 + K * A5)))));
if (d > 0)
cnd = 1.0 - cnd;
return cnd;
}

Est-il un moyen facile de modifier ce code pour tenir compte de degrés de liberté? Comme Scipy est t-test?

InformationsquelleAutor serbaut

0

De https://en.cppreference.com/w/cpp/numeric/math/erfc

Normal CDF peut être calculée comme ci-dessous:
```
#include <iostream>
#include <cmath>
#include <iomanip>
using namespace std;
double normalCDF(double x) //Phi(-∞, x) aka N(x)
{
return erfc(-x / sqrt(2))/2;
}
```
Une note de côté, de mon expérience, si vous avez un problème avec obtenir uniquement des entiers au lieu de décimales, en utilisant 2.0 au lieu de 2 dans le dénominateur pour chaque formule de l'aide.

Espère que ça aide.

InformationsquelleAutor Manohar Reddy Poreddy

Vous devez vous connecter pour publier un commentaire.