Statistical.php

Go to the documentation of this file.

<?php
 
namespace PhpOffice\PhpSpreadsheet\Calculation;
 
use PhpOffice\PhpSpreadsheet\Calculation\Statistical\Averages;
use PhpOffice\PhpSpreadsheet\Calculation\Statistical\Conditional;
use PhpOffice\PhpSpreadsheet\Calculation\Statistical\Confidence;
use PhpOffice\PhpSpreadsheet\Calculation\Statistical\Counts;
use PhpOffice\PhpSpreadsheet\Calculation\Statistical\Maximum;
use PhpOffice\PhpSpreadsheet\Calculation\Statistical\Minimum;
use PhpOffice\PhpSpreadsheet\Calculation\Statistical\Permutations;
use PhpOffice\PhpSpreadsheet\Calculation\Statistical\StandardDeviations;
use PhpOffice\PhpSpreadsheet\Calculation\Statistical\Trends;
use PhpOffice\PhpSpreadsheet\Calculation\Statistical\Variances;
 
class Statistical
{
    const LOG_GAMMA_X_MAX_VALUE = 2.55e305;
    const EPS = 2.22e-16;
    const MAX_VALUE = 1.2e308;
    const SQRT2PI = 2.5066282746310005024157652848110452530069867406099;
 
    public static function AVEDEV(...$args)
    {
        return Averages::averageDeviations(...$args);
    }
 
    public static function AVERAGE(...$args)
    {
        return Averages::average(...$args);
    }
 
    public static function AVERAGEA(...$args)
    {
        return Averages::averageA(...$args);
    }
 
    public static function AVERAGEIF($range, $condition, $averageRange = [])
    {
        return Conditional::AVERAGEIF($range, $condition, $averageRange);
    }
 
    public static function BETADIST($value, $alpha, $beta, $rMin = 0, $rMax = 1)
    {
        return Statistical\Distributions\Beta::distribution($value, $alpha, $beta, $rMin, $rMax);
    }
 
    public static function BETAINV($probability, $alpha, $beta, $rMin = 0, $rMax = 1)
    {
        return Statistical\Distributions\Beta::inverse($probability, $alpha, $beta, $rMin, $rMax);
    }
 
    public static function BINOMDIST($value, $trials, $probability, $cumulative)
    {
        return Statistical\Distributions\Binomial::distribution($value, $trials, $probability, $cumulative);
    }
 
    public static function CHIDIST($value, $degrees)
    {
        return Statistical\Distributions\ChiSquared::distributionRightTail($value, $degrees);
    }
 
    public static function CHIINV($probability, $degrees)
    {
        return Statistical\Distributions\ChiSquared::inverseRightTail($probability, $degrees);
    }
 
    public static function CONFIDENCE($alpha, $stdDev, $size)
    {
        return Confidence::CONFIDENCE($alpha, $stdDev, $size);
    }
 
    public static function CORREL($yValues, $xValues = null)
    {
        return Trends::CORREL($xValues, $yValues);
    }
 
    public static function COUNT(...$args)
    {
        return Counts::COUNT(...$args);
    }
 
    public static function COUNTA(...$args)
    {
        return Counts::COUNTA(...$args);
    }
 
    public static function COUNTBLANK(...$args)
    {
        return Counts::COUNTBLANK(...$args);
    }
 
    public static function COUNTIF($range, $condition)
    {
        return Conditional::COUNTIF($range, $condition);
    }
 
    public static function COUNTIFS(...$args)
    {
        return Conditional::COUNTIFS(...$args);
    }
 
    public static function COVAR($yValues, $xValues)
    {
        return Trends::COVAR($yValues, $xValues);
    }
 
    public static function CRITBINOM($trials, $probability, $alpha)
    {
        return Statistical\Distributions\Binomial::inverse($trials, $probability, $alpha);
    }
 
    public static function DEVSQ(...$args)
    {
        return Statistical\Deviations::sumSquares(...$args);
    }
 
    public static function EXPONDIST($value, $lambda, $cumulative)
    {
        return Statistical\Distributions\Exponential::distribution($value, $lambda, $cumulative);
    }
 
