ILIAS  eassessment Revision 61809
 All Data Structures Namespaces Files Functions Variables Groups Pages
Static Public Member Functions | Static Private Member Functions | Static Private Attributes
PHPExcel_Calculation_Statistical Class Reference
+ Collaboration diagram for PHPExcel_Calculation_Statistical:

Static Public Member Functions

static AVEDEV ()
static AVERAGE ()
static AVERAGEA ()
static AVERAGEIF ($aArgs, $condition, $averageArgs=array())
static BETADIST ($value, $alpha, $beta, $rMin=0, $rMax=1)
 BETADIST.
static BETAINV ($probability, $alpha, $beta, $rMin=0, $rMax=1)
 BETAINV.
static BINOMDIST ($value, $trials, $probability, $cumulative)
 BINOMDIST.
static CHIDIST ($value, $degrees)
 CHIDIST.
static CHIINV ($probability, $degrees)
 CHIINV.
static CONFIDENCE ($alpha, $stdDev, $size)
 CONFIDENCE.
static CORREL ($yValues, $xValues=null)
 CORREL.
static COUNT ()
static COUNTA ()
static COUNTBLANK ()
static COUNTIF ($aArgs, $condition)
static COVAR ($yValues, $xValues)
 COVAR.
static CRITBINOM ($trials, $probability, $alpha)
 CRITBINOM.
static DEVSQ ()
static EXPONDIST ($value, $lambda, $cumulative)
 EXPONDIST.
static FISHER ($value)
 FISHER.
static FISHERINV ($value)
 FISHERINV.
static FORECAST ($xValue, $yValues, $xValues)
 FORECAST.
static GAMMADIST ($value, $a, $b, $cumulative)
 GAMMADIST.
static GAMMAINV ($probability, $alpha, $beta)
 GAMMAINV.
static GAMMALN ($value)
 GAMMALN.
static GEOMEAN ()
static GROWTH ($yValues, $xValues=array(), $newValues=array(), $const =True)
 GROWTH.
static HARMEAN ()
static HYPGEOMDIST ($sampleSuccesses, $sampleNumber, $populationSuccesses, $populationNumber)
 HYPGEOMDIST.
static INTERCEPT ($yValues, $xValues)
 INTERCEPT.
static KURT ()
 KURT.
static LARGE ()
static LINEST ($yValues, $xValues=null, $const =True, $stats=False)
 LINEST.
static LOGEST ($yValues, $xValues=null, $const =True, $stats=False)
 LOGEST.
static LOGINV ($probability, $mean, $stdDev)
 LOGINV.
static LOGNORMDIST ($value, $mean, $stdDev)
 LOGNORMDIST.
static MAX ()
static MAXA ()
static MAXIF ($aArgs, $condition, $sumArgs=array())
static MEDIAN ()
static MIN ()
static MINA ()
static MINIF ($aArgs, $condition, $sumArgs=array())
static MODE ()
static NEGBINOMDIST ($failures, $successes, $probability)
 NEGBINOMDIST.
static NORMDIST ($value, $mean, $stdDev, $cumulative)
 NORMDIST.
static NORMINV ($probability, $mean, $stdDev)
 NORMINV.
static NORMSDIST ($value)
 NORMSDIST.
static NORMSINV ($value)
 NORMSINV.
static PERCENTILE ()
static PERCENTRANK ($valueSet, $value, $significance=3)
 PERCENTRANK.
static PERMUT ($numObjs, $numInSet)
 PERMUT.
static POISSON ($value, $mean, $cumulative)
 POISSON.
static QUARTILE ()
static RANK ($value, $valueSet, $order=0)
 RANK.
static RSQ ($yValues, $xValues)
 RSQ.
static SKEW ()
 SKEW.
static SLOPE ($yValues, $xValues)
 SLOPE.
static SMALL ()
static STANDARDIZE ($value, $mean, $stdDev)
 STANDARDIZE.
static STDEV ()
static STDEVA ()
static STDEVP ()
static STDEVPA ()
static STEYX ($yValues, $xValues)
 STEYX.
static TDIST ($value, $degrees, $tails)
 TDIST.
static TINV ($probability, $degrees)
 TINV.
static TREND ($yValues, $xValues=array(), $newValues=array(), $const =True)
 TREND.
static TRIMMEAN ()
static VARFunc ()
static VARA ()
static VARP ()
static VARPA ()
static WEIBULL ($value, $alpha, $beta, $cumulative)
 WEIBULL.
static ZTEST ($dataSet, $m0, $sigma=null)
 ZTEST.

Static Private Member Functions

static _checkTrendArrays (&$array1, &$array2)
static _beta ($p, $q)
 Beta function.
static _incompleteBeta ($x, $p, $q)
 Incomplete beta function.
static _logBeta ($p, $q)
 The natural logarithm of the beta function.
static _betaFraction ($x, $p, $q)
 Evaluates of continued fraction part of incomplete beta function.
static _logGamma ($x)
static _incompleteGamma ($a, $x)
static _gamma ($data)
static _inverse_ncdf ($p)
static _inverse_ncdf2 ($prob)
static _inverse_ncdf3 ($p)
static _modeCalc ($data)

Static Private Attributes

static $_logBetaCache_p = 0.0
static $_logBetaCache_q = 0.0
static $_logBetaCache_result = 0.0
static $_logGammaCache_result = 0.0
 logGamma function
static $_logGammaCache_x = 0.0

Detailed Description

Definition at line 62 of file Statistical.php.

Member Function Documentation

static PHPExcel_Calculation_Statistical::_beta (   $p,
  $q 
)
staticprivate

Beta function.

Author
Jaco van Kooten
Parameters
prequire p>0
qrequire q>0
Returns
0 if p<=0, q<=0 or p+q>2.55E305 to avoid errors and over/underflow

Definition at line 99 of file Statistical.php.

References LOG_GAMMA_X_MAX_VALUE.

{
if ($p <= 0.0 || $q <= 0.0 || ($p + $q) > LOG_GAMMA_X_MAX_VALUE) {
return 0.0;
} else {
return exp(self::_logBeta($p, $q));
}
} // function _beta()
static PHPExcel_Calculation_Statistical::_betaFraction (   $x,
  $p,
  $q 
)
staticprivate

Evaluates of continued fraction part of incomplete beta function.

Based on an idea from Numerical Recipes (W.H. Press et al, 1992).

Author
Jaco van Kooten

Definition at line 168 of file Statistical.php.

References $d, $x, MAX_ITERATIONS, PRECISION, and XMININ.

Referenced by _incompleteBeta().

{
$c = 1.0;
$sum_pq = $p + $q;
$p_plus = $p + 1.0;
$p_minus = $p - 1.0;
$h = 1.0 - $sum_pq * $x / $p_plus;
if (abs($h) < XMININ) {
$h = XMININ;
}
$h = 1.0 / $h;
$frac = $h;
$m = 1;
$delta = 0.0;
while ($m <= MAX_ITERATIONS && abs($delta-1.0) > PRECISION ) {
$m2 = 2 * $m;
// even index for d
$d = $m * ($q - $m) * $x / ( ($p_minus + $m2) * ($p + $m2));
$h = 1.0 + $d * $h;
if (abs($h) < XMININ) {
$h = XMININ;
}
$h = 1.0 / $h;
$c = 1.0 + $d / $c;
if (abs($c) < XMININ) {
$c = XMININ;
}
$frac *= $h * $c;
// odd index for d
$d = -($p + $m) * ($sum_pq + $m) * $x / (($p + $m2) * ($p_plus + $m2));
$h = 1.0 + $d * $h;
if (abs($h) < XMININ) {
$h = XMININ;
}
$h = 1.0 / $h;
$c = 1.0 + $d / $c;
if (abs($c) < XMININ) {
$c = XMININ;
}
$delta = $h * $c;
$frac *= $delta;
++$m;
}
return $frac;
} // function _betaFraction()

+ Here is the caller graph for this function:

static PHPExcel_Calculation_Statistical::_checkTrendArrays ( &  $array1,
&  $array2 
)
staticprivate

Definition at line 65 of file Statistical.php.

References PHPExcel_Calculation_Functions\flattenArray().

{
if (!is_array($array1)) { $array1 = array($array1); }
if (!is_array($array2)) { $array2 = array($array2); }
$array1 = PHPExcel_Calculation_Functions::flattenArray($array1);
$array2 = PHPExcel_Calculation_Functions::flattenArray($array2);
foreach($array1 as $key => $value) {
if ((is_bool($value)) || (is_string($value)) || (is_null($value))) {
unset($array1[$key]);
unset($array2[$key]);
}
}
foreach($array2 as $key => $value) {
if ((is_bool($value)) || (is_string($value)) || (is_null($value))) {
unset($array1[$key]);
unset($array2[$key]);
}
}
$array1 = array_merge($array1);
$array2 = array_merge($array2);
return True;
} // function _checkTrendArrays()

+ Here is the call graph for this function:

static PHPExcel_Calculation_Statistical::_gamma (   $data)
staticprivate

Definition at line 441 of file Statistical.php.

References $data, $x, $y, and SQRT2PI.

Referenced by CHIDIST(), and GAMMADIST().

{
if ($data == 0.0) return 0;
static $p0 = 1.000000000190015;
static $p = array ( 1 => 76.18009172947146,
2 => -86.50532032941677,
3 => 24.01409824083091,
4 => -1.231739572450155,
5 => 1.208650973866179e-3,
6 => -5.395239384953e-6
);
$y = $x = $data;
$tmp = $x + 5.5;
$tmp -= ($x + 0.5) * log($tmp);
$summer = $p0;
for ($j=1;$j<=6;++$j) {
$summer += ($p[$j] / ++$y);
}
return exp(0 - $tmp + log(SQRT2PI * $summer / $x));
} // function _gamma()

+ Here is the caller graph for this function:

static PHPExcel_Calculation_Statistical::_incompleteBeta (   $x,
  $p,
  $q 
)
staticprivate

Incomplete beta function.

Author
Jaco van Kooten
Paul Meagher

The computation is based on formulas from Numerical Recipes, Chapter 6.4 (W.H. Press et al, 1992).

Parameters
xrequire 0<=x<=1
prequire p>0
qrequire q>0
Returns
0 if x<0, p<=0, q<=0 or p+q>2.55E305 and 1 if x>1 to avoid errors and over/underflow

Definition at line 120 of file Statistical.php.

References $x, _betaFraction(), and LOG_GAMMA_X_MAX_VALUE.

Referenced by BETADIST().

{
if ($x <= 0.0) {
return 0.0;
} elseif ($x >= 1.0) {
return 1.0;
} elseif (($p <= 0.0) || ($q <= 0.0) || (($p + $q) > LOG_GAMMA_X_MAX_VALUE)) {
return 0.0;
}
$beta_gam = exp((0 - self::_logBeta($p, $q)) + $p * log($x) + $q * log(1.0 - $x));
if ($x < ($p + 1.0) / ($p + $q + 2.0)) {
return $beta_gam * self::_betaFraction($x, $p, $q) / $p;
} else {
return 1.0 - ($beta_gam * self::_betaFraction(1 - $x, $q, $p) / $q);
}
} // function _incompleteBeta()

+ Here is the call graph for this function:

+ Here is the caller graph for this function:

static PHPExcel_Calculation_Statistical::_incompleteGamma (   $a,
  $x 
)
staticprivate

Definition at line 424 of file Statistical.php.

References $x.

Referenced by CHIDIST(), and GAMMADIST().

{
static $max = 32;
$summer = 0;
for ($n=0; $n<=$max; ++$n) {
$divisor = $a;
for ($i=1; $i<=$n; ++$i) {
$divisor *= ($a + $i);
}
$summer += (pow($x,$n) / $divisor);
}
return pow($x,$a) * exp(0-$x) * $summer;
} // function _incompleteGamma()

+ Here is the caller graph for this function:

static PHPExcel_Calculation_Statistical::_inverse_ncdf (   $p)
staticprivate

Definition at line 473 of file Statistical.php.

References $d, and PHPExcel_Calculation_Functions\NULL().

{
// Inverse ncdf approximation by Peter J. Acklam, implementation adapted to
// PHP by Michael Nickerson, using Dr. Thomas Ziegler's C implementation as
// a guide. http://home.online.no/~pjacklam/notes/invnorm/index.html
// I have not checked the accuracy of this implementation. Be aware that PHP
// will truncate the coeficcients to 14 digits.
// You have permission to use and distribute this function freely for
// whatever purpose you want, but please show common courtesy and give credit
// where credit is due.
// Input paramater is $p - probability - where 0 < p < 1.
// Coefficients in rational approximations
static $a = array( 1 => -3.969683028665376e+01,
2 => 2.209460984245205e+02,
3 => -2.759285104469687e+02,
4 => 1.383577518672690e+02,
5 => -3.066479806614716e+01,
6 => 2.506628277459239e+00
);
static $b = array( 1 => -5.447609879822406e+01,
2 => 1.615858368580409e+02,
3 => -1.556989798598866e+02,
4 => 6.680131188771972e+01,
5 => -1.328068155288572e+01
);
static $c = array( 1 => -7.784894002430293e-03,
2 => -3.223964580411365e-01,
3 => -2.400758277161838e+00,
4 => -2.549732539343734e+00,
5 => 4.374664141464968e+00,
6 => 2.938163982698783e+00
);
static $d = array( 1 => 7.784695709041462e-03,
2 => 3.224671290700398e-01,
3 => 2.445134137142996e+00,
4 => 3.754408661907416e+00
);
// Define lower and upper region break-points.
$p_low = 0.02425; //Use lower region approx. below this
$p_high = 1 - $p_low; //Use upper region approx. above this
if (0 < $p && $p < $p_low) {
// Rational approximation for lower region.
$q = sqrt(-2 * log($p));
return ((((($c[1] * $q + $c[2]) * $q + $c[3]) * $q + $c[4]) * $q + $c[5]) * $q + $c[6]) /
(((($d[1] * $q + $d[2]) * $q + $d[3]) * $q + $d[4]) * $q + 1);
} elseif ($p_low <= $p && $p <= $p_high) {
// Rational approximation for central region.
$q = $p - 0.5;
$r = $q * $q;
return ((((($a[1] * $r + $a[2]) * $r + $a[3]) * $r + $a[4]) * $r + $a[5]) * $r + $a[6]) * $q /
((((($b[1] * $r + $b[2]) * $r + $b[3]) * $r + $b[4]) * $r + $b[5]) * $r + 1);
} elseif ($p_high < $p && $p < 1) {
// Rational approximation for upper region.
$q = sqrt(-2 * log(1 - $p));
return -((((($c[1] * $q + $c[2]) * $q + $c[3]) * $q + $c[4]) * $q + $c[5]) * $q + $c[6]) /
(((($d[1] * $q + $d[2]) * $q + $d[3]) * $q + $d[4]) * $q + 1);
}
// If 0 < p < 1, return a null value
return PHPExcel_Calculation_Functions::NULL();
} // function _inverse_ncdf()

+ Here is the call graph for this function:

static PHPExcel_Calculation_Statistical::_inverse_ncdf2 (   $prob)
staticprivate

Definition at line 542 of file Statistical.php.

References $y.

{
// Approximation of inverse standard normal CDF developed by
// B. Moro, "The Full Monte," Risk 8(2), Feb 1995, 57-58.
$a1 = 2.50662823884;
$a2 = -18.61500062529;
$a3 = 41.39119773534;
$a4 = -25.44106049637;
$b1 = -8.4735109309;
$b2 = 23.08336743743;
$b3 = -21.06224101826;
$b4 = 3.13082909833;
$c1 = 0.337475482272615;
$c2 = 0.976169019091719;
$c3 = 0.160797971491821;
$c4 = 2.76438810333863E-02;
$c5 = 3.8405729373609E-03;
$c6 = 3.951896511919E-04;
$c7 = 3.21767881768E-05;
$c8 = 2.888167364E-07;
$c9 = 3.960315187E-07;
$y = $prob - 0.5;
if (abs($y) < 0.42) {
$z = ($y * $y);
$z = $y * ((($a4 * $z + $a3) * $z + $a2) * $z + $a1) / (((($b4 * $z + $b3) * $z + $b2) * $z + $b1) * $z + 1);
} else {
if ($y > 0) {
$z = log(-log(1 - $prob));
} else {
$z = log(-log($prob));
}
$z = $c1 + $z * ($c2 + $z * ($c3 + $z * ($c4 + $z * ($c5 + $z * ($c6 + $z * ($c7 + $z * ($c8 + $z * $c9)))))));
if ($y < 0) {
$z = -$z;
}
}
return $z;
} // function _inverse_ncdf2()
static PHPExcel_Calculation_Statistical::_inverse_ncdf3 (   $p)
staticprivate

Definition at line 585 of file Statistical.php.

