Cumulative Distribution Function In Javascript

April 22, 2024 Post a Comment

I am searching for a way to calculate the Cumulative distribution function in Javascript. Are there classes which have implemented this? Do you have an idea to get this to work? It

Solution 1:

I was able to write my own function with the help of Is there an easily available implementation of erf() for Python? and the knowledge from wikipedia.

The calculation is not 100% correct as it is just a approximation.

functionnormalcdf(mean, sigma, to) 
{
    var z = (to-mean)/Math.sqrt(2*sigma*sigma);
    var t = 1/(1+0.3275911*Math.abs(z));
    var a1 =  0.254829592;
    var a2 = -0.284496736;
    var a3 =  1.421413741;
    var a4 = -1.453152027;
    var a5 =  1.061405429;
    var erf = 1-(((((a5*t + a4)*t) + a3)*t + a2)*t + a1)*t*Math.exp(-z*z);
    var sign = 1;
    if(z < 0)
    {
        sign = -1;
    }
    return (1/2)*(1+sign*erf);
}

normalcdf(30, 25, 1.4241); //-> 0.000223264606750539//wolframalpha.com              0.000223221102572082

Solution 2:

The math.js library provides an erf function. Based on a definition found at Wolfram Alpha , the cdfNormalfunction can be implemented like this in Javascript:

const mathjs = require('mathjs')

functioncdfNormal (x, mean, standardDeviation) {
  return (1 - mathjs.erf((mean - x ) / (Math.sqrt(2) * standardDeviation))) / 2
}

In the node.js console:

> console.log(cdfNormal(5, 30, 25))
> 0.15865525393145707 // Equal to Wolfram Alpha's result at: https://sandbox.open.wolframcloud.com/app/objects/4935c1cb-c245-4d8d-9668-4d353ad714ec#sidebar=compute

Solution 3:

This formula will give the correct normal CDF unlike the currently accepted answer

functionncdf(x, mean, std) {
  var x = (x - mean) / std
  var t = 1 / (1 + .2315419 * Math.abs(x))
  var d =.3989423 * Math.exp( -x * x / 2)
  var prob = d * t * (.3193815 + t * ( -.3565638 + t * (1.781478 + t * (-1.821256 + t * 1.330274))))
  if( x > 0 ) prob = 1 - prob
  return prob
}

This answer comes from math.ucla.edu

Solution 4:

This is a brute force implementation, but accurate to more digits of precision. The approximation above is accurate within 10^-7. My implementation runs slower (700 nano-sec) but is accurate within 10^-14. normal(25,30,1.4241) === 0.00022322110257305683, vs wolfram's 0.000223221102572082.

It takes the power series of the standard normal pdf, i.e. the bell-curve, and then integrates the series.

I originally wrote this in C, so I concede some of the optimizations might seem silly in Javascript.

functionnormal(x, mu, sigma) {
    returnstdNormal((x-mu)/sigma);
}

functionstdNormal(z) {
    var j, k, kMax, m, values, total, subtotal, item, z2, z4, a, b;

    // Power series is not stable at these extreme tail scenariosif (z < -6) { return0; }
    if (z >  6) { return1; }

    m      = 1;        // m(k) == (2**k)/factorial(k)
    b      = z;        // b(k) == z ** (2*k + 1)
    z2     = z * z;    // cache of z squared
    z4     = z2 * z2;  // cache of z to the 4th
    values = [];

    // Compute the power series in groups of two terms.// This reduces floating point errors because the series// alternates between positive and negative.for (k=0; k<100; k+=2) {
        a = 2*k + 1;
        item = b / (a*m);
        item *= (1 - (a*z2)/((a+1)*(a+2)));
        values.push(item);
        m *= (4*(k+1)*(k+2));
        b *= z4;
    }

    // Add the smallest terms to the total first that// way we minimize the floating point errors.
    total = 0;
    for (k=49; k>=0; k--) {
        total += values[k];
    }

    // Multiply total by 1/sqrt(2*PI)// Then add 0.5 so that stdNormal(0) === 0.5return0.5 + 0.3989422804014327 * total;
}

Solution 5:

Due to some needs in the past, i put together an implementation of distribution function in javascript. my library is available at github. You can take a look at https://github.com/chen0040/js-stats

it provides javascript implementation of CDF and inverse CDF for Normal distribution, Student's T distribution, F distribution and Chi-Square Distribution

To use the js lib for obtaining CDF and inverse CDF:

jsstats = require('js-stats');

//====================NORMAL DISTRIBUTION====================//varmu=0.0; // meanvarsd=1.0; // standard deviationvarnormal_distribution=newjsstats.NormalDistribution(mu, sd);

varX=10.0; // point estimate value varp= normal_distribution.cumulativeProbability(X); // cumulative probabilityvarp=0.7; // cumulative probabilityvarX= normal_distribution.invCumulativeProbability(p); // point estimate value//====================T DISTRIBUTION====================//vardf=10; // degrees of freedom for t-distributionvart_distribution=newjsstats.TDistribution(df);

vart_df=10.0; // point estimate or test statisticvarp= t_distribution.cumulativeProbability(t_df); // cumulative probabilityvarp=0.7;
vart_df= t_distribution.invCumulativeProbability(p); // point estimate or test statistic//====================F DISTRIBUTION====================//vardf1=10; // degrees of freedom for f-distributionvardf2=20; // degrees of freedom for f-distributionvarf_distribution=newjsstats.FDistribution(df1, df2);

varF=10.0; // point estimate or test statisticvarp= f_distribution.cumulativeProbability(F); // cumulative probability//====================Chi Square DISTRIBUTION====================//vardf=10; // degrees of freedom for cs-distributionvarcs_distribution=newjsstats.ChiSquareDistribution(df);

varX=10.0; // point estimate or test statisticvarp= cs_distribution.cumulativeProbability(X); // cumulative probability

JavaScript Lib