    public static function FDIST2($value, $u, $v, $cumulative)
    {
        return Statistical\Distributions\F::distribution($value, $u, $v, $cumulative);
    }
 
    public static function FISHER($value)
    {
        return Statistical\Distributions\Fisher::distribution($value);
    }
 
    public static function FISHERINV($value)
    {
        return Statistical\Distributions\Fisher::inverse($value);
    }
 
    public static function FORECAST($xValue, $yValues, $xValues)
    {
        return Trends::FORECAST($xValue, $yValues, $xValues);
    }
 
    public static function GAMMAFunction($value)
    {
        return Statistical\Distributions\Gamma::gamma($value);
    }
 
    public static function GAMMADIST($value, $a, $b, $cumulative)
    {
        return Statistical\Distributions\Gamma::distribution($value, $a, $b, $cumulative);
    }
 
    public static function GAMMAINV($probability, $alpha, $beta)
    {
        return Statistical\Distributions\Gamma::inverse($probability, $alpha, $beta);
    }
 
    public static function GAMMALN($value)
    {
        return Statistical\Distributions\Gamma::ln($value);
    }
 
    public static function GAUSS($value)
    {
        return Statistical\Distributions\StandardNormal::gauss($value);
    }
 
    public static function GEOMEAN(...$args)
    {
        return Statistical\Averages\Mean::geometric(...$args);
    }
 
    public static function GROWTH($yValues, $xValues = [], $newValues = [], $const = true)
    {
        return Trends::GROWTH($yValues, $xValues, $newValues, $const);
    }
 
    public static function HARMEAN(...$args)
    {
        return Statistical\Averages\Mean::harmonic(...$args);
    }
 
    public static function HYPGEOMDIST($sampleSuccesses, $sampleNumber, $populationSuccesses, $populationNumber)
    {
        return Statistical\Distributions\HyperGeometric::distribution(
            $sampleSuccesses,
            $sampleNumber,
            $populationSuccesses,
            $populationNumber
        );
    }
 
    public static function INTERCEPT($yValues, $xValues)
    {
        return Trends::INTERCEPT($yValues, $xValues);
    }
 
    public static function KURT(...$args)
    {
        return Statistical\Deviations::kurtosis(...$args);
    }
 
    public static function LARGE(...$args)
    {
        return Statistical\Size::large(...$args);
    }
 
    public static function LINEST($yValues, $xValues = null, $const = true, $stats = false)
    {
        return Trends::LINEST($yValues, $xValues, $const, $stats);
    }
 
    public static function LOGEST($yValues, $xValues = null, $const = true, $stats = false)
    {
        return Trends::LOGEST($yValues, $xValues, $const, $stats);
    }
 
    public static function LOGINV($probability, $mean, $stdDev)
    {
        return Statistical\Distributions\LogNormal::inverse($probability, $mean, $stdDev);
    }
 
    public static function LOGNORMDIST($value, $mean, $stdDev)
    {
        return Statistical\Distributions\LogNormal::cumulative($value, $mean, $stdDev);
    }
 
    public static function LOGNORMDIST2($value, $mean, $stdDev, $cumulative = false)
    {
        return Statistical\Distributions\LogNormal::distribution($value, $mean, $stdDev, $cumulative);
    }
 
    public static function MAX(...$args)
    {
        return Maximum::max(...$args);
    }
 
    public static function MAXA(...$args)
    {
        return Maximum::maxA(...$args);
    }
 
    public static function MAXIFS(...$args)
    {
        return Conditional::MAXIFS(...$args);
    }
 
    public static function MEDIAN(...$args)
    {
        return Statistical\Averages::median(...$args);
    }
 
    public static function MIN(...$args)
    {
        return Minimum::min(...$args);
    }
 
    public static function MINA(...$args)
    {
        return Minimum::minA(...$args);
    }
 
    public static function MINIFS(...$args)
    {
        return Conditional::MINIFS(...$args);
    }
 
    public static function MODE(...$args)
    {
        return Statistical\Averages::mode(...$args);
    }
 
    public static function NEGBINOMDIST($failures, $successes, $probability)
    {
        return Statistical\Distributions\Binomial::negative($failures, $successes, $probability);
    }
 