{
// ALGORITHM AS241 APPL. STATIST. (1988) VOL. 37, NO. 3.
// Produces the normal deviate Z corresponding to a given lower
// tail area of P; Z is accurate to about 1 part in 10**16.
//
// This is a PHP version of the original FORTRAN code that can
// be found at http://lib.stat.cmu.edu/apstat/
$split1 = 0.425;
$split2 = 5;
$const1 = 0.180625;
$const2 = 1.6;
// coefficients for p close to 0.5
$a0 = 3.3871328727963666080;
$a1 = 1.3314166789178437745E+2;
$a2 = 1.9715909503065514427E+3;
$a3 = 1.3731693765509461125E+4;
$a4 = 4.5921953931549871457E+4;
$a5 = 6.7265770927008700853E+4;
$a6 = 3.3430575583588128105E+4;
$a7 = 2.5090809287301226727E+3;
$b1 = 4.2313330701600911252E+1;
$b2 = 6.8718700749205790830E+2;
$b3 = 5.3941960214247511077E+3;
$b4 = 2.1213794301586595867E+4;
$b5 = 3.9307895800092710610E+4;
$b6 = 2.8729085735721942674E+4;
$b7 = 5.2264952788528545610E+3;
// coefficients for p not close to 0, 0.5 or 1.
$c0 = 1.42343711074968357734;
$c1 = 4.63033784615654529590;
$c2 = 5.76949722146069140550;
$c3 = 3.64784832476320460504;
$c4 = 1.27045825245236838258;
$c5 = 2.41780725177450611770E-1;
$c6 = 2.27238449892691845833E-2;
$c7 = 7.74545014278341407640E-4;
$d1 = 2.05319162663775882187;
$d2 = 1.67638483018380384940;
$d3 = 6.89767334985100004550E-1;
$d4 = 1.48103976427480074590E-1;
$d5 = 1.51986665636164571966E-2;
$d6 = 5.47593808499534494600E-4;
$d7 = 1.05075007164441684324E-9;
// coefficients for p near 0 or 1.
$e0 = 6.65790464350110377720;
$e1 = 5.46378491116411436990;
$e2 = 1.78482653991729133580;
$e3 = 2.96560571828504891230E-1;
$e4 = 2.65321895265761230930E-2;
$e5 = 1.24266094738807843860E-3;
$e6 = 2.71155556874348757815E-5;
$e7 = 2.01033439929228813265E-7;
$f1 = 5.99832206555887937690E-1;
$f2 = 1.36929880922735805310E-1;
$f3 = 1.48753612908506148525E-2;
$f4 = 7.86869131145613259100E-4;
$f5 = 1.84631831751005468180E-5;
$f6 = 1.42151175831644588870E-7;
$f7 = 2.04426310338993978564E-15;
$q = $p - 0.5;
// computation for p close to 0.5
if (abs($q) <= split1) {
$R = $const1 - $q * $q;
$z = $q * ((((((($a7 * $R + $a6) * $R + $a5) * $R + $a4) * $R + $a3) * $R + $a2) * $R + $a1) * $R + $a0) /
((((((($b7 * $R + $b6) * $R + $b5) * $R + $b4) * $R + $b3) * $R + $b2) * $R + $b1) * $R + 1);
} else {
if ($q < 0) {
$R = $p;
} else {
$R = 1 - $p;
}
$R = pow(-log($R),2);
// computation for p not close to 0, 0.5 or 1.
If ($R <= $split2) {
$R = $R - $const2;
$z = ((((((($c7 * $R + $c6) * $R + $c5) * $R + $c4) * $R + $c3) * $R + $c2) * $R + $c1) * $R + $c0) /
((((((($d7 * $R + $d6) * $R + $d5) * $R + $d4) * $R + $d3) * $R + $d2) * $R + $d1) * $R + 1);
} else {
// computation for p near 0 or 1.
$R = $R - $split2;
$z = ((((((($e7 * $R + $e6) * $R + $e5) * $R + $e4) * $R + $e3) * $R + $e2) * $R + $e1) * $R + $e0) /
((((((($f7 * $R + $f6) * $R + $f5) * $R + $f4) * $R + $f3) * $R + $f2) * $R + $f1) * $R + 1);
}
if ($q < 0) {
$z = -$z;
}
}
return $z;
} // function _inverse_ncdf3()
static PHPExcel_Calculation_Statistical::_logBeta (   $p,
  $q 
)
staticprivate

The natural logarithm of the beta function.

Parameters
prequire p>0
qrequire q>0
Returns
0 if p<=0, q<=0 or p+q>2.55E305 to avoid errors and over/underflow
Author
Jaco van Kooten

Definition at line 149 of file Statistical.php.

References $_logBetaCache_result, _logGamma(), and LOG_GAMMA_X_MAX_VALUE.

{
if ($p != self::$_logBetaCache_p || $q != self::$_logBetaCache_q) {
self::$_logBetaCache_p = $p;
self::$_logBetaCache_q = $q;
if (($p <= 0.0) || ($q <= 0.0) || (($p + $q) > LOG_GAMMA_X_MAX_VALUE)) {
self::$_logBetaCache_result = 0.0;
} else {
self::$_logBetaCache_result = self::_logGamma($p) + self::_logGamma($q) - self::_logGamma($p + $q);
}
}
return self::$_logBetaCache_result;
} // function _logBeta()

+ Here is the call graph for this function:

static PHPExcel_Calculation_Statistical::_logGamma (   $x)
staticprivate

Definition at line 261 of file Statistical.php.

References $_logGammaCache_result, $res, $x, $y, EPS, LOG_GAMMA_X_MAX_VALUE, MAX_VALUE, and SQRT2PI.

Referenced by _logBeta().

{
// Log Gamma related constants
static $lg_d1 = -0.5772156649015328605195174;
static $lg_d2 = 0.4227843350984671393993777;
static $lg_d4 = 1.791759469228055000094023;
static $lg_p1 = array( 4.945235359296727046734888,
201.8112620856775083915565,
2290.838373831346393026739,
11319.67205903380828685045,
28557.24635671635335736389,
38484.96228443793359990269,
26377.48787624195437963534,
7225.813979700288197698961 );
static $lg_p2 = array( 4.974607845568932035012064,
542.4138599891070494101986,
15506.93864978364947665077,
184793.2904445632425417223,
1088204.76946882876749847,
3338152.967987029735917223,
5106661.678927352456275255,
3074109.054850539556250927 );
static $lg_p4 = array( 14745.02166059939948905062,
2426813.369486704502836312,
121475557.4045093227939592,
2663432449.630976949898078,
29403789566.34553899906876,
170266573776.5398868392998,
492612579337.743088758812,
560625185622.3951465078242 );
static $lg_q1 = array( 67.48212550303777196073036,
1113.332393857199323513008,
7738.757056935398733233834,
27639.87074403340708898585,
54993.10206226157329794414,
61611.22180066002127833352,
36351.27591501940507276287,
8785.536302431013170870835 );
static $lg_q2 = array( 183.0328399370592604055942,
7765.049321445005871323047,
133190.3827966074194402448,
1136705.821321969608938755,
5267964.117437946917577538,
13467014.54311101692290052,
17827365.30353274213975932,
9533095.591844353613395747 );
static $lg_q4 = array( 2690.530175870899333379843,
639388.5654300092398984238,
41355999.30241388052042842,
1120872109.61614794137657,
14886137286.78813811542398,
101680358627.2438228077304,
341747634550.7377132798597,
446315818741.9713286462081 );
static $lg_c = array( -0.001910444077728,
8.4171387781295e-4,
-5.952379913043012e-4,
7.93650793500350248e-4,
-0.002777777777777681622553,
0.08333333333333333331554247,
0.0057083835261 );
// Rough estimate of the fourth root of logGamma_xBig
static $lg_frtbig = 2.25e76;
static $pnt68 = 0.6796875;
if ($x == self::$_logGammaCache_x) {
return self::$_logGammaCache_result;
}
$y = $x;
if ($y > 0.0 && $y <= LOG_GAMMA_X_MAX_VALUE) {
if ($y <= EPS) {
$res = -log(y);
} elseif ($y <= 1.5) {
// ---------------------
// EPS .LT. X .LE. 1.5
// ---------------------
if ($y < $pnt68) {
$corr = -log($y);
$xm1 = $y;
} else {
$corr = 0.0;
$xm1 = $y - 1.0;
}
if ($y <= 0.5 || $y >= $pnt68) {
$xden = 1.0;
$xnum = 0.0;
for ($i = 0; $i < 8; ++$i) {
$xnum = $xnum * $xm1 + $lg_p1[$i];
$xden = $xden * $xm1 + $lg_q1[$i];
}
$res = $corr + $xm1 * ($lg_d1 + $xm1 * ($xnum / $xden));
} else {
$xm2 = $y - 1.0;
$xden = 1.0;
$xnum = 0.0;
for ($i = 0; $i < 8; ++$i) {
$xnum = $xnum * $xm2 + $lg_p2[$i];
$xden = $xden * $xm2 + $lg_q2[$i];
}
$res = $corr + $xm2 * ($lg_d2 + $xm2 * ($xnum / $xden));
}
} elseif ($y <= 4.0) {
// ---------------------
// 1.5 .LT. X .LE. 4.0
// ---------------------
$xm2 = $y - 2.0;
$xden = 1.0;
$xnum = 0.0;
for ($i = 0; $i < 8; ++$i) {
$xnum = $xnum * $xm2 + $lg_p2[$i];
$xden = $xden * $xm2 + $lg_q2[$i];
}
$res = $xm2 * ($lg_d2 + $xm2 * ($xnum / $xden));
} elseif ($y <= 12.0) {
// ----------------------
// 4.0 .LT. X .LE. 12.0
// ----------------------
$xm4 = $y - 4.0;
$xden = -1.0;
$xnum = 0.0;
for ($i = 0; $i < 8; ++$i) {
$xnum = $xnum * $xm4 + $lg_p4[$i];
$xden = $xden * $xm4 + $lg_q4[$i];
}
$res = $lg_d4 + $xm4 * ($xnum / $xden);
} else {
// ---------------------------------
// Evaluate for argument .GE. 12.0
// ---------------------------------
$res = 0.0;
if ($y <= $lg_frtbig) {
$res = $lg_c[6];
$ysq = $y * $y;
for ($i = 0; $i < 6; ++$i)
$res = $res / $ysq + $lg_c[$i];
}
$res /= $y;
$corr = log($y);
$res = $res + log(SQRT2PI) - 0.5 * $corr;
$res += $y * ($corr - 1.0);
}
} else {
// --------------------------
// Return for bad arguments
// --------------------------
$res = MAX_VALUE;
}
// ------------------------------
// Final adjustments and return
// ------------------------------
self::$_logGammaCache_x = $x;
self::$_logGammaCache_result = $res;
return $res;
} // function _logGamma()

+ Here is the caller graph for this function:

static PHPExcel_Calculation_Statistical::_modeCalc (   $data)
staticprivate

Definition at line 2391 of file Statistical.php.

References $data, and PHPExcel_Calculation_Functions\NA().

Referenced by MODE().

{
$frequencyArray = array();
foreach($data as $datum) {
$found = False;
foreach($frequencyArray as $key => $value) {
if ((string) $value['value'] == (string) $datum) {
++$frequencyArray[$key]['frequency'];
$found = True;
break;
}
}
if (!$found) {
$frequencyArray[] = array('value' => $datum,
'frequency' => 1 );
}
}
foreach($frequencyArray as $key => $value) {
$frequencyList[$key] = $value['frequency'];
$valueList[$key] = $value['value'];
}
array_multisort($frequencyList, SORT_DESC, $valueList, SORT_ASC, SORT_NUMERIC, $frequencyArray);
if ($frequencyArray[0]['frequency'] == 1) {
return PHPExcel_Calculation_Functions::NA();
}
return $frequencyArray[0]['value'];
} // function _modeCalc()

+ Here is the call graph for this function:

+ Here is the caller graph for this function:

static PHPExcel_Calculation_Statistical::AVEDEV ( )
static

Definition at line 699 of file Statistical.php.

References $arg, AVERAGE(), PHPExcel_Calculation_Functions\COMPATIBILITY_OPENOFFICE, PHPExcel_Calculation_Functions\DIV0(), PHPExcel_Calculation_Functions\flattenArrayIndexed(), PHPExcel_Calculation_Functions\getCompatibilityMode(), PHPExcel_Calculation_Functions\isCellValue(), and PHPExcel_Calculation_Functions\NaN().

{
$aArgs = PHPExcel_Calculation_Functions::flattenArrayIndexed(func_get_args());
// Return value
$returnValue = null;
$aMean = self::AVERAGE($aArgs);
if ($aMean != PHPExcel_Calculation_Functions::DIV0()) {
$aCount = 0;
foreach ($aArgs as $k => $arg) {
if ((is_bool($arg)) &&
((!PHPExcel_Calculation_Functions::isCellValue($k)) || (PHPExcel_Calculation_Functions::getCompatibilityMode() == PHPExcel_Calculation_Functions::COMPATIBILITY_OPENOFFICE))) {
$arg = (integer) $arg;
}
// Is it a numeric value?
if ((is_numeric($arg)) && (!is_string($arg))) {
if (is_null($returnValue)) {
$returnValue = abs($arg - $aMean);
} else {
$returnValue += abs($arg - $aMean);
}
++$aCount;
}
}
// Return
if ($aCount == 0) {
return PHPExcel_Calculation_Functions::DIV0();
}
return $returnValue / $aCount;
}
return PHPExcel_Calculation_Functions::NaN();
} // function AVEDEV()

+ Here is the call graph for this function:

static PHPExcel_Calculation_Statistical::AVERAGE ( )
static

Definition at line 747 of file Statistical.php.

References $arg, PHPExcel_Calculation_Functions\COMPATIBILITY_OPENOFFICE, PHPExcel_Calculation_Functions\DIV0(), PHPExcel_Calculation_Functions\flattenArrayIndexed(), PHPExcel_Calculation_Functions\getCompatibilityMode(), and PHPExcel_Calculation_Functions\isCellValue().

Referenced by AVEDEV(), PHPExcel_Calculation_Database\DAVERAGE(), DEVSQ(), KURT(), SKEW(), STDEV(), STDEVP(), PHPExcel_Calculation_MathTrig\SUBTOTAL(), and TRIMMEAN().

{
$returnValue = $aCount = 0;
// Loop through arguments
foreach (PHPExcel_Calculation_Functions::flattenArrayIndexed(func_get_args()) as $k => $arg) {
if ((is_bool($arg)) &&
((!PHPExcel_Calculation_Functions::isCellValue($k)) || (PHPExcel_Calculation_Functions::getCompatibilityMode() == PHPExcel_Calculation_Functions::COMPATIBILITY_OPENOFFICE))) {
$arg = (integer) $arg;
}
// Is it a numeric value?
if ((is_numeric($arg)) && (!is_string($arg))) {
if (is_null($returnValue)) {
$returnValue = $arg;
} else {
$returnValue += $arg;
}
++$aCount;
}
}
// Return
if ($aCount > 0) {
return $returnValue / $aCount;
} else {
return PHPExcel_Calculation_Functions::DIV0();
}
} // function AVERAGE()

+ Here is the call graph for this function:

+ Here is the caller graph for this function:

static PHPExcel_Calculation_Statistical::AVERAGEA ( )
static

Definition at line 789 of file Statistical.php.

References $arg, PHPExcel_Calculation_Functions\DIV0(), PHPExcel_Calculation_Functions\flattenArrayIndexed(), and PHPExcel_Calculation_Functions\isMatrixValue().

Referenced by STDEVA(), and STDEVPA().

{
// Return value
$returnValue = null;
$aCount = 0;
// Loop through arguments
foreach (PHPExcel_Calculation_Functions::flattenArrayIndexed(func_get_args()) as $k => $arg) {
if ((is_bool($arg)) &&
(!PHPExcel_Calculation_Functions::isMatrixValue($k))) {
} else {
if ((is_numeric($arg)) || (is_bool($arg)) || ((is_string($arg) && ($arg != '')))) {
if (is_bool($arg)) {
$arg = (integer) $arg;
} elseif (is_string($arg)) {
$arg = 0;
}
if (is_null($returnValue)) {
$returnValue = $arg;
} else {
$returnValue += $arg;
}
++$aCount;
}
}
}
// Return
if ($aCount > 0) {
return $returnValue / $aCount;
} else {
return PHPExcel_Calculation_Functions::DIV0();
}
} // function AVERAGEA()

+ Here is the call graph for this function:

+ Here is the caller graph for this function:

static PHPExcel_Calculation_Statistical::AVERAGEIF (   $aArgs,
  $condition,
  $averageArgs = array() 
)
static

Definition at line 838 of file Statistical.php.

References $arg, PHPExcel_Calculation_Functions\_ifCondition(), PHPExcel_Calculation\_wrapResult(), PHPExcel_Calculation_Functions\DIV0(), PHPExcel_Calculation_Functions\flattenArray(), and PHPExcel_Calculation\getInstance().

{
// Return value
$returnValue = 0;
$aArgs = PHPExcel_Calculation_Functions::flattenArray($aArgs);
$averageArgs = PHPExcel_Calculation_Functions::flattenArray($averageArgs);
if (count($averageArgs) == 0) {
$averageArgs = $aArgs;
}
$condition = PHPExcel_Calculation_Functions::_ifCondition($condition);
// Loop through arguments
$aCount = 0;
foreach ($aArgs as $key => $arg) {
if (!is_numeric($arg)) { $arg = PHPExcel_Calculation::_wrapResult(strtoupper($arg)); }
$testCondition = '='.$arg.$condition;
if (PHPExcel_Calculation::getInstance()->_calculateFormulaValue($testCondition)) {
if ((is_null($returnValue)) || ($arg > $returnValue)) {
$returnValue += $arg;
++$aCount;
}
}
}
// Return
if ($aCount > 0) {
return $returnValue / $aCount;
} else {
return PHPExcel_Calculation_Functions::DIV0();
}
} // function AVERAGEIF()

+ Here is the call graph for this function:

static PHPExcel_Calculation_Statistical::BETADIST (   $value,
  $alpha,
  $beta,
  $rMin = 0,
  $rMax = 1 
)
static

BETADIST.

Returns the beta distribution.

