ILIAS  release_5-3 Revision v5.3.23-19-g915713cf615
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. More...
 
static BETAINV ($probability, $alpha, $beta, $rMin=0, $rMax=1)
 BETAINV. More...
 
static BINOMDIST ($value, $trials, $probability, $cumulative)
 BINOMDIST. More...
 
static CHIDIST ($value, $degrees)
 CHIDIST. More...
 
static CHIINV ($probability, $degrees)
 CHIINV. More...
 
static CONFIDENCE ($alpha, $stdDev, $size)
 CONFIDENCE. More...
 
static CORREL ($yValues, $xValues=null)
 CORREL. More...
 
static COUNT ()
 
static COUNTA ()
 
static COUNTBLANK ()
 
static COUNTIF ($aArgs, $condition)
 
static COVAR ($yValues, $xValues)
 COVAR. More...
 
static CRITBINOM ($trials, $probability, $alpha)
 CRITBINOM. More...
 
static DEVSQ ()
 
static EXPONDIST ($value, $lambda, $cumulative)
 EXPONDIST. More...
 
static FISHER ($value)
 FISHER. More...
 
static FISHERINV ($value)
 FISHERINV. More...
 
static FORECAST ($xValue, $yValues, $xValues)
 FORECAST. More...
 
static GAMMADIST ($value, $a, $b, $cumulative)
 GAMMADIST. More...
 
static GAMMAINV ($probability, $alpha, $beta)
 GAMMAINV. More...
 
static GAMMALN ($value)
 GAMMALN. More...
 
static GEOMEAN ()
 
static GROWTH ($yValues, $xValues=array(), $newValues=array(), $const=True)
 GROWTH. More...
 
static HARMEAN ()
 
static HYPGEOMDIST ($sampleSuccesses, $sampleNumber, $populationSuccesses, $populationNumber)
 HYPGEOMDIST. More...
 
static INTERCEPT ($yValues, $xValues)
 INTERCEPT. More...
 
static KURT ()
 KURT. More...
 
static LARGE ()
 
static LINEST ($yValues, $xValues=NULL, $const =TRUE, $stats=FALSE)
 LINEST. More...
 
static LOGEST ($yValues, $xValues=null, $const=True, $stats=False)
 LOGEST. More...
 
static LOGINV ($probability, $mean, $stdDev)
 LOGINV. More...
 
static LOGNORMDIST ($value, $mean, $stdDev)
 LOGNORMDIST. More...
 
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. More...
 
static NORMDIST ($value, $mean, $stdDev, $cumulative)
 NORMDIST. More...
 
static NORMINV ($probability, $mean, $stdDev)
 NORMINV. More...
 
static NORMSDIST ($value)
 NORMSDIST. More...
 
static NORMSINV ($value)
 NORMSINV. More...
 
static PERCENTILE ()
 
static PERCENTRANK ($valueSet, $value, $significance=3)
 PERCENTRANK. More...
 
static PERMUT ($numObjs, $numInSet)
 PERMUT. More...
 
static POISSON ($value, $mean, $cumulative)
 POISSON. More...
 
static QUARTILE ()
 
static RANK ($value, $valueSet, $order=0)
 RANK. More...
 
static RSQ ($yValues, $xValues)
 RSQ. More...
 
static SKEW ()
 SKEW. More...
 
static SLOPE ($yValues, $xValues)
 SLOPE. More...
 
static SMALL ()
 
static STANDARDIZE ($value, $mean, $stdDev)
 STANDARDIZE. More...
 
static STDEV ()
 
static STDEVA ()
 
static STDEVP ()
 
static STDEVPA ()
 
static STEYX ($yValues, $xValues)
 STEYX. More...
 
static TDIST ($value, $degrees, $tails)
 TDIST. More...
 
static TINV ($probability, $degrees)
 TINV. More...
 
static TREND ($yValues, $xValues=array(), $newValues=array(), $const=True)
 TREND. More...
 
static TRIMMEAN ()
 
static VARFunc ()
 
static VARA ()
 
static VARP ()
 
static VARPA ()
 
static WEIBULL ($value, $alpha, $beta, $cumulative)
 WEIBULL. More...
 
static ZTEST ($dataSet, $m0, $sigma=NULL)
 ZTEST. More...
 

Static Private Member Functions

static _checkTrendArrays (&$array1, &$array2)
 
static _beta ($p, $q)
 Beta function. More...
 
static _incompleteBeta ($x, $p, $q)
 Incomplete beta function. More...
 
static _logBeta ($p, $q)
 The natural logarithm of the beta function. More...
 
static _betaFraction ($x, $p, $q)
 Evaluates of continued fraction part of incomplete beta function. More...
 
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 More...
 
static $_logGammaCache_x = 0.0
 

Detailed Description

Definition at line 62 of file Statistical.php.

Member Function Documentation

◆ _beta()

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.

99  {
100  if ($p <= 0.0 || $q <= 0.0 || ($p + $q) > LOG_GAMMA_X_MAX_VALUE) {
101  return 0.0;
102  } else {
103  return exp(self::_logBeta($p, $q));
104  }
105  } // function _beta()
LOG_GAMMA_X_MAX_VALUE
const LOG_GAMMA_X_MAX_VALUE
LOG_GAMMA_X_MAX_VALUE.
Definition: Statistical.php:43

◆ _betaFraction()

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 169 of file Statistical.php.

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

169  {
170  $c = 1.0;
171  $sum_pq = $p + $q;
172  $p_plus = $p + 1.0;
173  $p_minus = $p - 1.0;
174  $h = 1.0 - $sum_pq * $x / $p_plus;
175  if (abs($h) < XMININ) {
176  $h = XMININ;
177  }
178  $h = 1.0 / $h;
179  $frac = $h;
180  $m = 1;
181  $delta = 0.0;
182  while ($m <= MAX_ITERATIONS && abs($delta-1.0) > PRECISION ) {
183  $m2 = 2 * $m;
184  // even index for d
185  $d = $m * ($q - $m) * $x / ( ($p_minus + $m2) * ($p + $m2));
186  $h = 1.0 + $d * $h;
187  if (abs($h) < XMININ) {
188  $h = XMININ;
189  }
190  $h = 1.0 / $h;
191  $c = 1.0 + $d / $c;
192  if (abs($c) < XMININ) {
193  $c = XMININ;
194  }
195  $frac *= $h * $c;
196  // odd index for d
197  $d = -($p + $m) * ($sum_pq + $m) * $x / (($p + $m2) * ($p_plus + $m2));
198  $h = 1.0 + $d * $h;
199  if (abs($h) < XMININ) {
200  $h = XMININ;
201  }
202  $h = 1.0 / $h;
203  $c = 1.0 + $d / $c;
204  if (abs($c) < XMININ) {
205  $c = XMININ;
206  }
207  $delta = $h * $c;
208  $frac *= $delta;
209  ++$m;
210  }
211  return $frac;
212  } // function _betaFraction()
$x
$x
Definition: example_009.php:98
$h
$h
Definition: example_009.php:101
XMININ
const XMININ
XMININ.
Definition: Statistical.php:46
PRECISION
const PRECISION
PRECISION.
Definition: Functions.php:49
$m
$m
Definition: show_metadata.php:25
MAX_ITERATIONS
const MAX_ITERATIONS
MAX_ITERATIONS.
Definition: Functions.php:46
$d
for($i=6; $i< 13; $i++) for($i=1; $i< 13; $i++) $d
Definition: date.php:296

◆ _checkTrendArrays()

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

Definition at line 65 of file Statistical.php.

References $key, array, and PHPExcel_Calculation_Functions\flattenArray().

65  {
66  if (!is_array($array1)) { $array1 = array($array1); }
67  if (!is_array($array2)) { $array2 = array($array2); }
68 
69  $array1 = PHPExcel_Calculation_Functions::flattenArray($array1);
70  $array2 = PHPExcel_Calculation_Functions::flattenArray($array2);
71  foreach($array1 as $key => $value) {
72  if ((is_bool($value)) || (is_string($value)) || (is_null($value))) {
73  unset($array1[$key]);
74  unset($array2[$key]);
75  }
76  }
77  foreach($array2 as $key => $value) {
78  if ((is_bool($value)) || (is_string($value)) || (is_null($value))) {
79  unset($array1[$key]);
80  unset($array2[$key]);
81  }
82  }
83  $array1 = array_merge($array1);
84  $array2 = array_merge($array2);
85 
86  return True;
87  } // function _checkTrendArrays()
PHPExcel_Calculation_Functions\flattenArray
static flattenArray($array)
Convert a multi-dimensional array to a simple 1-dimensional array.
Definition: Functions.php:598
array
Create styles array
The data for the language used.
Definition: 40duplicateStyle.php:19
$key
$key
Definition: croninfo.php:18
+ Here is the call graph for this function:

◆ _gamma()

static PHPExcel_Calculation_Statistical::_gamma (   $data)
staticprivate

Definition at line 442 of file Statistical.php.

References $data, $x, $y, array, e(), and SQRT2PI.

442  {
443  if ($data == 0.0) return 0;
444 
445  static $p0 = 1.000000000190015;
446  static $p = array ( 1 => 76.18009172947146,
447  2 => -86.50532032941677,
448  3 => 24.01409824083091,
449  4 => -1.231739572450155,
450  5 => 1.208650973866179e-3,
451  6 => -5.395239384953e-6
452  );
453 
454  $y = $x = $data;
455  $tmp = $x + 5.5;
456  $tmp -= ($x + 0.5) * log($tmp);
457 
458  $summer = $p0;
459  for ($j=1;$j<=6;++$j) {
460  $summer += ($p[$j] / ++$y);
461  }
462  return exp(0 - $tmp + log(SQRT2PI * $summer / $x));
463  } // function _gamma()
$x
$x
Definition: example_009.php:98
SQRT2PI
const SQRT2PI
SQRT2PI.
Definition: Statistical.php:52
$y
$y
Definition: example_007.php:83
e
e($cmd)
Definition: flush.php:14
array
Create styles array
The data for the language used.
Definition: 40duplicateStyle.php:19
+ Here is the call graph for this function:

◆ _incompleteBeta()

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, and LOG_GAMMA_X_MAX_VALUE.

120  {
121  if ($x <= 0.0) {
122  return 0.0;
123  } elseif ($x >= 1.0) {
124  return 1.0;
125  } elseif (($p <= 0.0) || ($q <= 0.0) || (($p + $q) > LOG_GAMMA_X_MAX_VALUE)) {
126  return 0.0;
127  }
128  $beta_gam = exp((0 - self::_logBeta($p, $q)) + $p * log($x) + $q * log(1.0 - $x));
129  if ($x < ($p + 1.0) / ($p + $q + 2.0)) {
130  return $beta_gam * self::_betaFraction($x, $p, $q) / $p;
131  } else {
132  return 1.0 - ($beta_gam * self::_betaFraction(1 - $x, $q, $p) / $q);
133  }
134  } // function _incompleteBeta()
LOG_GAMMA_X_MAX_VALUE
const LOG_GAMMA_X_MAX_VALUE
LOG_GAMMA_X_MAX_VALUE.
Definition: Statistical.php:43
$x
$x
Definition: example_009.php:98

◆ _incompleteGamma()

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

Definition at line 425 of file Statistical.php.

References $i, $n, and $x.

425  {
426  static $max = 32;
427  $summer = 0;
428  for ($n=0; $n<=$max; ++$n) {
429  $divisor = $a;
430  for ($i=1; $i<=$n; ++$i) {
431  $divisor *= ($a + $i);
432  }
433  $summer += (pow($x,$n) / $divisor);
434  }
435  return pow($x,$a) * exp(0-$x) * $summer;
436  } // function _incompleteGamma()
$x
$x
Definition: example_009.php:98
$n
$n
Definition: RandomTest.php:85
$i
$i
Definition: disco.tpl.php:19

◆ _inverse_ncdf()

static PHPExcel_Calculation_Statistical::_inverse_ncdf (   $p)
staticprivate

Definition at line 474 of file Statistical.php.

References $d, $r, array, e(), and PHPExcel_Calculation_Functions\NULL().

474  {
475  // Inverse ncdf approximation by Peter J. Acklam, implementation adapted to
476  // PHP by Michael Nickerson, using Dr. Thomas Ziegler's C implementation as
477  // a guide. http://home.online.no/~pjacklam/notes/invnorm/index.html
478  // I have not checked the accuracy of this implementation. Be aware that PHP
479  // will truncate the coeficcients to 14 digits.
480 
481  // You have permission to use and distribute this function freely for
482  // whatever purpose you want, but please show common courtesy and give credit
483  // where credit is due.
484 
485  // Input paramater is $p - probability - where 0 < p < 1.
486 
487  // Coefficients in rational approximations
488  static $a = array( 1 => -3.969683028665376e+01,
489  2 => 2.209460984245205e+02,
490  3 => -2.759285104469687e+02,
491  4 => 1.383577518672690e+02,
492  5 => -3.066479806614716e+01,
493  6 => 2.506628277459239e+00
494  );
495 
496  static $b = array( 1 => -5.447609879822406e+01,
497  2 => 1.615858368580409e+02,
498  3 => -1.556989798598866e+02,
499  4 => 6.680131188771972e+01,
500  5 => -1.328068155288572e+01
501  );
502 
503  static $c = array( 1 => -7.784894002430293e-03,
504  2 => -3.223964580411365e-01,
505  3 => -2.400758277161838e+00,
506  4 => -2.549732539343734e+00,
507  5 => 4.374664141464968e+00,
508  6 => 2.938163982698783e+00
509  );
510 
511  static $d = array( 1 => 7.784695709041462e-03,
512  2 => 3.224671290700398e-01,
513  3 => 2.445134137142996e+00,
514  4 => 3.754408661907416e+00
515  );
516 
517  // Define lower and upper region break-points.
518  $p_low = 0.02425; //Use lower region approx. below this
519  $p_high = 1 - $p_low; //Use upper region approx. above this
520 
521  if (0 < $p && $p < $p_low) {
522  // Rational approximation for lower region.
523  $q = sqrt(-2 * log($p));
524  return ((((($c[1] * $q + $c[2]) * $q + $c[3]) * $q + $c[4]) * $q + $c[5]) * $q + $c[6]) /
525  (((($d[1] * $q + $d[2]) * $q + $d[3]) * $q + $d[4]) * $q + 1);
526  } elseif ($p_low <= $p && $p <= $p_high) {
527  // Rational approximation for central region.
528  $q = $p - 0.5;
529  $r = $q * $q;
530  return ((((($a[1] * $r + $a[2]) * $r + $a[3]) * $r + $a[4]) * $r + $a[5]) * $r + $a[6]) * $q /
531  ((((($b[1] * $r + $b[2]) * $r + $b[3]) * $r + $b[4]) * $r + $b[5]) * $r + 1);
532  } elseif ($p_high < $p && $p < 1) {
533  // Rational approximation for upper region.
534  $q = sqrt(-2 * log(1 - $p));
535  return -((((($c[1] * $q + $c[2]) * $q + $c[3]) * $q + $c[4]) * $q + $c[5]) * $q + $c[6]) /
536  (((($d[1] * $q + $d[2]) * $q + $d[3]) * $q + $d[4]) * $q + 1);
537  }
538  // If 0 < p < 1, return a null value
539  return PHPExcel_Calculation_Functions::NULL();
540  } // function _inverse_ncdf()
$r
$r
Definition: example_031.php:79
e
e($cmd)
Definition: flush.php:14
PHPExcel_Calculation_Functions\NULL
static NULL()
Definition: Functions.php:275
array
Create styles array
The data for the language used.
Definition: 40duplicateStyle.php:19
$d
for($i=6; $i< 13; $i++) for($i=1; $i< 13; $i++) $d
Definition: date.php:296
+ Here is the call graph for this function:

◆ _inverse_ncdf2()

static PHPExcel_Calculation_Statistical::_inverse_ncdf2 (   $prob)
staticprivate

Definition at line 543 of file Statistical.php.

References $y.

543  {
544  // Approximation of inverse standard normal CDF developed by
545  // B. Moro, "The Full Monte," Risk 8(2), Feb 1995, 57-58.
546 
547  $a1 = 2.50662823884;
548  $a2 = -18.61500062529;
549  $a3 = 41.39119773534;
550  $a4 = -25.44106049637;
551 
552  $b1 = -8.4735109309;
553  $b2 = 23.08336743743;
554  $b3 = -21.06224101826;
555  $b4 = 3.13082909833;
556 
557  $c1 = 0.337475482272615;
558  $c2 = 0.976169019091719;
559  $c3 = 0.160797971491821;
560  $c4 = 2.76438810333863E-02;
561  $c5 = 3.8405729373609E-03;
562  $c6 = 3.951896511919E-04;
563  $c7 = 3.21767881768E-05;
564  $c8 = 2.888167364E-07;
565  $c9 = 3.960315187E-07;
566 
567  $y = $prob - 0.5;
568  if (abs($y) < 0.42) {
569  $z = ($y * $y);
570  $z = $y * ((($a4 * $z + $a3) * $z + $a2) * $z + $a1) / (((($b4 * $z + $b3) * $z + $b2) * $z + $b1) * $z + 1);
571  } else {
572  if ($y > 0) {
573  $z = log(-log(1 - $prob));
574  } else {
575  $z = log(-log($prob));
576  }
577  $z = $c1 + $z * ($c2 + $z * ($c3 + $z * ($c4 + $z * ($c5 + $z * ($c6 + $z * ($c7 + $z * ($c8 + $z * $c9)))))));
578  if ($y < 0) {
579  $z = -$z;
580  }
581  }
582  return $z;
583  } // function _inverse_ncdf2()
$y
$y
Definition: example_007.php:83

◆ _inverse_ncdf3()

static PHPExcel_Calculation_Statistical::_inverse_ncdf3 (   $p)
staticprivate

Definition at line 586 of file Statistical.php.

586  {
587  // ALGORITHM AS241 APPL. STATIST. (1988) VOL. 37, NO. 3.
588  // Produces the normal deviate Z corresponding to a given lower
589  // tail area of P; Z is accurate to about 1 part in 10**16.
590  //
591  // This is a PHP version of the original FORTRAN code that can
592  // be found at http://lib.stat.cmu.edu/apstat/
593  $split1 = 0.425;
594  $split2 = 5;
595  $const1 = 0.180625;
596  $const2 = 1.6;
597 
598  // coefficients for p close to 0.5
599  $a0 = 3.3871328727963666080;
600  $a1 = 1.3314166789178437745E+2;
601  $a2 = 1.9715909503065514427E+3;
602  $a3 = 1.3731693765509461125E+4;
603  $a4 = 4.5921953931549871457E+4;
604  $a5 = 6.7265770927008700853E+4;
605  $a6 = 3.3430575583588128105E+4;
606  $a7 = 2.5090809287301226727E+3;
607 
608  $b1 = 4.2313330701600911252E+1;
609  $b2 = 6.8718700749205790830E+2;
610  $b3 = 5.3941960214247511077E+3;
611  $b4 = 2.1213794301586595867E+4;
612  $b5 = 3.9307895800092710610E+4;
613  $b6 = 2.8729085735721942674E+4;
614  $b7 = 5.2264952788528545610E+3;
615 
616  // coefficients for p not close to 0, 0.5 or 1.
617  $c0 = 1.42343711074968357734;
618  $c1 = 4.63033784615654529590;
619  $c2 = 5.76949722146069140550;
620  $c3 = 3.64784832476320460504;
621  $c4 = 1.27045825245236838258;
622  $c5 = 2.41780725177450611770E-1;
623  $c6 = 2.27238449892691845833E-2;
624  $c7 = 7.74545014278341407640E-4;
625 
626  $d1 = 2.05319162663775882187;
627  $d2 = 1.67638483018380384940;
628  $d3 = 6.89767334985100004550E-1;
629  $d4 = 1.48103976427480074590E-1;
630  $d5 = 1.51986665636164571966E-2;
631  $d6 = 5.47593808499534494600E-4;
632  $d7 = 1.05075007164441684324E-9;
633 
634  // coefficients for p near 0 or 1.
635  $e0 = 6.65790464350110377720;
636  $e1 = 5.46378491116411436990;
637  $e2 = 1.78482653991729133580;
638  $e3 = 2.96560571828504891230E-1;
639  $e4 = 2.65321895265761230930E-2;
640  $e5 = 1.24266094738807843860E-3;
641  $e6 = 2.71155556874348757815E-5;
642  $e7 = 2.01033439929228813265E-7;
643 
644  $f1 = 5.99832206555887937690E-1;
645  $f2 = 1.36929880922735805310E-1;
646  $f3 = 1.48753612908506148525E-2;
647  $f4 = 7.86869131145613259100E-4;
648  $f5 = 1.84631831751005468180E-5;
649  $f6 = 1.42151175831644588870E-7;
650  $f7 = 2.04426310338993978564E-15;
651 
652  $q = $p - 0.5;
653 
654  // computation for p close to 0.5
655  if (abs($q) <= split1) {
656  $R = $const1 - $q * $q;
657  $z = $q * ((((((($a7 * $R + $a6) * $R + $a5) * $R + $a4) * $R + $a3) * $R + $a2) * $R + $a1) * $R + $a0) /
658  ((((((($b7 * $R + $b6) * $R + $b5) * $R + $b4) * $R + $b3) * $R + $b2) * $R + $b1) * $R + 1);
659  } else {
660  if ($q < 0) {
661  $R = $p;
662  } else {
663  $R = 1 - $p;
664  }
665  $R = pow(-log($R),2);
666 
667  // computation for p not close to 0, 0.5 or 1.
668  If ($R <= $split2) {
669  $R = $R - $const2;
670  $z = ((((((($c7 * $R + $c6) * $R + $c5) * $R + $c4) * $R + $c3) * $R + $c2) * $R + $c1) * $R + $c0) /
671  ((((((($d7 * $R + $d6) * $R + $d5) * $R + $d4) * $R + $d3) * $R + $d2) * $R + $d1) * $R + 1);
672  } else {
673  // computation for p near 0 or 1.
674  $R = $R - $split2;
675  $z = ((((((($e7 * $R + $e6) * $R + $e5) * $R + $e4) * $R + $e3) * $R + $e2) * $R + $e1) * $R + $e0) /
676  ((((((($f7 * $R + $f6) * $R + $f5) * $R + $f4) * $R + $f3) * $R + $f2) * $R + $f1) * $R + 1);
677  }
678  if ($q < 0) {
679  $z = -$z;
680  }
681  }
682  return $z;
683  } // function _inverse_ncdf3()