    public static function NORMDIST($value, $mean, $stdDev, $cumulative)
    {
        return Statistical\Distributions\Normal::distribution($value, $mean, $stdDev, $cumulative);
    }
 
    public static function NORMINV($probability, $mean, $stdDev)
    {
        return Statistical\Distributions\Normal::inverse($probability, $mean, $stdDev);
    }
 
    public static function NORMSDIST($value)
    {
        return Statistical\Distributions\StandardNormal::cumulative($value);
    }
 
    public static function NORMSDIST2($value, $cumulative)
    {
        return Statistical\Distributions\StandardNormal::distribution($value, $cumulative);
    }
 
    public static function NORMSINV($value)
    {
        return Statistical\Distributions\StandardNormal::inverse($value);
    }
 
    public static function PERCENTILE(...$args)
    {
        return Statistical\Percentiles::PERCENTILE(...$args);
    }
 
    public static function PERCENTRANK($valueSet, $value, $significance = 3)
    {
        return Statistical\Percentiles::PERCENTRANK($valueSet, $value, $significance);
    }
 
    public static function PERMUT($numObjs, $numInSet)
    {
        return Permutations::PERMUT($numObjs, $numInSet);
    }
 
    public static function POISSON($value, $mean, $cumulative)
    {
        return Statistical\Distributions\Poisson::distribution($value, $mean, $cumulative);
    }
 
    public static function QUARTILE(...$args)
    {
        return Statistical\Percentiles::QUARTILE(...$args);
    }
 
    public static function RANK($value, $valueSet, $order = 0)
    {
        return Statistical\Percentiles::RANK($value, $valueSet, $order);
    }
 
    public static function RSQ($yValues, $xValues)
    {
        return Trends::RSQ($yValues, $xValues);
    }
 
    public static function SKEW(...$args)
    {
        return Statistical\Deviations::skew(...$args);
    }
 
    public static function SLOPE($yValues, $xValues)
    {
        return Trends::SLOPE($yValues, $xValues);
    }
 
    public static function SMALL(...$args)
    {
        return Statistical\Size::small(...$args);
    }
 
    public static function STANDARDIZE($value, $mean, $stdDev)
    {
        return Statistical\Standardize::execute($value, $mean, $stdDev);
    }
 
    public static function STDEV(...$args)
    {
        return StandardDeviations::STDEV(...$args);
    }
 
    public static function STDEVA(...$args)
    {
        return StandardDeviations::STDEVA(...$args);
    }
 
    public static function STDEVP(...$args)
    {
        return StandardDeviations::STDEVP(...$args);
    }
 
    public static function STDEVPA(...$args)
    {
        return StandardDeviations::STDEVPA(...$args);
    }
 
    public static function STEYX($yValues, $xValues)
    {
        return Trends::STEYX($yValues, $xValues);
    }
 
    public static function TDIST($value, $degrees, $tails)
    {
        return Statistical\Distributions\StudentT::distribution($value, $degrees, $tails);
    }
 
    public static function TINV($probability, $degrees)
    {
        return Statistical\Distributions\StudentT::inverse($probability, $degrees);
    }
 
    public static function TREND($yValues, $xValues = [], $newValues = [], $const = true)
    {
        return Trends::TREND($yValues, $xValues, $newValues, $const);
    }
 
    public static function TRIMMEAN(...$args)
    {
        return Statistical\Averages\Mean::trim(...$args);
    }
 
    public static function VARFunc(...$args)
    {
        return Variances::VAR(...$args);
    }
 
    public static function VARA(...$args)
    {
        return Variances::VARA(...$args);
    }
 
    public static function VARP(...$args)
    {
        return Variances::VARP(...$args);
    }
 
    public static function VARPA(...$args)
    {
        return Variances::VARPA(...$args);
    }
 
    public static function WEIBULL($value, $alpha, $beta, $cumulative)
    {
        return Statistical\Distributions\Weibull::distribution($value, $alpha, $beta, $cumulative);
    }
 
    public static function ZTEST($dataSet, $m0, $sigma = null)
    {
        return Statistical\Distributions\StandardNormal::zTest($dataSet, $m0, $sigma);
    }
}