Parameters
float$valueValue at which you want to evaluate the distribution
float$alphaParameter to the distribution
float$betaParameter to the distribution
boolean$cumulative
Returns
float

Definition at line 882 of file Statistical.php.

References _incompleteBeta(), PHPExcel_Calculation_Functions\flattenSingleValue(), PHPExcel_Calculation_Functions\NaN(), and PHPExcel_Calculation_Functions\VALUE().

Referenced by BETAINV().

{
$value = PHPExcel_Calculation_Functions::flattenSingleValue($value);
$alpha = PHPExcel_Calculation_Functions::flattenSingleValue($alpha);
$beta = PHPExcel_Calculation_Functions::flattenSingleValue($beta);
$rMin = PHPExcel_Calculation_Functions::flattenSingleValue($rMin);
$rMax = PHPExcel_Calculation_Functions::flattenSingleValue($rMax);
if ((is_numeric($value)) && (is_numeric($alpha)) && (is_numeric($beta)) && (is_numeric($rMin)) && (is_numeric($rMax))) {
if (($value < $rMin) || ($value > $rMax) || ($alpha <= 0) || ($beta <= 0) || ($rMin == $rMax)) {
return PHPExcel_Calculation_Functions::NaN();
}
if ($rMin > $rMax) {
$tmp = $rMin;
$rMin = $rMax;
$rMax = $tmp;
}
$value -= $rMin;
$value /= ($rMax - $rMin);
return self::_incompleteBeta($value,$alpha,$beta);
}
return PHPExcel_Calculation_Functions::VALUE();
} // function BETADIST()

+ Here is the call graph for this function:

+ Here is the caller graph for this function:

static PHPExcel_Calculation_Statistical::BETAINV (   $probability,
  $alpha,
  $beta,
  $rMin = 0,
  $rMax = 1 
)
static

BETAINV.

Returns the inverse of the beta distribution.

Parameters
float$probabilityProbability at which you want to evaluate the distribution
float$alphaParameter to the distribution
float$betaParameter to the distribution
boolean$cumulative
Returns
float

Definition at line 918 of file Statistical.php.

References BETADIST(), PHPExcel_Calculation_Functions\flattenSingleValue(), MAX_ITERATIONS, PHPExcel_Calculation_Functions\NA(), PHPExcel_Calculation_Functions\NaN(), PRECISION, and PHPExcel_Calculation_Functions\VALUE().

{
$probability = PHPExcel_Calculation_Functions::flattenSingleValue($probability);
$alpha = PHPExcel_Calculation_Functions::flattenSingleValue($alpha);
$beta = PHPExcel_Calculation_Functions::flattenSingleValue($beta);
$rMin = PHPExcel_Calculation_Functions::flattenSingleValue($rMin);
$rMax = PHPExcel_Calculation_Functions::flattenSingleValue($rMax);
if ((is_numeric($probability)) && (is_numeric($alpha)) && (is_numeric($beta)) && (is_numeric($rMin)) && (is_numeric($rMax))) {
if (($alpha <= 0) || ($beta <= 0) || ($rMin == $rMax) || ($probability <= 0) || ($probability > 1)) {
return PHPExcel_Calculation_Functions::NaN();
}
if ($rMin > $rMax) {
$tmp = $rMin;
$rMin = $rMax;
$rMax = $tmp;
}
$a = 0;
$b = 2;
$i = 0;
while ((($b - $a) > PRECISION) && ($i++ < MAX_ITERATIONS)) {
$guess = ($a + $b) / 2;
$result = self::BETADIST($guess, $alpha, $beta);
if (($result == $probability) || ($result == 0)) {
$b = $a;
} elseif ($result > $probability) {
$b = $guess;
} else {
$a = $guess;
}
}
if ($i == MAX_ITERATIONS) {
return PHPExcel_Calculation_Functions::NA();
}
return round($rMin + $guess * ($rMax - $rMin),12);
}
return PHPExcel_Calculation_Functions::VALUE();
} // function BETAINV()

+ Here is the call graph for this function:

static PHPExcel_Calculation_Statistical::BINOMDIST (   $value,
  $trials,
  $probability,
  $cumulative 
)
static

BINOMDIST.

Returns the individual term binomial distribution probability. Use BINOMDIST in problems with a fixed number of tests or trials, when the outcomes of any trial are only success or failure, when trials are independent, and when the probability of success is constant throughout the experiment. For example, BINOMDIST can calculate the probability that two of the next three babies born are male.

Parameters
float$valueNumber of successes in trials
float$trialsNumber of trials
float$probabilityProbability of success on each trial
boolean$cumulative
Returns
float
Todo:
Cumulative distribution function

Definition at line 976 of file Statistical.php.

References PHPExcel_Calculation_MathTrig\COMBIN(), PHPExcel_Calculation_Functions\flattenSingleValue(), PHPExcel_Calculation_Functions\NaN(), and PHPExcel_Calculation_Functions\VALUE().

{
$value = floor(PHPExcel_Calculation_Functions::flattenSingleValue($value));
$trials = floor(PHPExcel_Calculation_Functions::flattenSingleValue($trials));
$probability = PHPExcel_Calculation_Functions::flattenSingleValue($probability);
if ((is_numeric($value)) && (is_numeric($trials)) && (is_numeric($probability))) {
if (($value < 0) || ($value > $trials)) {
return PHPExcel_Calculation_Functions::NaN();
}
if (($probability < 0) || ($probability > 1)) {
return PHPExcel_Calculation_Functions::NaN();
}
if ((is_numeric($cumulative)) || (is_bool($cumulative))) {
if ($cumulative) {
$summer = 0;
for ($i = 0; $i <= $value; ++$i) {
$summer += PHPExcel_Calculation_MathTrig::COMBIN($trials,$i) * pow($probability,$i) * pow(1 - $probability,$trials - $i);
}
return $summer;
} else {
return PHPExcel_Calculation_MathTrig::COMBIN($trials,$value) * pow($probability,$value) * pow(1 - $probability,$trials - $value) ;
}
}
}
return PHPExcel_Calculation_Functions::VALUE();
} // function BINOMDIST()

+ Here is the call graph for this function:

static PHPExcel_Calculation_Statistical::CHIDIST (   $value,
  $degrees 
)
static

CHIDIST.

Returns the one-tailed probability of the chi-squared distribution.

Parameters
float$valueValue for the function
float$degreesdegrees of freedom
Returns
float

Definition at line 1013 of file Statistical.php.

References _gamma(), _incompleteGamma(), PHPExcel_Calculation_Functions\COMPATIBILITY_GNUMERIC, PHPExcel_Calculation_Functions\flattenSingleValue(), PHPExcel_Calculation_Functions\getCompatibilityMode(), PHPExcel_Calculation_Functions\NaN(), and PHPExcel_Calculation_Functions\VALUE().

Referenced by CHIINV().

{
$value = PHPExcel_Calculation_Functions::flattenSingleValue($value);
$degrees = floor(PHPExcel_Calculation_Functions::flattenSingleValue($degrees));
if ((is_numeric($value)) && (is_numeric($degrees))) {
if ($degrees < 1) {
return PHPExcel_Calculation_Functions::NaN();
}
if ($value < 0) {
if (PHPExcel_Calculation_Functions::getCompatibilityMode() == PHPExcel_Calculation_Functions::COMPATIBILITY_GNUMERIC) {
return 1;
}
return PHPExcel_Calculation_Functions::NaN();
}
return 1 - (self::_incompleteGamma($degrees/2,$value/2) / self::_gamma($degrees/2));
}
return PHPExcel_Calculation_Functions::VALUE();
} // function CHIDIST()

+ Here is the call graph for this function:

+ Here is the caller graph for this function:

static PHPExcel_Calculation_Statistical::CHIINV (   $probability,
  $degrees 
)
static

CHIINV.

Returns the one-tailed probability of the chi-squared distribution.

Parameters
float$probabilityProbability for the function
float$degreesdegrees of freedom
Returns
float

Definition at line 1042 of file Statistical.php.

References $error, $x, CHIDIST(), PHPExcel_Calculation_Functions\flattenSingleValue(), MAX_ITERATIONS, PHPExcel_Calculation_Functions\NA(), PRECISION, and PHPExcel_Calculation_Functions\VALUE().

{
$probability = PHPExcel_Calculation_Functions::flattenSingleValue($probability);
$degrees = floor(PHPExcel_Calculation_Functions::flattenSingleValue($degrees));
if ((is_numeric($probability)) && (is_numeric($degrees))) {
$xLo = 100;
$xHi = 0;
$x = $xNew = 1;
$dx = 1;
$i = 0;
while ((abs($dx) > PRECISION) && ($i++ < MAX_ITERATIONS)) {
// Apply Newton-Raphson step
$result = self::CHIDIST($x, $degrees);
$error = $result - $probability;
if ($error == 0.0) {
$dx = 0;
} elseif ($error < 0.0) {
$xLo = $x;
} else {
$xHi = $x;
}
// Avoid division by zero
if ($result != 0.0) {
$dx = $error / $result;
$xNew = $x - $dx;
}
// If the NR fails to converge (which for example may be the
// case if the initial guess is too rough) we apply a bisection
// step to determine a more narrow interval around the root.
if (($xNew < $xLo) || ($xNew > $xHi) || ($result == 0.0)) {
$xNew = ($xLo + $xHi) / 2;
$dx = $xNew - $x;
}
$x = $xNew;
}
if ($i == MAX_ITERATIONS) {
return PHPExcel_Calculation_Functions::NA();
}
return round($x,12);
}
return PHPExcel_Calculation_Functions::VALUE();
} // function CHIINV()

+ Here is the call graph for this function:

static PHPExcel_Calculation_Statistical::CONFIDENCE (   $alpha,
  $stdDev,
  $size 
)
static

CONFIDENCE.

Returns the confidence interval for a population mean

Parameters
float$alpha
float$stdDevStandard Deviation
float$size
Returns
float

Definition at line 1100 of file Statistical.php.

References PHPExcel_Calculation_Functions\flattenSingleValue(), PHPExcel_Calculation_Functions\NaN(), NORMSINV(), and PHPExcel_Calculation_Functions\VALUE().

{
$alpha = PHPExcel_Calculation_Functions::flattenSingleValue($alpha);
$stdDev = PHPExcel_Calculation_Functions::flattenSingleValue($stdDev);
$size = floor(PHPExcel_Calculation_Functions::flattenSingleValue($size));
if ((is_numeric($alpha)) && (is_numeric($stdDev)) && (is_numeric($size))) {
if (($alpha <= 0) || ($alpha >= 1)) {
return PHPExcel_Calculation_Functions::NaN();
}
if (($stdDev <= 0) || ($size < 1)) {
return PHPExcel_Calculation_Functions::NaN();
}
return self::NORMSINV(1 - $alpha / 2) * $stdDev / sqrt($size);
}
return PHPExcel_Calculation_Functions::VALUE();
} // function CONFIDENCE()

+ Here is the call graph for this function:

static PHPExcel_Calculation_Statistical::CORREL (   $yValues,
  $xValues = null 
)
static

CORREL.

Returns covariance, the average of the products of deviations for each data point pair.

Parameters
arrayof mixed Data Series Y
arrayof mixed Data Series X
Returns
float

Definition at line 1127 of file Statistical.php.

References trendClass\calculate(), PHPExcel_Calculation_Functions\DIV0(), PHPExcel_Calculation_Functions\NA(), trendClass\TREND_LINEAR, and PHPExcel_Calculation_Functions\VALUE().

{
if ((is_null($xValues)) || (!is_array($yValues)) || (!is_array($xValues))) {
return PHPExcel_Calculation_Functions::VALUE();
}
if (!self::_checkTrendArrays($yValues,$xValues)) {
return PHPExcel_Calculation_Functions::VALUE();
}
$yValueCount = count($yValues);
$xValueCount = count($xValues);
if (($yValueCount == 0) || ($yValueCount != $xValueCount)) {
return PHPExcel_Calculation_Functions::NA();
} elseif ($yValueCount == 1) {
return PHPExcel_Calculation_Functions::DIV0();
}
$bestFitLinear = trendClass::calculate(trendClass::TREND_LINEAR,$yValues,$xValues);
return $bestFitLinear->getCorrelation();
} // function CORREL()

+ Here is the call graph for this function:

static PHPExcel_Calculation_Statistical::COUNT ( )
static

Definition at line 1161 of file Statistical.php.

References $arg, PHPExcel_Calculation_Functions\COMPATIBILITY_OPENOFFICE, PHPExcel_Calculation_Functions\flattenArrayIndexed(), PHPExcel_Calculation_Functions\getCompatibilityMode(), and PHPExcel_Calculation_Functions\isCellValue().

Referenced by PHPExcel_Calculation_Database\DCOUNT(), GEOMEAN(), LARGE(), PERCENTILE(), SMALL(), and PHPExcel_Calculation_MathTrig\SUBTOTAL().

{
// Return value
$returnValue = 0;
// Loop through arguments
$aArgs = PHPExcel_Calculation_Functions::flattenArrayIndexed(func_get_args());
foreach ($aArgs as $k => $arg) {
if ((is_bool($arg)) &&
((!PHPExcel_Calculation_Functions::isCellValue($k)) || (PHPExcel_Calculation_Functions::getCompatibilityMode() == PHPExcel_Calculation_Functions::COMPATIBILITY_OPENOFFICE))) {
$arg = (integer) $arg;
}
// Is it a numeric value?
if ((is_numeric($arg)) && (!is_string($arg))) {
++$returnValue;
}
}
// Return
return $returnValue;
} // function COUNT()

+ Here is the call graph for this function:

+ Here is the caller graph for this function:

static PHPExcel_Calculation_Statistical::COUNTA ( )
static

Definition at line 1196 of file Statistical.php.

References $arg, and PHPExcel_Calculation_Functions\flattenArray().

Referenced by PHPExcel_Calculation_Database\DCOUNTA(), and PHPExcel_Calculation_MathTrig\SUBTOTAL().

{
// Return value
$returnValue = 0;
// Loop through arguments
$aArgs = PHPExcel_Calculation_Functions::flattenArray(func_get_args());
foreach ($aArgs as $arg) {
// Is it a numeric, boolean or string value?
if ((is_numeric($arg)) || (is_bool($arg)) || ((is_string($arg) && ($arg != '')))) {
++$returnValue;
}
}
// Return
return $returnValue;
} // function COUNTA()

+ Here is the call graph for this function:

+ Here is the caller graph for this function:

static PHPExcel_Calculation_Statistical::COUNTBLANK ( )
static

Definition at line 1227 of file Statistical.php.

References $arg, and PHPExcel_Calculation_Functions\flattenArray().

{
// Return value
$returnValue = 0;
// Loop through arguments
$aArgs = PHPExcel_Calculation_Functions::flattenArray(func_get_args());
foreach ($aArgs as $arg) {
// Is it a blank cell?
if ((is_null($arg)) || ((is_string($arg)) && ($arg == ''))) {
++$returnValue;
}
}
// Return
return $returnValue;
} // function COUNTBLANK()

+ Here is the call graph for this function:

static PHPExcel_Calculation_Statistical::COUNTIF (   $aArgs,
  $condition 
)
static

Definition at line 1259 of file Statistical.php.

References $arg, PHPExcel_Calculation_Functions\_ifCondition(), PHPExcel_Calculation\_wrapResult(), PHPExcel_Calculation_Functions\flattenArray(), and PHPExcel_Calculation\getInstance().

{
// Return value
$returnValue = 0;
$aArgs = PHPExcel_Calculation_Functions::flattenArray($aArgs);
$condition = PHPExcel_Calculation_Functions::_ifCondition($condition);
// Loop through arguments
foreach ($aArgs as $arg) {
if (!is_numeric($arg)) { $arg = PHPExcel_Calculation::_wrapResult(strtoupper($arg)); }
$testCondition = '='.$arg.$condition;
if (PHPExcel_Calculation::getInstance()->_calculateFormulaValue($testCondition)) {
// Is it a value within our criteria
++$returnValue;
}
}
// Return
return $returnValue;
} // function COUNTIF()

+ Here is the call graph for this function:

static PHPExcel_Calculation_Statistical::COVAR (   $yValues,
  $xValues 
)
static

COVAR.

Returns covariance, the average of the products of deviations for each data point pair.

Parameters
arrayof mixed Data Series Y
arrayof mixed Data Series X
Returns
float

Definition at line 1289 of file Statistical.php.

References trendClass\calculate(), PHPExcel_Calculation_Functions\DIV0(), PHPExcel_Calculation_Functions\NA(), trendClass\TREND_LINEAR, and PHPExcel_Calculation_Functions\VALUE().

{
if (!self::_checkTrendArrays($yValues,$xValues)) {
return PHPExcel_Calculation_Functions::VALUE();
}
$yValueCount = count($yValues);
$xValueCount = count($xValues);
if (($yValueCount == 0) || ($yValueCount != $xValueCount)) {
return PHPExcel_Calculation_Functions::NA();
} elseif ($yValueCount == 1) {
return PHPExcel_Calculation_Functions::DIV0();
}
$bestFitLinear = trendClass::calculate(trendClass::TREND_LINEAR,$yValues,$xValues);
return $bestFitLinear->getCovariance();
} // function COVAR()

+ Here is the call graph for this function:

static PHPExcel_Calculation_Statistical::CRITBINOM (   $trials,
  $probability,
  $alpha 
)
static

CRITBINOM.

Returns the smallest value for which the cumulative binomial distribution is greater than or equal to a criterion value

See http://support.microsoft.com/kb/828117/ for details of the algorithm used