◆ _logBeta()

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 150 of file Statistical.php.

References LOG_GAMMA_X_MAX_VALUE.

150  {
151  if ($p != self::$_logBetaCache_p || $q != self::$_logBetaCache_q) {
152  self::$_logBetaCache_p = $p;
153  self::$_logBetaCache_q = $q;
154  if (($p <= 0.0) || ($q <= 0.0) || (($p + $q) > LOG_GAMMA_X_MAX_VALUE)) {
155  self::$_logBetaCache_result = 0.0;
156  } else {
157  self::$_logBetaCache_result = self::_logGamma($p) + self::_logGamma($q) - self::_logGamma($p + $q);
158  }
159  }
160  return self::$_logBetaCache_result;
161  } // function _logBeta()
LOG_GAMMA_X_MAX_VALUE
const LOG_GAMMA_X_MAX_VALUE
LOG_GAMMA_X_MAX_VALUE.
Definition: Statistical.php:43

◆ _logGamma()

static PHPExcel_Calculation_Statistical::_logGamma (   $x)
staticprivate

Definition at line 262 of file Statistical.php.

References $i, $res, $x, $y, array, e(), EPS, LOG_GAMMA_X_MAX_VALUE, MAX_VALUE, and SQRT2PI.

262  {
263  // Log Gamma related constants
264  static $lg_d1 = -0.5772156649015328605195174;
265  static $lg_d2 = 0.4227843350984671393993777;
266  static $lg_d4 = 1.791759469228055000094023;
267 
268  static $lg_p1 = array( 4.945235359296727046734888,
269  201.8112620856775083915565,
270  2290.838373831346393026739,
271  11319.67205903380828685045,
272  28557.24635671635335736389,
273  38484.96228443793359990269,
274  26377.48787624195437963534,
275  7225.813979700288197698961 );
276  static $lg_p2 = array( 4.974607845568932035012064,
277  542.4138599891070494101986,
278  15506.93864978364947665077,
279  184793.2904445632425417223,
280  1088204.76946882876749847,
281  3338152.967987029735917223,
282  5106661.678927352456275255,
283  3074109.054850539556250927 );
284  static $lg_p4 = array( 14745.02166059939948905062,
285  2426813.369486704502836312,
286  121475557.4045093227939592,
287  2663432449.630976949898078,
288  29403789566.34553899906876,
289  170266573776.5398868392998,
290  492612579337.743088758812,
291  560625185622.3951465078242 );
292 
293  static $lg_q1 = array( 67.48212550303777196073036,
294  1113.332393857199323513008,
295  7738.757056935398733233834,
296  27639.87074403340708898585,
297  54993.10206226157329794414,
298  61611.22180066002127833352,
299  36351.27591501940507276287,
300  8785.536302431013170870835 );
301  static $lg_q2 = array( 183.0328399370592604055942,
302  7765.049321445005871323047,
303  133190.3827966074194402448,
304  1136705.821321969608938755,
305  5267964.117437946917577538,
306  13467014.54311101692290052,
307  17827365.30353274213975932,
308  9533095.591844353613395747 );
309  static $lg_q4 = array( 2690.530175870899333379843,
310  639388.5654300092398984238,
311  41355999.30241388052042842,
312  1120872109.61614794137657,
313  14886137286.78813811542398,
314  101680358627.2438228077304,
315  341747634550.7377132798597,
316  446315818741.9713286462081 );
317 
318  static $lg_c = array( -0.001910444077728,
319  8.4171387781295e-4,
320  -5.952379913043012e-4,
321  7.93650793500350248e-4,
322  -0.002777777777777681622553,
323  0.08333333333333333331554247,
324  0.0057083835261 );
325 
326  // Rough estimate of the fourth root of logGamma_xBig
327  static $lg_frtbig = 2.25e76;
328  static $pnt68 = 0.6796875;
329 
330 
331  if ($x == self::$_logGammaCache_x) {
332  return self::$_logGammaCache_result;
333  }
334  $y = $x;
335  if ($y > 0.0 && $y <= LOG_GAMMA_X_MAX_VALUE) {
336  if ($y <= EPS) {
337  $res = -log(y);
338  } elseif ($y <= 1.5) {
339  // ---------------------
340  // EPS .LT. X .LE. 1.5
341  // ---------------------
342  if ($y < $pnt68) {
343  $corr = -log($y);
344  $xm1 = $y;
345  } else {
346  $corr = 0.0;
347  $xm1 = $y - 1.0;
348  }
349  if ($y <= 0.5 || $y >= $pnt68) {
350  $xden = 1.0;
351  $xnum = 0.0;
352  for ($i = 0; $i < 8; ++$i) {
353  $xnum = $xnum * $xm1 + $lg_p1[$i];
354  $xden = $xden * $xm1 + $lg_q1[$i];
355  }
356  $res = $corr + $xm1 * ($lg_d1 + $xm1 * ($xnum / $xden));
357  } else {
358  $xm2 = $y - 1.0;
359  $xden = 1.0;
360  $xnum = 0.0;
361  for ($i = 0; $i < 8; ++$i) {
362  $xnum = $xnum * $xm2 + $lg_p2[$i];
363  $xden = $xden * $xm2 + $lg_q2[$i];
364  }
365  $res = $corr + $xm2 * ($lg_d2 + $xm2 * ($xnum / $xden));
366  }
367  } elseif ($y <= 4.0) {
368  // ---------------------
369  // 1.5 .LT. X .LE. 4.0
370  // ---------------------
371  $xm2 = $y - 2.0;
372  $xden = 1.0;
373  $xnum = 0.0;
374  for ($i = 0; $i < 8; ++$i) {
375  $xnum = $xnum * $xm2 + $lg_p2[$i];
376  $xden = $xden * $xm2 + $lg_q2[$i];
377  }
378  $res = $xm2 * ($lg_d2 + $xm2 * ($xnum / $xden));
379  } elseif ($y <= 12.0) {
380  // ----------------------
381  // 4.0 .LT. X .LE. 12.0
382  // ----------------------
383  $xm4 = $y - 4.0;
384  $xden = -1.0;
385  $xnum = 0.0;
386  for ($i = 0; $i < 8; ++$i) {
387  $xnum = $xnum * $xm4 + $lg_p4[$i];
388  $xden = $xden * $xm4 + $lg_q4[$i];
389  }
390  $res = $lg_d4 + $xm4 * ($xnum / $xden);
391  } else {
392  // ---------------------------------
393  // Evaluate for argument .GE. 12.0
394  // ---------------------------------
395  $res = 0.0;
396  if ($y <= $lg_frtbig) {
397  $res = $lg_c[6];
398  $ysq = $y * $y;
399  for ($i = 0; $i < 6; ++$i)
400  $res = $res / $ysq + $lg_c[$i];
401  }
402  $res /= $y;
403  $corr = log($y);
404  $res = $res + log(SQRT2PI) - 0.5 * $corr;
405  $res += $y * ($corr - 1.0);
406  }
407  } else {
408  // --------------------------
409  // Return for bad arguments
410  // --------------------------
411  $res = MAX_VALUE;
412  }
413  // ------------------------------
414  // Final adjustments and return
415  // ------------------------------
416  self::$_logGammaCache_x = $x;
417  self::$_logGammaCache_result = $res;
418  return $res;
419  } // function _logGamma()
LOG_GAMMA_X_MAX_VALUE
const LOG_GAMMA_X_MAX_VALUE
LOG_GAMMA_X_MAX_VALUE.
Definition: Statistical.php:43
$x
$x
Definition: example_009.php:98
SQRT2PI
const SQRT2PI
SQRT2PI.
Definition: Statistical.php:52
MAX_VALUE
const MAX_VALUE(!defined('PHPEXCEL_ROOT'))
PHPExcel root directory.
Definition: Functions.php:40
EPS
const EPS
EPS.
Definition: Statistical.php:49
$y
$y
Definition: example_007.php:83
$res
foreach($_POST as $key=> $value) $res
Definition: save_question_post_data.php:15
e
e($cmd)
Definition: flush.php:14
array
Create styles array
The data for the language used.
Definition: 40duplicateStyle.php:19
$i
$i
Definition: disco.tpl.php:19
+ Here is the call graph for this function:

◆ _modeCalc()

static PHPExcel_Calculation_Statistical::_modeCalc (   $data)
staticprivate

Definition at line 2399 of file Statistical.php.

References $data, $key, array, and PHPExcel_Calculation_Functions\NA().

2399  {
2400  $frequencyArray = array();
2401  foreach($data as $datum) {
2402  $found = False;
2403  foreach($frequencyArray as $key => $value) {
2404  if ((string) $value['value'] == (string) $datum) {
2405  ++$frequencyArray[$key]['frequency'];
2406  $found = True;
2407  break;
2408  }
2409  }
2410  if (!$found) {
2411  $frequencyArray[] = array('value' => $datum,
2412  'frequency' => 1 );
2413  }
2414  }
2415 
2416  foreach($frequencyArray as $key => $value) {
2417  $frequencyList[$key] = $value['frequency'];
2418  $valueList[$key] = $value['value'];
2419  }
2420  array_multisort($frequencyList, SORT_DESC, $valueList, SORT_ASC, SORT_NUMERIC, $frequencyArray);
2421 
2422  if ($frequencyArray[0]['frequency'] == 1) {
2423  return PHPExcel_Calculation_Functions::NA();
2424  }
2425  return $frequencyArray[0]['value'];
2426  } // function _modeCalc()
PHPExcel_Calculation_Functions\NA
static NA()
Definition: Functions.php:219
array
Create styles array
The data for the language used.
Definition: 40duplicateStyle.php:19
$key
$key
Definition: croninfo.php:18
+ Here is the call graph for this function:

◆ AVEDEV()

static PHPExcel_Calculation_Statistical::AVEDEV ( )
static

Definition at line 700 of file Statistical.php.

References 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().

700  {
701  $aArgs = PHPExcel_Calculation_Functions::flattenArrayIndexed(func_get_args());
702 
703  // Return value
704  $returnValue = null;
705 
706  $aMean = self::AVERAGE($aArgs);
707  if ($aMean != PHPExcel_Calculation_Functions::DIV0()) {
708  $aCount = 0;
709  foreach ($aArgs as $k => $arg) {
710  if ((is_bool($arg)) &&
711  ((!PHPExcel_Calculation_Functions::isCellValue($k)) || (PHPExcel_Calculation_Functions::getCompatibilityMode() == PHPExcel_Calculation_Functions::COMPATIBILITY_OPENOFFICE))) {
712  $arg = (integer) $arg;
713  }
714  // Is it a numeric value?
715  if ((is_numeric($arg)) && (!is_string($arg))) {
716  if (is_null($returnValue)) {
717  $returnValue = abs($arg - $aMean);
718  } else {
719  $returnValue += abs($arg - $aMean);
720  }
721  ++$aCount;
722  }
723  }
724 
725  // Return
726  if ($aCount == 0) {
727  return PHPExcel_Calculation_Functions::DIV0();
728  }
729  return $returnValue / $aCount;
730  }
731  return PHPExcel_Calculation_Functions::NaN();
732  } // function AVEDEV()
PHPExcel_Calculation_Functions\DIV0
static DIV0()
Definition: Functions.php:201
PHPExcel_Calculation_Functions\flattenArrayIndexed
static flattenArrayIndexed($array)
Convert a multi-dimensional array to a simple 1-dimensional array, but retain an element of indexing...
Definition: Functions.php:630
PHPExcel_Calculation_Functions\isCellValue
static isCellValue($idx)
Definition: Functions.php:304
PHPExcel_Calculation_Functions\COMPATIBILITY_OPENOFFICE
const COMPATIBILITY_OPENOFFICE
Definition: Functions.php:64
PHPExcel_Calculation_Functions\getCompatibilityMode
static getCompatibilityMode()
Definition: Functions.php:138
PHPExcel_Calculation_Functions\NaN
static NaN()
Definition: Functions.php:233
+ Here is the call graph for this function:

◆ AVERAGE()

static PHPExcel_Calculation_Statistical::AVERAGE ( )
static

Definition at line 748 of file Statistical.php.

References 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\DAVERAGE(), and PHPExcel_Calculation_MathTrig\SUBTOTAL().

748  {
749  $returnValue = $aCount = 0;
750 
751  // Loop through arguments
752  foreach (PHPExcel_Calculation_Functions::flattenArrayIndexed(func_get_args()) as $k => $arg) {
753  if ((is_bool($arg)) &&
754  ((!PHPExcel_Calculation_Functions::isCellValue($k)) || (PHPExcel_Calculation_Functions::getCompatibilityMode() == PHPExcel_Calculation_Functions::COMPATIBILITY_OPENOFFICE))) {
755  $arg = (integer) $arg;
756  }
757  // Is it a numeric value?
758  if ((is_numeric($arg)) && (!is_string($arg))) {
759  if (is_null($returnValue)) {
760  $returnValue = $arg;
761  } else {
762  $returnValue += $arg;
763  }
764  ++$aCount;
765  }
766  }
767 
768  // Return
769  if ($aCount > 0) {
770  return $returnValue / $aCount;
771  } else {
772  return PHPExcel_Calculation_Functions::DIV0();
773  }
774  } // function AVERAGE()
PHPExcel_Calculation_Functions\DIV0
static DIV0()
Definition: Functions.php:201
PHPExcel_Calculation_Functions\flattenArrayIndexed
static flattenArrayIndexed($array)
Convert a multi-dimensional array to a simple 1-dimensional array, but retain an element of indexing...
Definition: Functions.php:630
PHPExcel_Calculation_Functions\isCellValue
static isCellValue($idx)
Definition: Functions.php:304
PHPExcel_Calculation_Functions\COMPATIBILITY_OPENOFFICE
const COMPATIBILITY_OPENOFFICE
Definition: Functions.php:64
PHPExcel_Calculation_Functions\getCompatibilityMode
static getCompatibilityMode()
Definition: Functions.php:138
+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ AVERAGEA()

static PHPExcel_Calculation_Statistical::AVERAGEA ( )
static

Definition at line 790 of file Statistical.php.

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

790  {
791  // Return value
792  $returnValue = null;
793 
794  $aCount = 0;
795  // Loop through arguments
796  foreach (PHPExcel_Calculation_Functions::flattenArrayIndexed(func_get_args()) as $k => $arg) {
797  if ((is_bool($arg)) &&
798  (!PHPExcel_Calculation_Functions::isMatrixValue($k))) {
799  } else {
800  if ((is_numeric($arg)) || (is_bool($arg)) || ((is_string($arg) && ($arg != '')))) {
801  if (is_bool($arg)) {
802  $arg = (integer) $arg;
803  } elseif (is_string($arg)) {
804  $arg = 0;
805  }
806  if (is_null($returnValue)) {
807  $returnValue = $arg;
808  } else {
809  $returnValue += $arg;
810  }
811  ++$aCount;
812  }
813  }
814  }
815 
816  // Return
817  if ($aCount > 0) {
818  return $returnValue / $aCount;
819  } else {
820  return PHPExcel_Calculation_Functions::DIV0();
821  }
822  } // function AVERAGEA()
PHPExcel_Calculation_Functions\DIV0
static DIV0()
Definition: Functions.php:201
PHPExcel_Calculation_Functions\flattenArrayIndexed
static flattenArrayIndexed($array)
Convert a multi-dimensional array to a simple 1-dimensional array, but retain an element of indexing...
Definition: Functions.php:630
PHPExcel_Calculation_Functions\isMatrixValue
static isMatrixValue($idx)
Definition: Functions.php:294
+ Here is the call graph for this function:

◆ AVERAGEIF()

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

Definition at line 840 of file Statistical.php.

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

840  {
841  // Return value
842  $returnValue = 0;
843 
844  $aArgs = PHPExcel_Calculation_Functions::flattenArray($aArgs);
845  $averageArgs = PHPExcel_Calculation_Functions::flattenArray($averageArgs);
846  if (empty($averageArgs)) {
847  $averageArgs = $aArgs;
848  }
849  $condition = PHPExcel_Calculation_Functions::_ifCondition($condition);
850  // Loop through arguments
851  $aCount = 0;
852  foreach ($aArgs as $key => $arg) {
853  if (!is_numeric($arg)) { $arg = PHPExcel_Calculation::_wrapResult(strtoupper($arg)); }
854  $testCondition = '='.$arg.$condition;
855  if (PHPExcel_Calculation::getInstance()->_calculateFormulaValue($testCondition)) {
856  if ((is_null($returnValue)) || ($arg > $returnValue)) {
857  $returnValue += $arg;
858  ++$aCount;
859  }
860  }
861  }
862 
863  // Return
864  if ($aCount > 0) {
865  return $returnValue / $aCount;
866  } else {
867  return PHPExcel_Calculation_Functions::DIV0();
868  }
869  } // function AVERAGEIF()
PHPExcel_Calculation_Functions\DIV0
static DIV0()
Definition: Functions.php:201
PHPExcel_Calculation\_wrapResult
static _wrapResult($value)
Wrap string values in quotes.
Definition: Calculation.php:2163
PHPExcel_Calculation_Functions\flattenArray
static flattenArray($array)
Convert a multi-dimensional array to a simple 1-dimensional array.
Definition: Functions.php:598
PHPExcel_Calculation_Functions\_ifCondition
static _ifCondition($condition)
Definition: Functions.php:309
PHPExcel_Calculation\getInstance
static getInstance(PHPExcel $workbook=NULL)
Get an instance of this class.
Definition: Calculation.php:1765
$key
$key
Definition: croninfo.php:18
+ Here is the call graph for this function:

◆ BETADIST()

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 884 of file Statistical.php.

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

