Algorithms

What is a good approximation to the inverse of the 
cumulative normal distribution function? Mathematically we can 
write this as: Find X such that Q(X) = p for any 0 < p < 1. 
(Note: this computes an upper tail probability.) Again, it is 
not possible to write this as a closed form expression, so we 
resort to approximations. Because of the symmetry of the normal distribution, 
we need only consider 0 < p < 0.5. If you 
have p > 0.5, then apply the algorithm below to q = 1-p, 
and then negate the value for X obtained. (This approximation 
is also from Abramowitz and Stegun.) 

t = sqrt[ ln(1/p^2) ] 


           c_0 + c_1*t + c_2*t^2 
X = t - ------------------------------ 
         1 + d_1*t + d_2*t^2 + d_3*t^3 


c_0 = 2.515517 
c_1 = 0.802853 
c_2 = 0.010328 
d_1 = 1.432788 
d_2 = 0.189269 
d_3 = 0.001308 

See Abramowitz and Stegun; Press, et al.

73Zeppelin wrote:

You should Google a little harder instead of always asking here

sumit7034 wrote:

can u implement it??

sumit7034 wrote:

can u implement it??

cp9876 wrote:

yes

sumit7034 wrote:

plz implement it

sumit7034 wrote:

i want to make function

sumit7034 wrote:

can u implement it?

// returns the cumulative normal distribution function (CNDF)
// for a standard normal: N(0,1)
double CNDF(double x)
{
	int neg = (x < 0);
	if ( neg ) 
		x *= -1;

	double k(1/(1+0.2316419*x));
	double y=((((1.330274429*k-1.821255978)*k+1.781477937)*k-0.356563782)*k+0.319381530)*k;
	y = 1.0 - 0.398942280401*exp(-0.5*x*x)*y;
	
	return (1-neg)*y + neg*(1-y);
}

// another implementation of the CNDF
// for a standard normal: N(0,1)
double CumNorm(double x)
{
	// protect against overflow
	if (x > 6.0)
		return 1.0;
	if (x < -6.0)
		return 0.0;

	double b1 = 0.31938153;
	double b2 = -0.356563782;
	double b3 = 1.781477937;
	double b4 = -1.821255978;
	double b5 = 1.330274429;
	double p = 0.2316419;
	double c2 = 0.3989423;

	double a = fabs(x);
	double t = 1.0 / (1.0 + a * p);
	double b = c2*exp((-x)*(x/2.0));
	double n = ((((b5*t+b4)*t+b3)*t+b2)*t+b1)*t;
	n = 1.0-b*n;
	
	if ( x < 0.0 )
		n = 1.0 - n;
	
	return n;
}

// Calculate the least significant (non-zero) digits of large factorials.
// By Robert C. Cartaino
// Posted via http://www.codeproject.com
// 02-July-2008

using System;

class Program
{
    const ulong Target = 1000000;       // This is the number you are trying to find the factorial of.
    const ulong RoundOff = 10000000000; // This rounds off the answer so the intermediate results don't overflow.

    static void Main(string[] args)
    {
        ulong factorial = 1;

        // Iterate through all numbers up to 'Target', multiply by each to find the factorial of 'Target'.
        for (ulong n = 1; n <= Target; n++)
        {
            factorial *= n;

            // Remove the trailing zeros.
            while (factorial % 10 == 0)
            {
                factorial /= 10;
            }

            // We only need the right-most digits.
            factorial %= RoundOff;

            //Console.WriteLine("{0}! = {1}", n, factorial);
        }

        Console.WriteLine("{0}! (truncated) = {1}", Target, factorial);
    }
}