Parameters
float$trialsnumber of Bernoulli trials
float$probabilityprobability of a success on each trial
float$alphacriterion value
Returns
int
Todo:
Warning. This implementation differs from the algorithm detailed on the MS web site in that $CumPGuessMinus1 = $CumPGuess - 1 rather than $CumPGuess - $PGuess This eliminates a potential endless loop error, but may have an adverse affect on the accuracy of the function (although all my tests have so far returned correct results).

Definition at line 1326 of file Statistical.php.

References $t, PHPExcel_Calculation_Functions\flattenSingleValue(), PHPExcel_Calculation_Functions\NaN(), and PHPExcel_Calculation_Functions\VALUE().

{
$trials = floor(PHPExcel_Calculation_Functions::flattenSingleValue($trials));
$probability = PHPExcel_Calculation_Functions::flattenSingleValue($probability);
$alpha = PHPExcel_Calculation_Functions::flattenSingleValue($alpha);
if ((is_numeric($trials)) && (is_numeric($probability)) && (is_numeric($alpha))) {
if ($trials < 0) {
return PHPExcel_Calculation_Functions::NaN();
}
if (($probability < 0) || ($probability > 1)) {
return PHPExcel_Calculation_Functions::NaN();
}
if (($alpha < 0) || ($alpha > 1)) {
return PHPExcel_Calculation_Functions::NaN();
}
if ($alpha <= 0.5) {
$t = sqrt(log(1 / ($alpha * $alpha)));
$trialsApprox = 0 - ($t + (2.515517 + 0.802853 * $t + 0.010328 * $t * $t) / (1 + 1.432788 * $t + 0.189269 * $t * $t + 0.001308 * $t * $t * $t));
} else {
$t = sqrt(log(1 / pow(1 - $alpha,2)));
$trialsApprox = $t - (2.515517 + 0.802853 * $t + 0.010328 * $t * $t) / (1 + 1.432788 * $t + 0.189269 * $t * $t + 0.001308 * $t * $t * $t);
}
$Guess = floor($trials * $probability + $trialsApprox * sqrt($trials * $probability * (1 - $probability)));
if ($Guess < 0) {
$Guess = 0;
} elseif ($Guess > $trials) {
$Guess = $trials;
}
$TotalUnscaledProbability = $UnscaledPGuess = $UnscaledCumPGuess = 0.0;
$EssentiallyZero = 10e-12;
$m = floor($trials * $probability);
++$TotalUnscaledProbability;
if ($m == $Guess) { ++$UnscaledPGuess; }
if ($m <= $Guess) { ++$UnscaledCumPGuess; }
$PreviousValue = 1;
$Done = False;
$k = $m + 1;
while ((!$Done) && ($k <= $trials)) {
$CurrentValue = $PreviousValue * ($trials - $k + 1) * $probability / ($k * (1 - $probability));
$TotalUnscaledProbability += $CurrentValue;
if ($k == $Guess) { $UnscaledPGuess += $CurrentValue; }
if ($k <= $Guess) { $UnscaledCumPGuess += $CurrentValue; }
if ($CurrentValue <= $EssentiallyZero) { $Done = True; }
$PreviousValue = $CurrentValue;
++$k;
}
$PreviousValue = 1;
$Done = False;
$k = $m - 1;
while ((!$Done) && ($k >= 0)) {
$CurrentValue = $PreviousValue * $k + 1 * (1 - $probability) / (($trials - $k) * $probability);
$TotalUnscaledProbability += $CurrentValue;
if ($k == $Guess) { $UnscaledPGuess += $CurrentValue; }
if ($k <= $Guess) { $UnscaledCumPGuess += $CurrentValue; }
if ($CurrentValue <= $EssentiallyZero) { $Done = True; }
$PreviousValue = $CurrentValue;
--$k;
}
$PGuess = $UnscaledPGuess / $TotalUnscaledProbability;
$CumPGuess = $UnscaledCumPGuess / $TotalUnscaledProbability;
// $CumPGuessMinus1 = $CumPGuess - $PGuess;
$CumPGuessMinus1 = $CumPGuess - 1;
while (True) {
if (($CumPGuessMinus1 < $alpha) && ($CumPGuess >= $alpha)) {
return $Guess;
} elseif (($CumPGuessMinus1 < $alpha) && ($CumPGuess < $alpha)) {
$PGuessPlus1 = $PGuess * ($trials - $Guess) * $probability / $Guess / (1 - $probability);
$CumPGuessMinus1 = $CumPGuess;
$CumPGuess = $CumPGuess + $PGuessPlus1;
$PGuess = $PGuessPlus1;
++$Guess;
} elseif (($CumPGuessMinus1 >= $alpha) && ($CumPGuess >= $alpha)) {
$PGuessMinus1 = $PGuess * $Guess * (1 - $probability) / ($trials - $Guess + 1) / $probability;
$CumPGuess = $CumPGuessMinus1;
$CumPGuessMinus1 = $CumPGuessMinus1 - $PGuess;
$PGuess = $PGuessMinus1;
--$Guess;
}
}
}
return PHPExcel_Calculation_Functions::VALUE();
} // function CRITBINOM()

+ Here is the call graph for this function:

static PHPExcel_Calculation_Statistical::DEVSQ ( )
static

Definition at line 1430 of file Statistical.php.

References $arg, AVERAGE(), PHPExcel_Calculation_Functions\COMPATIBILITY_OPENOFFICE, PHPExcel_Calculation_Functions\DIV0(), PHPExcel_Calculation_Functions\flattenArrayIndexed(), PHPExcel_Calculation_Functions\getCompatibilityMode(), PHPExcel_Calculation_Functions\isCellValue(), and PHPExcel_Calculation_Functions\NaN().

{
$aArgs = PHPExcel_Calculation_Functions::flattenArrayIndexed(func_get_args());
// Return value
$returnValue = null;
$aMean = self::AVERAGE($aArgs);
if ($aMean != PHPExcel_Calculation_Functions::DIV0()) {
$aCount = -1;
foreach ($aArgs as $k => $arg) {
// Is it a numeric value?
if ((is_bool($arg)) &&
((!PHPExcel_Calculation_Functions::isCellValue($k)) || (PHPExcel_Calculation_Functions::getCompatibilityMode() == PHPExcel_Calculation_Functions::COMPATIBILITY_OPENOFFICE))) {
$arg = (integer) $arg;
}
if ((is_numeric($arg)) && (!is_string($arg))) {
if (is_null($returnValue)) {
$returnValue = pow(($arg - $aMean),2);
} else {
$returnValue += pow(($arg - $aMean),2);
}
++$aCount;
}
}
// Return
if (is_null($returnValue)) {
return PHPExcel_Calculation_Functions::NaN();
} else {
return $returnValue;
}
}
return self::NA();
} // function DEVSQ()

+ Here is the call graph for this function:

static PHPExcel_Calculation_Statistical::EXPONDIST (   $value,
  $lambda,
  $cumulative 
)
static

EXPONDIST.

Returns the exponential distribution. Use EXPONDIST to model the time between events, such as how long an automated bank teller takes to deliver cash. For example, you can use EXPONDIST to determine the probability that the process takes at most 1 minute.

Parameters
float$valueValue of the function
float$lambdaThe parameter value
boolean$cumulative
Returns
float

Definition at line 1478 of file Statistical.php.

References PHPExcel_Calculation_Functions\flattenSingleValue(), PHPExcel_Calculation_Functions\NaN(), and PHPExcel_Calculation_Functions\VALUE().

{
$value = PHPExcel_Calculation_Functions::flattenSingleValue($value);
$lambda = PHPExcel_Calculation_Functions::flattenSingleValue($lambda);
$cumulative = PHPExcel_Calculation_Functions::flattenSingleValue($cumulative);
if ((is_numeric($value)) && (is_numeric($lambda))) {
if (($value < 0) || ($lambda < 0)) {
return PHPExcel_Calculation_Functions::NaN();
}
if ((is_numeric($cumulative)) || (is_bool($cumulative))) {
if ($cumulative) {
return 1 - exp(0-$value*$lambda);
} else {
return $lambda * exp(0-$value*$lambda);
}
}
}
return PHPExcel_Calculation_Functions::VALUE();
} // function EXPONDIST()

+ Here is the call graph for this function:

static PHPExcel_Calculation_Statistical::FISHER (   $value)
static

FISHER.

Returns the Fisher transformation at x. This transformation produces a function that is normally distributed rather than skewed. Use this function to perform hypothesis testing on the correlation coefficient.

Parameters
float$value
Returns
float

Definition at line 1509 of file Statistical.php.

References PHPExcel_Calculation_Functions\flattenSingleValue(), PHPExcel_Calculation_Functions\NaN(), and PHPExcel_Calculation_Functions\VALUE().

{
$value = PHPExcel_Calculation_Functions::flattenSingleValue($value);
if (is_numeric($value)) {
if (($value <= -1) || ($value >= 1)) {
return PHPExcel_Calculation_Functions::NaN();
}
return 0.5 * log((1+$value)/(1-$value));
}
return PHPExcel_Calculation_Functions::VALUE();
} // function FISHER()

+ Here is the call graph for this function:

static PHPExcel_Calculation_Statistical::FISHERINV (   $value)
static

FISHERINV.

Returns the inverse of the Fisher transformation. Use this transformation when analyzing correlations between ranges or arrays of data. If y = FISHER(x), then FISHERINV(y) = x.

Parameters
float$value
Returns
float

Definition at line 1532 of file Statistical.php.

References PHPExcel_Calculation_Functions\flattenSingleValue(), and PHPExcel_Calculation_Functions\VALUE().

{
$value = PHPExcel_Calculation_Functions::flattenSingleValue($value);
if (is_numeric($value)) {
return (exp(2 * $value) - 1) / (exp(2 * $value) + 1);
}
return PHPExcel_Calculation_Functions::VALUE();
} // function FISHERINV()

+ Here is the call graph for this function:

static PHPExcel_Calculation_Statistical::FORECAST (   $xValue,
  $yValues,
  $xValues 
)
static

FORECAST.

Calculates, or predicts, a future value by using existing values. The predicted value is a y-value for a given x-value.

Parameters
floatValue of X for which we want to find Y
arrayof mixed Data Series Y
arrayof mixed Data Series X
Returns
float

Definition at line 1552 of file Statistical.php.

References trendClass\calculate(), PHPExcel_Calculation_Functions\DIV0(), PHPExcel_Calculation_Functions\flattenSingleValue(), PHPExcel_Calculation_Functions\NA(), trendClass\TREND_LINEAR, and PHPExcel_Calculation_Functions\VALUE().

{
$xValue = PHPExcel_Calculation_Functions::flattenSingleValue($xValue);
if (!is_numeric($xValue)) {
return PHPExcel_Calculation_Functions::VALUE();
}
if (!self::_checkTrendArrays($yValues,$xValues)) {
return PHPExcel_Calculation_Functions::VALUE();
}
$yValueCount = count($yValues);
$xValueCount = count($xValues);
if (($yValueCount == 0) || ($yValueCount != $xValueCount)) {
return PHPExcel_Calculation_Functions::NA();
} elseif ($yValueCount == 1) {
return PHPExcel_Calculation_Functions::DIV0();
}
$bestFitLinear = trendClass::calculate(trendClass::TREND_LINEAR,$yValues,$xValues);
return $bestFitLinear->getValueOfYForX($xValue);
} // function FORECAST()

+ Here is the call graph for this function:

static PHPExcel_Calculation_Statistical::GAMMADIST (   $value,
  $a,
  $b,
  $cumulative 
)
static

GAMMADIST.

Returns the gamma distribution.

Parameters
float$valueValue at which you want to evaluate the distribution
float$aParameter to the distribution
float$bParameter to the distribution
boolean$cumulative
Returns
float

Definition at line 1587 of file Statistical.php.

References _gamma(), _incompleteGamma(), PHPExcel_Calculation_Functions\flattenSingleValue(), PHPExcel_Calculation_Functions\NaN(), and PHPExcel_Calculation_Functions\VALUE().

Referenced by GAMMAINV().

{
$value = PHPExcel_Calculation_Functions::flattenSingleValue($value);
$a = PHPExcel_Calculation_Functions::flattenSingleValue($a);
$b = PHPExcel_Calculation_Functions::flattenSingleValue($b);
if ((is_numeric($value)) && (is_numeric($a)) && (is_numeric($b))) {
if (($value < 0) || ($a <= 0) || ($b <= 0)) {
return PHPExcel_Calculation_Functions::NaN();
}
if ((is_numeric($cumulative)) || (is_bool($cumulative))) {
if ($cumulative) {
return self::_incompleteGamma($a,$value / $b) / self::_gamma($a);
} else {
return (1 / (pow($b,$a) * self::_gamma($a))) * pow($value,$a-1) * exp(0-($value / $b));
}
}
}
return PHPExcel_Calculation_Functions::VALUE();
} // function GAMMADIST()

+ Here is the call graph for this function:

+ Here is the caller graph for this function:

static PHPExcel_Calculation_Statistical::GAMMAINV (   $probability,
  $alpha,
  $beta 
)
static

GAMMAINV.

Returns the inverse of the beta distribution.

Parameters
float$probabilityProbability at which you want to evaluate the distribution
float$alphaParameter to the distribution
float$betaParameter to the distribution
Returns
float

Definition at line 1619 of file Statistical.php.

References $error, $x, PHPExcel_Calculation_Functions\flattenSingleValue(), GAMMADIST(), MAX_ITERATIONS, PHPExcel_Calculation_Functions\NA(), PHPExcel_Calculation_Functions\NaN(), PRECISION, and PHPExcel_Calculation_Functions\VALUE().

{
$probability = PHPExcel_Calculation_Functions::flattenSingleValue($probability);
$alpha = PHPExcel_Calculation_Functions::flattenSingleValue($alpha);
$beta = PHPExcel_Calculation_Functions::flattenSingleValue($beta);
if ((is_numeric($probability)) && (is_numeric($alpha)) && (is_numeric($beta))) {
if (($alpha <= 0) || ($beta <= 0) || ($probability < 0) || ($probability > 1)) {
return PHPExcel_Calculation_Functions::NaN();
}
$xLo = 0;
$xHi = $alpha * $beta * 5;
$x = $xNew = 1;
$error = $pdf = 0;
$dx = 1024;
$i = 0;
while ((abs($dx) > PRECISION) && ($i++ < MAX_ITERATIONS)) {
// Apply Newton-Raphson step
$error = self::GAMMADIST($x, $alpha, $beta, True) - $probability;
if ($error < 0.0) {
$xLo = $x;
} else {
$xHi = $x;
}
$pdf = self::GAMMADIST($x, $alpha, $beta, False);
// Avoid division by zero
if ($pdf != 0.0) {
$dx = $error / $pdf;
$xNew = $x - $dx;
}
// If the NR fails to converge (which for example may be the
// case if the initial guess is too rough) we apply a bisection
// step to determine a more narrow interval around the root.
if (($xNew < $xLo) || ($xNew > $xHi) || ($pdf == 0.0)) {
$xNew = ($xLo + $xHi) / 2;
$dx = $xNew - $x;
}
$x = $xNew;
}
if ($i == MAX_ITERATIONS) {
return PHPExcel_Calculation_Functions::NA();
}
return $x;
}
return PHPExcel_Calculation_Functions::VALUE();
} // function GAMMAINV()

+ Here is the call graph for this function:

static PHPExcel_Calculation_Statistical::GAMMALN (   $value)
static

GAMMALN.

Returns the natural logarithm of the gamma function.

Parameters
float$value
Returns
float

Definition at line 1677 of file Statistical.php.

References PHPExcel_Calculation_Functions\flattenSingleValue(), PHPExcel_Calculation_Functions\NaN(), and PHPExcel_Calculation_Functions\VALUE().

{
$value = PHPExcel_Calculation_Functions::flattenSingleValue($value);
if (is_numeric($value)) {
if ($value <= 0) {
return PHPExcel_Calculation_Functions::NaN();
}
return log(self::_gamma($value));
}
return PHPExcel_Calculation_Functions::VALUE();
} // function GAMMALN()

+ Here is the call graph for this function:

static PHPExcel_Calculation_Statistical::GEOMEAN ( )
static

Definition at line 1705 of file Statistical.php.

References COUNT(), PHPExcel_Calculation_Functions\flattenArray(), PHPExcel_Calculation_Functions\NaN(), and PHPExcel_Calculation_MathTrig\PRODUCT().

{
$aArgs = PHPExcel_Calculation_Functions::flattenArray(func_get_args());
$aMean = PHPExcel_Calculation_MathTrig::PRODUCT($aArgs);
if (is_numeric($aMean) && ($aMean > 0)) {
$aCount = self::COUNT($aArgs) ;
if (self::MIN($aArgs) > 0) {
return pow($aMean, (1 / $aCount));
}
}
return PHPExcel_Calculation_Functions::NaN();
} // GEOMEAN()

+ Here is the call graph for this function:

static PHPExcel_Calculation_Statistical::GROWTH (   $yValues,
  $xValues = array(),
  $newValues = array(),
  $const = True 
)
static

GROWTH.

Returns values along a predicted emponential trend

Parameters
arrayof mixed Data Series Y
arrayof mixed Data Series X
arrayof mixed Values of X for which we want to find Y
booleanA logical value specifying whether to force the intersect to equal 0.
Returns
array of float

Definition at line 1730 of file Statistical.php.

References trendClass\calculate(), PHPExcel_Calculation_Functions\flattenArray(), PHPExcel_Calculation_Functions\flattenSingleValue(), and trendClass\TREND_EXPONENTIAL.