884  {
885  $value = PHPExcel_Calculation_Functions::flattenSingleValue($value);
886  $alpha = PHPExcel_Calculation_Functions::flattenSingleValue($alpha);
887  $beta = PHPExcel_Calculation_Functions::flattenSingleValue($beta);
888  $rMin = PHPExcel_Calculation_Functions::flattenSingleValue($rMin);
889  $rMax = PHPExcel_Calculation_Functions::flattenSingleValue($rMax);
890 
891  if ((is_numeric($value)) && (is_numeric($alpha)) && (is_numeric($beta)) && (is_numeric($rMin)) && (is_numeric($rMax))) {
892  if (($value < $rMin) || ($value > $rMax) || ($alpha <= 0) || ($beta <= 0) || ($rMin == $rMax)) {
893  return PHPExcel_Calculation_Functions::NaN();
894  }
895  if ($rMin > $rMax) {
896  $tmp = $rMin;
897  $rMin = $rMax;
898  $rMax = $tmp;
899  }
900  $value -= $rMin;
901  $value /= ($rMax - $rMin);
902  return self::_incompleteBeta($value,$alpha,$beta);
903  }
904  return PHPExcel_Calculation_Functions::VALUE();
905  } // function BETADIST()
PHPExcel_Calculation_Functions\flattenSingleValue
static flattenSingleValue($value='')
Convert an array to a single scalar value by extracting the first element.
Definition: Functions.php:662
PHPExcel_Calculation_Functions\VALUE
static VALUE()
Definition: Functions.php:289
PHPExcel_Calculation_Functions\NaN
static NaN()
Definition: Functions.php:233
+ Here is the call graph for this function:

◆ BETAINV()

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
float$rMinMinimum value
float$rMaxMaximum value
boolean$cumulative
Returns
float

Definition at line 922 of file Statistical.php.

References $i, $result, PHPExcel_Calculation_Functions\flattenSingleValue(), MAX_ITERATIONS, PHPExcel_Calculation_Functions\NA(), PHPExcel_Calculation_Functions\NaN(), PRECISION, and PHPExcel_Calculation_Functions\VALUE().

922  {
923  $probability = PHPExcel_Calculation_Functions::flattenSingleValue($probability);
924  $alpha = PHPExcel_Calculation_Functions::flattenSingleValue($alpha);
925  $beta = PHPExcel_Calculation_Functions::flattenSingleValue($beta);
926  $rMin = PHPExcel_Calculation_Functions::flattenSingleValue($rMin);
927  $rMax = PHPExcel_Calculation_Functions::flattenSingleValue($rMax);
928 
929  if ((is_numeric($probability)) && (is_numeric($alpha)) && (is_numeric($beta)) && (is_numeric($rMin)) && (is_numeric($rMax))) {
930  if (($alpha <= 0) || ($beta <= 0) || ($rMin == $rMax) || ($probability <= 0) || ($probability > 1)) {
931  return PHPExcel_Calculation_Functions::NaN();
932  }
933  if ($rMin > $rMax) {
934  $tmp = $rMin;
935  $rMin = $rMax;
936  $rMax = $tmp;
937  }
938  $a = 0;
939  $b = 2;
940 
941  $i = 0;
942  while ((($b - $a) > PRECISION) && ($i++ < MAX_ITERATIONS)) {
943  $guess = ($a + $b) / 2;
944  $result = self::BETADIST($guess, $alpha, $beta);
945  if (($result == $probability) || ($result == 0)) {
946  $b = $a;
947  } elseif ($result > $probability) {
948  $b = $guess;
949  } else {
950  $a = $guess;
951  }
952  }
953  if ($i == MAX_ITERATIONS) {
954  return PHPExcel_Calculation_Functions::NA();
955  }
956  return round($rMin + $guess * ($rMax - $rMin),12);
957  }
958  return PHPExcel_Calculation_Functions::VALUE();
959  } // function BETAINV()
PHPExcel_Calculation_Functions\flattenSingleValue
static flattenSingleValue($value='')
Convert an array to a single scalar value by extracting the first element.
Definition: Functions.php:662
$result
$result
Definition: CleanUpTest.php:463
PRECISION
const PRECISION
PRECISION.
Definition: Functions.php:49
PHPExcel_Calculation_Functions\VALUE
static VALUE()
Definition: Functions.php:289
MAX_ITERATIONS
const MAX_ITERATIONS
MAX_ITERATIONS.
Definition: Functions.php:46
PHPExcel_Calculation_Functions\NA
static NA()
Definition: Functions.php:219
PHPExcel_Calculation_Functions\NaN
static NaN()
Definition: Functions.php:233
$i
$i
Definition: disco.tpl.php:19
+ Here is the call graph for this function:

◆ BINOMDIST()

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 980 of file Statistical.php.

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

980  {
981  $value = floor(PHPExcel_Calculation_Functions::flattenSingleValue($value));
982  $trials = floor(PHPExcel_Calculation_Functions::flattenSingleValue($trials));
983  $probability = PHPExcel_Calculation_Functions::flattenSingleValue($probability);
984 
985  if ((is_numeric($value)) && (is_numeric($trials)) && (is_numeric($probability))) {
986  if (($value < 0) || ($value > $trials)) {
987  return PHPExcel_Calculation_Functions::NaN();
988  }
989  if (($probability < 0) || ($probability > 1)) {
990  return PHPExcel_Calculation_Functions::NaN();
991  }
992  if ((is_numeric($cumulative)) || (is_bool($cumulative))) {
993  if ($cumulative) {
994  $summer = 0;
995  for ($i = 0; $i <= $value; ++$i) {
996  $summer += PHPExcel_Calculation_MathTrig::COMBIN($trials,$i) * pow($probability,$i) * pow(1 - $probability,$trials - $i);
997  }
998  return $summer;
999  } else {
1000  return PHPExcel_Calculation_MathTrig::COMBIN($trials,$value) * pow($probability,$value) * pow(1 - $probability,$trials - $value) ;
1001  }
1002  }
1003  }
1004  return PHPExcel_Calculation_Functions::VALUE();
1005  } // function BINOMDIST()
PHPExcel_Calculation_Functions\flattenSingleValue
static flattenSingleValue($value='')
Convert an array to a single scalar value by extracting the first element.
Definition: Functions.php:662
PHPExcel_Calculation_Functions\VALUE
static VALUE()
Definition: Functions.php:289
PHPExcel_Calculation_MathTrig\COMBIN
static COMBIN($numObjs, $numInSet)
Definition: MathTrig.php:176
PHPExcel_Calculation_Functions\NaN
static NaN()
Definition: Functions.php:233
$i
$i
Definition: disco.tpl.php:19
+ Here is the call graph for this function:

◆ CHIDIST()

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 1017 of file Statistical.php.

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

1017  {
1018  $value = PHPExcel_Calculation_Functions::flattenSingleValue($value);
1019  $degrees = floor(PHPExcel_Calculation_Functions::flattenSingleValue($degrees));
1020 
1021  if ((is_numeric($value)) && (is_numeric($degrees))) {
1022  if ($degrees < 1) {
1023  return PHPExcel_Calculation_Functions::NaN();
1024  }
1025  if ($value < 0) {
1026  if (PHPExcel_Calculation_Functions::getCompatibilityMode() == PHPExcel_Calculation_Functions::COMPATIBILITY_GNUMERIC) {
1027  return 1;
1028  }
1029  return PHPExcel_Calculation_Functions::NaN();
1030  }
1031  return 1 - (self::_incompleteGamma($degrees/2,$value/2) / self::_gamma($degrees/2));
1032  }
1033  return PHPExcel_Calculation_Functions::VALUE();
1034  } // function CHIDIST()
PHPExcel_Calculation_Functions\flattenSingleValue
static flattenSingleValue($value='')
Convert an array to a single scalar value by extracting the first element.
Definition: Functions.php:662
PHPExcel_Calculation_Functions\VALUE
static VALUE()
Definition: Functions.php:289
PHPExcel_Calculation_Functions\getCompatibilityMode
static getCompatibilityMode()
Definition: Functions.php:138
PHPExcel_Calculation_Functions\NaN
static NaN()
Definition: Functions.php:233
PHPExcel_Calculation_Functions\COMPATIBILITY_GNUMERIC
const COMPATIBILITY_GNUMERIC
Definition: Functions.php:63
+ Here is the call graph for this function:

◆ CHIINV()

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 1046 of file Statistical.php.

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

1046  {
1047  $probability = PHPExcel_Calculation_Functions::flattenSingleValue($probability);
1048  $degrees = floor(PHPExcel_Calculation_Functions::flattenSingleValue($degrees));
1049 
1050  if ((is_numeric($probability)) && (is_numeric($degrees))) {
1051 
1052  $xLo = 100;
1053  $xHi = 0;
1054 
1055  $x = $xNew = 1;
1056  $dx = 1;
1057  $i = 0;
1058 
1059  while ((abs($dx) > PRECISION) && ($i++ < MAX_ITERATIONS)) {
1060  // Apply Newton-Raphson step
1061  $result = self::CHIDIST($x, $degrees);
1062  $error = $result - $probability;
1063  if ($error == 0.0) {
1064  $dx = 0;
1065  } elseif ($error < 0.0) {
1066  $xLo = $x;
1067  } else {
1068  $xHi = $x;
1069  }
1070  // Avoid division by zero
1071  if ($result != 0.0) {
1072  $dx = $error / $result;
1073  $xNew = $x - $dx;
1074  }
1075  // If the NR fails to converge (which for example may be the
1076  // case if the initial guess is too rough) we apply a bisection
1077  // step to determine a more narrow interval around the root.
1078  if (($xNew < $xLo) || ($xNew > $xHi) || ($result == 0.0)) {
1079  $xNew = ($xLo + $xHi) / 2;
1080  $dx = $xNew - $x;
1081  }
1082  $x = $xNew;
1083  }
1084  if ($i == MAX_ITERATIONS) {
1085  return PHPExcel_Calculation_Functions::NA();
1086  }
1087  return round($x,12);
1088  }
1089  return PHPExcel_Calculation_Functions::VALUE();
1090  } // function CHIINV()
PHPExcel_Calculation_Functions\flattenSingleValue
static flattenSingleValue($value='')
Convert an array to a single scalar value by extracting the first element.
Definition: Functions.php:662
$result
$result
Definition: CleanUpTest.php:463
$x
$x
Definition: example_009.php:98
PRECISION
const PRECISION
PRECISION.
Definition: Functions.php:49
PHPExcel_Calculation_Functions\VALUE
static VALUE()
Definition: Functions.php:289
$error
$error
Definition: Error.php:17
MAX_ITERATIONS
const MAX_ITERATIONS
MAX_ITERATIONS.
Definition: Functions.php:46
PHPExcel_Calculation_Functions\NA
static NA()
Definition: Functions.php:219
$i
$i
Definition: disco.tpl.php:19
+ Here is the call graph for this function:

◆ CONFIDENCE()

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 1104 of file Statistical.php.

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

1104  {
1105  $alpha = PHPExcel_Calculation_Functions::flattenSingleValue($alpha);
1106  $stdDev = PHPExcel_Calculation_Functions::flattenSingleValue($stdDev);
1107  $size = floor(PHPExcel_Calculation_Functions::flattenSingleValue($size));
1108 
1109  if ((is_numeric($alpha)) && (is_numeric($stdDev)) && (is_numeric($size))) {
1110  if (($alpha <= 0) || ($alpha >= 1)) {
1111  return PHPExcel_Calculation_Functions::NaN();
1112  }
1113  if (($stdDev <= 0) || ($size < 1)) {
1114  return PHPExcel_Calculation_Functions::NaN();
1115  }
1116  return self::NORMSINV(1 - $alpha / 2) * $stdDev / sqrt($size);
1117  }
1118  return PHPExcel_Calculation_Functions::VALUE();
1119  } // function CONFIDENCE()
$size
$size
Definition: RandomTest.php:84
PHPExcel_Calculation_Functions\flattenSingleValue
static flattenSingleValue($value='')
Convert an array to a single scalar value by extracting the first element.
Definition: Functions.php:662
PHPExcel_Calculation_Functions\VALUE
static VALUE()
Definition: Functions.php:289
PHPExcel_Calculation_Functions\NaN
static NaN()
Definition: Functions.php:233
+ Here is the call graph for this function:

◆ CORREL()

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 1131 of file Statistical.php.

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

1131  {
1132  if ((is_null($xValues)) || (!is_array($yValues)) || (!is_array($xValues))) {
1133  return PHPExcel_Calculation_Functions::VALUE();
1134  }
1135  if (!self::_checkTrendArrays($yValues,$xValues)) {
1136  return PHPExcel_Calculation_Functions::VALUE();
1137  }
1138  $yValueCount = count($yValues);
1139  $xValueCount = count($xValues);
1140 
1141  if (($yValueCount == 0) || ($yValueCount != $xValueCount)) {
1142  return PHPExcel_Calculation_Functions::NA();
1143  } elseif ($yValueCount == 1) {
1144  return PHPExcel_Calculation_Functions::DIV0();
1145  }
1146 
1147  $bestFitLinear = trendClass::calculate(trendClass::TREND_LINEAR,$yValues,$xValues);
1148  return $bestFitLinear->getCorrelation();
1149  } // function CORREL()
PHPExcel_Calculation_Functions\DIV0
static DIV0()
Definition: Functions.php:201
trendClass\calculate
static calculate($trendType=self::TREND_BEST_FIT, $yValues, $xValues=array(), $const=True)
Definition: trendClass.php:87
PHPExcel_Calculation_Functions\VALUE
static VALUE()
Definition: Functions.php:289
PHPExcel_Calculation_Functions\NA
static NA()
Definition: Functions.php:219
trendClass\TREND_LINEAR
const TREND_LINEAR
Definition: trendClass.php:45
+ Here is the call graph for this function:

◆ COUNT()

static PHPExcel_Calculation_Statistical::COUNT ( )
static

Definition at line 1165 of file Statistical.php.

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

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

1165  {
1166  // Return value
1167  $returnValue = 0;
1168 
1169  // Loop through arguments
1170  $aArgs = PHPExcel_Calculation_Functions::flattenArrayIndexed(func_get_args());
1171  foreach ($aArgs as $k => $arg) {
1172  if ((is_bool($arg)) &&
1173  ((!PHPExcel_Calculation_Functions::isCellValue($k)) || (PHPExcel_Calculation_Functions::getCompatibilityMode() == PHPExcel_Calculation_Functions::COMPATIBILITY_OPENOFFICE))) {
1174  $arg = (integer) $arg;
1175  }
1176  // Is it a numeric value?
1177  if ((is_numeric($arg)) && (!is_string($arg))) {
1178  ++$returnValue;
1179  }
1180  }
1181 
1182  // Return
1183  return $returnValue;
1184  } // function COUNT()
PHPExcel_Calculation_Functions\flattenArrayIndexed
static flattenArrayIndexed($array)
Convert a multi-dimensional array to a simple 1-dimensional array, but retain an element of indexing...
Definition: Functions.php:630
PHPExcel_Calculation_Functions\isCellValue
static isCellValue($idx)
Definition: Functions.php:304
PHPExcel_Calculation_Functions\COMPATIBILITY_OPENOFFICE
const COMPATIBILITY_OPENOFFICE
Definition: Functions.php:64
PHPExcel_Calculation_Functions\getCompatibilityMode
static getCompatibilityMode()
Definition: Functions.php:138
+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ COUNTA()

static PHPExcel_Calculation_Statistical::COUNTA ( )
static

Definition at line 1200 of file Statistical.php.

References PHPExcel_Calculation_Functions\flattenArray().

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

1200  {
1201  // Return value
1202  $returnValue = 0;
1203 
1204  // Loop through arguments
1205  $aArgs = PHPExcel_Calculation_Functions::flattenArray(func_get_args());
1206  foreach ($aArgs as $arg) {
1207  // Is it a numeric, boolean or string value?
1208  if ((is_numeric($arg)) || (is_bool($arg)) || ((is_string($arg) && ($arg != '')))) {
1209  ++$returnValue;
1210  }
1211  }
1212 
1213  // Return
1214  return $returnValue;
1215  } // function COUNTA()
PHPExcel_Calculation_Functions\flattenArray
static flattenArray($array)
Convert a multi-dimensional array to a simple 1-dimensional array.
Definition: Functions.php:598
+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ COUNTBLANK()

static PHPExcel_Calculation_Statistical::COUNTBLANK ( )
static

Definition at line 1231 of file Statistical.php.

References PHPExcel_Calculation_Functions\flattenArray().

1231  {
1232  // Return value
1233  $returnValue = 0;
1234 
1235  // Loop through arguments
1236  $aArgs = PHPExcel_Calculation_Functions::flattenArray(func_get_args());
1237  foreach ($aArgs as $arg) {
1238  // Is it a blank cell?
1239  if ((is_null($arg)) || ((is_string($arg)) && ($arg == ''))) {
1240  ++$returnValue;
1241  }
1242  }
1243 
1244  // Return
1245  return $returnValue;
1246  } // function COUNTBLANK()
PHPExcel_Calculation_Functions\flattenArray
static flattenArray($array)
Convert a multi-dimensional array to a simple 1-dimensional array.
Definition: Functions.php:598
+ Here is the call graph for this function:

◆ COUNTIF()

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

Definition at line 1263 of file Statistical.php.

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

1263  {
1264  // Return value
1265  $returnValue = 0;
1266 
1267  $aArgs = PHPExcel_Calculation_Functions::flattenArray($aArgs);
1268  $condition = PHPExcel_Calculation_Functions::_ifCondition($condition);
1269  // Loop through arguments
1270  foreach ($aArgs as $arg) {
1271  if (!is_numeric($arg)) { $arg = PHPExcel_Calculation::_wrapResult(strtoupper($arg)); }
1272  $testCondition = '='.$arg.$condition;
1273  if (PHPExcel_Calculation::getInstance()->_calculateFormulaValue($testCondition)) {
1274  // Is it a value within our criteria
1275  ++$returnValue;
1276  }
1277  }
1278 
1279  // Return
1280  return $returnValue;
1281  } // function COUNTIF()
PHPExcel_Calculation\_wrapResult
static _wrapResult($value)
Wrap string values in quotes.
Definition: Calculation.php:2163
PHPExcel_Calculation_Functions\flattenArray
static flattenArray($array)
Convert a multi-dimensional array to a simple 1-dimensional array.
Definition: Functions.php:598
PHPExcel_Calculation_Functions\_ifCondition
static _ifCondition($condition)
Definition: Functions.php:309
PHPExcel_Calculation\getInstance
static getInstance(PHPExcel $workbook=NULL)
Get an instance of this class.
Definition: Calculation.php:1765
+ Here is the call graph for this function:

◆ COVAR()

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 1293 of file Statistical.php.

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

1293  {
1294  if (!self::_checkTrendArrays($yValues,$xValues)) {
1295  return PHPExcel_Calculation_Functions::VALUE();
1296  }
1297  $yValueCount = count($yValues);
1298  $xValueCount = count($xValues);
1299 
1300  if (($yValueCount == 0) || ($yValueCount != $xValueCount)) {
1301  return PHPExcel_Calculation_Functions::NA();
1302  } elseif ($yValueCount == 1) {
1303  return PHPExcel_Calculation_Functions::DIV0();
1304  }
1305 
1306  $bestFitLinear = trendClass::calculate(trendClass::TREND_LINEAR,$yValues,$xValues);
1307  return $bestFitLinear->getCovariance();
1308  } // function COVAR()
PHPExcel_Calculation_Functions\DIV0
static DIV0()
Definition: Functions.php:201
trendClass\calculate
static calculate($trendType=self::TREND_BEST_FIT, $yValues, $xValues=array(), $const=True)
Definition: trendClass.php:87
PHPExcel_Calculation_Functions\VALUE
static VALUE()
Definition: Functions.php:289
PHPExcel_Calculation_Functions\NA
static NA()
Definition: Functions.php:219
trendClass\TREND_LINEAR
const TREND_LINEAR
Definition: trendClass.php:45
+ Here is the call graph for this function:

◆ CRITBINOM()

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 1330 of file Statistical.php.

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

