Exemplo n.º 1
0
// return the culmulative function of standard normal distribution; 
//=========distribution of standard normal distribution
// return the probability of P(N(0,1)<x);
double pnormal( double x )
{
	if(x>=0)
		return 0.5+0.5*gammp(0.5,x*x/2.0);
	else 
		return 0.5-0.5*gammp(0.5,x*x/2.0);
}
Exemplo n.º 2
0
// **************************************************************
fdouble erff(fdouble x)
/**
 * Returns the error function erf(x).
 * See "Numerical Recipes in C", 2nd edition, page 220
 */
{
    return x < 0.0 ? -gammp(0.5,x*x) : gammp(0.5,x*x);
}
Exemplo n.º 3
0
double* JarqueBera(double* e, long n, long k)
{

	double sigma2 = norm(e,n);
	if (n <=30) 
       sigma2 = sigma2 / (n-1); //        # unbiased estimator of population sig sq.
  else
       sigma2 = sigma2 / n; // # mean square of sample residuals

  double* m2e = vproduct(e,e,n);

  double skewness = product(m2e,e,n) / n / pow(sigma2,1.5);
  skewness *= skewness;
  double kurtosis = product(m2e,m2e,n) /n / geoda_sqr(sigma2);

  double jb = n * (skewness/6.0 + (geoda_sqr(kurtosis-3.0) / 24.0));

	double* rslt = new double [3];
	rslt[0] = jb;
	rslt[1] = 2.0;
	rslt[2] = gammp( 1.0, jb/2.0 );
// rslt[2] = chicdf(jb,2.0);
/*
	rslt[3] = skewness;
	rslt[4] = 1.0;
	rslt[5] = chicdf(skewness,1);
	rslt[6] = kurtosis;
	rslt[7] = 1.0;
	rslt[8] = chicdf(kurtosis,1);
*/
	return rslt;
//local JB = (r(N)/6)*((r(skewness)^2)+[(1/4)*(r(kurtosis)-3)^2])

}
Exemplo n.º 4
0
float erffc(float x)
{
	float gammp(float a, float x);
	float gammq(float a, float x);

	return x < 0.0 ? 1.0+gammp(0.5,x*x) : gammq(0.5,x*x);
}
Exemplo n.º 5
0
double pchisq( double x, int df )
{

	// df = degrees of freedom
	// x = chi square value
	return( gammp( df/2.0, x/2.0 ) );
//	return the culmulative function of chi-square distribuition
//  with df freedom;
}
Exemplo n.º 6
0
double gauss (double z)
{   double res,a=0.5;
	double x=z*z/2;
	gammp(&a,&x,&res);
	res/=gamm(0.5)*2;
	if (z<0)
		return 0.5-res;
	else
		return 0.5+res;
}
Exemplo n.º 7
0
//Returns the complementary error function erfc(x).
double erffc(double x)
{
    double retval;
   
    if ( x < 0.0 ) {
	retval = gammp(0.5,x*x);
	return 1+ retval;
    } else {
	gammq(0.5,x*x, & retval);
	return retval;
    }
}
Exemplo n.º 8
0
double getchi2(double dof, double alpha)
{
    double  tol = 1.0E-3;
    double  ac, lm, rm, eps, chi2, za, x;
    int     i, itmax = 100;
    
    if (dof > 30.0) {
        /* approximate a value if degrees of freedom are > 30 based on eqn 1. Sachs, 1984 */
        za   = -getz(alpha);        /* NB: Eq. requires change of sign for percentile */
         x    = 2.0 / 9.0 / dof;
         chi2 = pow((dof * (1.0 - x + za * sqrt(x))), 3.0);
      } else{
         
        lm   = 0.0;
         rm   = 1000.0;
         if (alpha > 0.5)
               eps = (1.0 - alpha) * tol;
         else
            eps = alpha * tol;
     
        for (i = 1; i <= itmax; i++) {
               chi2 = 0.5 * (lm + rm);
            ac   = 1.0 - gammp(0.5 * dof, 0.5 * chi2);
            
               if (fabs(ac - alpha) <= eps) 
                return (chi2);    
       
               if (ac > alpha){
                  lm = chi2;
               }else {
                  rm = chi2;
            }    
       }
     }
    return (chi2);
}
Exemplo n.º 9
0
float erff(float x) {
  return x < 0.0 ? -gammp(0.5,x*x) : gammp(0.5,x*x);
}
Exemplo n.º 10
0
DP NR::erffc(const DP x)
{
	return x < 0.0 ? 1.0+gammp(0.5,x*x) : gammq(0.5,x*x);
}
Exemplo n.º 11
0
double *BP_Test(double *resid, int obs, double** X, int nvar, bool InclConst)
{
	DenseVector e(resid, obs, false), g(obs), sqvar(obs);
	DenseVector *x = new DenseVector [nvar];
	int i = 0, j = 0;
 	double ns = 0;

	// Assign x = X * X

	x[0].alloc(obs);
	for (j = 0; j < obs; j++) {
		x[0].setAt(j, 1.0);
	}
	for (i = 1; i < nvar; i++) {
		if (InclConst) {
			x[i].absorb(X[i], obs);
		} else {
			x[i].absorb(X[i - 1], obs);
		}
		ns = x[i].norm();
		for (j = 0; j < obs; j++) {
			x[i].setAt(j, geoda_sqr(x[i].getValue(j) / sqrt(ns)));
		}
	}

	double **cov = new double * [nvar];
	for (i = 0; i < nvar; i++)
		alloc(cov[i], nvar);

	// use SVD to compute inverse(Z'Z)
	// use dgesvd_

	char jobu = 'S', jobvt = 'S';
	long int m = obs, n = nvar;
	long int lda = obs, ldu = obs, ldvt = nvar, lwork = 5 * obs, info = 0;
	double *a = new double [obs * nvar];
	double *s = new double [nvar];
	double *u = new double [ldu * nvar];
	double *vt = new double [ldvt * nvar];
	double *work = new double [lwork];
	for (i = 0; i < obs; i++) {
		for (j = 0; j < nvar; j++) {
			a[i + obs * j] = x[j].getValue(i);
		}
	}

// use __WXMAC__ to call vecLib
//#ifdef WORDS_BIGENDIAN
#ifdef __WXMAC__MMM
	dgesvd_(&jobu, &jobvt, &m, &n, a, &lda, s, u, &ldu, vt, &ldvt, work, &lwork, &info);
#else
	dgesvd_(&jobu, &jobvt, (integer*)&m, (integer*)&n, (doublereal*)a, (integer*)&lda, (doublereal*)s, (doublereal*)u, (integer*)&ldu, (doublereal*)vt, (integer*)&ldvt, (doublereal*)work, (integer*)&lwork, (integer*)&info);
#endif

	if (!info) {
		// (z'z)^(-1) = VW^(-2)V'
		for (i = 0; i < nvar; i++) {
			for (j = 0; j < nvar; j++) {
				for (m = 0; m < nvar; m++) {
					cov[i][j] += (vt[i * nvar + m] * vt[m + j * nvar]) / (s[m] * s[m]);
				}
			}
		}
	} else {
		// do nothing
	}

	double mse = e.norm() / obs;

	// compute gi

	for (j = 0; j < obs; j++) {
		double e2 = geoda_sqr(e.getValue(j));
		g.setAt(j, e2 - mse);
		sqvar.setAt(j, geoda_sqr(e2 - mse));
	}
	double mean = sqvar.sum() / obs;

	DenseVector gz(nvar), gzizz(nvar);

	for (i = 0; i < nvar; i++)
		gz.setAt(i, g.product(x[i])); // gz = g'z (1 x expl)

	gz.squareTimesColumn(gzizz, cov); // gzizz = g'z * inv(cov)
	double bp = gz.product(gzizz); // bp = g'z[(z'z)^-1]z'g

	double *rslt = new double [6];
	rslt[0] = 1. / (2 * geoda_sqr(mse)) * bp; // Breusch-Pagan
	rslt[1] = InclConst ? nvar - 1 : nvar;
 	rslt[2] = gammp(rslt[1] / 2.0, rslt[0] / 2.0);
	rslt[3] = (1.0 / mean) * bp; // Koenker-Basset
	rslt[4] = rslt[1];
 	rslt[5] = gammp(rslt[1] / 2.0, rslt[3] / 2.0);

	release(&x);
	release(&cov);

	return rslt;
}
Exemplo n.º 12
0
double* WhiteTest(int obs, int nvar, double* resid, double** X, bool InclConstant)
{
	double *r2 = new double[obs];
	int i = 0, jj = 0;
//	if (!InclConstant)
//		DevFromMean(obs,resid);

	// (1) r2 = Compute e2
	double r2_bar = 0;
	for (i=0;i<obs;i++)
	{
		r2[i] = geoda_sqr(resid[i]);
		r2_bar += r2[i];
	}
	r2_bar /= obs;
	
	
	// (2) define (n*n + 3n)/2 memory location for w
	const int df = InclConstant? (geoda_sqr(nvar-1)+3*(nvar-1))/2 : (geoda_sqr(nvar)+3*nvar)/2;
	DoublePtr *w  = new DoublePtr[df+1];

	for (i=0;i<=df;i++)
		w[i] = new double[obs];


	// (3) keep original X into w[1 .. nvar][]
	int ix = InclConstant? 0 : 1;
	int k = nvar+ix;

	for (jj=0;jj<obs;jj++)
		w[0][jj] = 1.0;

	if (InclConstant)
	{
		for (i=1;i<nvar;i++)
		{

				for (jj=0;jj<obs;jj++)
					w[i][jj] = X[i][jj];
		}
	}
	else
	{
		for (i=0;i<nvar;i++)
				for (jj=0;jj<obs;jj++)
					w[i+1][jj] = X[i][jj];
	}

	// (4) Create cross product of Xs and store them into w[nvar ... df][]
	for (i=1-ix;i<nvar;i++)
	{
		for (int j=i; j<nvar;j++)
		{
			for (jj=0;jj<obs;jj++)
				w[k][jj] = X[i][jj] * X[j][jj];
			k++;
		}
	}

	// (5) Compute OLS, r2 on w
	DenseVector		yw(r2, obs, false), olsw(k);
  DenseVector *xw = new DenseVector[k];

  for (int cnt = 0; cnt < k; ++cnt)  
	{

     xw[cnt].absorb(w[cnt], obs, false);
	}


  double ** cov = new double * [k];
  double *u = new double[obs];
	for (i = 0; i < k; i++) {
		cov[i] = new double [k];
		for (jj = 0; jj < k; jj++) {
			cov[i][jj] = 0;
		}
	}
	double *rsl = new double[3];
	rsl[0] = df;
	rsl[1] = -99999;
	rsl[2] = -99999;
  if (!ordinaryLS(yw, xw, cov, u, olsw))
	{
		return rsl;
	}

	double s_u = 0.0;
	for (i=0;i<obs;i++)
		s_u += geoda_sqr(r2[i] - r2_bar);

	rsl[1]= obs * ( 1 - (norm(u,obs) / s_u));
//	rsl[1]= chicdf(rsl[0],df);
	rsl[2]= gammp( double (df) / 2.0, rsl[1]/2.0 );

	
	return rsl;

}
Exemplo n.º 13
0
double gamm_inc(const double a, const double x) {
	double gammap = gammp(a,x);
	double gln = gammln(a);
	return exp(gln) * gammap;
}
Exemplo n.º 14
0
double
vpRobust::erf(double x)
{
  return x < 0.0 ? -gammp(0.5,x*x) : gammp(0.5,x*x);
}
Exemplo n.º 15
0
double erffc(double x)
   {
   return x < 0.0 ? 1.0 + gammp(0.5, x*x) : gammq(0.5, x*x);
   }
 REAL_TYPE erff(REAL_TYPE x)
 {
     return x<0.0?1.0+gammp(0.5,x*x):gammq(0.5,x*x);
 }
Exemplo n.º 17
0
Arquivo: erff.c Projeto: gnovak/bin
float erff(float x)
{
	float gammp(float a, float x);

	return x < 0.0 ? -gammp(0.5,x*x) : gammp(0.5,x*x);
}
Exemplo n.º 18
0
Scalar erf(Scalar x)
{
//	Scalar gammp();

	return x < 0.0 ? -gammp(0.5,x*x) : gammp(0.5,x*x);
}
Exemplo n.º 19
0
Scalar erfc(Scalar x)
{
//	Scalar gammp(),gammq();

	return x < 0.0 ? 1.0+gammp(0.5,x*x) : gammq(0.5,x*x);
}
Exemplo n.º 20
0
// The error function
//
double erff(double x)
   {
   return x < 0.0 ? -gammp(0.5, x*x) : gammp(0.5, x*x);
   }
const MDOUBLE generalGammaDistribution::getCumulativeProb(const MDOUBLE x) const
{//	 
	//since r~gamma(alpha, beta) then beta*r~ gamma(alpha,1)=gammp
	//here we assume alpha=beta
	return gammp(_alpha, x*_beta);
}