{
$yValues = PHPExcel_Calculation_Functions::flattenArray($yValues);
$xValues = PHPExcel_Calculation_Functions::flattenArray($xValues);
$newValues = PHPExcel_Calculation_Functions::flattenArray($newValues);
$const = (is_null($const)) ? True : (boolean) PHPExcel_Calculation_Functions::flattenSingleValue($const);
$bestFitExponential = trendClass::calculate(trendClass::TREND_EXPONENTIAL,$yValues,$xValues,$const);
if (count($newValues) == 0) {
$newValues = $bestFitExponential->getXValues();
}
$returnArray = array();
foreach($newValues as $xValue) {
$returnArray[0][] = $bestFitExponential->getValueOfYForX($xValue);
}
return $returnArray;
} // function GROWTH()

+ Here is the call graph for this function:

static PHPExcel_Calculation_Statistical::HARMEAN ( )
static

Definition at line 1764 of file Statistical.php.

References $arg, PHPExcel_Calculation_Functions\flattenArray(), PHPExcel_Calculation_Functions\NA(), and PHPExcel_Calculation_Functions\NaN().

{
// Return value
$returnValue = PHPExcel_Calculation_Functions::NA();
// Loop through arguments
$aArgs = PHPExcel_Calculation_Functions::flattenArray(func_get_args());
if (self::MIN($aArgs) < 0) {
return PHPExcel_Calculation_Functions::NaN();
}
$aCount = 0;
foreach ($aArgs as $arg) {
// Is it a numeric value?
if ((is_numeric($arg)) && (!is_string($arg))) {
if ($arg <= 0) {
return PHPExcel_Calculation_Functions::NaN();
}
if (is_null($returnValue)) {
$returnValue = (1 / $arg);
} else {
$returnValue += (1 / $arg);
}
++$aCount;
}
}
// Return
if ($aCount > 0) {
return 1 / ($returnValue / $aCount);
} else {
return $returnValue;
}
} // function HARMEAN()

+ Here is the call graph for this function:

static PHPExcel_Calculation_Statistical::HYPGEOMDIST (   $sampleSuccesses,
  $sampleNumber,
  $populationSuccesses,
  $populationNumber 
)
static

HYPGEOMDIST.

Returns the hypergeometric distribution. HYPGEOMDIST returns the probability of a given number of sample successes, given the sample size, population successes, and population size.

Parameters
float$sampleSuccessesNumber of successes in the sample
float$sampleNumberSize of the sample
float$populationSuccessesNumber of successes in the population
float$populationNumberPopulation size
Returns
float

Definition at line 1811 of file Statistical.php.

References PHPExcel_Calculation_MathTrig\COMBIN(), PHPExcel_Calculation_Functions\flattenSingleValue(), PHPExcel_Calculation_Functions\NaN(), and PHPExcel_Calculation_Functions\VALUE().

{
$sampleSuccesses = floor(PHPExcel_Calculation_Functions::flattenSingleValue($sampleSuccesses));
$sampleNumber = floor(PHPExcel_Calculation_Functions::flattenSingleValue($sampleNumber));
$populationSuccesses = floor(PHPExcel_Calculation_Functions::flattenSingleValue($populationSuccesses));
$populationNumber = floor(PHPExcel_Calculation_Functions::flattenSingleValue($populationNumber));
if ((is_numeric($sampleSuccesses)) && (is_numeric($sampleNumber)) && (is_numeric($populationSuccesses)) && (is_numeric($populationNumber))) {
if (($sampleSuccesses < 0) || ($sampleSuccesses > $sampleNumber) || ($sampleSuccesses > $populationSuccesses)) {
return PHPExcel_Calculation_Functions::NaN();
}
if (($sampleNumber <= 0) || ($sampleNumber > $populationNumber)) {
return PHPExcel_Calculation_Functions::NaN();
}
if (($populationSuccesses <= 0) || ($populationSuccesses > $populationNumber)) {
return PHPExcel_Calculation_Functions::NaN();
}
return PHPExcel_Calculation_MathTrig::COMBIN($populationSuccesses,$sampleSuccesses) *
PHPExcel_Calculation_MathTrig::COMBIN($populationNumber - $populationSuccesses,$sampleNumber - $sampleSuccesses) /
PHPExcel_Calculation_MathTrig::COMBIN($populationNumber,$sampleNumber);
}
return PHPExcel_Calculation_Functions::VALUE();
} // function HYPGEOMDIST()

+ Here is the call graph for this function:

static PHPExcel_Calculation_Statistical::INTERCEPT (   $yValues,
  $xValues 
)
static

INTERCEPT.

Calculates the point at which a line will intersect the y-axis by using existing x-values and y-values.

Parameters
arrayof mixed Data Series Y
arrayof mixed Data Series X
Returns
float

Definition at line 1844 of file Statistical.php.

References trendClass\calculate(), PHPExcel_Calculation_Functions\DIV0(), PHPExcel_Calculation_Functions\NA(), trendClass\TREND_LINEAR, and PHPExcel_Calculation_Functions\VALUE().

{
if (!self::_checkTrendArrays($yValues,$xValues)) {
return PHPExcel_Calculation_Functions::VALUE();
}
$yValueCount = count($yValues);
$xValueCount = count($xValues);
if (($yValueCount == 0) || ($yValueCount != $xValueCount)) {
return PHPExcel_Calculation_Functions::NA();
} elseif ($yValueCount == 1) {
return PHPExcel_Calculation_Functions::DIV0();
}
$bestFitLinear = trendClass::calculate(trendClass::TREND_LINEAR,$yValues,$xValues);
return $bestFitLinear->getIntersect();
} // function INTERCEPT()

+ Here is the call graph for this function:

static PHPExcel_Calculation_Statistical::KURT ( )
static

KURT.

Returns the kurtosis of a data set. Kurtosis characterizes the relative peakedness or flatness of a distribution compared with the normal distribution. Positive kurtosis indicates a relatively peaked distribution. Negative kurtosis indicates a relatively flat distribution.

Parameters
arrayData Series
Returns
float

Definition at line 1873 of file Statistical.php.

References $arg, AVERAGE(), PHPExcel_Calculation_Functions\DIV0(), PHPExcel_Calculation_Functions\flattenArrayIndexed(), PHPExcel_Calculation_Functions\isMatrixValue(), and STDEV().

{
$aArgs = PHPExcel_Calculation_Functions::flattenArrayIndexed(func_get_args());
$mean = self::AVERAGE($aArgs);
$stdDev = self::STDEV($aArgs);
if ($stdDev > 0) {
$count = $summer = 0;
// Loop through arguments
foreach ($aArgs as $k => $arg) {
if ((is_bool($arg)) &&
(!PHPExcel_Calculation_Functions::isMatrixValue($k))) {
} else {
// Is it a numeric value?
if ((is_numeric($arg)) && (!is_string($arg))) {
$summer += pow((($arg - $mean) / $stdDev),4) ;
++$count;
}
}
}
// Return
if ($count > 3) {
return $summer * ($count * ($count+1) / (($count-1) * ($count-2) * ($count-3))) - (3 * pow($count-1,2) / (($count-2) * ($count-3)));
}
}
return PHPExcel_Calculation_Functions::DIV0();
} // function KURT()

+ Here is the call graph for this function:

static PHPExcel_Calculation_Statistical::LARGE ( )
static

Definition at line 1918 of file Statistical.php.

References $arg, COUNT(), PHPExcel_Calculation_Functions\flattenArray(), PHPExcel_Calculation_Functions\NaN(), and PHPExcel_Calculation_Functions\VALUE().

{
$aArgs = PHPExcel_Calculation_Functions::flattenArray(func_get_args());
// Calculate
$entry = floor(array_pop($aArgs));
if ((is_numeric($entry)) && (!is_string($entry))) {
$mArgs = array();
foreach ($aArgs as $arg) {
// Is it a numeric value?
if ((is_numeric($arg)) && (!is_string($arg))) {
$mArgs[] = $arg;
}
}
$count = self::COUNT($mArgs);
$entry = floor(--$entry);
if (($entry < 0) || ($entry >= $count) || ($count == 0)) {
return PHPExcel_Calculation_Functions::NaN();
}
rsort($mArgs);
return $mArgs[$entry];
}
return PHPExcel_Calculation_Functions::VALUE();
} // function LARGE()

+ Here is the call graph for this function:

static PHPExcel_Calculation_Statistical::LINEST (   $yValues,
  $xValues = null,
  $const = True,
  $stats = False 
)
static

LINEST.

Calculates the statistics for a line by using the "least squares" method to calculate a straight line that best fits your data, and then returns an array that describes the line.

Parameters
arrayof mixed Data Series Y
arrayof mixed Data Series X
booleanA logical value specifying whether to force the intersect to equal 0.
booleanA logical value specifying whether to return additional regression statistics.
Returns
array

Definition at line 1956 of file Statistical.php.

References trendClass\calculate(), PHPExcel_Calculation_Functions\flattenArray(), PHPExcel_Calculation_Functions\flattenSingleValue(), PHPExcel_Calculation_Functions\NA(), trendClass\TREND_LINEAR, and PHPExcel_Calculation_Functions\VALUE().

{
$const = (is_null($const)) ? True : (boolean) PHPExcel_Calculation_Functions::flattenSingleValue($const);
$stats = (is_null($stats)) ? False : (boolean) PHPExcel_Calculation_Functions::flattenSingleValue($stats);
if (is_null($xValues)) $xValues = range(1,count(PHPExcel_Calculation_Functions::flattenArray($yValues)));
if (!self::_checkTrendArrays($yValues,$xValues)) {
return PHPExcel_Calculation_Functions::VALUE();
}
$yValueCount = count($yValues);
$xValueCount = count($xValues);
if (($yValueCount == 0) || ($yValueCount != $xValueCount)) {
return PHPExcel_Calculation_Functions::NA();
} elseif ($yValueCount == 1) {
return 0;
}
$bestFitLinear = trendClass::calculate(trendClass::TREND_LINEAR,$yValues,$xValues,$const);
if ($stats) {
return array( array( $bestFitLinear->getSlope(),
$bestFitLinear->getSlopeSE(),
$bestFitLinear->getGoodnessOfFit(),
$bestFitLinear->getF(),
$bestFitLinear->getSSRegression(),
),
array( $bestFitLinear->getIntersect(),
$bestFitLinear->getIntersectSE(),
$bestFitLinear->getStdevOfResiduals(),
$bestFitLinear->getDFResiduals(),
$bestFitLinear->getSSResiduals()
)
);
} else {
return array( $bestFitLinear->getSlope(),
$bestFitLinear->getIntersect()
);
}
} // function LINEST()

+ Here is the call graph for this function:

static PHPExcel_Calculation_Statistical::LOGEST (   $yValues,
  $xValues = null,
  $const = True,
  $stats = False 
)
static

LOGEST.

Calculates an exponential curve that best fits the X and Y data series, and then returns an array that describes the line.

Parameters
arrayof mixed Data Series Y
arrayof mixed Data Series X
booleanA logical value specifying whether to force the intersect to equal 0.
booleanA logical value specifying whether to return additional regression statistics.
Returns
array

Definition at line 2009 of file Statistical.php.

References trendClass\calculate(), PHPExcel_Calculation_Functions\flattenArray(), PHPExcel_Calculation_Functions\flattenSingleValue(), PHPExcel_Calculation_Functions\NA(), PHPExcel_Calculation_Functions\NaN(), trendClass\TREND_EXPONENTIAL, and PHPExcel_Calculation_Functions\VALUE().

{
$const = (is_null($const)) ? True : (boolean) PHPExcel_Calculation_Functions::flattenSingleValue($const);
$stats = (is_null($stats)) ? False : (boolean) PHPExcel_Calculation_Functions::flattenSingleValue($stats);
if (is_null($xValues)) $xValues = range(1,count(PHPExcel_Calculation_Functions::flattenArray($yValues)));
if (!self::_checkTrendArrays($yValues,$xValues)) {
return PHPExcel_Calculation_Functions::VALUE();
}
$yValueCount = count($yValues);
$xValueCount = count($xValues);
foreach($yValues as $value) {
if ($value <= 0.0) {
return PHPExcel_Calculation_Functions::NaN();
}
}
if (($yValueCount == 0) || ($yValueCount != $xValueCount)) {
return PHPExcel_Calculation_Functions::NA();
} elseif ($yValueCount == 1) {
return 1;
}
$bestFitExponential = trendClass::calculate(trendClass::TREND_EXPONENTIAL,$yValues,$xValues,$const);
if ($stats) {
return array( array( $bestFitExponential->getSlope(),
$bestFitExponential->getSlopeSE(),
$bestFitExponential->getGoodnessOfFit(),
$bestFitExponential->getF(),
$bestFitExponential->getSSRegression(),
),
array( $bestFitExponential->getIntersect(),
$bestFitExponential->getIntersectSE(),
$bestFitExponential->getStdevOfResiduals(),
$bestFitExponential->getDFResiduals(),
$bestFitExponential->getSSResiduals()
)
);
} else {
return array( $bestFitExponential->getSlope(),
$bestFitExponential->getIntersect()
);
}
} // function LOGEST()

+ Here is the call graph for this function:

static PHPExcel_Calculation_Statistical::LOGINV (   $probability,
  $mean,
  $stdDev 
)
static

LOGINV.

Returns the inverse of the normal cumulative distribution

Parameters
float$value
Returns
float
Todo:
Try implementing P J Acklam's refinement algorithm for greater accuracy if I can get my head round the mathematics (as described at) http://home.online.no/~pjacklam/notes/invnorm/

Definition at line 2068 of file Statistical.php.

References PHPExcel_Calculation_Functions\flattenSingleValue(), PHPExcel_Calculation_Functions\NaN(), and PHPExcel_Calculation_Functions\VALUE().

{
$probability = PHPExcel_Calculation_Functions::flattenSingleValue($probability);
$mean = PHPExcel_Calculation_Functions::flattenSingleValue($mean);
$stdDev = PHPExcel_Calculation_Functions::flattenSingleValue($stdDev);
if ((is_numeric($probability)) && (is_numeric($mean)) && (is_numeric($stdDev))) {
if (($probability < 0) || ($probability > 1) || ($stdDev <= 0)) {
return PHPExcel_Calculation_Functions::NaN();
}
return exp($mean + $stdDev * self::NORMSINV($probability));
}
return PHPExcel_Calculation_Functions::VALUE();
} // function LOGINV()

+ Here is the call graph for this function:

static PHPExcel_Calculation_Statistical::LOGNORMDIST (   $value,
  $mean,
  $stdDev 
)
static

LOGNORMDIST.

Returns the cumulative lognormal distribution of x, where ln(x) is normally distributed with parameters mean and standard_dev.

Parameters
float$value
Returns
float

Definition at line 2092 of file Statistical.php.

References PHPExcel_Calculation_Functions\flattenSingleValue(), PHPExcel_Calculation_Functions\NaN(), NORMSDIST(), and PHPExcel_Calculation_Functions\VALUE().

{
$value = PHPExcel_Calculation_Functions::flattenSingleValue($value);
$mean = PHPExcel_Calculation_Functions::flattenSingleValue($mean);
$stdDev = PHPExcel_Calculation_Functions::flattenSingleValue($stdDev);
if ((is_numeric($value)) && (is_numeric($mean)) && (is_numeric($stdDev))) {
if (($value <= 0) || ($stdDev <= 0)) {
return PHPExcel_Calculation_Functions::NaN();
}
return self::NORMSDIST((log($value) - $mean) / $stdDev);
}
return PHPExcel_Calculation_Functions::VALUE();
} // function LOGNORMDIST()

+ Here is the call graph for this function:

static PHPExcel_Calculation_Statistical::MAX ( )
static

Definition at line 2121 of file Statistical.php.

References $arg, and PHPExcel_Calculation_Functions\flattenArray().

Referenced by PHPExcel_Calculation_Database\DMAX(), and PHPExcel_Calculation_MathTrig\SUBTOTAL().

{
// Return value
$returnValue = null;
// Loop through arguments
$aArgs = PHPExcel_Calculation_Functions::flattenArray(func_get_args());
foreach ($aArgs as $arg) {
// Is it a numeric value?
if ((is_numeric($arg)) && (!is_string($arg))) {
if ((is_null($returnValue)) || ($arg > $returnValue)) {
$returnValue = $arg;
}
}
}
// Return
if(is_null($returnValue)) {
return 0;
}
return $returnValue;
} // function MAX()

+ Here is the call graph for this function:

+ Here is the caller graph for this function:

static PHPExcel_Calculation_Statistical::MAXA ( )
static

Definition at line 2157 of file Statistical.php.

References $arg, and PHPExcel_Calculation_Functions\flattenArray().

{
// Return value
$returnValue = null;
// Loop through arguments
$aArgs = PHPExcel_Calculation_Functions::flattenArray(func_get_args());
foreach ($aArgs as $arg) {
// Is it a numeric value?
if ((is_numeric($arg)) || (is_bool($arg)) || ((is_string($arg) && ($arg != '')))) {
if (is_bool($arg)) {
$arg = (integer) $arg;
} elseif (is_string($arg)) {
$arg = 0;
}
if ((is_null($returnValue)) || ($arg > $returnValue)) {
$returnValue = $arg;
}
}
}
// Return
if(is_null($returnValue)) {
return 0;
}
return $returnValue;
} // function MAXA()

+ Here is the call graph for this function:

static PHPExcel_Calculation_Statistical::MAXIF (   $aArgs,
  $condition,
  $sumArgs = array() 
)
static