1330  {
1331  $trials = floor(PHPExcel_Calculation_Functions::flattenSingleValue($trials));
1332  $probability = PHPExcel_Calculation_Functions::flattenSingleValue($probability);
1333  $alpha = PHPExcel_Calculation_Functions::flattenSingleValue($alpha);
1334 
1335  if ((is_numeric($trials)) && (is_numeric($probability)) && (is_numeric($alpha))) {
1336  if ($trials < 0) {
1337  return PHPExcel_Calculation_Functions::NaN();
1338  }
1339  if (($probability < 0) || ($probability > 1)) {
1340  return PHPExcel_Calculation_Functions::NaN();
1341  }
1342  if (($alpha < 0) || ($alpha > 1)) {
1343  return PHPExcel_Calculation_Functions::NaN();
1344  }
1345  if ($alpha <= 0.5) {
1346  $t = sqrt(log(1 / ($alpha * $alpha)));
1347  $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));
1348  } else {
1349  $t = sqrt(log(1 / pow(1 - $alpha,2)));
1350  $trialsApprox = $t - (2.515517 + 0.802853 * $t + 0.010328 * $t * $t) / (1 + 1.432788 * $t + 0.189269 * $t * $t + 0.001308 * $t * $t * $t);
1351  }
1352  $Guess = floor($trials * $probability + $trialsApprox * sqrt($trials * $probability * (1 - $probability)));
1353  if ($Guess < 0) {
1354  $Guess = 0;
1355  } elseif ($Guess > $trials) {
1356  $Guess = $trials;
1357  }
1358 
1359  $TotalUnscaledProbability = $UnscaledPGuess = $UnscaledCumPGuess = 0.0;
1360  $EssentiallyZero = 10e-12;
1361 
1362  $m = floor($trials * $probability);
1363  ++$TotalUnscaledProbability;
1364  if ($m == $Guess) { ++$UnscaledPGuess; }
1365  if ($m <= $Guess) { ++$UnscaledCumPGuess; }
1366 
1367  $PreviousValue = 1;
1368  $Done = False;
1369  $k = $m + 1;
1370  while ((!$Done) && ($k <= $trials)) {
1371  $CurrentValue = $PreviousValue * ($trials - $k + 1) * $probability / ($k * (1 - $probability));
1372  $TotalUnscaledProbability += $CurrentValue;
1373  if ($k == $Guess) { $UnscaledPGuess += $CurrentValue; }
1374  if ($k <= $Guess) { $UnscaledCumPGuess += $CurrentValue; }
1375  if ($CurrentValue <= $EssentiallyZero) { $Done = True; }
1376  $PreviousValue = $CurrentValue;
1377  ++$k;
1378  }
1379 
1380  $PreviousValue = 1;
1381  $Done = False;
1382  $k = $m - 1;
1383  while ((!$Done) && ($k >= 0)) {
1384  $CurrentValue = $PreviousValue * $k + 1 * (1 - $probability) / (($trials - $k) * $probability);
1385  $TotalUnscaledProbability += $CurrentValue;
1386  if ($k == $Guess) { $UnscaledPGuess += $CurrentValue; }
1387  if ($k <= $Guess) { $UnscaledCumPGuess += $CurrentValue; }
1388  if ($CurrentValue <= $EssentiallyZero) { $Done = True; }
1389  $PreviousValue = $CurrentValue;
1390  --$k;
1391  }
1392 
1393  $PGuess = $UnscaledPGuess / $TotalUnscaledProbability;
1394  $CumPGuess = $UnscaledCumPGuess / $TotalUnscaledProbability;
1395 
1396 // $CumPGuessMinus1 = $CumPGuess - $PGuess;
1397  $CumPGuessMinus1 = $CumPGuess - 1;
1398 
1399  while (True) {
1400  if (($CumPGuessMinus1 < $alpha) && ($CumPGuess >= $alpha)) {
1401  return $Guess;
1402  } elseif (($CumPGuessMinus1 < $alpha) && ($CumPGuess < $alpha)) {
1403  $PGuessPlus1 = $PGuess * ($trials - $Guess) * $probability / $Guess / (1 - $probability);
1404  $CumPGuessMinus1 = $CumPGuess;
1405  $CumPGuess = $CumPGuess + $PGuessPlus1;
1406  $PGuess = $PGuessPlus1;
1407  ++$Guess;
1408  } elseif (($CumPGuessMinus1 >= $alpha) && ($CumPGuess >= $alpha)) {
1409  $PGuessMinus1 = $PGuess * $Guess * (1 - $probability) / ($trials - $Guess + 1) / $probability;
1410  $CumPGuess = $CumPGuessMinus1;
1411  $CumPGuessMinus1 = $CumPGuessMinus1 - $PGuess;
1412  $PGuess = $PGuessMinus1;
1413  --$Guess;
1414  }
1415  }
1416  }
1417  return PHPExcel_Calculation_Functions::VALUE();
1418  } // function CRITBINOM()
PHPExcel_Calculation_Functions\flattenSingleValue
static flattenSingleValue($value='')
Convert an array to a single scalar value by extracting the first element.
Definition: Functions.php:662
$m
$m
Definition: show_metadata.php:25
PHPExcel_Calculation_Functions\VALUE
static VALUE()
Definition: Functions.php:289
e
e($cmd)
Definition: flush.php:14
PHPExcel_Calculation_Functions\NaN
static NaN()
Definition: Functions.php:233
+ Here is the call graph for this function:

◆ DEVSQ()

static PHPExcel_Calculation_Statistical::DEVSQ ( )
static

Definition at line 1434 of file Statistical.php.

References 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().

1434  {
1435  $aArgs = PHPExcel_Calculation_Functions::flattenArrayIndexed(func_get_args());
1436 
1437  // Return value
1438  $returnValue = null;
1439 
1440  $aMean = self::AVERAGE($aArgs);
1441  if ($aMean != PHPExcel_Calculation_Functions::DIV0()) {
1442  $aCount = -1;
1443  foreach ($aArgs as $k => $arg) {
1444  // Is it a numeric value?
1445  if ((is_bool($arg)) &&
1446  ((!PHPExcel_Calculation_Functions::isCellValue($k)) || (PHPExcel_Calculation_Functions::getCompatibilityMode() == PHPExcel_Calculation_Functions::COMPATIBILITY_OPENOFFICE))) {
1447  $arg = (integer) $arg;
1448  }
1449  if ((is_numeric($arg)) && (!is_string($arg))) {
1450  if (is_null($returnValue)) {
1451  $returnValue = pow(($arg - $aMean),2);
1452  } else {
1453  $returnValue += pow(($arg - $aMean),2);
1454  }
1455  ++$aCount;
1456  }
1457  }
1458 
1459  // Return
1460  if (is_null($returnValue)) {
1461  return PHPExcel_Calculation_Functions::NaN();
1462  } else {
1463  return $returnValue;
1464  }
1465  }
1466  return self::NA();
1467  } // function DEVSQ()
PHPExcel_Calculation_Functions\DIV0
static DIV0()
Definition: Functions.php:201
PHPExcel_Calculation_Functions\flattenArrayIndexed
static flattenArrayIndexed($array)
Convert a multi-dimensional array to a simple 1-dimensional array, but retain an element of indexing...
Definition: Functions.php:630
PHPExcel_Calculation_Functions\isCellValue
static isCellValue($idx)
Definition: Functions.php:304
PHPExcel_Calculation_Functions\COMPATIBILITY_OPENOFFICE
const COMPATIBILITY_OPENOFFICE
Definition: Functions.php:64
PHPExcel_Calculation_Functions\getCompatibilityMode
static getCompatibilityMode()
Definition: Functions.php:138
PHPExcel_Calculation_Functions\NaN
static NaN()
Definition: Functions.php:233
+ Here is the call graph for this function:

◆ EXPONDIST()

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 1482 of file Statistical.php.

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

1482  {
1483  $value = PHPExcel_Calculation_Functions::flattenSingleValue($value);
1484  $lambda = PHPExcel_Calculation_Functions::flattenSingleValue($lambda);
1485  $cumulative = PHPExcel_Calculation_Functions::flattenSingleValue($cumulative);
1486 
1487  if ((is_numeric($value)) && (is_numeric($lambda))) {
1488  if (($value < 0) || ($lambda < 0)) {
1489  return PHPExcel_Calculation_Functions::NaN();
1490  }
1491  if ((is_numeric($cumulative)) || (is_bool($cumulative))) {
1492  if ($cumulative) {
1493  return 1 - exp(0-$value*$lambda);
1494  } else {
1495  return $lambda * exp(0-$value*$lambda);
1496  }
1497  }
1498  }
1499  return PHPExcel_Calculation_Functions::VALUE();
1500  } // function EXPONDIST()
PHPExcel_Calculation_Functions\flattenSingleValue
static flattenSingleValue($value='')
Convert an array to a single scalar value by extracting the first element.
Definition: Functions.php:662
PHPExcel_Calculation_Functions\VALUE
static VALUE()
Definition: Functions.php:289
PHPExcel_Calculation_Functions\NaN
static NaN()
Definition: Functions.php:233
+ Here is the call graph for this function:

◆ FISHER()

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 1513 of file Statistical.php.

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

1513  {
1514  $value = PHPExcel_Calculation_Functions::flattenSingleValue($value);
1515 
1516  if (is_numeric($value)) {
1517  if (($value <= -1) || ($value >= 1)) {
1518  return PHPExcel_Calculation_Functions::NaN();
1519  }
1520  return 0.5 * log((1+$value)/(1-$value));
1521  }
1522  return PHPExcel_Calculation_Functions::VALUE();
1523  } // function FISHER()
PHPExcel_Calculation_Functions\flattenSingleValue
static flattenSingleValue($value='')
Convert an array to a single scalar value by extracting the first element.
Definition: Functions.php:662
PHPExcel_Calculation_Functions\VALUE
static VALUE()
Definition: Functions.php:289
PHPExcel_Calculation_Functions\NaN
static NaN()
Definition: Functions.php:233
+ Here is the call graph for this function:

◆ FISHERINV()

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 1536 of file Statistical.php.

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

1536  {
1537  $value = PHPExcel_Calculation_Functions::flattenSingleValue($value);
1538 
1539  if (is_numeric($value)) {
1540  return (exp(2 * $value) - 1) / (exp(2 * $value) + 1);
1541  }
1542  return PHPExcel_Calculation_Functions::VALUE();
1543  } // function FISHERINV()
PHPExcel_Calculation_Functions\flattenSingleValue
static flattenSingleValue($value='')
Convert an array to a single scalar value by extracting the first element.
Definition: Functions.php:662
PHPExcel_Calculation_Functions\VALUE
static VALUE()
Definition: Functions.php:289
+ Here is the call graph for this function:

◆ FORECAST()

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 1556 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().

1556  {
1557  $xValue = PHPExcel_Calculation_Functions::flattenSingleValue($xValue);
1558  if (!is_numeric($xValue)) {
1559  return PHPExcel_Calculation_Functions::VALUE();
1560  }
1561 
1562  if (!self::_checkTrendArrays($yValues,$xValues)) {
1563  return PHPExcel_Calculation_Functions::VALUE();
1564  }
1565  $yValueCount = count($yValues);
1566  $xValueCount = count($xValues);
1567 
1568  if (($yValueCount == 0) || ($yValueCount != $xValueCount)) {
1569  return PHPExcel_Calculation_Functions::NA();
1570  } elseif ($yValueCount == 1) {
1571  return PHPExcel_Calculation_Functions::DIV0();
1572  }
1573 
1574  $bestFitLinear = trendClass::calculate(trendClass::TREND_LINEAR,$yValues,$xValues);
1575  return $bestFitLinear->getValueOfYForX($xValue);
1576  } // function FORECAST()
PHPExcel_Calculation_Functions\DIV0
static DIV0()
Definition: Functions.php:201
PHPExcel_Calculation_Functions\flattenSingleValue
static flattenSingleValue($value='')
Convert an array to a single scalar value by extracting the first element.
Definition: Functions.php:662
trendClass\calculate
static calculate($trendType=self::TREND_BEST_FIT, $yValues, $xValues=array(), $const=True)
Definition: trendClass.php:87
PHPExcel_Calculation_Functions\VALUE
static VALUE()
Definition: Functions.php:289
PHPExcel_Calculation_Functions\NA
static NA()
Definition: Functions.php:219
trendClass\TREND_LINEAR
const TREND_LINEAR
Definition: trendClass.php:45
+ Here is the call graph for this function:

◆ GAMMADIST()

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 1591 of file Statistical.php.

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

1591  {
1592  $value = PHPExcel_Calculation_Functions::flattenSingleValue($value);
1593  $a = PHPExcel_Calculation_Functions::flattenSingleValue($a);
1594  $b = PHPExcel_Calculation_Functions::flattenSingleValue($b);
1595 
1596  if ((is_numeric($value)) && (is_numeric($a)) && (is_numeric($b))) {
1597  if (($value < 0) || ($a <= 0) || ($b <= 0)) {
1598  return PHPExcel_Calculation_Functions::NaN();
1599  }
1600  if ((is_numeric($cumulative)) || (is_bool($cumulative))) {
1601  if ($cumulative) {
1602  return self::_incompleteGamma($a,$value / $b) / self::_gamma($a);
1603  } else {
1604  return (1 / (pow($b,$a) * self::_gamma($a))) * pow($value,$a-1) * exp(0-($value / $b));
1605  }
1606  }
1607  }
1608  return PHPExcel_Calculation_Functions::VALUE();
1609  } // function GAMMADIST()
PHPExcel_Calculation_Functions\flattenSingleValue
static flattenSingleValue($value='')
Convert an array to a single scalar value by extracting the first element.
Definition: Functions.php:662
PHPExcel_Calculation_Functions\VALUE
static VALUE()
Definition: Functions.php:289
PHPExcel_Calculation_Functions\NaN
static NaN()
Definition: Functions.php:233
+ Here is the call graph for this function:

◆ GAMMAINV()

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 1623 of file Statistical.php.

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

1623  {
1624  $probability = PHPExcel_Calculation_Functions::flattenSingleValue($probability);
1625  $alpha = PHPExcel_Calculation_Functions::flattenSingleValue($alpha);
1626  $beta = PHPExcel_Calculation_Functions::flattenSingleValue($beta);
1627 
1628  if ((is_numeric($probability)) && (is_numeric($alpha)) && (is_numeric($beta))) {
1629  if (($alpha <= 0) || ($beta <= 0) || ($probability < 0) || ($probability > 1)) {
1630  return PHPExcel_Calculation_Functions::NaN();
1631  }
1632 
1633  $xLo = 0;
1634  $xHi = $alpha * $beta * 5;
1635 
1636  $x = $xNew = 1;
1637  $error = $pdf = 0;
1638  $dx = 1024;
1639  $i = 0;
1640 
1641  while ((abs($dx) > PRECISION) && ($i++ < MAX_ITERATIONS)) {
1642  // Apply Newton-Raphson step
1643  $error = self::GAMMADIST($x, $alpha, $beta, True) - $probability;
1644  if ($error < 0.0) {
1645  $xLo = $x;
1646  } else {
1647  $xHi = $x;
1648  }
1649  $pdf = self::GAMMADIST($x, $alpha, $beta, False);
1650  // Avoid division by zero
1651  if ($pdf != 0.0) {
1652  $dx = $error / $pdf;
1653  $xNew = $x - $dx;
1654  }
1655  // If the NR fails to converge (which for example may be the
1656  // case if the initial guess is too rough) we apply a bisection
1657  // step to determine a more narrow interval around the root.
1658  if (($xNew < $xLo) || ($xNew > $xHi) || ($pdf == 0.0)) {
1659  $xNew = ($xLo + $xHi) / 2;
1660  $dx = $xNew - $x;
1661  }
1662  $x = $xNew;
1663  }
1664  if ($i == MAX_ITERATIONS) {
1665  return PHPExcel_Calculation_Functions::NA();
1666  }
1667  return $x;
1668  }
1669  return PHPExcel_Calculation_Functions::VALUE();
1670  } // function GAMMAINV()
PHPExcel_Calculation_Functions\flattenSingleValue
static flattenSingleValue($value='')
Convert an array to a single scalar value by extracting the first element.
Definition: Functions.php:662
$x
$x
Definition: example_009.php:98
$pdf
$pdf
Definition: example_001.php:31
PRECISION
const PRECISION
PRECISION.
Definition: Functions.php:49
PHPExcel_Calculation_Functions\VALUE
static VALUE()
Definition: Functions.php:289
$error
$error
Definition: Error.php:17
MAX_ITERATIONS
const MAX_ITERATIONS
MAX_ITERATIONS.
Definition: Functions.php:46
PHPExcel_Calculation_Functions\NA
static NA()
Definition: Functions.php:219
PHPExcel_Calculation_Functions\NaN
static NaN()
Definition: Functions.php:233
$i
$i
Definition: disco.tpl.php:19
+ Here is the call graph for this function:

◆ GAMMALN()

static PHPExcel_Calculation_Statistical::GAMMALN (   $value)
static

GAMMALN.

Returns the natural logarithm of the gamma function.

Parameters
float$value
Returns
float

Definition at line 1681 of file Statistical.php.

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

1681  {
1682  $value = PHPExcel_Calculation_Functions::flattenSingleValue($value);
1683 
1684  if (is_numeric($value)) {
1685  if ($value <= 0) {
1686  return PHPExcel_Calculation_Functions::NaN();
1687  }
1688  return log(self::_gamma($value));
1689  }
1690  return PHPExcel_Calculation_Functions::VALUE();
1691  } // function GAMMALN()
PHPExcel_Calculation_Functions\flattenSingleValue
static flattenSingleValue($value='')
Convert an array to a single scalar value by extracting the first element.
Definition: Functions.php:662
PHPExcel_Calculation_Functions\VALUE
static VALUE()
Definition: Functions.php:289
PHPExcel_Calculation_Functions\NaN
static NaN()
Definition: Functions.php:233
+ Here is the call graph for this function:

◆ GEOMEAN()

static PHPExcel_Calculation_Statistical::GEOMEAN ( )
static

Definition at line 1709 of file Statistical.php.

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

1709  {
1710  $aArgs = PHPExcel_Calculation_Functions::flattenArray(func_get_args());
1711 
1712  $aMean = PHPExcel_Calculation_MathTrig::PRODUCT($aArgs);
1713  if (is_numeric($aMean) && ($aMean > 0)) {
1714  $aCount = self::COUNT($aArgs) ;
1715  if (self::MIN($aArgs) > 0) {
1716  return pow($aMean, (1 / $aCount));
1717  }
1718  }
1719  return PHPExcel_Calculation_Functions::NaN();
1720  } // GEOMEAN()
PHPExcel_Calculation_Functions\flattenArray
static flattenArray($array)
Convert a multi-dimensional array to a simple 1-dimensional array.
Definition: Functions.php:598
PHPExcel_Calculation_Functions\NaN
static NaN()
Definition: Functions.php:233
PHPExcel_Calculation_MathTrig\PRODUCT
static PRODUCT()
Definition: MathTrig.php:811
+ Here is the call graph for this function:

◆ GROWTH()

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 1734 of file Statistical.php.

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

1734  {
1735  $yValues = PHPExcel_Calculation_Functions::flattenArray($yValues);
1736  $xValues = PHPExcel_Calculation_Functions::flattenArray($xValues);
1737  $newValues = PHPExcel_Calculation_Functions::flattenArray($newValues);
1738  $const = (is_null($const)) ? True : (boolean) PHPExcel_Calculation_Functions::flattenSingleValue($const);
1739 
1740  $bestFitExponential = trendClass::calculate(trendClass::TREND_EXPONENTIAL,$yValues,$xValues,$const);
1741  if (empty($newValues)) {
1742  $newValues = $bestFitExponential->getXValues();
1743  }
1744 
1745  $returnArray = array();
1746  foreach($newValues as $xValue) {
1747  $returnArray[0][] = $bestFitExponential->getValueOfYForX($xValue);
1748  }
1749 
1750  return $returnArray;
1751  } // function GROWTH()
PHPExcel_Calculation_Functions\flattenSingleValue
static flattenSingleValue($value='')
Convert an array to a single scalar value by extracting the first element.
Definition: Functions.php:662
trendClass\TREND_EXPONENTIAL
const TREND_EXPONENTIAL
Definition: trendClass.php:47
trendClass\calculate
static calculate($trendType=self::TREND_BEST_FIT, $yValues, $xValues=array(), $const=True)
Definition: trendClass.php:87
PHPExcel_Calculation_Functions\flattenArray
static flattenArray($array)
Convert a multi-dimensional array to a simple 1-dimensional array.
Definition: Functions.php:598
array
Create styles array
The data for the language used.
Definition: 40duplicateStyle.php:19
+ Here is the call graph for this function:

◆ HARMEAN()

static PHPExcel_Calculation_Statistical::HARMEAN ( )
static

Definition at line 1768 of file Statistical.php.

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

1768  {
1769  // Return value
1770  $returnValue = PHPExcel_Calculation_Functions::NA();
1771 
1772  // Loop through arguments
1773  $aArgs = PHPExcel_Calculation_Functions::flattenArray(func_get_args());
1774  if (self::MIN($aArgs) < 0) {
1775  return PHPExcel_Calculation_Functions::NaN();
1776  }
1777  $aCount = 0;
1778  foreach ($aArgs as $arg) {
1779  // Is it a numeric value?
1780  if ((is_numeric($arg)) && (!is_string($arg))) {
1781  if ($arg <= 0) {
1782  return PHPExcel_Calculation_Functions::NaN();
1783  }
1784  if (is_null($returnValue)) {
1785  $returnValue = (1 / $arg);
1786  } else {
1787  $returnValue += (1 / $arg);
1788  }
1789  ++$aCount;
1790  }
1791  }
1792 
1793  // Return
1794  if ($aCount > 0) {
1795  return 1 / ($returnValue / $aCount);
1796  } else {
1797  return $returnValue;
1798  }
1799  } // function HARMEAN()
PHPExcel_Calculation_Functions\flattenArray
static flattenArray($array)
Convert a multi-dimensional array to a simple 1-dimensional array.
Definition: Functions.php:598
PHPExcel_Calculation_Functions\NA
static NA()
Definition: Functions.php:219
PHPExcel_Calculation_Functions\NaN
static NaN()
Definition: Functions.php:233
+ Here is the call graph for this function:

◆ HYPGEOMDIST()

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 1815 of file Statistical.php.

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

1815  {
1816  $sampleSuccesses = floor(PHPExcel_Calculation_Functions::flattenSingleValue($sampleSuccesses));
1817  $sampleNumber = floor(PHPExcel_Calculation_Functions::flattenSingleValue($sampleNumber));
1818  $populationSuccesses = floor(PHPExcel_Calculation_Functions::flattenSingleValue($populationSuccesses));
1819  $populationNumber = floor(PHPExcel_Calculation_Functions::flattenSingleValue($populationNumber));
1820 
1821  if ((is_numeric($sampleSuccesses)) && (is_numeric($sampleNumber)) && (is_numeric($populationSuccesses)) && (is_numeric($populationNumber))) {
1822  if (($sampleSuccesses < 0) || ($sampleSuccesses > $sampleNumber) || ($sampleSuccesses > $populationSuccesses)) {
1823  return PHPExcel_Calculation_Functions::NaN();
1824  }
1825  if (($sampleNumber <= 0) || ($sampleNumber > $populationNumber)) {
1826  return PHPExcel_Calculation_Functions::NaN();
1827  }
1828  if (($populationSuccesses <= 0) || ($populationSuccesses > $populationNumber)) {
1829  return PHPExcel_Calculation_Functions::NaN();
1830  }
1831  return PHPExcel_Calculation_MathTrig::COMBIN($populationSuccesses,$sampleSuccesses) *
1832  PHPExcel_Calculation_MathTrig::COMBIN($populationNumber - $populationSuccesses,$sampleNumber - $sampleSuccesses) /
1833  PHPExcel_Calculation_MathTrig::COMBIN($populationNumber,$sampleNumber);
1834  }
1835  return PHPExcel_Calculation_Functions::VALUE();
1836  } // function HYPGEOMDIST()
PHPExcel_Calculation_Functions\flattenSingleValue
static flattenSingleValue($value='')
Convert an array to a single scalar value by extracting the first element.
Definition: Functions.php:662
PHPExcel_Calculation_Functions\VALUE
static VALUE()
Definition: Functions.php:289
PHPExcel_Calculation_MathTrig\COMBIN
static COMBIN($numObjs, $numInSet)
Definition: MathTrig.php:176
PHPExcel_Calculation_Functions\NaN
static NaN()
Definition: Functions.php:233
+ Here is the call graph for this function:

◆ INTERCEPT()

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 1848 of file Statistical.php.

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

1848  {
1849  if (!self::_checkTrendArrays($yValues,$xValues)) {
1850  return PHPExcel_Calculation_Functions::VALUE();
1851  }
1852  $yValueCount = count($yValues);
1853  $xValueCount = count($xValues);
1854 
1855  if (($yValueCount == 0) || ($yValueCount != $xValueCount)) {
1856  return PHPExcel_Calculation_Functions::NA();
1857  } elseif ($yValueCount == 1) {
1858  return PHPExcel_Calculation_Functions::DIV0();
1859  }
1860 
1861  $bestFitLinear = trendClass::calculate(trendClass::TREND_LINEAR,$yValues,$xValues);
1862  return $bestFitLinear->getIntersect();
1863  } // function INTERCEPT()
PHPExcel_Calculation_Functions\DIV0
static DIV0()
Definition: Functions.php:201
trendClass\calculate
static calculate($trendType=self::TREND_BEST_FIT, $yValues, $xValues=array(), $const=True)
Definition: trendClass.php:87
PHPExcel_Calculation_Functions\VALUE
static VALUE()
Definition: Functions.php:289
PHPExcel_Calculation_Functions\NA
static NA()
Definition: Functions.php:219
trendClass\TREND_LINEAR
const TREND_LINEAR
Definition: trendClass.php:45
+ Here is the call graph for this function:

◆ KURT()

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 1877 of file Statistical.php.

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

1877  {
1878  $aArgs = PHPExcel_Calculation_Functions::flattenArrayIndexed(func_get_args());
1879  $mean = self::AVERAGE($aArgs);
1880  $stdDev = self::STDEV($aArgs);
1881 
1882  if ($stdDev > 0) {
1883  $count = $summer = 0;
1884  // Loop through arguments
1885  foreach ($aArgs as $k => $arg) {
1886  if ((is_bool($arg)) &&
1887  (!PHPExcel_Calculation_Functions::isMatrixValue($k))) {
1888  } else {
1889  // Is it a numeric value?
1890  if ((is_numeric($arg)) && (!is_string($arg))) {
1891  $summer += pow((($arg - $mean) / $stdDev),4) ;
1892  ++$count;
1893  }
1894  }
1895  }
1896 
1897  // Return
1898  if ($count > 3) {
1899  return $summer * ($count * ($count+1) / (($count-1) * ($count-2) * ($count-3))) - (3 * pow($count-1,2) / (($count-2) * ($count-3)));
1900  }
1901  }
1902  return PHPExcel_Calculation_Functions::DIV0();
1903  } // function KURT()
PHPExcel_Calculation_Functions\DIV0
static DIV0()
Definition: Functions.php:201
PHPExcel_Calculation_Functions\flattenArrayIndexed
static flattenArrayIndexed($array)
Convert a multi-dimensional array to a simple 1-dimensional array, but retain an element of indexing...
Definition: Functions.php:630
PHPExcel_Calculation_Functions\isMatrixValue
static isMatrixValue($idx)
Definition: Functions.php:294
+ Here is the call graph for this function:

◆ LARGE()

static PHPExcel_Calculation_Statistical::LARGE ( )
static

Definition at line 1922 of file Statistical.php.

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

1922  {
1923  $aArgs = PHPExcel_Calculation_Functions::flattenArray(func_get_args());
1924 
1925  // Calculate
1926  $entry = floor(array_pop($aArgs));
1927 
1928  if ((is_numeric($entry)) && (!is_string($entry))) {
1929  $mArgs = array();
1930  foreach ($aArgs as $arg) {
1931  // Is it a numeric value?
1932  if ((is_numeric($arg)) && (!is_string($arg))) {
1933  $mArgs[] = $arg;
1934  }
1935  }
1936  $count = self::COUNT($mArgs);
1937  $entry = floor(--$entry);
1938  if (($entry < 0) || ($entry >= $count) || ($count == 0)) {
1939  return PHPExcel_Calculation_Functions::NaN();
1940  }
1941  rsort($mArgs);
1942  return $mArgs[$entry];
1943  }
1944  return PHPExcel_Calculation_Functions::VALUE();
1945  } // function LARGE()
PHPExcel_Calculation_Functions\flattenArray
static flattenArray($array)
Convert a multi-dimensional array to a simple 1-dimensional array.
Definition: Functions.php:598
PHPExcel_Calculation_Functions\VALUE
static VALUE()
Definition: Functions.php:289
array
Create styles array
The data for the language used.
Definition: 40duplicateStyle.php:19
PHPExcel_Calculation_Functions\NaN
static NaN()
Definition: Functions.php:233
+ Here is the call graph for this function:

◆ LINEST()

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 1960 of file Statistical.php.

References $stats, array, trendClass\calculate(), PHPExcel_Calculation_Functions\flattenArray(), PHPExcel_Calculation_Functions\flattenSingleValue(), PHPExcel_Calculation_Functions\NA(), range, trendClass\TREND_LINEAR, and PHPExcel_Calculation_Functions\VALUE().

1960  {
1961  $const = (is_null($const)) ? TRUE : (boolean) PHPExcel_Calculation_Functions::flattenSingleValue($const);
1962  $stats = (is_null($stats)) ? FALSE : (boolean) PHPExcel_Calculation_Functions::flattenSingleValue($stats);
1963  if (is_null($xValues)) $xValues = range(1,count(PHPExcel_Calculation_Functions::flattenArray($yValues)));
1964 
1965  if (!self::_checkTrendArrays($yValues,$xValues)) {
1966  return PHPExcel_Calculation_Functions::VALUE();
1967  }
1968  $yValueCount = count($yValues);
1969  $xValueCount = count($xValues);
1970 
1971 
1972  if (($yValueCount == 0) || ($yValueCount != $xValueCount)) {
1973  return PHPExcel_Calculation_Functions::NA();
1974  } elseif ($yValueCount == 1) {
1975  return 0;
1976  }
1977 
1978  $bestFitLinear = trendClass::calculate(trendClass::TREND_LINEAR,$yValues,$xValues,$const);
1979  if ($stats) {
1980  return array( array( $bestFitLinear->getSlope(),
1981  $bestFitLinear->getSlopeSE(),
1982  $bestFitLinear->getGoodnessOfFit(),
1983  $bestFitLinear->getF(),
1984  $bestFitLinear->getSSRegression(),
1985  ),
1986  array( $bestFitLinear->getIntersect(),
1987  $bestFitLinear->getIntersectSE(),
1988  $bestFitLinear->getStdevOfResiduals(),
1989  $bestFitLinear->getDFResiduals(),
1990  $bestFitLinear->getSSResiduals()
1991  )
1992  );
1993  } else {
1994  return array( $bestFitLinear->getSlope(),
1995  $bestFitLinear->getIntersect()
1996  );
1997  }
1998  } // function LINEST()
PHPExcel_Calculation_Functions\flattenSingleValue
static flattenSingleValue($value='')
Convert an array to a single scalar value by extracting the first element.
Definition: Functions.php:662
trendClass\calculate
static calculate($trendType=self::TREND_BEST_FIT, $yValues, $xValues=array(), $const=True)
Definition: trendClass.php:87
range
Resolve range
Definition: 19namedrange.php:96
PHPExcel_Calculation_Functions\flattenArray
static flattenArray($array)
Convert a multi-dimensional array to a simple 1-dimensional array.
Definition: Functions.php:598
PHPExcel_Calculation_Functions\VALUE
static VALUE()
Definition: Functions.php:289
$stats
$stats
Definition: memcacheSync.php:36
PHPExcel_Calculation_Functions\NA
static NA()
Definition: Functions.php:219
array
Create styles array
The data for the language used.
Definition: 40duplicateStyle.php:19
trendClass\TREND_LINEAR
const TREND_LINEAR
Definition: trendClass.php:45
+ Here is the call graph for this function:

◆ LOGEST()

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 2013 of file Statistical.php.

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

2013  {
2014  $const = (is_null($const)) ? True : (boolean) PHPExcel_Calculation_Functions::flattenSingleValue($const);
2015  $stats = (is_null($stats)) ? False : (boolean) PHPExcel_Calculation_Functions::flattenSingleValue($stats);
2016  if (is_null($xValues)) $xValues = range(1,count(PHPExcel_Calculation_Functions::flattenArray($yValues)));
2017 
2018  if (!self::_checkTrendArrays($yValues,$xValues)) {
2019  return PHPExcel_Calculation_Functions::VALUE();
2020  }
2021  $yValueCount = count($yValues);
2022  $xValueCount = count($xValues);
2023 
2024  foreach($yValues as $value) {
2025  if ($value <= 0.0) {
2026  return PHPExcel_Calculation_Functions::NaN();
2027  }
2028  }
2029 
2030 
2031  if (($yValueCount == 0) || ($yValueCount != $xValueCount)) {
2032  return PHPExcel_Calculation_Functions::NA();
2033  } elseif ($yValueCount == 1) {
2034  return 1;
2035  }
2036 
2037  $bestFitExponential = trendClass::calculate(trendClass::TREND_EXPONENTIAL,$yValues,$xValues,$const);
2038  if ($stats) {
2039  return array( array( $bestFitExponential->getSlope(),
2040  $bestFitExponential->getSlopeSE(),
2041  $bestFitExponential->getGoodnessOfFit(),
2042  $bestFitExponential->getF(),
2043  $bestFitExponential->getSSRegression(),
2044  ),
2045  array( $bestFitExponential->getIntersect(),
2046  $bestFitExponential->getIntersectSE(),
2047  $bestFitExponential->getStdevOfResiduals(),
2048  $bestFitExponential->getDFResiduals(),
2049  $bestFitExponential->getSSResiduals()
2050  )
2051  );
2052  } else {
2053  return array( $bestFitExponential->getSlope(),
2054  $bestFitExponential->getIntersect()
2055  );
2056  }
2057  } // function LOGEST()
PHPExcel_Calculation_Functions\flattenSingleValue
static flattenSingleValue($value='')
Convert an array to a single scalar value by extracting the first element.
Definition: Functions.php:662
trendClass\TREND_EXPONENTIAL
const TREND_EXPONENTIAL
Definition: trendClass.php:47
trendClass\calculate
static calculate($trendType=self::TREND_BEST_FIT, $yValues, $xValues=array(), $const=True)
Definition: trendClass.php:87
range
Resolve range
Definition: 19namedrange.php:96
PHPExcel_Calculation_Functions\flattenArray
static flattenArray($array)
Convert a multi-dimensional array to a simple 1-dimensional array.
Definition: Functions.php:598
PHPExcel_Calculation_Functions\VALUE
static VALUE()
Definition: Functions.php:289
$stats
$stats
Definition: memcacheSync.php:36
PHPExcel_Calculation_Functions\NA
static NA()
Definition: Functions.php:219
array
Create styles array
The data for the language used.
Definition: 40duplicateStyle.php:19
PHPExcel_Calculation_Functions\NaN
static NaN()
Definition: Functions.php:233
+ Here is the call graph for this function:

◆ LOGINV()

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

LOGINV.

Returns the inverse of the normal cumulative distribution

Parameters
float$probability
float$mean
float$stdDev
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 2074 of file Statistical.php.

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

2074  {
2075  $probability = PHPExcel_Calculation_Functions::flattenSingleValue($probability);
2076  $mean = PHPExcel_Calculation_Functions::flattenSingleValue($mean);
2077  $stdDev = PHPExcel_Calculation_Functions::flattenSingleValue($stdDev);
2078 
2079  if ((is_numeric($probability)) && (is_numeric($mean)) && (is_numeric($stdDev))) {
2080  if (($probability < 0) || ($probability > 1) || ($stdDev <= 0)) {
2081  return PHPExcel_Calculation_Functions::NaN();
2082  }
2083  return exp($mean + $stdDev * self::NORMSINV($probability));
2084  }
2085  return PHPExcel_Calculation_Functions::VALUE();
2086  } // function LOGINV()
PHPExcel_Calculation_Functions\flattenSingleValue
static flattenSingleValue($value='')
Convert an array to a single scalar value by extracting the first element.
Definition: Functions.php:662
PHPExcel_Calculation_Functions\VALUE
static VALUE()
Definition: Functions.php:289
PHPExcel_Calculation_Functions\NaN
static NaN()
Definition: Functions.php:233
+ Here is the call graph for this function:

◆ LOGNORMDIST()

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
float$mean
float$stdDev
Returns
float

Definition at line 2100 of file Statistical.php.

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

2100  {
2101  $value = PHPExcel_Calculation_Functions::flattenSingleValue($value);
2102  $mean = PHPExcel_Calculation_Functions::flattenSingleValue($mean);
2103  $stdDev = PHPExcel_Calculation_Functions::flattenSingleValue($stdDev);
2104 
2105  if ((is_numeric($value)) && (is_numeric($mean)) && (is_numeric($stdDev))) {
2106  if (($value <= 0) || ($stdDev <= 0)) {
2107  return PHPExcel_Calculation_Functions::NaN();
2108  }
2109  return self::NORMSDIST((log($value) - $mean) / $stdDev);
2110  }
2111  return PHPExcel_Calculation_Functions::VALUE();
2112  } // function LOGNORMDIST()
PHPExcel_Calculation_Functions\flattenSingleValue
static flattenSingleValue($value='')
Convert an array to a single scalar value by extracting the first element.
Definition: Functions.php:662
PHPExcel_Calculation_Functions\VALUE
static VALUE()
Definition: Functions.php:289
PHPExcel_Calculation_Functions\NaN
static NaN()
Definition: Functions.php:233
+ Here is the call graph for this function:

◆ MAX()

static PHPExcel_Calculation_Statistical::MAX ( )
static

Definition at line 2129 of file Statistical.php.

References PHPExcel_Calculation_Functions\flattenArray().

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

2129  {
2130  // Return value
2131  $returnValue = null;
2132 
2133  // Loop through arguments
2134  $aArgs = PHPExcel_Calculation_Functions::flattenArray(func_get_args());
2135  foreach ($aArgs as $arg) {
2136  // Is it a numeric value?
2137  if ((is_numeric($arg)) && (!is_string($arg))) {
2138  if ((is_null($returnValue)) || ($arg > $returnValue)) {
2139  $returnValue = $arg;
2140  }
2141  }
2142  }
2143 
2144  // Return
2145  if(is_null($returnValue)) {
2146  return 0;
2147  }
2148  return $returnValue;
2149  } // function MAX()
PHPExcel_Calculation_Functions\flattenArray
static flattenArray($array)
Convert a multi-dimensional array to a simple 1-dimensional array.
Definition: Functions.php:598
+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ MAXA()

static PHPExcel_Calculation_Statistical::MAXA ( )
static

Definition at line 2165 of file Statistical.php.

References PHPExcel_Calculation_Functions\flattenArray().

2165  {
2166  // Return value
2167  $returnValue = null;
2168 
2169  // Loop through arguments
2170  $aArgs = PHPExcel_Calculation_Functions::flattenArray(func_get_args());
2171  foreach ($aArgs as $arg) {
2172  // Is it a numeric value?
2173  if ((is_numeric($arg)) || (is_bool($arg)) || ((is_string($arg) && ($arg != '')))) {
2174  if (is_bool($arg)) {
2175  $arg = (integer) $arg;
2176  } elseif (is_string($arg)) {
2177  $arg = 0;
2178  }
2179  if ((is_null($returnValue)) || ($arg > $returnValue)) {
2180  $returnValue = $arg;
2181  }
2182  }
2183  }
2184 
2185  // Return
2186  if(is_null($returnValue)) {
2187  return 0;
2188  }
2189  return $returnValue;
2190  } // function MAXA()
PHPExcel_Calculation_Functions\flattenArray
static flattenArray($array)
Convert a multi-dimensional array to a simple 1-dimensional array.
Definition: Functions.php:598
+ Here is the call graph for this function:

◆ MAXIF()

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

Definition at line 2207 of file Statistical.php.

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

2207  {
2208  // Return value
2209  $returnValue = null;
2210 
2211  $aArgs = PHPExcel_Calculation_Functions::flattenArray($aArgs);
2212  $sumArgs = PHPExcel_Calculation_Functions::flattenArray($sumArgs);
2213  if (empty($sumArgs)) {
2214  $sumArgs = $aArgs;
2215  }
2216  $condition = PHPExcel_Calculation_Functions::_ifCondition($condition);
2217  // Loop through arguments
2218  foreach ($aArgs as $key => $arg) {
2219  if (!is_numeric($arg)) { $arg = PHPExcel_Calculation::_wrapResult(strtoupper($arg)); }
2220  $testCondition = '='.$arg.$condition;
2221  if (PHPExcel_Calculation::getInstance()->_calculateFormulaValue($testCondition)) {
2222  if ((is_null($returnValue)) || ($arg > $returnValue)) {
2223  $returnValue = $arg;
2224  }
2225  }
2226  }
2227 
2228  // Return
2229  return $returnValue;
2230  } // function MAXIF()
PHPExcel_Calculation\_wrapResult
static _wrapResult($value)
Wrap string values in quotes.
Definition: Calculation.php:2163
PHPExcel_Calculation_Functions\flattenArray
static flattenArray($array)
Convert a multi-dimensional array to a simple 1-dimensional array.
Definition: Functions.php:598
PHPExcel_Calculation_Functions\_ifCondition
static _ifCondition($condition)
Definition: Functions.php:309
PHPExcel_Calculation\getInstance
static getInstance(PHPExcel $workbook=NULL)
Get an instance of this class.
Definition: Calculation.php:1765
$key
$key
Definition: croninfo.php:18
+ Here is the call graph for this function:

◆ MEDIAN()

static PHPExcel_Calculation_Statistical::MEDIAN ( )
static

Definition at line 2246 of file Statistical.php.

References array, PHPExcel_Calculation_Functions\flattenArray(), and PHPExcel_Calculation_Functions\NaN().

2246  {
2247  // Return value
2248  $returnValue = PHPExcel_Calculation_Functions::NaN();
2249 
2250  $mArgs = array();
2251  // Loop through arguments
2252  $aArgs = PHPExcel_Calculation_Functions::flattenArray(func_get_args());
2253  foreach ($aArgs as $arg) {
2254  // Is it a numeric value?
2255  if ((is_numeric($arg)) && (!is_string($arg))) {
2256  $mArgs[] = $arg;
2257  }
2258  }
2259 
2260  $mValueCount = count($mArgs);
2261  if ($mValueCount > 0) {
2262  sort($mArgs,SORT_NUMERIC);
2263  $mValueCount = $mValueCount / 2;
2264  if ($mValueCount == floor($mValueCount)) {
2265  $returnValue = ($mArgs[$mValueCount--] + $mArgs[$mValueCount]) / 2;
2266  } else {
2267  $mValueCount == floor($mValueCount);
2268  $returnValue = $mArgs[$mValueCount];
2269  }
2270  }
2271 
2272  // Return
2273  return $returnValue;
2274  } // function MEDIAN()
PHPExcel_Calculation_Functions\flattenArray
static flattenArray($array)
Convert a multi-dimensional array to a simple 1-dimensional array.
Definition: Functions.php:598
array
Create styles array
The data for the language used.
Definition: 40duplicateStyle.php:19
PHPExcel_Calculation_Functions\NaN
static NaN()
Definition: Functions.php:233
+ Here is the call graph for this function:

◆ MIN()

static PHPExcel_Calculation_Statistical::MIN ( )
static

Definition at line 2291 of file Statistical.php.

References PHPExcel_Calculation_Functions\flattenArray().

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

2291  {
2292  // Return value
2293  $returnValue = null;
2294 
2295  // Loop through arguments
2296  $aArgs = PHPExcel_Calculation_Functions::flattenArray(func_get_args());
2297  foreach ($aArgs as $arg) {
2298  // Is it a numeric value?
2299  if ((is_numeric($arg)) && (!is_string($arg))) {
2300  if ((is_null($returnValue)) || ($arg < $returnValue)) {
2301  $returnValue = $arg;
2302  }
2303  }
2304  }
2305 
2306  // Return
2307  if(is_null($returnValue)) {
2308  return 0;
2309  }
2310  return $returnValue;
2311  } // function MIN()
PHPExcel_Calculation_Functions\flattenArray
static flattenArray($array)
Convert a multi-dimensional array to a simple 1-dimensional array.
Definition: Functions.php:598
+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ MINA()

static PHPExcel_Calculation_Statistical::MINA ( )
static

Definition at line 2327 of file Statistical.php.

References PHPExcel_Calculation_Functions\flattenArray().

2327  {
2328  // Return value
2329  $returnValue = null;
2330 
2331  // Loop through arguments
2332  $aArgs = PHPExcel_Calculation_Functions::flattenArray(func_get_args());
2333  foreach ($aArgs as $arg) {
2334  // Is it a numeric value?
2335  if ((is_numeric($arg)) || (is_bool($arg)) || ((is_string($arg) && ($arg != '')))) {
2336  if (is_bool($arg)) {
2337  $arg = (integer) $arg;
2338  } elseif (is_string($arg)) {
2339  $arg = 0;
2340  }
2341  if ((is_null($returnValue)) || ($arg < $returnValue)) {
2342  $returnValue = $arg;
2343  }
2344  }
2345  }
2346 
2347  // Return
2348  if(is_null($returnValue)) {
2349  return 0;
2350  }
2351  return $returnValue;
2352  } // function MINA()
PHPExcel_Calculation_Functions\flattenArray
static flattenArray($array)
Convert a multi-dimensional array to a simple 1-dimensional array.
Definition: Functions.php:598
+ Here is the call graph for this function:

◆ MINIF()

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

Definition at line 2369 of file Statistical.php.

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

2369  {
2370  // Return value
2371  $returnValue = null;
2372 
2373  $aArgs = PHPExcel_Calculation_Functions::flattenArray($aArgs);
2374  $sumArgs = PHPExcel_Calculation_Functions::flattenArray($sumArgs);
2375  if (empty($sumArgs)) {
2376  $sumArgs = $aArgs;
2377  }
2378  $condition = PHPExcel_Calculation_Functions::_ifCondition($condition);
2379  // Loop through arguments
2380  foreach ($aArgs as $key => $arg) {
2381  if (!is_numeric($arg)) { $arg = PHPExcel_Calculation::_wrapResult(strtoupper($arg)); }
2382  $testCondition = '='.$arg.$condition;
2383  if (PHPExcel_Calculation::getInstance()->_calculateFormulaValue($testCondition)) {
2384  if ((is_null($returnValue)) || ($arg < $returnValue)) {
2385  $returnValue = $arg;
2386  }
2387  }
2388  }
2389 
2390  // Return
2391  return $returnValue;
2392  } // function MINIF()
PHPExcel_Calculation\_wrapResult
static _wrapResult($value)
Wrap string values in quotes.
Definition: Calculation.php:2163
PHPExcel_Calculation_Functions\flattenArray
static flattenArray($array)
Convert a multi-dimensional array to a simple 1-dimensional array.
Definition: Functions.php:598
PHPExcel_Calculation_Functions\_ifCondition
static _ifCondition($condition)
Definition: Functions.php:309
PHPExcel_Calculation\getInstance
static getInstance(PHPExcel $workbook=NULL)
Get an instance of this class.
Definition: Calculation.php:1765
$key
$key
Definition: croninfo.php:18
+ Here is the call graph for this function:

◆ MODE()

static PHPExcel_Calculation_Statistical::MODE ( )
static

Definition at line 2442 of file Statistical.php.

References array, PHPExcel_Calculation_Functions\flattenArray(), and PHPExcel_Calculation_Functions\NA().

2442  {
2443  // Return value
2444  $returnValue = PHPExcel_Calculation_Functions::NA();
2445 
2446  // Loop through arguments
2447  $aArgs = PHPExcel_Calculation_Functions::flattenArray(func_get_args());
2448 
2449  $mArgs = array();
2450  foreach ($aArgs as $arg) {
2451  // Is it a numeric value?
2452  if ((is_numeric($arg)) && (!is_string($arg))) {
2453  $mArgs[] = $arg;
2454  }
2455  }
2456 
2457  if (!empty($mArgs)) {
2458  return self::_modeCalc($mArgs);
2459  }
2460 
2461  // Return
2462  return $returnValue;
2463  } // function MODE()
PHPExcel_Calculation_Functions\flattenArray
static flattenArray($array)
Convert a multi-dimensional array to a simple 1-dimensional array.
Definition: Functions.php:598
PHPExcel_Calculation_Functions\NA
static NA()
Definition: Functions.php:219
array
Create styles array
The data for the language used.
Definition: 40duplicateStyle.php:19
+ Here is the call graph for this function:

◆ NEGBINOMDIST()

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 2481 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().

2481  {
2482  $failures = floor(PHPExcel_Calculation_Functions::flattenSingleValue($failures));
2483  $successes = floor(PHPExcel_Calculation_Functions::flattenSingleValue($successes));
2484  $probability = PHPExcel_Calculation_Functions::flattenSingleValue($probability);
2485 
2486  if ((is_numeric($failures)) && (is_numeric($successes)) && (is_numeric($probability))) {
2487  if (($failures < 0) || ($successes < 1)) {
2488  return PHPExcel_Calculation_Functions::NaN();
2489  }
2490  if (($probability < 0) || ($probability > 1)) {
2491  return PHPExcel_Calculation_Functions::NaN();
2492  }
2493  if (PHPExcel_Calculation_Functions::getCompatibilityMode() == PHPExcel_Calculation_Functions::COMPATIBILITY_GNUMERIC) {
2494  if (($failures + $successes - 1) <= 0) {
2495  return PHPExcel_Calculation_Functions::NaN();
2496  }
2497  }
2498  return (PHPExcel_Calculation_MathTrig::COMBIN($failures + $successes - 1,$successes - 1)) * (pow($probability,$successes)) * (pow(1 - $probability,$failures)) ;
2499  }
2500  return PHPExcel_Calculation_Functions::VALUE();
2501  } // function NEGBINOMDIST()
PHPExcel_Calculation_Functions\flattenSingleValue
static flattenSingleValue($value='')
Convert an array to a single scalar value by extracting the first element.
Definition: Functions.php:662
PHPExcel_Calculation_Functions\VALUE
static VALUE()
Definition: Functions.php:289
PHPExcel_Calculation_MathTrig\COMBIN
static COMBIN($numObjs, $numInSet)
Definition: MathTrig.php:176
PHPExcel_Calculation_Functions\getCompatibilityMode
static getCompatibilityMode()
Definition: Functions.php:138
PHPExcel_Calculation_Functions\NaN
static NaN()
Definition: Functions.php:233
PHPExcel_Calculation_Functions\COMPATIBILITY_GNUMERIC
const COMPATIBILITY_GNUMERIC
Definition: Functions.php:63
+ Here is the call graph for this function:

◆ NORMDIST()

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 2518 of file Statistical.php.

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

2518  {
2519  $value = PHPExcel_Calculation_Functions::flattenSingleValue($value);
2520  $mean = PHPExcel_Calculation_Functions::flattenSingleValue($mean);
2521  $stdDev = PHPExcel_Calculation_Functions::flattenSingleValue($stdDev);
2522 
2523  if ((is_numeric($value)) && (is_numeric($mean)) && (is_numeric($stdDev))) {
2524  if ($stdDev < 0) {
2525  return PHPExcel_Calculation_Functions::NaN();
2526  }
2527  if ((is_numeric($cumulative)) || (is_bool($cumulative))) {
2528  if ($cumulative) {
2529  return 0.5 * (1 + PHPExcel_Calculation_Engineering::_erfVal(($value - $mean) / ($stdDev * sqrt(2))));
2530  } else {
2531  return (1 / (SQRT2PI * $stdDev)) * exp(0 - (pow($value - $mean,2) / (2 * ($stdDev * $stdDev))));
2532  }
2533  }
2534  }
2535  return PHPExcel_Calculation_Functions::VALUE();
2536  } // function NORMDIST()
PHPExcel_Calculation_Functions\flattenSingleValue
static flattenSingleValue($value='')
Convert an array to a single scalar value by extracting the first element.
Definition: Functions.php:662
SQRT2PI
const SQRT2PI
SQRT2PI.
Definition: Statistical.php:52
PHPExcel_Calculation_Engineering\_erfVal
static _erfVal($x)
Definition: Engineering.php:2228
PHPExcel_Calculation_Functions\VALUE
static VALUE()
Definition: Functions.php:289
PHPExcel_Calculation_Functions\NaN
static NaN()
Definition: Functions.php:233
+ Here is the call graph for this function:

◆ NORMINV()

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 2550 of file Statistical.php.

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

2550  {
2551  $probability = PHPExcel_Calculation_Functions::flattenSingleValue($probability);
2552  $mean = PHPExcel_Calculation_Functions::flattenSingleValue($mean);
2553  $stdDev = PHPExcel_Calculation_Functions::flattenSingleValue($stdDev);
2554 
2555  if ((is_numeric($probability)) && (is_numeric($mean)) && (is_numeric($stdDev))) {
2556  if (($probability < 0) || ($probability > 1)) {
2557  return PHPExcel_Calculation_Functions::NaN();
2558  }
2559  if ($stdDev < 0) {
2560  return PHPExcel_Calculation_Functions::NaN();
2561  }
2562  return (self::_inverse_ncdf($probability) * $stdDev) + $mean;
2563  }
2564  return PHPExcel_Calculation_Functions::VALUE();
2565  } // function NORMINV()
PHPExcel_Calculation_Functions\flattenSingleValue
static flattenSingleValue($value='')
Convert an array to a single scalar value by extracting the first element.
Definition: Functions.php:662
PHPExcel_Calculation_Functions\VALUE
static VALUE()
Definition: Functions.php:289
PHPExcel_Calculation_Functions\NaN
static NaN()
Definition: Functions.php:233
+ Here is the call graph for this function:

◆ NORMSDIST()

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 2578 of file Statistical.php.

References PHPExcel_Calculation_Functions\flattenSingleValue().

2578  {
2579  $value = PHPExcel_Calculation_Functions::flattenSingleValue($value);
2580 
2581  return self::NORMDIST($value, 0, 1, True);
2582  } // function NORMSDIST()
PHPExcel_Calculation_Functions\flattenSingleValue
static flattenSingleValue($value='')
Convert an array to a single scalar value by extracting the first element.
Definition: Functions.php:662
+ Here is the call graph for this function:

◆ NORMSINV()

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 2593 of file Statistical.php.

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

◆ PERCENTILE()

static PHPExcel_Calculation_Statistical::PERCENTILE ( )
static

Definition at line 2612 of file Statistical.php.

References $index, array, PHPExcel_Calculation_Functions\flattenArray(), PHPExcel_Calculation_Functions\NaN(), and PHPExcel_Calculation_Functions\VALUE().

2612  {
2613  $aArgs = PHPExcel_Calculation_Functions::flattenArray(func_get_args());
2614 
2615  // Calculate
2616  $entry = array_pop($aArgs);
2617 
2618  if ((is_numeric($entry)) && (!is_string($entry))) {
2619  if (($entry < 0) || ($entry > 1)) {
2620  return PHPExcel_Calculation_Functions::NaN();
2621  }
2622  $mArgs = array();
2623  foreach ($aArgs as $arg) {
2624  // Is it a numeric value?
2625  if ((is_numeric($arg)) && (!is_string($arg))) {
2626  $mArgs[] = $arg;
2627  }
2628  }
2629  $mValueCount = count($mArgs);
2630  if ($mValueCount > 0) {
2631  sort($mArgs);
2632  $count = self::COUNT($mArgs);
2633  $index = $entry * ($count-1);
2634  $iBase = floor($index);
2635  if ($index == $iBase) {
2636  return $mArgs[$index];
2637  } else {
2638  $iNext = $iBase + 1;
2639  $iProportion = $index - $iBase;
2640  return $mArgs[$iBase] + (($mArgs[$iNext] - $mArgs[$iBase]) * $iProportion) ;
2641  }
2642  }
2643  }
2644  return PHPExcel_Calculation_Functions::VALUE();
2645  } // function PERCENTILE()
$index
$index
Definition: metadata.php:60
PHPExcel_Calculation_Functions\flattenArray
static flattenArray($array)
Convert a multi-dimensional array to a simple 1-dimensional array.
Definition: Functions.php:598
PHPExcel_Calculation_Functions\VALUE
static VALUE()
Definition: Functions.php:289
array
Create styles array
The data for the language used.
Definition: 40duplicateStyle.php:19
PHPExcel_Calculation_Functions\NaN
static NaN()
Definition: Functions.php:233
+ Here is the call graph for this function:

◆ PERCENTRANK()

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 2658 of file Statistical.php.

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

2658  {
2659  $valueSet = PHPExcel_Calculation_Functions::flattenArray($valueSet);
2660  $value = PHPExcel_Calculation_Functions::flattenSingleValue($value);
2661  $significance = (is_null($significance)) ? 3 : (integer) PHPExcel_Calculation_Functions::flattenSingleValue($significance);
2662 
2663  foreach($valueSet as $key => $valueEntry) {
2664  if (!is_numeric($valueEntry)) {
2665  unset($valueSet[$key]);
2666  }
2667  }
2668  sort($valueSet,SORT_NUMERIC);
2669  $valueCount = count($valueSet);
2670  if ($valueCount == 0) {
2671  return PHPExcel_Calculation_Functions::NaN();
2672  }
2673 
2674  $valueAdjustor = $valueCount - 1;
2675  if (($value < $valueSet[0]) || ($value > $valueSet[$valueAdjustor])) {
2676  return PHPExcel_Calculation_Functions::NA();
2677  }
2678 
2679  $pos = array_search($value,$valueSet);
2680  if ($pos === False) {
2681  $pos = 0;
2682  $testValue = $valueSet[0];
2683  while ($testValue < $value) {
2684  $testValue = $valueSet[++$pos];
2685  }
2686  --$pos;
2687  $pos += (($value - $valueSet[$pos]) / ($testValue - $valueSet[$pos]));
2688  }
2689 
2690  return round($pos / $valueAdjustor,$significance);
2691  } // function PERCENTRANK()
PHPExcel_Calculation_Functions\flattenSingleValue
static flattenSingleValue($value='')
Convert an array to a single scalar value by extracting the first element.
Definition: Functions.php:662
PHPExcel_Calculation_Functions\flattenArray
static flattenArray($array)
Convert a multi-dimensional array to a simple 1-dimensional array.
Definition: Functions.php:598
PHPExcel_Calculation_Functions\NA
static NA()
Definition: Functions.php:219
PHPExcel_Calculation_Functions\NaN
static NaN()
Definition: Functions.php:233
$key
$key
Definition: croninfo.php:18
+ Here is the call graph for this function:

◆ PERMUT()

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 2707 of file Statistical.php.

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

2707  {
2708  $numObjs = PHPExcel_Calculation_Functions::flattenSingleValue($numObjs);
2709  $numInSet = PHPExcel_Calculation_Functions::flattenSingleValue($numInSet);
2710 
2711  if ((is_numeric($numObjs)) && (is_numeric($numInSet))) {
2712  $numInSet = floor($numInSet);
2713  if ($numObjs < $numInSet) {
2714  return PHPExcel_Calculation_Functions::NaN();
2715  }
2716  return round(PHPExcel_Calculation_MathTrig::FACT($numObjs) / PHPExcel_Calculation_MathTrig::FACT($numObjs - $numInSet));
2717  }
2718  return PHPExcel_Calculation_Functions::VALUE();
2719  } // function PERMUT()
PHPExcel_Calculation_Functions\flattenSingleValue
static flattenSingleValue($value='')
Convert an array to a single scalar value by extracting the first element.
Definition: Functions.php:662
PHPExcel_Calculation_MathTrig\FACT
static FACT($factVal)
Definition: MathTrig.php:240
PHPExcel_Calculation_Functions\VALUE
static VALUE()
Definition: Functions.php:289
PHPExcel_Calculation_Functions\NaN
static NaN()
Definition: Functions.php:233
+ Here is the call graph for this function:

◆ POISSON()

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 2735 of file Statistical.php.

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