Definition at line 2199 of file Statistical.php.

References $arg, PHPExcel_Calculation_Functions\_ifCondition(), PHPExcel_Calculation\_wrapResult(), PHPExcel_Calculation_Functions\flattenArray(), and PHPExcel_Calculation\getInstance().

{
// Return value
$returnValue = null;
$aArgs = PHPExcel_Calculation_Functions::flattenArray($aArgs);
$sumArgs = PHPExcel_Calculation_Functions::flattenArray($sumArgs);
if (count($sumArgs) == 0) {
$sumArgs = $aArgs;
}
$condition = PHPExcel_Calculation_Functions::_ifCondition($condition);
// Loop through arguments
foreach ($aArgs as $key => $arg) {
if (!is_numeric($arg)) { $arg = PHPExcel_Calculation::_wrapResult(strtoupper($arg)); }
$testCondition = '='.$arg.$condition;
if (PHPExcel_Calculation::getInstance()->_calculateFormulaValue($testCondition)) {
if ((is_null($returnValue)) || ($arg > $returnValue)) {
$returnValue = $arg;
}
}
}
// Return
return $returnValue;
} // function MAXIF()

+ Here is the call graph for this function:

static PHPExcel_Calculation_Statistical::MEDIAN ( )
static

Definition at line 2238 of file Statistical.php.

References $arg, PHPExcel_Calculation_Functions\flattenArray(), and PHPExcel_Calculation_Functions\NaN().

{
// Return value
$returnValue = PHPExcel_Calculation_Functions::NaN();
$mArgs = array();
// Loop through arguments
$aArgs = PHPExcel_Calculation_Functions::flattenArray(func_get_args());
foreach ($aArgs as $arg) {
// Is it a numeric value?
if ((is_numeric($arg)) && (!is_string($arg))) {
$mArgs[] = $arg;
}
}
$mValueCount = count($mArgs);
if ($mValueCount > 0) {
sort($mArgs,SORT_NUMERIC);
$mValueCount = $mValueCount / 2;
if ($mValueCount == floor($mValueCount)) {
$returnValue = ($mArgs[$mValueCount--] + $mArgs[$mValueCount]) / 2;
} else {
$mValueCount == floor($mValueCount);
$returnValue = $mArgs[$mValueCount];
}
}
// Return
return $returnValue;
} // function MEDIAN()

+ Here is the call graph for this function:

static PHPExcel_Calculation_Statistical::MIN ( )
static

Definition at line 2283 of file Statistical.php.

References $arg, and PHPExcel_Calculation_Functions\flattenArray().

Referenced by PHPExcel_Calculation_Database\DMIN(), and PHPExcel_Calculation_MathTrig\SUBTOTAL().

{
// Return value
$returnValue = null;
// Loop through arguments
$aArgs = PHPExcel_Calculation_Functions::flattenArray(func_get_args());
foreach ($aArgs as $arg) {
// Is it a numeric value?
if ((is_numeric($arg)) && (!is_string($arg))) {
if ((is_null($returnValue)) || ($arg < $returnValue)) {
$returnValue = $arg;
}
}
}
// Return
if(is_null($returnValue)) {
return 0;
}
return $returnValue;
} // function MIN()

+ Here is the call graph for this function:

+ Here is the caller graph for this function:

static PHPExcel_Calculation_Statistical::MINA ( )
static

Definition at line 2319 of file Statistical.php.

References $arg, and PHPExcel_Calculation_Functions\flattenArray().

{
// Return value
$returnValue = null;
// Loop through arguments
$aArgs = PHPExcel_Calculation_Functions::flattenArray(func_get_args());
foreach ($aArgs as $arg) {
// Is it a numeric value?
if ((is_numeric($arg)) || (is_bool($arg)) || ((is_string($arg) && ($arg != '')))) {
if (is_bool($arg)) {
$arg = (integer) $arg;
} elseif (is_string($arg)) {
$arg = 0;
}
if ((is_null($returnValue)) || ($arg < $returnValue)) {
$returnValue = $arg;
}
}
}
// Return
if(is_null($returnValue)) {
return 0;
}
return $returnValue;
} // function MINA()

+ Here is the call graph for this function:

static PHPExcel_Calculation_Statistical::MINIF (   $aArgs,
  $condition,
  $sumArgs = array() 
)
static

Definition at line 2361 of file Statistical.php.

References $arg, PHPExcel_Calculation_Functions\_ifCondition(), PHPExcel_Calculation\_wrapResult(), PHPExcel_Calculation_Functions\flattenArray(), and PHPExcel_Calculation\getInstance().

{
// Return value
$returnValue = null;
$aArgs = PHPExcel_Calculation_Functions::flattenArray($aArgs);
$sumArgs = PHPExcel_Calculation_Functions::flattenArray($sumArgs);
if (count($sumArgs) == 0) {
$sumArgs = $aArgs;
}
$condition = PHPExcel_Calculation_Functions::_ifCondition($condition);
// Loop through arguments
foreach ($aArgs as $key => $arg) {
if (!is_numeric($arg)) { $arg = PHPExcel_Calculation::_wrapResult(strtoupper($arg)); }
$testCondition = '='.$arg.$condition;
if (PHPExcel_Calculation::getInstance()->_calculateFormulaValue($testCondition)) {
if ((is_null($returnValue)) || ($arg < $returnValue)) {
$returnValue = $arg;
}
}
}
// Return
return $returnValue;
} // function MINIF()

+ Here is the call graph for this function:

static PHPExcel_Calculation_Statistical::MODE ( )
static

Definition at line 2434 of file Statistical.php.

References $arg, _modeCalc(), PHPExcel_Calculation_Functions\flattenArray(), and PHPExcel_Calculation_Functions\NA().

{
// Return value
$returnValue = PHPExcel_Calculation_Functions::NA();
// Loop through arguments
$aArgs = PHPExcel_Calculation_Functions::flattenArray(func_get_args());
$mArgs = array();
foreach ($aArgs as $arg) {
// Is it a numeric value?
if ((is_numeric($arg)) && (!is_string($arg))) {
$mArgs[] = $arg;
}
}
if (count($mArgs) > 0) {
return self::_modeCalc($mArgs);
}
// Return
return $returnValue;
} // function MODE()

+ Here is the call graph for this function:

static PHPExcel_Calculation_Statistical::NEGBINOMDIST (   $failures,
  $successes,
  $probability 
)
static

NEGBINOMDIST.

Returns the negative binomial distribution. NEGBINOMDIST returns the probability that there will be number_f failures before the number_s-th success, when the constant probability of a success is probability_s. This function is similar to the binomial distribution, except that the number of successes is fixed, and the number of trials is variable. Like the binomial, trials are assumed to be independent.

Parameters
float$failuresNumber of Failures
float$successesThreshold number of Successes
float$probabilityProbability of success on each trial
Returns
float

Definition at line 2473 of file Statistical.php.

References PHPExcel_Calculation_MathTrig\COMBIN(), PHPExcel_Calculation_Functions\COMPATIBILITY_GNUMERIC, PHPExcel_Calculation_Functions\flattenSingleValue(), PHPExcel_Calculation_Functions\getCompatibilityMode(), PHPExcel_Calculation_Functions\NaN(), and PHPExcel_Calculation_Functions\VALUE().

{
$failures = floor(PHPExcel_Calculation_Functions::flattenSingleValue($failures));
$successes = floor(PHPExcel_Calculation_Functions::flattenSingleValue($successes));
$probability = PHPExcel_Calculation_Functions::flattenSingleValue($probability);
if ((is_numeric($failures)) && (is_numeric($successes)) && (is_numeric($probability))) {
if (($failures < 0) || ($successes < 1)) {
return PHPExcel_Calculation_Functions::NaN();
}
if (($probability < 0) || ($probability > 1)) {
return PHPExcel_Calculation_Functions::NaN();
}
if (PHPExcel_Calculation_Functions::getCompatibilityMode() == PHPExcel_Calculation_Functions::COMPATIBILITY_GNUMERIC) {
if (($failures + $successes - 1) <= 0) {
return PHPExcel_Calculation_Functions::NaN();
}
}
return (PHPExcel_Calculation_MathTrig::COMBIN($failures + $successes - 1,$successes - 1)) * (pow($probability,$successes)) * (pow(1 - $probability,$failures)) ;
}
return PHPExcel_Calculation_Functions::VALUE();
} // function NEGBINOMDIST()

+ Here is the call graph for this function:

static PHPExcel_Calculation_Statistical::NORMDIST (   $value,
  $mean,
  $stdDev,
  $cumulative 
)
static

NORMDIST.

Returns the normal distribution for the specified mean and standard deviation. This function has a very wide range of applications in statistics, including hypothesis testing.

Parameters
float$value
float$meanMean Value
float$stdDevStandard Deviation
boolean$cumulative
Returns
float

Definition at line 2510 of file Statistical.php.

References PHPExcel_Calculation_Engineering\_erfVal(), PHPExcel_Calculation_Functions\flattenSingleValue(), PHPExcel_Calculation_Functions\NaN(), SQRT2PI, and PHPExcel_Calculation_Functions\VALUE().

Referenced by NORMSDIST().

{
$value = PHPExcel_Calculation_Functions::flattenSingleValue($value);
$mean = PHPExcel_Calculation_Functions::flattenSingleValue($mean);
$stdDev = PHPExcel_Calculation_Functions::flattenSingleValue($stdDev);
if ((is_numeric($value)) && (is_numeric($mean)) && (is_numeric($stdDev))) {
if ($stdDev < 0) {
return PHPExcel_Calculation_Functions::NaN();
}
if ((is_numeric($cumulative)) || (is_bool($cumulative))) {
if ($cumulative) {
return 0.5 * (1 + PHPExcel_Calculation_Engineering::_erfVal(($value - $mean) / ($stdDev * sqrt(2))));
} else {
return (1 / (SQRT2PI * $stdDev)) * exp(0 - (pow($value - $mean,2) / (2 * ($stdDev * $stdDev))));
}
}
}
return PHPExcel_Calculation_Functions::VALUE();
} // function NORMDIST()

+ Here is the call graph for this function:

+ Here is the caller graph for this function:

static PHPExcel_Calculation_Statistical::NORMINV (   $probability,
  $mean,
  $stdDev 
)
static

NORMINV.

Returns the inverse of the normal cumulative distribution for the specified mean and standard deviation.

Parameters
float$value
float$meanMean Value
float$stdDevStandard Deviation
Returns
float

Definition at line 2542 of file Statistical.php.

References PHPExcel_Calculation_Functions\flattenSingleValue(), PHPExcel_Calculation_Functions\NaN(), and PHPExcel_Calculation_Functions\VALUE().

Referenced by NORMSINV().

{
$probability = PHPExcel_Calculation_Functions::flattenSingleValue($probability);
$mean = PHPExcel_Calculation_Functions::flattenSingleValue($mean);
$stdDev = PHPExcel_Calculation_Functions::flattenSingleValue($stdDev);
if ((is_numeric($probability)) && (is_numeric($mean)) && (is_numeric($stdDev))) {
if (($probability < 0) || ($probability > 1)) {
return PHPExcel_Calculation_Functions::NaN();
}
if ($stdDev < 0) {
return PHPExcel_Calculation_Functions::NaN();
}
return (self::_inverse_ncdf($probability) * $stdDev) + $mean;
}
return PHPExcel_Calculation_Functions::VALUE();
} // function NORMINV()

+ Here is the call graph for this function:

+ Here is the caller graph for this function:

static PHPExcel_Calculation_Statistical::NORMSDIST (   $value)
static

NORMSDIST.

Returns the standard normal cumulative distribution function. The distribution has a mean of 0 (zero) and a standard deviation of one. Use this function in place of a table of standard normal curve areas.

Parameters
float$value
Returns
float

Definition at line 2570 of file Statistical.php.

References PHPExcel_Calculation_Functions\flattenSingleValue(), and NORMDIST().

Referenced by LOGNORMDIST(), and ZTEST().

{
$value = PHPExcel_Calculation_Functions::flattenSingleValue($value);
return self::NORMDIST($value, 0, 1, True);
} // function NORMSDIST()

+ Here is the call graph for this function:

+ Here is the caller graph for this function:

static PHPExcel_Calculation_Statistical::NORMSINV (   $value)
static

NORMSINV.

Returns the inverse of the standard normal cumulative distribution

Parameters
float$value
Returns
float

Definition at line 2585 of file Statistical.php.

References NORMINV().

Referenced by CONFIDENCE().

{
return self::NORMINV($value, 0, 1);
} // function NORMSINV()

+ Here is the call graph for this function:

+ Here is the caller graph for this function:

static PHPExcel_Calculation_Statistical::PERCENTILE ( )
static

Definition at line 2604 of file Statistical.php.

References $arg, COUNT(), PHPExcel_Calculation_Functions\flattenArray(), PHPExcel_Calculation_Functions\NaN(), and PHPExcel_Calculation_Functions\VALUE().

Referenced by QUARTILE().

{
$aArgs = PHPExcel_Calculation_Functions::flattenArray(func_get_args());
// Calculate
$entry = array_pop($aArgs);
if ((is_numeric($entry)) && (!is_string($entry))) {
if (($entry < 0) || ($entry > 1)) {
return PHPExcel_Calculation_Functions::NaN();
}
$mArgs = array();
foreach ($aArgs as $arg) {
// Is it a numeric value?
if ((is_numeric($arg)) && (!is_string($arg))) {
$mArgs[] = $arg;
}
}
$mValueCount = count($mArgs);
if ($mValueCount > 0) {
sort($mArgs);
$count = self::COUNT($mArgs);
$index = $entry * ($count-1);
$iBase = floor($index);
if ($index == $iBase) {
return $mArgs[$index];
} else {
$iNext = $iBase + 1;
$iProportion = $index - $iBase;
return $mArgs[$iBase] + (($mArgs[$iNext] - $mArgs[$iBase]) * $iProportion) ;
}
}
}
return PHPExcel_Calculation_Functions::VALUE();
} // function PERCENTILE()

+ Here is the call graph for this function:

+ Here is the caller graph for this function:

static PHPExcel_Calculation_Statistical::PERCENTRANK (   $valueSet,
  $value,
  $significance = 3 
)
static

PERCENTRANK.

Returns the rank of a value in a data set as a percentage of the data set.

Parameters
arrayof number An array of, or a reference to, a list of numbers.
numberThe number whose rank you want to find.
numberThe number of significant digits for the returned percentage value.
Returns
float

Definition at line 2650 of file Statistical.php.

References $pos, PHPExcel_Calculation_Functions\flattenArray(), PHPExcel_Calculation_Functions\flattenSingleValue(), PHPExcel_Calculation_Functions\NA(), and PHPExcel_Calculation_Functions\NaN().

{
$valueSet = PHPExcel_Calculation_Functions::flattenArray($valueSet);
$value = PHPExcel_Calculation_Functions::flattenSingleValue($value);
$significance = (is_null($significance)) ? 3 : (integer) PHPExcel_Calculation_Functions::flattenSingleValue($significance);
foreach($valueSet as $key => $valueEntry) {
if (!is_numeric($valueEntry)) {
unset($valueSet[$key]);
}
}
sort($valueSet,SORT_NUMERIC);
$valueCount = count($valueSet);
if ($valueCount == 0) {
return PHPExcel_Calculation_Functions::NaN();
}
$valueAdjustor = $valueCount - 1;
if (($value < $valueSet[0]) || ($value > $valueSet[$valueAdjustor])) {
return PHPExcel_Calculation_Functions::NA();
}
$pos = array_search($value,$valueSet);
if ($pos === False) {
$pos = 0;
$testValue = $valueSet[0];
while ($testValue < $value) {
$testValue = $valueSet[++$pos];
}
--$pos;
$pos += (($value - $valueSet[$pos]) / ($testValue - $valueSet[$pos]));
}
return round($pos / $valueAdjustor,$significance);
} // function PERCENTRANK()

+ Here is the call graph for this function:

static PHPExcel_Calculation_Statistical::PERMUT (   $numObjs,
  $numInSet 
)
static

PERMUT.

Returns the number of permutations for a given number of objects that can be selected from number objects. A permutation is any set or subset of objects or events where internal order is significant. Permutations are different from combinations, for which the internal order is not significant. Use this function for lottery-style probability calculations.

Parameters
int$numObjsNumber of different objects
int$numInSetNumber of objects in each permutation
Returns
int Number of permutations

Definition at line 2699 of file Statistical.php.

References PHPExcel_Calculation_MathTrig\FACT(), PHPExcel_Calculation_Functions\flattenSingleValue(), PHPExcel_Calculation_Functions\NaN(), and PHPExcel_Calculation_Functions\VALUE().

{
$numObjs = PHPExcel_Calculation_Functions::flattenSingleValue($numObjs);
$numInSet = PHPExcel_Calculation_Functions::flattenSingleValue($numInSet);
if ((is_numeric($numObjs)) && (is_numeric($numInSet))) {
$numInSet = floor($numInSet);
if ($numObjs < $numInSet) {
return PHPExcel_Calculation_Functions::NaN();
}
return round(PHPExcel_Calculation_MathTrig::FACT($numObjs) / PHPExcel_Calculation_MathTrig::FACT($numObjs - $numInSet));
}
return PHPExcel_Calculation_Functions::VALUE();
} // function PERMUT()

+ Here is the call graph for this function:

static PHPExcel_Calculation_Statistical::POISSON (   $value,
  $mean,
  $cumulative 
)
static

POISSON.