2735  {
2736  $value = PHPExcel_Calculation_Functions::flattenSingleValue($value);
2737  $mean = PHPExcel_Calculation_Functions::flattenSingleValue($mean);
2738 
2739  if ((is_numeric($value)) && (is_numeric($mean))) {
2740  if (($value < 0) || ($mean <= 0)) {
2741  return PHPExcel_Calculation_Functions::NaN();
2742  }
2743  if ((is_numeric($cumulative)) || (is_bool($cumulative))) {
2744  if ($cumulative) {
2745  $summer = 0;
2746  for ($i = 0; $i <= floor($value); ++$i) {
2747  $summer += pow($mean,$i) / PHPExcel_Calculation_MathTrig::FACT($i);
2748  }
2749  return exp(0-$mean) * $summer;
2750  } else {
2751  return (exp(0-$mean) * pow($mean,$value)) / PHPExcel_Calculation_MathTrig::FACT($value);
2752  }
2753  }
2754  }
2755  return PHPExcel_Calculation_Functions::VALUE();
2756  } // function POISSON()
PHPExcel_Calculation_Functions\flattenSingleValue
static flattenSingleValue($value='')
Convert an array to a single scalar value by extracting the first element.
Definition: Functions.php:662
PHPExcel_Calculation_MathTrig\FACT
static FACT($factVal)
Definition: MathTrig.php:240
PHPExcel_Calculation_Functions\VALUE
static VALUE()
Definition: Functions.php:289
PHPExcel_Calculation_Functions\NaN
static NaN()
Definition: Functions.php:233
$i
$i
Definition: disco.tpl.php:19
+ Here is the call graph for this function:

◆ QUARTILE()

static PHPExcel_Calculation_Statistical::QUARTILE ( )
static

Definition at line 2773 of file Statistical.php.

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

2773  {
2774  $aArgs = PHPExcel_Calculation_Functions::flattenArray(func_get_args());
2775 
2776  // Calculate
2777  $entry = floor(array_pop($aArgs));
2778 
2779  if ((is_numeric($entry)) && (!is_string($entry))) {
2780  $entry /= 4;
2781  if (($entry < 0) || ($entry > 1)) {
2782  return PHPExcel_Calculation_Functions::NaN();
2783  }
2784  return self::PERCENTILE($aArgs,$entry);
2785  }
2786  return PHPExcel_Calculation_Functions::VALUE();
2787  } // function QUARTILE()
PHPExcel_Calculation_Functions\flattenArray
static flattenArray($array)
Convert a multi-dimensional array to a simple 1-dimensional array.
Definition: Functions.php:598
PHPExcel_Calculation_Functions\VALUE
static VALUE()
Definition: Functions.php:289
PHPExcel_Calculation_Functions\NaN
static NaN()
Definition: Functions.php:233
+ Here is the call graph for this function:

◆ RANK()

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 2800 of file Statistical.php.

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

2800  {
2801  $value = PHPExcel_Calculation_Functions::flattenSingleValue($value);
2802  $valueSet = PHPExcel_Calculation_Functions::flattenArray($valueSet);
2803  $order = (is_null($order)) ? 0 : (integer) PHPExcel_Calculation_Functions::flattenSingleValue($order);
2804 
2805  foreach($valueSet as $key => $valueEntry) {
2806  if (!is_numeric($valueEntry)) {
2807  unset($valueSet[$key]);
2808  }
2809  }
2810 
2811  if ($order == 0) {
2812  rsort($valueSet,SORT_NUMERIC);
2813  } else {
2814  sort($valueSet,SORT_NUMERIC);
2815  }
2816  $pos = array_search($value,$valueSet);
2817  if ($pos === False) {
2818  return PHPExcel_Calculation_Functions::NA();
2819  }
2820 
2821  return ++$pos;
2822  } // function RANK()
PHPExcel_Calculation_Functions\flattenSingleValue
static flattenSingleValue($value='')
Convert an array to a single scalar value by extracting the first element.
Definition: Functions.php:662
PHPExcel_Calculation_Functions\flattenArray
static flattenArray($array)
Convert a multi-dimensional array to a simple 1-dimensional array.
Definition: Functions.php:598
PHPExcel_Calculation_Functions\NA
static NA()
Definition: Functions.php:219
$key
$key
Definition: croninfo.php:18
+ Here is the call graph for this function:

◆ RSQ()

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 2834 of file Statistical.php.

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

2834  {
2835  if (!self::_checkTrendArrays($yValues,$xValues)) {
2836  return PHPExcel_Calculation_Functions::VALUE();
2837  }
2838  $yValueCount = count($yValues);
2839  $xValueCount = count($xValues);
2840 
2841  if (($yValueCount == 0) || ($yValueCount != $xValueCount)) {
2842  return PHPExcel_Calculation_Functions::NA();
2843  } elseif ($yValueCount == 1) {
2844  return PHPExcel_Calculation_Functions::DIV0();
2845  }
2846 
2847  $bestFitLinear = trendClass::calculate(trendClass::TREND_LINEAR,$yValues,$xValues);
2848  return $bestFitLinear->getGoodnessOfFit();
2849  } // function RSQ()
PHPExcel_Calculation_Functions\DIV0
static DIV0()
Definition: Functions.php:201
trendClass\calculate
static calculate($trendType=self::TREND_BEST_FIT, $yValues, $xValues=array(), $const=True)
Definition: trendClass.php:87
PHPExcel_Calculation_Functions\VALUE
static VALUE()
Definition: Functions.php:289
PHPExcel_Calculation_Functions\NA
static NA()
Definition: Functions.php:219
trendClass\TREND_LINEAR
const TREND_LINEAR
Definition: trendClass.php:45
+ Here is the call graph for this function:

◆ SKEW()

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 2863 of file Statistical.php.

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

2863  {
2864  $aArgs = PHPExcel_Calculation_Functions::flattenArrayIndexed(func_get_args());
2865  $mean = self::AVERAGE($aArgs);
2866  $stdDev = self::STDEV($aArgs);
2867 
2868  $count = $summer = 0;
2869  // Loop through arguments
2870  foreach ($aArgs as $k => $arg) {
2871  if ((is_bool($arg)) &&
2872  (!PHPExcel_Calculation_Functions::isMatrixValue($k))) {
2873  } else {
2874  // Is it a numeric value?
2875  if ((is_numeric($arg)) && (!is_string($arg))) {
2876  $summer += pow((($arg - $mean) / $stdDev),3) ;
2877  ++$count;
2878  }
2879  }
2880  }
2881 
2882  // Return
2883  if ($count > 2) {
2884  return $summer * ($count / (($count-1) * ($count-2)));
2885  }
2886  return PHPExcel_Calculation_Functions::DIV0();
2887  } // function SKEW()
PHPExcel_Calculation_Functions\DIV0
static DIV0()
Definition: Functions.php:201
PHPExcel_Calculation_Functions\flattenArrayIndexed
static flattenArrayIndexed($array)
Convert a multi-dimensional array to a simple 1-dimensional array, but retain an element of indexing...
Definition: Functions.php:630
PHPExcel_Calculation_Functions\isMatrixValue
static isMatrixValue($idx)
Definition: Functions.php:294
+ Here is the call graph for this function:

◆ SLOPE()

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 2899 of file Statistical.php.

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

2899  {
2900  if (!self::_checkTrendArrays($yValues,$xValues)) {
2901  return PHPExcel_Calculation_Functions::VALUE();
2902  }
2903  $yValueCount = count($yValues);
2904  $xValueCount = count($xValues);
2905 
2906  if (($yValueCount == 0) || ($yValueCount != $xValueCount)) {
2907  return PHPExcel_Calculation_Functions::NA();
2908  } elseif ($yValueCount == 1) {
2909  return PHPExcel_Calculation_Functions::DIV0();
2910  }
2911 
2912  $bestFitLinear = trendClass::calculate(trendClass::TREND_LINEAR,$yValues,$xValues);
2913  return $bestFitLinear->getSlope();
2914  } // function SLOPE()
PHPExcel_Calculation_Functions\DIV0
static DIV0()
Definition: Functions.php:201
trendClass\calculate
static calculate($trendType=self::TREND_BEST_FIT, $yValues, $xValues=array(), $const=True)
Definition: trendClass.php:87
PHPExcel_Calculation_Functions\VALUE
static VALUE()
Definition: Functions.php:289
PHPExcel_Calculation_Functions\NA
static NA()
Definition: Functions.php:219
trendClass\TREND_LINEAR
const TREND_LINEAR
Definition: trendClass.php:45
+ Here is the call graph for this function:

◆ SMALL()

static PHPExcel_Calculation_Statistical::SMALL ( )
static

Definition at line 2932 of file Statistical.php.

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

2932  {
2933  $aArgs = PHPExcel_Calculation_Functions::flattenArray(func_get_args());
2934 
2935  // Calculate
2936  $entry = array_pop($aArgs);
2937 
2938  if ((is_numeric($entry)) && (!is_string($entry))) {
2939  $mArgs = array();
2940  foreach ($aArgs as $arg) {
2941  // Is it a numeric value?
2942  if ((is_numeric($arg)) && (!is_string($arg))) {
2943  $mArgs[] = $arg;
2944  }
2945  }
2946  $count = self::COUNT($mArgs);
2947  $entry = floor(--$entry);
2948  if (($entry < 0) || ($entry >= $count) || ($count == 0)) {
2949  return PHPExcel_Calculation_Functions::NaN();
2950  }
2951  sort($mArgs);
2952  return $mArgs[$entry];
2953  }
2954  return PHPExcel_Calculation_Functions::VALUE();
2955  } // function SMALL()
PHPExcel_Calculation_Functions\flattenArray
static flattenArray($array)
Convert a multi-dimensional array to a simple 1-dimensional array.
Definition: Functions.php:598
PHPExcel_Calculation_Functions\VALUE
static VALUE()
Definition: Functions.php:289
array
Create styles array
The data for the language used.
Definition: 40duplicateStyle.php:19
PHPExcel_Calculation_Functions\NaN
static NaN()
Definition: Functions.php:233
+ Here is the call graph for this function:

◆ STANDARDIZE()

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 2968 of file Statistical.php.

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

2968  {
2969  $value = PHPExcel_Calculation_Functions::flattenSingleValue($value);
2970  $mean = PHPExcel_Calculation_Functions::flattenSingleValue($mean);
2971  $stdDev = PHPExcel_Calculation_Functions::flattenSingleValue($stdDev);
2972 
2973  if ((is_numeric($value)) && (is_numeric($mean)) && (is_numeric($stdDev))) {
2974  if ($stdDev <= 0) {
2975  return PHPExcel_Calculation_Functions::NaN();
2976  }
2977  return ($value - $mean) / $stdDev ;
2978  }
2979  return PHPExcel_Calculation_Functions::VALUE();
2980  } // function STANDARDIZE()
PHPExcel_Calculation_Functions\flattenSingleValue
static flattenSingleValue($value='')
Convert an array to a single scalar value by extracting the first element.
Definition: Functions.php:662
PHPExcel_Calculation_Functions\VALUE
static VALUE()
Definition: Functions.php:289
PHPExcel_Calculation_Functions\NaN
static NaN()
Definition: Functions.php:233
+ Here is the call graph for this function:

◆ STDEV()

static PHPExcel_Calculation_Statistical::STDEV ( )
static

Definition at line 2997 of file Statistical.php.

References 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(), and PHPExcel_Calculation_MathTrig\SUBTOTAL().

2997  {
2998  $aArgs = PHPExcel_Calculation_Functions::flattenArrayIndexed(func_get_args());
2999 
3000  // Return value
3001  $returnValue = null;
3002 
3003  $aMean = self::AVERAGE($aArgs);
3004  if (!is_null($aMean)) {
3005  $aCount = -1;
3006  foreach ($aArgs as $k => $arg) {
3007  if ((is_bool($arg)) &&
3008  ((!PHPExcel_Calculation_Functions::isCellValue($k)) || (PHPExcel_Calculation_Functions::getCompatibilityMode() == PHPExcel_Calculation_Functions::COMPATIBILITY_OPENOFFICE))) {
3009  $arg = (integer) $arg;
3010  }
3011  // Is it a numeric value?
3012  if ((is_numeric($arg)) && (!is_string($arg))) {
3013  if (is_null($returnValue)) {
3014  $returnValue = pow(($arg - $aMean),2);
3015  } else {
3016  $returnValue += pow(($arg - $aMean),2);
3017  }
3018  ++$aCount;
3019  }
3020  }
3021 
3022  // Return
3023  if (($aCount > 0) && ($returnValue >= 0)) {
3024  return sqrt($returnValue / $aCount);
3025  }
3026  }
3027  return PHPExcel_Calculation_Functions::DIV0();
3028  } // function STDEV()
PHPExcel_Calculation_Functions\DIV0
static DIV0()
Definition: Functions.php:201
PHPExcel_Calculation_Functions\flattenArrayIndexed
static flattenArrayIndexed($array)
Convert a multi-dimensional array to a simple 1-dimensional array, but retain an element of indexing...
Definition: Functions.php:630
PHPExcel_Calculation_Functions\isCellValue
static isCellValue($idx)
Definition: Functions.php:304
PHPExcel_Calculation_Functions\COMPATIBILITY_OPENOFFICE
const COMPATIBILITY_OPENOFFICE
Definition: Functions.php:64
PHPExcel_Calculation_Functions\getCompatibilityMode
static getCompatibilityMode()
Definition: Functions.php:138
+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ STDEVA()

static PHPExcel_Calculation_Statistical::STDEVA ( )
static

Definition at line 3044 of file Statistical.php.

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

3044  {
3045  $aArgs = PHPExcel_Calculation_Functions::flattenArrayIndexed(func_get_args());
3046 
3047  // Return value
3048  $returnValue = null;
3049 
3050  $aMean = self::AVERAGEA($aArgs);
3051  if (!is_null($aMean)) {
3052  $aCount = -1;
3053  foreach ($aArgs as $k => $arg) {
3054  if ((is_bool($arg)) &&
3055  (!PHPExcel_Calculation_Functions::isMatrixValue($k))) {
3056  } else {
3057  // Is it a numeric value?
3058  if ((is_numeric($arg)) || (is_bool($arg)) || ((is_string($arg) & ($arg != '')))) {
3059  if (is_bool($arg)) {
3060  $arg = (integer) $arg;
3061  } elseif (is_string($arg)) {
3062  $arg = 0;
3063  }
3064  if (is_null($returnValue)) {
3065  $returnValue = pow(($arg - $aMean),2);
3066  } else {
3067  $returnValue += pow(($arg - $aMean),2);
3068  }
3069  ++$aCount;
3070  }
3071  }
3072  }
3073 
3074  // Return
3075  if (($aCount > 0) && ($returnValue >= 0)) {
3076  return sqrt($returnValue / $aCount);
3077  }
3078  }
3079  return PHPExcel_Calculation_Functions::DIV0();
3080  } // function STDEVA()
PHPExcel_Calculation_Functions\DIV0
static DIV0()
Definition: Functions.php:201
PHPExcel_Calculation_Functions\flattenArrayIndexed
static flattenArrayIndexed($array)
Convert a multi-dimensional array to a simple 1-dimensional array, but retain an element of indexing...
Definition: Functions.php:630
PHPExcel_Calculation_Functions\isMatrixValue
static isMatrixValue($idx)
Definition: Functions.php:294
+ Here is the call graph for this function:

◆ STDEVP()

static PHPExcel_Calculation_Statistical::STDEVP ( )
static

Definition at line 3096 of file Statistical.php.

References 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().

3096  {
3097  $aArgs = PHPExcel_Calculation_Functions::flattenArrayIndexed(func_get_args());
3098 
3099  // Return value
3100  $returnValue = null;
3101 
3102  $aMean = self::AVERAGE($aArgs);
3103  if (!is_null($aMean)) {
3104  $aCount = 0;
3105  foreach ($aArgs as $k => $arg) {
3106  if ((is_bool($arg)) &&
3107  ((!PHPExcel_Calculation_Functions::isCellValue($k)) || (PHPExcel_Calculation_Functions::getCompatibilityMode() == PHPExcel_Calculation_Functions::COMPATIBILITY_OPENOFFICE))) {
3108  $arg = (integer) $arg;
3109  }
3110  // Is it a numeric value?
3111  if ((is_numeric($arg)) && (!is_string($arg))) {
3112  if (is_null($returnValue)) {
3113  $returnValue = pow(($arg - $aMean),2);
3114  } else {
3115  $returnValue += pow(($arg - $aMean),2);
3116  }
3117  ++$aCount;
3118  }
3119  }
3120 
3121  // Return
3122  if (($aCount > 0) && ($returnValue >= 0)) {
3123  return sqrt($returnValue / $aCount);
3124  }
3125  }
3126  return PHPExcel_Calculation_Functions::DIV0();
3127  } // function STDEVP()
PHPExcel_Calculation_Functions\DIV0
static DIV0()
Definition: Functions.php:201
PHPExcel_Calculation_Functions\flattenArrayIndexed
static flattenArrayIndexed($array)
Convert a multi-dimensional array to a simple 1-dimensional array, but retain an element of indexing...
Definition: Functions.php:630
PHPExcel_Calculation_Functions\isCellValue
static isCellValue($idx)
Definition: Functions.php:304
PHPExcel_Calculation_Functions\COMPATIBILITY_OPENOFFICE
const COMPATIBILITY_OPENOFFICE
Definition: Functions.php:64
PHPExcel_Calculation_Functions\getCompatibilityMode
static getCompatibilityMode()
Definition: Functions.php:138
+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ STDEVPA()

static PHPExcel_Calculation_Statistical::STDEVPA ( )
static

Definition at line 3143 of file Statistical.php.

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

3143  {
3144  $aArgs = PHPExcel_Calculation_Functions::flattenArrayIndexed(func_get_args());
3145 
3146  // Return value
3147  $returnValue = null;
3148 
3149  $aMean = self::AVERAGEA($aArgs);
3150  if (!is_null($aMean)) {
3151  $aCount = 0;
3152  foreach ($aArgs as $k => $arg) {
3153  if ((is_bool($arg)) &&
3154  (!PHPExcel_Calculation_Functions::isMatrixValue($k))) {
3155  } else {
3156  // Is it a numeric value?
3157  if ((is_numeric($arg)) || (is_bool($arg)) || ((is_string($arg) & ($arg != '')))) {
3158  if (is_bool($arg)) {
3159  $arg = (integer) $arg;
3160  } elseif (is_string($arg)) {
3161  $arg = 0;
3162  }
3163  if (is_null($returnValue)) {
3164  $returnValue = pow(($arg - $aMean),2);
3165  } else {
3166  $returnValue += pow(($arg - $aMean),2);
3167  }
3168  ++$aCount;
3169  }
3170  }
3171  }
3172 
3173  // Return
3174  if (($aCount > 0) && ($returnValue >= 0)) {
3175  return sqrt($returnValue / $aCount);
3176  }
3177  }
3178  return PHPExcel_Calculation_Functions::DIV0();
3179  } // function STDEVPA()
PHPExcel_Calculation_Functions\DIV0
static DIV0()
Definition: Functions.php:201
PHPExcel_Calculation_Functions\flattenArrayIndexed
static flattenArrayIndexed($array)
Convert a multi-dimensional array to a simple 1-dimensional array, but retain an element of indexing...
Definition: Functions.php:630
PHPExcel_Calculation_Functions\isMatrixValue
static isMatrixValue($idx)
Definition: Functions.php:294
+ Here is the call graph for this function:

◆ STEYX()

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 3191 of file Statistical.php.

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

3191  {
3192  if (!self::_checkTrendArrays($yValues,$xValues)) {
3193  return PHPExcel_Calculation_Functions::VALUE();
3194  }
3195  $yValueCount = count($yValues);
3196  $xValueCount = count($xValues);
3197 
3198  if (($yValueCount == 0) || ($yValueCount != $xValueCount)) {
3199  return PHPExcel_Calculation_Functions::NA();
3200  } elseif ($yValueCount == 1) {
3201  return PHPExcel_Calculation_Functions::DIV0();
3202  }
3203 
3204  $bestFitLinear = trendClass::calculate(trendClass::TREND_LINEAR,$yValues,$xValues);
3205  return $bestFitLinear->getStdevOfResiduals();
3206  } // function STEYX()
PHPExcel_Calculation_Functions\DIV0
static DIV0()
Definition: Functions.php:201
trendClass\calculate
static calculate($trendType=self::TREND_BEST_FIT, $yValues, $xValues=array(), $const=True)
Definition: trendClass.php:87
PHPExcel_Calculation_Functions\VALUE
static VALUE()
Definition: Functions.php:289
PHPExcel_Calculation_Functions\NA
static NA()
Definition: Functions.php:219
trendClass\TREND_LINEAR
const TREND_LINEAR
Definition: trendClass.php:45
+ Here is the call graph for this function:

◆ TDIST()

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 3219 of file Statistical.php.

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

3219  {
3220  $value = PHPExcel_Calculation_Functions::flattenSingleValue($value);
3221  $degrees = floor(PHPExcel_Calculation_Functions::flattenSingleValue($degrees));
3222  $tails = floor(PHPExcel_Calculation_Functions::flattenSingleValue($tails));
3223 
3224  if ((is_numeric($value)) && (is_numeric($degrees)) && (is_numeric($tails))) {
3225  if (($value < 0) || ($degrees < 1) || ($tails < 1) || ($tails > 2)) {
3226  return PHPExcel_Calculation_Functions::NaN();
3227  }
3228  // tdist, which finds the probability that corresponds to a given value
3229  // of t with k degrees of freedom. This algorithm is translated from a
3230  // pascal function on p81 of "Statistical Computing in Pascal" by D
3231  // Cooke, A H Craven & G M Clark (1985: Edward Arnold (Pubs.) Ltd:
3232  // London). The above Pascal algorithm is itself a translation of the
3233  // fortran algoritm "AS 3" by B E Cooper of the Atlas Computer
3234  // Laboratory as reported in (among other places) "Applied Statistics
3235  // Algorithms", editied by P Griffiths and I D Hill (1985; Ellis
3236  // Horwood Ltd.; W. Sussex, England).
3237  $tterm = $degrees;
3238  $ttheta = atan2($value,sqrt($tterm));
3239  $tc = cos($ttheta);
3240  $ts = sin($ttheta);
3241  $tsum = 0;
3242 
3243  if (($degrees % 2) == 1) {
3244  $ti = 3;
3245  $tterm = $tc;
3246  } else {
3247  $ti = 2;
3248  $tterm = 1;
3249  }
3250 
3251  $tsum = $tterm;
3252  while ($ti < $degrees) {
3253  $tterm *= $tc * $tc * ($ti - 1) / $ti;
3254  $tsum += $tterm;
3255  $ti += 2;
3256  }
3257  $tsum *= $ts;
3258  if (($degrees % 2) == 1) { $tsum = M_2DIVPI * ($tsum + $ttheta); }
3259  $tValue = 0.5 * (1 + $tsum);
3260  if ($tails == 1) {
3261  return 1 - abs($tValue);
3262  } else {
3263  return 1 - abs((1 - $tValue) - $tValue);
3264  }
3265  }
3266  return PHPExcel_Calculation_Functions::VALUE();
3267  } // function TDIST()
PHPExcel_Calculation_Functions\flattenSingleValue
static flattenSingleValue($value='')
Convert an array to a single scalar value by extracting the first element.
Definition: Functions.php:662
PHPExcel_Calculation_Functions\VALUE
static VALUE()
Definition: Functions.php:289
PHPExcel_Calculation_Functions\NaN
static NaN()
Definition: Functions.php:233
M_2DIVPI
const M_2DIVPI
2 / PI
Definition: Functions.php:43
+ Here is the call graph for this function:

◆ TINV()

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 3279 of file Statistical.php.

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

3279  {
3280  $probability = PHPExcel_Calculation_Functions::flattenSingleValue($probability);
3281  $degrees = floor(PHPExcel_Calculation_Functions::flattenSingleValue($degrees));
3282 
3283  if ((is_numeric($probability)) && (is_numeric($degrees))) {
3284  $xLo = 100;
3285  $xHi = 0;
3286 
3287  $x = $xNew = 1;
3288  $dx = 1;
3289  $i = 0;
3290 
3291  while ((abs($dx) > PRECISION) && ($i++ < MAX_ITERATIONS)) {
3292  // Apply Newton-Raphson step
3293  $result = self::TDIST($x, $degrees, 2);
3294  $error = $result - $probability;
3295  if ($error == 0.0) {
3296  $dx = 0;
3297  } elseif ($error < 0.0) {
3298  $xLo = $x;
3299  } else {
3300  $xHi = $x;
3301  }
3302  // Avoid division by zero
3303  if ($result != 0.0) {
3304  $dx = $error / $result;
3305  $xNew = $x - $dx;
3306  }
3307  // If the NR fails to converge (which for example may be the
3308  // case if the initial guess is too rough) we apply a bisection
3309  // step to determine a more narrow interval around the root.
3310  if (($xNew < $xLo) || ($xNew > $xHi) || ($result == 0.0)) {
3311  $xNew = ($xLo + $xHi) / 2;
3312  $dx = $xNew - $x;
3313  }
3314  $x = $xNew;
3315  }
3316  if ($i == MAX_ITERATIONS) {
3317  return PHPExcel_Calculation_Functions::NA();
3318  }
3319  return round($x,12);
3320  }
3321  return PHPExcel_Calculation_Functions::VALUE();
3322  } // function TINV()
PHPExcel_Calculation_Functions\flattenSingleValue
static flattenSingleValue($value='')
Convert an array to a single scalar value by extracting the first element.
Definition: Functions.php:662
$result
$result
Definition: CleanUpTest.php:463
$x
$x
Definition: example_009.php:98
PRECISION
const PRECISION
PRECISION.
Definition: Functions.php:49
PHPExcel_Calculation_Functions\VALUE
static VALUE()
Definition: Functions.php:289
$error
$error
Definition: Error.php:17
MAX_ITERATIONS
const MAX_ITERATIONS
MAX_ITERATIONS.
Definition: Functions.php:46
PHPExcel_Calculation_Functions\NA
static NA()
Definition: Functions.php:219
$i
$i
Definition: disco.tpl.php:19
+ Here is the call graph for this function:

◆ TREND()

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 3336 of file Statistical.php.

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

3336  {
3337  $yValues = PHPExcel_Calculation_Functions::flattenArray($yValues);
3338  $xValues = PHPExcel_Calculation_Functions::flattenArray($xValues);
3339  $newValues = PHPExcel_Calculation_Functions::flattenArray($newValues);
3340  $const = (is_null($const)) ? True : (boolean) PHPExcel_Calculation_Functions::flattenSingleValue($const);
3341 
3342  $bestFitLinear = trendClass::calculate(trendClass::TREND_LINEAR,$yValues,$xValues,$const);
3343  if (empty($newValues)) {
3344  $newValues = $bestFitLinear->getXValues();
3345  }
3346 
3347  $returnArray = array();
3348  foreach($newValues as $xValue) {
3349  $returnArray[0][] = $bestFitLinear->getValueOfYForX($xValue);
3350  }
3351 
3352  return $returnArray;
3353  } // function TREND()
PHPExcel_Calculation_Functions\flattenSingleValue
static flattenSingleValue($value='')
Convert an array to a single scalar value by extracting the first element.
Definition: Functions.php:662
trendClass\calculate
static calculate($trendType=self::TREND_BEST_FIT, $yValues, $xValues=array(), $const=True)
Definition: trendClass.php:87
PHPExcel_Calculation_Functions\flattenArray
static flattenArray($array)
Convert a multi-dimensional array to a simple 1-dimensional array.
Definition: Functions.php:598
array
Create styles array
The data for the language used.
Definition: 40duplicateStyle.php:19
trendClass\TREND_LINEAR
const TREND_LINEAR
Definition: trendClass.php:45
+ Here is the call graph for this function:

◆ TRIMMEAN()

static PHPExcel_Calculation_Statistical::TRIMMEAN ( )
static

Definition at line 3372 of file Statistical.php.

References $i, array, PHPExcel_Calculation_Functions\flattenArray(), PHPExcel_Calculation_Functions\NaN(), and PHPExcel_Calculation_Functions\VALUE().

3372  {
3373  $aArgs = PHPExcel_Calculation_Functions::flattenArray(func_get_args());
3374 
3375  // Calculate
3376  $percent = array_pop($aArgs);
3377 
3378  if ((is_numeric($percent)) && (!is_string($percent))) {
3379  if (($percent < 0) || ($percent > 1)) {
3380  return PHPExcel_Calculation_Functions::NaN();
3381  }
3382  $mArgs = array();
3383  foreach ($aArgs as $arg) {
3384  // Is it a numeric value?
3385  if ((is_numeric($arg)) && (!is_string($arg))) {
3386  $mArgs[] = $arg;
3387  }
3388  }
3389  $discard = floor(self::COUNT($mArgs) * $percent / 2);
3390  sort($mArgs);
3391  for ($i=0; $i < $discard; ++$i) {
3392  array_pop($mArgs);
3393  array_shift($mArgs);
3394  }
3395  return self::AVERAGE($mArgs);
3396  }
3397  return PHPExcel_Calculation_Functions::VALUE();
3398  } // function TRIMMEAN()
PHPExcel_Calculation_Functions\flattenArray
static flattenArray($array)
Convert a multi-dimensional array to a simple 1-dimensional array.
Definition: Functions.php:598
PHPExcel_Calculation_Functions\VALUE
static VALUE()
Definition: Functions.php:289
array
Create styles array
The data for the language used.
Definition: 40duplicateStyle.php:19
PHPExcel_Calculation_Functions\NaN
static NaN()
Definition: Functions.php:233
$i
$i
Definition: disco.tpl.php:19
+ Here is the call graph for this function:

◆ VARA()

static PHPExcel_Calculation_Statistical::VARA ( )
static

Definition at line 3456 of file Statistical.php.

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

3456  {
3457  // Return value
3458  $returnValue = PHPExcel_Calculation_Functions::DIV0();
3459 
3460  $summerA = $summerB = 0;
3461 
3462  // Loop through arguments
3463  $aArgs = PHPExcel_Calculation_Functions::flattenArrayIndexed(func_get_args());
3464  $aCount = 0;
3465  foreach ($aArgs as $k => $arg) {
3466  if ((is_string($arg)) &&
3467  (PHPExcel_Calculation_Functions::isValue($k))) {
3468  return PHPExcel_Calculation_Functions::VALUE();
3469  } elseif ((is_string($arg)) &&
3470  (!PHPExcel_Calculation_Functions::isMatrixValue($k))) {
3471  } else {
3472  // Is it a numeric value?
3473  if ((is_numeric($arg)) || (is_bool($arg)) || ((is_string($arg) & ($arg != '')))) {
3474  if (is_bool($arg)) {
3475  $arg = (integer) $arg;
3476  } elseif (is_string($arg)) {
3477  $arg = 0;
3478  }
3479  $summerA += ($arg * $arg);
3480  $summerB += $arg;
3481  ++$aCount;
3482  }
3483  }
3484  }
3485 
3486  // Return
3487  if ($aCount > 1) {
3488  $summerA *= $aCount;
3489  $summerB *= $summerB;
3490  $returnValue = ($summerA - $summerB) / ($aCount * ($aCount - 1));
3491  }
3492  return $returnValue;
3493  } // function VARA()
PHPExcel_Calculation_Functions\DIV0
static DIV0()
Definition: Functions.php:201
PHPExcel_Calculation_Functions\VALUE
static VALUE()
Definition: Functions.php:289
PHPExcel_Calculation_Functions\flattenArrayIndexed
static flattenArrayIndexed($array)
Convert a multi-dimensional array to a simple 1-dimensional array, but retain an element of indexing...
Definition: Functions.php:630
PHPExcel_Calculation_Functions\isMatrixValue
static isMatrixValue($idx)
Definition: Functions.php:294
PHPExcel_Calculation_Functions\isValue
static isValue($idx)
Definition: Functions.php:299
+ Here is the call graph for this function:

◆ VARFunc()

static PHPExcel_Calculation_Statistical::VARFunc ( )
static

Definition at line 3414 of file Statistical.php.

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

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

3414  {
3415  // Return value
3416  $returnValue = PHPExcel_Calculation_Functions::DIV0();
3417 
3418  $summerA = $summerB = 0;
3419 
3420  // Loop through arguments
3421  $aArgs = PHPExcel_Calculation_Functions::flattenArray(func_get_args());
3422  $aCount = 0;
3423  foreach ($aArgs as $arg) {
3424  if (is_bool($arg)) { $arg = (integer) $arg; }
3425  // Is it a numeric value?
3426  if ((is_numeric($arg)) && (!is_string($arg))) {
3427  $summerA += ($arg * $arg);
3428  $summerB += $arg;
3429  ++$aCount;
3430  }
3431  }
3432 
3433  // Return
3434  if ($aCount > 1) {
3435  $summerA *= $aCount;
3436  $summerB *= $summerB;
3437  $returnValue = ($summerA - $summerB) / ($aCount * ($aCount - 1));
3438  }
3439  return $returnValue;
3440  } // function VARFunc()
PHPExcel_Calculation_Functions\DIV0
static DIV0()
Definition: Functions.php:201
PHPExcel_Calculation_Functions\flattenArray
static flattenArray($array)
Convert a multi-dimensional array to a simple 1-dimensional array.
Definition: Functions.php:598
+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ VARP()

static PHPExcel_Calculation_Statistical::VARP ( )
static

Definition at line 3509 of file Statistical.php.

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

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

3509  {
3510  // Return value
3511  $returnValue = PHPExcel_Calculation_Functions::DIV0();
3512 
3513  $summerA = $summerB = 0;
3514 
3515  // Loop through arguments
3516  $aArgs = PHPExcel_Calculation_Functions::flattenArray(func_get_args());
3517  $aCount = 0;
3518  foreach ($aArgs as $arg) {
3519  if (is_bool($arg)) { $arg = (integer) $arg; }
3520  // Is it a numeric value?
3521  if ((is_numeric($arg)) && (!is_string($arg))) {
3522  $summerA += ($arg * $arg);
3523  $summerB += $arg;
3524  ++$aCount;
3525  }
3526  }
3527 
3528  // Return
3529  if ($aCount > 0) {
3530  $summerA *= $aCount;
3531  $summerB *= $summerB;
3532  $returnValue = ($summerA - $summerB) / ($aCount * $aCount);
3533  }
3534  return $returnValue;
3535  } // function VARP()
PHPExcel_Calculation_Functions\DIV0
static DIV0()
Definition: Functions.php:201
PHPExcel_Calculation_Functions\flattenArray
static flattenArray($array)
Convert a multi-dimensional array to a simple 1-dimensional array.
Definition: Functions.php:598
+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ VARPA()

static PHPExcel_Calculation_Statistical::VARPA ( )
static

Definition at line 3551 of file Statistical.php.

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

3551  {
3552  // Return value
3553  $returnValue = PHPExcel_Calculation_Functions::DIV0();
3554 
3555  $summerA = $summerB = 0;
3556 
3557  // Loop through arguments
3558  $aArgs = PHPExcel_Calculation_Functions::flattenArrayIndexed(func_get_args());
3559  $aCount = 0;
3560  foreach ($aArgs as $k => $arg) {
3561  if ((is_string($arg)) &&
3562  (PHPExcel_Calculation_Functions::isValue($k))) {
3563  return PHPExcel_Calculation_Functions::VALUE();
3564  } elseif ((is_string($arg)) &&
3565  (!PHPExcel_Calculation_Functions::isMatrixValue($k))) {
3566  } else {
3567  // Is it a numeric value?
3568  if ((is_numeric($arg)) || (is_bool($arg)) || ((is_string($arg) & ($arg != '')))) {
3569  if (is_bool($arg)) {
3570  $arg = (integer) $arg;
3571  } elseif (is_string($arg)) {
3572  $arg = 0;
3573  }
3574  $summerA += ($arg * $arg);
3575  $summerB += $arg;
3576  ++$aCount;
3577  }
3578  }
3579  }
3580 
3581  // Return
3582  if ($aCount > 0) {
3583  $summerA *= $aCount;
3584  $summerB *= $summerB;
3585  $returnValue = ($summerA - $summerB) / ($aCount * $aCount);
3586  }
3587  return $returnValue;
3588  } // function VARPA()
PHPExcel_Calculation_Functions\DIV0
static DIV0()
Definition: Functions.php:201
PHPExcel_Calculation_Functions\VALUE
static VALUE()
Definition: Functions.php:289
PHPExcel_Calculation_Functions\flattenArrayIndexed
static flattenArrayIndexed($array)
Convert a multi-dimensional array to a simple 1-dimensional array, but retain an element of indexing...
Definition: Functions.php:630
PHPExcel_Calculation_Functions\isMatrixValue
static isMatrixValue($idx)
Definition: Functions.php:294
PHPExcel_Calculation_Functions\isValue
static isValue($idx)
Definition: Functions.php:299
+ Here is the call graph for this function:

◆ WEIBULL()

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 3604 of file Statistical.php.

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

3604  {
3605  $value = PHPExcel_Calculation_Functions::flattenSingleValue($value);
3606  $alpha = PHPExcel_Calculation_Functions::flattenSingleValue($alpha);
3607  $beta = PHPExcel_Calculation_Functions::flattenSingleValue($beta);
3608 
3609  if ((is_numeric($value)) && (is_numeric($alpha)) && (is_numeric($beta))) {
3610  if (($value < 0) || ($alpha <= 0) || ($beta <= 0)) {
3611  return PHPExcel_Calculation_Functions::NaN();
3612  }
3613  if ((is_numeric($cumulative)) || (is_bool($cumulative))) {
3614  if ($cumulative) {
3615  return 1 - exp(0 - pow($value / $beta,$alpha));
3616  } else {
3617  return ($alpha / pow($beta,$alpha)) * pow($value,$alpha - 1) * exp(0 - pow($value / $beta,$alpha));
3618  }
3619  }
3620  }
3621  return PHPExcel_Calculation_Functions::VALUE();
3622  } // function WEIBULL()
PHPExcel_Calculation_Functions\flattenSingleValue
static flattenSingleValue($value='')
Convert an array to a single scalar value by extracting the first element.
Definition: Functions.php:662
PHPExcel_Calculation_Functions\VALUE
static VALUE()
Definition: Functions.php:289
PHPExcel_Calculation_Functions\NaN
static NaN()
Definition: Functions.php:233
+ Here is the call graph for this function:

◆ ZTEST()

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$dataSet
float$m0Alpha Parameter
float$sigmaBeta Parameter
boolean$cumulative
Returns
float

Definition at line 3638 of file Statistical.php.

References $n, PHPExcel_Calculation_Functions\flattenArrayIndexed(), and PHPExcel_Calculation_Functions\flattenSingleValue().

3638  {
3639  $dataSet = PHPExcel_Calculation_Functions::flattenArrayIndexed($dataSet);
3640  $m0 = PHPExcel_Calculation_Functions::flattenSingleValue($m0);
3641  $sigma = PHPExcel_Calculation_Functions::flattenSingleValue($sigma);
3642 
3643  if (is_null($sigma)) {
3644  $sigma = self::STDEV($dataSet);
3645  }
3646  $n = count($dataSet);
3647 
3648  return 1 - self::NORMSDIST((self::AVERAGE($dataSet) - $m0)/($sigma/SQRT($n)));
3649  } // function ZTEST()
PHPExcel_Calculation_Functions\flattenSingleValue
static flattenSingleValue($value='')
Convert an array to a single scalar value by extracting the first element.
Definition: Functions.php:662
PHPExcel_Calculation_Functions\flattenArrayIndexed
static flattenArrayIndexed($array)
Convert a multi-dimensional array to a simple 1-dimensional array, but retain an element of indexing...
Definition: Functions.php:630
$n
$n
Definition: RandomTest.php:85
+ Here is the call graph for this function:

Field Documentation

◆ $_logBetaCache_p

PHPExcel_Calculation_Statistical::$_logBetaCache_p = 0.0
staticprivate

Definition at line 138 of file Statistical.php.

◆ $_logBetaCache_q

PHPExcel_Calculation_Statistical::$_logBetaCache_q = 0.0
staticprivate

Definition at line 139 of file Statistical.php.

◆ $_logBetaCache_result

PHPExcel_Calculation_Statistical::$_logBetaCache_result = 0.0
staticprivate

Definition at line 140 of file Statistical.php.

◆ $_logGammaCache_result

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 259 of file Statistical.php.

◆ $_logGammaCache_x

PHPExcel_Calculation_Statistical::$_logGammaCache_x = 0.0
staticprivate

Definition at line 260 of file Statistical.php.

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