Returns the Poisson distribution. A common application of the Poisson distribution is predicting the number of events over a specific time, such as the number of cars arriving at a toll plaza in 1 minute.

Parameters
float$value
float$meanMean Value
boolean$cumulative
Returns
float

Definition at line 2727 of file Statistical.php.

References PHPExcel_Calculation_MathTrig\FACT(), PHPExcel_Calculation_Functions\flattenSingleValue(), PHPExcel_Calculation_Functions\NaN(), and PHPExcel_Calculation_Functions\VALUE().

{
$value = PHPExcel_Calculation_Functions::flattenSingleValue($value);
$mean = PHPExcel_Calculation_Functions::flattenSingleValue($mean);
if ((is_numeric($value)) && (is_numeric($mean))) {
if (($value <= 0) || ($mean <= 0)) {
return PHPExcel_Calculation_Functions::NaN();
}
if ((is_numeric($cumulative)) || (is_bool($cumulative))) {
if ($cumulative) {
$summer = 0;
for ($i = 0; $i <= floor($value); ++$i) {
$summer += pow($mean,$i) / PHPExcel_Calculation_MathTrig::FACT($i);
}
return exp(0-$mean) * $summer;
} else {
return (exp(0-$mean) * pow($mean,$value)) / PHPExcel_Calculation_MathTrig::FACT($value);
}
}
}
return PHPExcel_Calculation_Functions::VALUE();
} // function POISSON()

+ Here is the call graph for this function:

static PHPExcel_Calculation_Statistical::QUARTILE ( )
static

Definition at line 2765 of file Statistical.php.

References PHPExcel_Calculation_Functions\flattenArray(), PHPExcel_Calculation_Functions\NaN(), PERCENTILE(), and PHPExcel_Calculation_Functions\VALUE().

{
$aArgs = PHPExcel_Calculation_Functions::flattenArray(func_get_args());
// Calculate
$entry = floor(array_pop($aArgs));
if ((is_numeric($entry)) && (!is_string($entry))) {
$entry /= 4;
if (($entry < 0) || ($entry > 1)) {
return PHPExcel_Calculation_Functions::NaN();
}
return self::PERCENTILE($aArgs,$entry);
}
return PHPExcel_Calculation_Functions::VALUE();
} // function QUARTILE()

+ Here is the call graph for this function:

static PHPExcel_Calculation_Statistical::RANK (   $value,
  $valueSet,
  $order = 0 
)
static

RANK.

Returns the rank of a number in a list of numbers.

Parameters
numberThe number whose rank you want to find.
arrayof number An array of, or a reference to, a list of numbers.
mixedOrder to sort the values in the value set
Returns
float

Definition at line 2792 of file Statistical.php.

References $pos, PHPExcel_Calculation_Functions\flattenArray(), PHPExcel_Calculation_Functions\flattenSingleValue(), and PHPExcel_Calculation_Functions\NA().

{
$value = PHPExcel_Calculation_Functions::flattenSingleValue($value);
$valueSet = PHPExcel_Calculation_Functions::flattenArray($valueSet);
$order = (is_null($order)) ? 0 : (integer) PHPExcel_Calculation_Functions::flattenSingleValue($order);
foreach($valueSet as $key => $valueEntry) {
if (!is_numeric($valueEntry)) {
unset($valueSet[$key]);
}
}
if ($order == 0) {
rsort($valueSet,SORT_NUMERIC);
} else {
sort($valueSet,SORT_NUMERIC);
}
$pos = array_search($value,$valueSet);
if ($pos === False) {
return PHPExcel_Calculation_Functions::NA();
}
return ++$pos;
} // function RANK()

+ Here is the call graph for this function:

static PHPExcel_Calculation_Statistical::RSQ (   $yValues,
  $xValues 
)
static

RSQ.

Returns the square of the Pearson product moment correlation coefficient through data points in known_y's and known_x's.

Parameters
arrayof mixed Data Series Y
arrayof mixed Data Series X
Returns
float

Definition at line 2826 of file Statistical.php.

References trendClass\calculate(), PHPExcel_Calculation_Functions\DIV0(), PHPExcel_Calculation_Functions\NA(), trendClass\TREND_LINEAR, and PHPExcel_Calculation_Functions\VALUE().

{
if (!self::_checkTrendArrays($yValues,$xValues)) {
return PHPExcel_Calculation_Functions::VALUE();
}
$yValueCount = count($yValues);
$xValueCount = count($xValues);
if (($yValueCount == 0) || ($yValueCount != $xValueCount)) {
return PHPExcel_Calculation_Functions::NA();
} elseif ($yValueCount == 1) {
return PHPExcel_Calculation_Functions::DIV0();
}
$bestFitLinear = trendClass::calculate(trendClass::TREND_LINEAR,$yValues,$xValues);
return $bestFitLinear->getGoodnessOfFit();
} // function RSQ()

+ Here is the call graph for this function:

static PHPExcel_Calculation_Statistical::SKEW ( )
static

SKEW.

Returns the skewness of a distribution. Skewness characterizes the degree of asymmetry of a distribution around its mean. Positive skewness indicates a distribution with an asymmetric tail extending toward more positive values. Negative skewness indicates a distribution with an asymmetric tail extending toward more negative values.

Parameters
arrayData Series
Returns
float

Definition at line 2855 of file Statistical.php.

References $arg, AVERAGE(), PHPExcel_Calculation_Functions\DIV0(), PHPExcel_Calculation_Functions\flattenArrayIndexed(), PHPExcel_Calculation_Functions\isMatrixValue(), and STDEV().

{
$aArgs = PHPExcel_Calculation_Functions::flattenArrayIndexed(func_get_args());
$mean = self::AVERAGE($aArgs);
$stdDev = self::STDEV($aArgs);
$count = $summer = 0;
// Loop through arguments
foreach ($aArgs as $k => $arg) {
if ((is_bool($arg)) &&
(!PHPExcel_Calculation_Functions::isMatrixValue($k))) {
} else {
// Is it a numeric value?
if ((is_numeric($arg)) && (!is_string($arg))) {
$summer += pow((($arg - $mean) / $stdDev),3) ;
++$count;
}
}
}
// Return
if ($count > 2) {
return $summer * ($count / (($count-1) * ($count-2)));
}
return PHPExcel_Calculation_Functions::DIV0();
} // function SKEW()

+ Here is the call graph for this function:

static PHPExcel_Calculation_Statistical::SLOPE (   $yValues,
  $xValues 
)
static

SLOPE.

Returns the slope of the linear regression line through data points in known_y's and known_x's.

Parameters
arrayof mixed Data Series Y
arrayof mixed Data Series X
Returns
float

Definition at line 2891 of file Statistical.php.

References trendClass\calculate(), PHPExcel_Calculation_Functions\DIV0(), PHPExcel_Calculation_Functions\NA(), trendClass\TREND_LINEAR, and PHPExcel_Calculation_Functions\VALUE().

{
if (!self::_checkTrendArrays($yValues,$xValues)) {
return PHPExcel_Calculation_Functions::VALUE();
}
$yValueCount = count($yValues);
$xValueCount = count($xValues);
if (($yValueCount == 0) || ($yValueCount != $xValueCount)) {
return PHPExcel_Calculation_Functions::NA();
} elseif ($yValueCount == 1) {
return PHPExcel_Calculation_Functions::DIV0();
}
$bestFitLinear = trendClass::calculate(trendClass::TREND_LINEAR,$yValues,$xValues);
return $bestFitLinear->getSlope();
} // function SLOPE()

+ Here is the call graph for this function:

static PHPExcel_Calculation_Statistical::SMALL ( )
static

Definition at line 2924 of file Statistical.php.

References $arg, COUNT(), PHPExcel_Calculation_Functions\flattenArray(), PHPExcel_Calculation_Functions\NaN(), and PHPExcel_Calculation_Functions\VALUE().

{
$aArgs = PHPExcel_Calculation_Functions::flattenArray(func_get_args());
// Calculate
$entry = array_pop($aArgs);
if ((is_numeric($entry)) && (!is_string($entry))) {
$mArgs = array();
foreach ($aArgs as $arg) {
// Is it a numeric value?
if ((is_numeric($arg)) && (!is_string($arg))) {
$mArgs[] = $arg;
}
}
$count = self::COUNT($mArgs);
$entry = floor(--$entry);
if (($entry < 0) || ($entry >= $count) || ($count == 0)) {
return PHPExcel_Calculation_Functions::NaN();
}
sort($mArgs);
return $mArgs[$entry];
}
return PHPExcel_Calculation_Functions::VALUE();
} // function SMALL()

+ Here is the call graph for this function:

static PHPExcel_Calculation_Statistical::STANDARDIZE (   $value,
  $mean,
  $stdDev 
)
static

STANDARDIZE.

Returns a normalized value from a distribution characterized by mean and standard_dev.

Parameters
float$valueValue to normalize
float$meanMean Value
float$stdDevStandard Deviation
Returns
float Standardized value

Definition at line 2960 of file Statistical.php.

References PHPExcel_Calculation_Functions\flattenSingleValue(), PHPExcel_Calculation_Functions\NaN(), and PHPExcel_Calculation_Functions\VALUE().

{
$value = PHPExcel_Calculation_Functions::flattenSingleValue($value);
$mean = PHPExcel_Calculation_Functions::flattenSingleValue($mean);
$stdDev = PHPExcel_Calculation_Functions::flattenSingleValue($stdDev);
if ((is_numeric($value)) && (is_numeric($mean)) && (is_numeric($stdDev))) {
if ($stdDev <= 0) {
return PHPExcel_Calculation_Functions::NaN();
}
return ($value - $mean) / $stdDev ;
}
return PHPExcel_Calculation_Functions::VALUE();
} // function STANDARDIZE()

+ Here is the call graph for this function:

static PHPExcel_Calculation_Statistical::STDEV ( )
static

Definition at line 2989 of file Statistical.php.

References $arg, AVERAGE(), PHPExcel_Calculation_Functions\COMPATIBILITY_OPENOFFICE, PHPExcel_Calculation_Functions\DIV0(), PHPExcel_Calculation_Functions\flattenArrayIndexed(), PHPExcel_Calculation_Functions\getCompatibilityMode(), and PHPExcel_Calculation_Functions\isCellValue().

Referenced by PHPExcel_Calculation_Database\DSTDEV(), KURT(), SKEW(), PHPExcel_Calculation_MathTrig\SUBTOTAL(), and ZTEST().

{
$aArgs = PHPExcel_Calculation_Functions::flattenArrayIndexed(func_get_args());
// Return value
$returnValue = null;
$aMean = self::AVERAGE($aArgs);
if (!is_null($aMean)) {
$aCount = -1;
foreach ($aArgs as $k => $arg) {
if ((is_bool($arg)) &&
((!PHPExcel_Calculation_Functions::isCellValue($k)) || (PHPExcel_Calculation_Functions::getCompatibilityMode() == PHPExcel_Calculation_Functions::COMPATIBILITY_OPENOFFICE))) {
$arg = (integer) $arg;
}
// Is it a numeric value?
if ((is_numeric($arg)) && (!is_string($arg))) {
if (is_null($returnValue)) {
$returnValue = pow(($arg - $aMean),2);
} else {
$returnValue += pow(($arg - $aMean),2);
}
++$aCount;
}
}
// Return
if (($aCount > 0) && ($returnValue >= 0)) {
return sqrt($returnValue / $aCount);
}
}
return PHPExcel_Calculation_Functions::DIV0();
} // function STDEV()

+ Here is the call graph for this function:

+ Here is the caller graph for this function:

static PHPExcel_Calculation_Statistical::STDEVA ( )
static

Definition at line 3036 of file Statistical.php.

References $arg, AVERAGEA(), PHPExcel_Calculation_Functions\DIV0(), PHPExcel_Calculation_Functions\flattenArrayIndexed(), and PHPExcel_Calculation_Functions\isMatrixValue().

{
$aArgs = PHPExcel_Calculation_Functions::flattenArrayIndexed(func_get_args());
// Return value
$returnValue = null;
$aMean = self::AVERAGEA($aArgs);
if (!is_null($aMean)) {
$aCount = -1;
foreach ($aArgs as $k => $arg) {
if ((is_bool($arg)) &&
(!PHPExcel_Calculation_Functions::isMatrixValue($k))) {
} else {
// Is it a numeric value?
if ((is_numeric($arg)) || (is_bool($arg)) || ((is_string($arg) & ($arg != '')))) {
if (is_bool($arg)) {
$arg = (integer) $arg;
} elseif (is_string($arg)) {
$arg = 0;
}
if (is_null($returnValue)) {
$returnValue = pow(($arg - $aMean),2);
} else {
$returnValue += pow(($arg - $aMean),2);
}
++$aCount;
}
}
}
// Return
if (($aCount > 0) && ($returnValue >= 0)) {
return sqrt($returnValue / $aCount);
}
}
return PHPExcel_Calculation_Functions::DIV0();
} // function STDEVA()

+ Here is the call graph for this function:

static PHPExcel_Calculation_Statistical::STDEVP ( )
static

Definition at line 3088 of file Statistical.php.

References $arg, AVERAGE(), PHPExcel_Calculation_Functions\COMPATIBILITY_OPENOFFICE, PHPExcel_Calculation_Functions\DIV0(), PHPExcel_Calculation_Functions\flattenArrayIndexed(), PHPExcel_Calculation_Functions\getCompatibilityMode(), and PHPExcel_Calculation_Functions\isCellValue().

Referenced by PHPExcel_Calculation_Database\DSTDEVP(), and PHPExcel_Calculation_MathTrig\SUBTOTAL().

{
$aArgs = PHPExcel_Calculation_Functions::flattenArrayIndexed(func_get_args());
// Return value
$returnValue = null;
$aMean = self::AVERAGE($aArgs);
if (!is_null($aMean)) {
$aCount = 0;
foreach ($aArgs as $k => $arg) {
if ((is_bool($arg)) &&
((!PHPExcel_Calculation_Functions::isCellValue($k)) || (PHPExcel_Calculation_Functions::getCompatibilityMode() == PHPExcel_Calculation_Functions::COMPATIBILITY_OPENOFFICE))) {
$arg = (integer) $arg;
}
// Is it a numeric value?
if ((is_numeric($arg)) && (!is_string($arg))) {
if (is_null($returnValue)) {
$returnValue = pow(($arg - $aMean),2);
} else {
$returnValue += pow(($arg - $aMean),2);
}
++$aCount;
}
}
// Return
if (($aCount > 0) && ($returnValue >= 0)) {
return sqrt($returnValue / $aCount);
}
}
return PHPExcel_Calculation_Functions::DIV0();
} // function STDEVP()

+ Here is the call graph for this function:

+ Here is the caller graph for this function:

static PHPExcel_Calculation_Statistical::STDEVPA ( )
static

Definition at line 3135 of file Statistical.php.

References $arg, AVERAGEA(), PHPExcel_Calculation_Functions\DIV0(), PHPExcel_Calculation_Functions\flattenArrayIndexed(), and PHPExcel_Calculation_Functions\isMatrixValue().

{
$aArgs = PHPExcel_Calculation_Functions::flattenArrayIndexed(func_get_args());
// Return value
$returnValue = null;
$aMean = self::AVERAGEA($aArgs);
if (!is_null($aMean)) {
$aCount = 0;
foreach ($aArgs as $k => $arg) {
if ((is_bool($arg)) &&
(!PHPExcel_Calculation_Functions::isMatrixValue($k))) {
} else {
// Is it a numeric value?
if ((is_numeric($arg)) || (is_bool($arg)) || ((is_string($arg) & ($arg != '')))) {
if (is_bool($arg)) {
$arg = (integer) $arg;
} elseif (is_string($arg)) {
$arg = 0;
}
if (is_null($returnValue)) {
$returnValue = pow(($arg - $aMean),2);
} else {
$returnValue += pow(($arg - $aMean),2);
}
++$aCount;
}
}
}
// Return
if (($aCount > 0) && ($returnValue >= 0)) {
return sqrt($returnValue / $aCount);
}
}
return PHPExcel_Calculation_Functions::DIV0();
} // function STDEVPA()

+ Here is the call graph for this function:

static PHPExcel_Calculation_Statistical::STEYX (   $yValues,
  $xValues 
)
static

STEYX.

Returns the standard error of the predicted y-value for each x in the regression.

Parameters
arrayof mixed Data Series Y
arrayof mixed Data Series X
Returns
float

Definition at line 3183 of file Statistical.php.

References trendClass\calculate(), PHPExcel_Calculation_Functions\DIV0(), PHPExcel_Calculation_Functions\NA(), trendClass\TREND_LINEAR, and PHPExcel_Calculation_Functions\VALUE().

{
if (!self::_checkTrendArrays($yValues,$xValues)) {
return PHPExcel_Calculation_Functions::VALUE();
}
$yValueCount = count($yValues);
$xValueCount = count($xValues);
if (($yValueCount == 0) || ($yValueCount != $xValueCount)) {
return PHPExcel_Calculation_Functions::NA();
} elseif ($yValueCount == 1) {
return PHPExcel_Calculation_Functions::DIV0();
}
$bestFitLinear = trendClass::calculate(trendClass::TREND_LINEAR,$yValues,$xValues);
return $bestFitLinear->getStdevOfResiduals();
} // function STEYX()

+ Here is the call graph for this function:

static PHPExcel_Calculation_Statistical::TDIST (   $value,
  $degrees,
  $tails 
)
static

TDIST.

Returns the probability of Student's T distribution.

Parameters
float$valueValue for the function
float$degreesdegrees of freedom
float$tailsnumber of tails (1 or 2)
Returns
float

Definition at line 3211 of file Statistical.php.

References PHPExcel_Calculation_Functions\flattenSingleValue(), M_2DIVPI, PHPExcel_Calculation_Functions\NaN(), and PHPExcel_Calculation_Functions\VALUE().

Referenced by TINV().

{
$value = PHPExcel_Calculation_Functions::flattenSingleValue($value);
$degrees = floor(PHPExcel_Calculation_Functions::flattenSingleValue($degrees));
$tails = floor(PHPExcel_Calculation_Functions::flattenSingleValue($tails));
if ((is_numeric($value)) && (is_numeric($degrees)) && (is_numeric($tails))) {
if (($value < 0) || ($degrees < 1) || ($tails < 1) || ($tails > 2)) {
return PHPExcel_Calculation_Functions::NaN();
}
// tdist, which finds the probability that corresponds to a given value
// of t with k degrees of freedom. This algorithm is translated from a
// pascal function on p81 of "Statistical Computing in Pascal" by D
// Cooke, A H Craven & G M Clark (1985: Edward Arnold (Pubs.) Ltd:
// London). The above Pascal algorithm is itself a translation of the
// fortran algoritm "AS 3" by B E Cooper of the Atlas Computer
// Laboratory as reported in (among other places) "Applied Statistics
// Algorithms", editied by P Griffiths and I D Hill (1985; Ellis
// Horwood Ltd.; W. Sussex, England).
$tterm = $degrees;
$ttheta = atan2($value,sqrt($tterm));
$tc = cos($ttheta);
$ts = sin($ttheta);
$tsum = 0;
if (($degrees % 2) == 1) {
$ti = 3;
$tterm = $tc;
} else {
$ti = 2;
$tterm = 1;
}
$tsum = $tterm;
while ($ti < $degrees) {
$tterm *= $tc * $tc * ($ti - 1) / $ti;
$tsum += $tterm;
$ti += 2;
}
$tsum *= $ts;
if (($degrees % 2) == 1) { $tsum = M_2DIVPI * ($tsum + $ttheta); }
$tValue = 0.5 * (1 + $tsum);
if ($tails == 1) {
return 1 - abs($tValue);
} else {
return 1 - abs((1 - $tValue) - $tValue);
}
}
return PHPExcel_Calculation_Functions::VALUE();
} // function TDIST()

+ Here is the call graph for this function:

+ Here is the caller graph for this function:

static PHPExcel_Calculation_Statistical::TINV (   $probability,
  $degrees 
)
static

TINV.

Returns the one-tailed probability of the chi-squared distribution.

Parameters
float$probabilityProbability for the function
float$degreesdegrees of freedom
Returns
float

Definition at line 3271 of file Statistical.php.

References $error, $x, PHPExcel_Calculation_Functions\flattenSingleValue(), MAX_ITERATIONS, PHPExcel_Calculation_Functions\NA(), PRECISION, TDIST(), and PHPExcel_Calculation_Functions\VALUE().

{
$probability = PHPExcel_Calculation_Functions::flattenSingleValue($probability);
$degrees = floor(PHPExcel_Calculation_Functions::flattenSingleValue($degrees));
if ((is_numeric($probability)) && (is_numeric($degrees))) {
$xLo = 100;
$xHi = 0;
$x = $xNew = 1;
$dx = 1;
$i = 0;
while ((abs($dx) > PRECISION) && ($i++ < MAX_ITERATIONS)) {
// Apply Newton-Raphson step
$result = self::TDIST($x, $degrees, 2);
$error = $result - $probability;
if ($error == 0.0) {
$dx = 0;
} elseif ($error < 0.0) {
$xLo = $x;
} else {
$xHi = $x;
}
// Avoid division by zero
if ($result != 0.0) {
$dx = $error / $result;
$xNew = $x - $dx;
}
// If the NR fails to converge (which for example may be the
// case if the initial guess is too rough) we apply a bisection
// step to determine a more narrow interval around the root.
if (($xNew < $xLo) || ($xNew > $xHi) || ($result == 0.0)) {
$xNew = ($xLo + $xHi) / 2;
$dx = $xNew - $x;
}
$x = $xNew;
}
if ($i == MAX_ITERATIONS) {
return PHPExcel_Calculation_Functions::NA();
}
return round($x,12);
}
return PHPExcel_Calculation_Functions::VALUE();
} // function TINV()

+ Here is the call graph for this function:

static PHPExcel_Calculation_Statistical::TREND (   $yValues,
  $xValues = array(),
  $newValues = array(),
  $const = True 
)
static

TREND.

Returns values along a linear trend

Parameters
arrayof mixed Data Series Y
arrayof mixed Data Series X
arrayof mixed Values of X for which we want to find Y
booleanA logical value specifying whether to force the intersect to equal 0.
Returns
array of float

Definition at line 3328 of file Statistical.php.

References trendClass\calculate(), PHPExcel_Calculation_Functions\flattenArray(), PHPExcel_Calculation_Functions\flattenSingleValue(), and trendClass\TREND_LINEAR.

{
$yValues = PHPExcel_Calculation_Functions::flattenArray($yValues);
$xValues = PHPExcel_Calculation_Functions::flattenArray($xValues);
$newValues = PHPExcel_Calculation_Functions::flattenArray($newValues);
$const = (is_null($const)) ? True : (boolean) PHPExcel_Calculation_Functions::flattenSingleValue($const);
$bestFitLinear = trendClass::calculate(trendClass::TREND_LINEAR,$yValues,$xValues,$const);
if (count($newValues) == 0) {
$newValues = $bestFitLinear->getXValues();
}
$returnArray = array();
foreach($newValues as $xValue) {
$returnArray[0][] = $bestFitLinear->getValueOfYForX($xValue);
}
return $returnArray;
} // function TREND()

+ Here is the call graph for this function:

static PHPExcel_Calculation_Statistical::TRIMMEAN ( )
static

Definition at line 3364 of file Statistical.php.

References $arg, AVERAGE(), PHPExcel_Calculation_Functions\flattenArray(), PHPExcel_Calculation_Functions\NaN(), and PHPExcel_Calculation_Functions\VALUE().

{
$aArgs = PHPExcel_Calculation_Functions::flattenArray(func_get_args());
// Calculate
$percent = array_pop($aArgs);
if ((is_numeric($percent)) && (!is_string($percent))) {
if (($percent < 0) || ($percent > 1)) {
return PHPExcel_Calculation_Functions::NaN();
}
$mArgs = array();
foreach ($aArgs as $arg) {
// Is it a numeric value?
if ((is_numeric($arg)) && (!is_string($arg))) {
$mArgs[] = $arg;
}
}
$discard = floor(self::COUNT($mArgs) * $percent / 2);
sort($mArgs);
for ($i=0; $i < $discard; ++$i) {
array_pop($mArgs);
array_shift($mArgs);
}
return self::AVERAGE($mArgs);
}
return PHPExcel_Calculation_Functions::VALUE();
} // function TRIMMEAN()

+ Here is the call graph for this function:

static PHPExcel_Calculation_Statistical::VARA ( )
static

Definition at line 3448 of file Statistical.php.

References $arg, PHPExcel_Calculation_Functions\DIV0(), PHPExcel_Calculation_Functions\flattenArrayIndexed(), PHPExcel_Calculation_Functions\isMatrixValue(), PHPExcel_Calculation_Functions\isValue(), and PHPExcel_Calculation_Functions\VALUE().

{
// Return value
$returnValue = PHPExcel_Calculation_Functions::DIV0();
$summerA = $summerB = 0;
// Loop through arguments
$aArgs = PHPExcel_Calculation_Functions::flattenArrayIndexed(func_get_args());
$aCount = 0;
foreach ($aArgs as $k => $arg) {
if ((is_string($arg)) &&
(PHPExcel_Calculation_Functions::isValue($k))) {
return PHPExcel_Calculation_Functions::VALUE();
} elseif ((is_string($arg)) &&
(!PHPExcel_Calculation_Functions::isMatrixValue($k))) {
} else {
// Is it a numeric value?
if ((is_numeric($arg)) || (is_bool($arg)) || ((is_string($arg) & ($arg != '')))) {
if (is_bool($arg)) {
$arg = (integer) $arg;
} elseif (is_string($arg)) {
$arg = 0;
}
$summerA += ($arg * $arg);
$summerB += $arg;
++$aCount;
}
}
}
// Return
if ($aCount > 1) {
$summerA *= $aCount;
$summerB *= $summerB;
$returnValue = ($summerA - $summerB) / ($aCount * ($aCount - 1));
}
return $returnValue;
} // function VARA()

+ Here is the call graph for this function:

static PHPExcel_Calculation_Statistical::VARFunc ( )
static

Definition at line 3406 of file Statistical.php.

References $arg, PHPExcel_Calculation_Functions\DIV0(), and PHPExcel_Calculation_Functions\flattenArray().

Referenced by PHPExcel_Calculation_Database\DVAR(), and PHPExcel_Calculation_MathTrig\SUBTOTAL().

{
// Return value
$returnValue = PHPExcel_Calculation_Functions::DIV0();
$summerA = $summerB = 0;
// Loop through arguments
$aArgs = PHPExcel_Calculation_Functions::flattenArray(func_get_args());
$aCount = 0;
foreach ($aArgs as $arg) {
if (is_bool($arg)) { $arg = (integer) $arg; }
// Is it a numeric value?
if ((is_numeric($arg)) && (!is_string($arg))) {
$summerA += ($arg * $arg);
$summerB += $arg;
++$aCount;
}
}
// Return
if ($aCount > 1) {
$summerA *= $aCount;
$summerB *= $summerB;
$returnValue = ($summerA - $summerB) / ($aCount * ($aCount - 1));
}
return $returnValue;
} // function VARFunc()

+ Here is the call graph for this function:

+ Here is the caller graph for this function:

static PHPExcel_Calculation_Statistical::VARP ( )
static

Definition at line 3501 of file Statistical.php.

References $arg, PHPExcel_Calculation_Functions\DIV0(), and PHPExcel_Calculation_Functions\flattenArray().

Referenced by PHPExcel_Calculation_Database\DVARP(), and PHPExcel_Calculation_MathTrig\SUBTOTAL().

{
// Return value
$returnValue = PHPExcel_Calculation_Functions::DIV0();
$summerA = $summerB = 0;
// Loop through arguments
$aArgs = PHPExcel_Calculation_Functions::flattenArray(func_get_args());
$aCount = 0;
foreach ($aArgs as $arg) {
if (is_bool($arg)) { $arg = (integer) $arg; }
// Is it a numeric value?
if ((is_numeric($arg)) && (!is_string($arg))) {
$summerA += ($arg * $arg);
$summerB += $arg;
++$aCount;
}
}
// Return
if ($aCount > 0) {
$summerA *= $aCount;
$summerB *= $summerB;
$returnValue = ($summerA - $summerB) / ($aCount * $aCount);
}
return $returnValue;
} // function VARP()

+ Here is the call graph for this function:

+ Here is the caller graph for this function:

static PHPExcel_Calculation_Statistical::VARPA ( )
static

Definition at line 3543 of file Statistical.php.

References $arg, PHPExcel_Calculation_Functions\DIV0(), PHPExcel_Calculation_Functions\flattenArrayIndexed(), PHPExcel_Calculation_Functions\isMatrixValue(), PHPExcel_Calculation_Functions\isValue(), and PHPExcel_Calculation_Functions\VALUE().

{
// Return value
$returnValue = PHPExcel_Calculation_Functions::DIV0();
$summerA = $summerB = 0;
// Loop through arguments
$aArgs = PHPExcel_Calculation_Functions::flattenArrayIndexed(func_get_args());
$aCount = 0;
foreach ($aArgs as $k => $arg) {
if ((is_string($arg)) &&
(PHPExcel_Calculation_Functions::isValue($k))) {
return PHPExcel_Calculation_Functions::VALUE();
} elseif ((is_string($arg)) &&
(!PHPExcel_Calculation_Functions::isMatrixValue($k))) {
} else {
// Is it a numeric value?
if ((is_numeric($arg)) || (is_bool($arg)) || ((is_string($arg) & ($arg != '')))) {
if (is_bool($arg)) {
$arg = (integer) $arg;
} elseif (is_string($arg)) {
$arg = 0;
}
$summerA += ($arg * $arg);
$summerB += $arg;
++$aCount;
}
}
}
// Return
if ($aCount > 0) {
$summerA *= $aCount;
$summerB *= $summerB;
$returnValue = ($summerA - $summerB) / ($aCount * $aCount);
}
return $returnValue;
} // function VARPA()

+ Here is the call graph for this function:

static PHPExcel_Calculation_Statistical::WEIBULL (   $value,
  $alpha,
  $beta,
  $cumulative 
)
static

WEIBULL.

Returns the Weibull distribution. Use this distribution in reliability analysis, such as calculating a device's mean time to failure.

Parameters
float$value
float$alphaAlpha Parameter
float$betaBeta Parameter
boolean$cumulative
Returns
float

Definition at line 3596 of file Statistical.php.

References PHPExcel_Calculation_Functions\flattenSingleValue(), PHPExcel_Calculation_Functions\NaN(), and PHPExcel_Calculation_Functions\VALUE().

{
$value = PHPExcel_Calculation_Functions::flattenSingleValue($value);
$alpha = PHPExcel_Calculation_Functions::flattenSingleValue($alpha);
$beta = PHPExcel_Calculation_Functions::flattenSingleValue($beta);
if ((is_numeric($value)) && (is_numeric($alpha)) && (is_numeric($beta))) {
if (($value < 0) || ($alpha <= 0) || ($beta <= 0)) {
return PHPExcel_Calculation_Functions::NaN();
}
if ((is_numeric($cumulative)) || (is_bool($cumulative))) {
if ($cumulative) {
return 1 - exp(0 - pow($value / $beta,$alpha));
} else {
return ($alpha / pow($beta,$alpha)) * pow($value,$alpha - 1) * exp(0 - pow($value / $beta,$alpha));
}
}
}
return PHPExcel_Calculation_Functions::VALUE();
} // function WEIBULL()

+ Here is the call graph for this function:

static PHPExcel_Calculation_Statistical::ZTEST (   $dataSet,
  $m0,
  $sigma = null 
)
static

ZTEST.

Returns the Weibull distribution. Use this distribution in reliability analysis, such as calculating a device's mean time to failure.

Parameters
float$value
float$alphaAlpha Parameter
float$betaBeta Parameter
boolean$cumulative
Returns
float

Definition at line 3630 of file Statistical.php.

References PHPExcel_Calculation_Functions\flattenArrayIndexed(), PHPExcel_Calculation_Functions\flattenSingleValue(), NORMSDIST(), and STDEV().

{
$dataSet = PHPExcel_Calculation_Functions::flattenArrayIndexed($dataSet);
$m0 = PHPExcel_Calculation_Functions::flattenSingleValue($m0);
$sigma = PHPExcel_Calculation_Functions::flattenSingleValue($sigma);
if (is_null($sigma)) {
$sigma = self::STDEV($dataSet);
}
$n = count($dataSet);
return 1 - self::NORMSDIST((self::AVERAGE($dataSet) - $m0)/($sigma/SQRT($n)));
} // function ZTEST()

+ Here is the call graph for this function:

Field Documentation

PHPExcel_Calculation_Statistical::$_logBetaCache_p = 0.0
staticprivate

Definition at line 138 of file Statistical.php.

PHPExcel_Calculation_Statistical::$_logBetaCache_q = 0.0
staticprivate

Definition at line 139 of file Statistical.php.

PHPExcel_Calculation_Statistical::$_logBetaCache_result = 0.0
staticprivate

Definition at line 140 of file Statistical.php.

Referenced by _logBeta().

PHPExcel_Calculation_Statistical::$_logGammaCache_result = 0.0
staticprivate

logGamma function

Version
1.1
Author
Jaco van Kooten

Original author was Jaco van Kooten. Ported to PHP by Paul Meagher.

The natural logarithm of the gamma function.
Based on public domain NETLIB (Fortran) code by W. J. Cody and L. Stoltz
Applied Mathematics Division
Argonne National Laboratory
Argonne, IL 60439

References:

  1. W. J. Cody and K. E. Hillstrom, 'Chebyshev Approximations for the Natural Logarithm of the Gamma Function,' Math. Comp. 21, 1967, pp. 198-203.
  2. K. E. Hillstrom, ANL/AMD Program ANLC366S, DGAMMA/DLGAMA, May, 1969.
  3. Hart, Et. Al., Computer Approximations, Wiley and sons, New York, 1968.

From the original documentation:

This routine calculates the LOG(GAMMA) function for a positive real argument X. Computation is based on an algorithm outlined in references 1 and 2. The program uses rational functions that theoretically approximate LOG(GAMMA) to at least 18 significant decimal digits. The approximation for X > 12 is from reference 3, while approximations for X < 12.0 are similar to those in reference 1, but are unpublished. The accuracy achieved depends on the arithmetic system, the compiler, the intrinsic functions, and proper selection of the machine-dependent constants.

Error returns:
The program returns the value XINF for X .LE. 0.0 or when overflow would occur. The computation is believed to be free of underflow and overflow.

Returns
MAX_VALUE for x < 0.0 or when overflow would occur, i.e. x > 2.55E305

Definition at line 258 of file Statistical.php.

Referenced by _logGamma().

PHPExcel_Calculation_Statistical::$_logGammaCache_x = 0.0
staticprivate

Definition at line 259 of file Statistical.php.

The documentation for this class was generated from the following file: