ILIAS  release_5-2 Revision v5.2.25-18-g3f80b828510
Statistical.php
Go to the documentation of this file.
1 <?php
30 if (!defined('PHPEXCEL_ROOT')) {
34  define('PHPEXCEL_ROOT', dirname(__FILE__) . '/../../');
35  require(PHPEXCEL_ROOT . 'PHPExcel/Autoloader.php');
36 }
37 
38 
39 require_once PHPEXCEL_ROOT . 'PHPExcel/Shared/trend/trendClass.php';
40 
41 
43 define('LOG_GAMMA_X_MAX_VALUE', 2.55e305);
44 
46 define('XMININ', 2.23e-308);
47 
49 define('EPS', 2.22e-16);
50 
52 define('SQRT2PI', 2.5066282746310005024157652848110452530069867406099);
53 
54 
62 class PHPExcel_Calculation_Statistical {
63 
64 
65  private static function _checkTrendArrays(&$array1,&$array2) {
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()
88 
89 
99  private static function _beta($p, $q) {
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()
106 
107 
120  private static function _incompleteBeta($x, $p, $q) {
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()
135 
136 
137  // Function cache for _logBeta function
138  private static $_logBetaCache_p = 0.0;
139  private static $_logBetaCache_q = 0.0;
140  private static $_logBetaCache_result = 0.0;
141 
150  private static function _logBeta($p, $q) {
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()
162 
163 
169  private static function _betaFraction($x, $p, $q) {
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()
213 
214 
258  // Function cache for logGamma
259  private static $_logGammaCache_result = 0.0;
260  private static $_logGammaCache_x = 0.0;
261 
262  private static function _logGamma($x) {
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()
420 
421 
422  //
423  // Private implementation of the incomplete Gamma function
424  //
425  private static function _incompleteGamma($a,$x) {
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()
437 
438 
439  //
440  // Private implementation of the Gamma function
441  //
442  private static function _gamma($data) {
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()
464 
465 
466  /***************************************************************************
467  * inverse_ncdf.php
468  * -------------------
469  * begin : Friday, January 16, 2004
470  * copyright : (C) 2004 Michael Nickerson
471  * email : nickersonm@yahoo.com
472  *
473  ***************************************************************************/
474  private static function _inverse_ncdf($p) {
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()
541 
542 
543  private static function _inverse_ncdf2($prob) {
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()
584 
585 
586  private static function _inverse_ncdf3($p) {
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()
684 
685 
700  public static function AVEDEV() {
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()
733 
734 
748  public static function AVERAGE() {
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()
775 
776 
790  public static function AVERAGEA() {
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()
823 
824 
840  public static function AVERAGEIF($aArgs,$condition,$averageArgs = array()) {
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()
870 
871 
884  public static function BETADIST($value,$alpha,$beta,$rMin=0,$rMax=1) {
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()
906 
907 
922  public static function BETAINV($probability,$alpha,$beta,$rMin=0,$rMax=1) {
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()
960 
961 
980  public static function BINOMDIST($value, $trials, $probability, $cumulative) {
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()
1006 
1007 
1017  public static function CHIDIST($value, $degrees) {
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()
1035 
1036 
1046  public static function CHIINV($probability, $degrees) {
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()
1091 
1092 
1104  public static function CONFIDENCE($alpha,$stdDev,$size) {
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()
1120 
1121 
1131  public static function CORREL($yValues,$xValues=null) {
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()
1150 
1151 
1165  public static function COUNT() {
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()
1185 
1186 
1200  public static function COUNTA() {
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()
1216 
1217 
1231  public static function COUNTBLANK() {
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()
1247 
1248 
1263  public static function COUNTIF($aArgs,$condition) {
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()
1282 
1283 
1293  public static function COVAR($yValues,$xValues) {
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()
1309 
1310 
1330  public static function CRITBINOM($trials, $probability, $alpha) {
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()
1419 
1420 
1434  public static function DEVSQ() {
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()
1468 
1469 
1482  public static function EXPONDIST($value, $lambda, $cumulative) {
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()
1501 
1502 
1513  public static function FISHER($value) {
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()
1524 
1525 
1536  public static function FISHERINV($value) {
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()
1544 
1545 
1556  public static function FORECAST($xValue,$yValues,$xValues) {
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()
1577 
1578 
1591  public static function GAMMADIST($value,$a,$b,$cumulative) {
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()
1610 
1611 
1623  public static function GAMMAINV($probability,$alpha,$beta) {
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()
1671 
1672 
1681  public static function GAMMALN($value) {
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()
1692 
1693 
1709  public static function GEOMEAN() {
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()
1721 
1722 
1734  public static function GROWTH($yValues,$xValues=array(),$newValues=array(),$const=True) {
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()
1752 
1753 
1768  public static function HARMEAN() {
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()
1800 
1801 
1815  public static function HYPGEOMDIST($sampleSuccesses, $sampleNumber, $populationSuccesses, $populationNumber) {
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()
1837 
1838 
1848  public static function INTERCEPT($yValues,$xValues) {
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()
1864 
1865 
1877  public static function KURT() {
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()
1904 
1905 
1922  public static function LARGE() {
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()
1946 
1947 
1960  public static function LINEST($yValues, $xValues = NULL, $const = TRUE, $stats = FALSE) {
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()
1999 
2000 
2013  public static function LOGEST($yValues,$xValues=null,$const=True,$stats=False) {
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()
2058 
2059 
2074  public static function LOGINV($probability, $mean, $stdDev) {
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()
2087 
2088 
2100  public static function LOGNORMDIST($value, $mean, $stdDev) {
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()
2113 
2114 
2129  public static function MAX() {
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()
2150 
2151 
2165  public static function MAXA() {
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()
2191 
2192 
2207  public static function MAXIF($aArgs,$condition,$sumArgs = array()) {
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()
2231 
2232 
2246  public static function MEDIAN() {
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()
2275 
2276 
2291  public static function MIN() {
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()
2312 
2313 
2327  public static function MINA() {
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()
2353 
2354 
2369  public static function MINIF($aArgs,$condition,$sumArgs = array()) {
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()
2393 
2394 
2395  //
2396  // Special variant of array_count_values that isn't limited to strings and integers,
2397  // but can work with floating point numbers as values
2398  //
2399  private static function _modeCalc($data) {
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()
2427 
2428 
2442  public static function MODE() {
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()
2464 
2465 
2481  public static function NEGBINOMDIST($failures, $successes, $probability) {
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()
2502 
2503 
2518  public static function NORMDIST($value, $mean, $stdDev, $cumulative) {
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()
2537 
2538 
2550  public static function NORMINV($probability,$mean,$stdDev) {
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()
2566 
2567 
2578  public static function NORMSDIST($value) {
2579  $value = PHPExcel_Calculation_Functions::flattenSingleValue($value);
2580 
2581  return self::NORMDIST($value, 0, 1, True);
2582  } // function NORMSDIST()
2583 
2584 
2593  public static function NORMSINV($value) {
2594  return self::NORMINV($value, 0, 1);
2595  } // function NORMSINV()
2596 
2597 
2612  public static function PERCENTILE() {
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()
2646 
2647 
2658  public static function PERCENTRANK($valueSet,$value,$significance=3) {
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()
2692 
2693 
2707  public static function PERMUT($numObjs,$numInSet) {
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()
2720 
2721 
2735  public static function POISSON($value, $mean, $cumulative) {
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()
2757 
2758 
2773  public static function QUARTILE() {
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()
2788 
2789 
2800  public static function RANK($value,$valueSet,$order=0) {
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()
2823 
2824 
2834  public static function RSQ($yValues,$xValues) {
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()
2850 
2851 
2863  public static function SKEW() {
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()
2888 
2889 
2899  public static function SLOPE($yValues,$xValues) {
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()
2915 
2916 
2932  public static function SMALL() {
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()
2956 
2957 
2968  public static function STANDARDIZE($value,$mean,$stdDev) {
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()
2981 
2982 
2997  public static function STDEV() {
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()
3029 
3030 
3044  public static function STDEVA() {
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()
3081 
3082 
3096  public static function STDEVP() {
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()
3128 
3129 
3143  public static function STDEVPA() {
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()
3180 
3181 
3191  public static function STEYX($yValues,$xValues) {
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()
3207 
3208 
3219  public static function TDIST($value, $degrees, $tails) {
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()
3268 
3269 
3279  public static function TINV($probability, $degrees) {
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()
3323 
3324 
3336  public static function TREND($yValues,$xValues=array(),$newValues=array(),$const=True) {
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()
3354 
3355 
3372  public static function TRIMMEAN() {
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()
3399 
3400 
3414  public static function VARFunc() {
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()
3441 
3442 
3456  public static function VARA() {
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()
3494 
3495 
3509  public static function VARP() {
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()
3536 
3537 
3551  public static function VARPA() {
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()
3589 
3590 
3604  public static function WEIBULL($value, $alpha, $beta, $cumulative) {
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()
3623 
3624 
3638  public static function ZTEST($dataSet, $m0, $sigma = NULL) {
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()
3650 
3651 } // class PHPExcel_Calculation_Statistical
PHPExcel_Calculation_Statistical\RANK
static RANK($value, $valueSet, $order=0)
RANK.
Definition: Statistical.php:2800
PHPExcel_Calculation_Statistical\STEYX
static STEYX($yValues, $xValues)
STEYX.
Definition: Statistical.php:3191
PHPExcel_Calculation_Statistical\COUNT
static COUNT()
Definition: Statistical.php:1165
PHPExcel_Calculation_Functions\DIV0
static DIV0()
Definition: Functions.php:201
PHPExcel_Calculation_Statistical\AVERAGEA
static AVERAGEA()
Definition: Statistical.php:790
PHPExcel_Calculation_Statistical\MAX
static MAX()
Definition: Statistical.php:2129
$error
$error
Definition: Error.php:17
PHPExcel_Calculation_Statistical\_betaFraction
static _betaFraction($x, $p, $q)
Evaluates of continued fraction part of incomplete beta function.
Definition: Statistical.php:169
PHPExcel_Calculation_Statistical\LARGE
static LARGE()
Definition: Statistical.php:1922
PHPExcel_Calculation_Statistical\_checkTrendArrays
static _checkTrendArrays(&$array1, &$array2)
Definition: Statistical.php:65
PHPExcel_Calculation_Statistical\MIN
static MIN()
Definition: Statistical.php:2291
$size
$size
Definition: RandomTest.php:79
PHPExcel_Calculation_Statistical\$_logBetaCache_result
static $_logBetaCache_result
Definition: Statistical.php:140
PHPExcel_Calculation_Statistical\AVERAGEIF
static AVERAGEIF($aArgs, $condition, $averageArgs=array())
Definition: Statistical.php:840
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_Statistical\CHIINV
static CHIINV($probability, $degrees)
CHIINV.
Definition: Statistical.php:1046
PHPExcel_Calculation_Statistical\_logGamma
static _logGamma($x)
Definition: Statistical.php:262
PHPExcel_Calculation_MathTrig\FACT
static FACT($factVal)
Definition: MathTrig.php:240
LOG_GAMMA_X_MAX_VALUE
const LOG_GAMMA_X_MAX_VALUE
LOG_GAMMA_X_MAX_VALUE.
Definition: Statistical.php:43
PHPExcel_Calculation_Statistical\NORMINV
static NORMINV($probability, $mean, $stdDev)
NORMINV.
Definition: Statistical.php:2550
$result
$result
Definition: CleanUpTest.php:407
PHPExcel_Calculation_Statistical\STDEVP
static STDEVP()
Definition: Statistical.php:3096
$x
$x
Definition: example_009.php:98
PHPExcel_Calculation_Statistical
Definition: Statistical.php:62
PHPExcel_Calculation_Statistical\VARPA
static VARPA()
Definition: Statistical.php:3551
$pdf
$pdf
Definition: example_001.php:31
$h
$h
Definition: example_009.php:101
trendClass\TREND_EXPONENTIAL
const TREND_EXPONENTIAL
Definition: trendClass.php:47
PHPExcel_Calculation_Statistical\LINEST
static LINEST($yValues, $xValues=NULL, $const =TRUE, $stats=FALSE)
LINEST.
Definition: Statistical.php:1960
PHPExcel_Calculation_Statistical\STANDARDIZE
static STANDARDIZE($value, $mean, $stdDev)
STANDARDIZE.
Definition: Statistical.php:2968
PHPExcel_Calculation_Statistical\NEGBINOMDIST
static NEGBINOMDIST($failures, $successes, $probability)
NEGBINOMDIST.
Definition: Statistical.php:2481
PHPExcel_Calculation_Statistical\MEDIAN
static MEDIAN()
Definition: Statistical.php:2246
SQRT2PI
const SQRT2PI
SQRT2PI.
Definition: Statistical.php:52
PHPExcel_Calculation_Statistical\STDEVA
static STDEVA()
Definition: Statistical.php:3044
PHPExcel_Calculation_Statistical\_inverse_ncdf3
static _inverse_ncdf3($p)
Definition: Statistical.php:586
XMININ
const XMININ
XMININ.
Definition: Statistical.php:46
trendClass\calculate
static calculate($trendType=self::TREND_BEST_FIT, $yValues, $xValues=array(), $const=True)
Definition: trendClass.php:87
PHPExcel_Calculation_Statistical\SLOPE
static SLOPE($yValues, $xValues)
SLOPE.
Definition: Statistical.php:2899
PHPExcel_Calculation_Statistical\PERCENTRANK
static PERCENTRANK($valueSet, $value, $significance=3)
PERCENTRANK.
Definition: Statistical.php:2658
PRECISION
const PRECISION
PRECISION.
Definition: Functions.php:49
PHPExcel_Calculation_Statistical\MINA
static MINA()
Definition: Statistical.php:2327
PHPExcel_Calculation\_wrapResult
static _wrapResult($value)
Wrap string values in quotes.
Definition: Calculation.php:2163
PHPExcel_Calculation_Engineering\_erfVal
static _erfVal($x)
Definition: Engineering.php:2228
PHPExcel_Calculation_Statistical\RSQ
static RSQ($yValues, $xValues)
RSQ.
Definition: Statistical.php:2834
PHPExcel_Calculation_Statistical\_logBeta
static _logBeta($p, $q)
The natural logarithm of the beta function.
Definition: Statistical.php:150
PHPExcel_Calculation_Statistical\_inverse_ncdf
static _inverse_ncdf($p)
Definition: Statistical.php:474
PHPExcel_Calculation_Statistical\COUNTBLANK
static COUNTBLANK()
Definition: Statistical.php:1231
PHPExcel_Calculation_Statistical\CORREL
static CORREL($yValues, $xValues=null)
CORREL.
Definition: Statistical.php:1131
PHPExcel_Calculation_Statistical\GAMMAINV
static GAMMAINV($probability, $alpha, $beta)
GAMMAINV.
Definition: Statistical.php:1623
MAX_VALUE
const MAX_VALUE(!defined('PHPEXCEL_ROOT'))
PHPExcel root directory.
Definition: Functions.php:40
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
$d
for($col=0; $col< 50; $col++) $d
Definition: 40duplicateStyle.php:38
PHPExcel_Calculation_Statistical\_inverse_ncdf2
static _inverse_ncdf2($prob)
Definition: Statistical.php:543
PHPExcel_Calculation_Statistical\MAXA
static MAXA()
Definition: Statistical.php:2165
PHPExcel_Calculation_Statistical\$_logBetaCache_p
static $_logBetaCache_p
Definition: Statistical.php:138
PHPExcel_Calculation_Statistical\NORMDIST
static NORMDIST($value, $mean, $stdDev, $cumulative)
NORMDIST.
Definition: Statistical.php:2518
PHPExcel_Calculation_Statistical\ZTEST
static ZTEST($dataSet, $m0, $sigma=NULL)
ZTEST.
Definition: Statistical.php:3638
PHPExcel_Calculation_Functions\VALUE
static VALUE()
Definition: Functions.php:289
EPS
const EPS
EPS.
Definition: Statistical.php:49
PHPExcel_Calculation_Statistical\FISHER
static FISHER($value)
FISHER.
Definition: Statistical.php:1513
PHPExcel_Calculation_Statistical\PERCENTILE
static PERCENTILE()
Definition: Statistical.php:2612
PHPExcel_Calculation_Statistical\TREND
static TREND($yValues, $xValues=array(), $newValues=array(), $const=True)
TREND.
Definition: Statistical.php:3336
PHPExcel_Calculation_Statistical\MODE
static MODE()
Definition: Statistical.php:2442
PHPExcel_Calculation_Statistical\SKEW
static SKEW()
SKEW.
Definition: Statistical.php:2863
PHPExcel_Calculation_Statistical\DEVSQ
static DEVSQ()
Definition: Statistical.php:1434
PHPExcel_Calculation_Statistical\$_logBetaCache_q
static $_logBetaCache_q
Definition: Statistical.php:139
MAX_ITERATIONS
const MAX_ITERATIONS
MAX_ITERATIONS.
Definition: Functions.php:46
PHPExcel_Calculation_Statistical\STDEV
static STDEV()
Definition: Statistical.php:2997
$r
$r
Definition: example_031.php:79
PHPExcel_Calculation_Statistical\VARP
static VARP()
Definition: Statistical.php:3509
$y
$y
Definition: example_007.php:83
PHPExcel_Calculation_Statistical\_gamma
static _gamma($data)
Definition: Statistical.php:442
PHPExcel_Calculation_Statistical\AVEDEV
static AVEDEV()
Definition: Statistical.php:700
PHPExcel_Calculation_Statistical\PERMUT
static PERMUT($numObjs, $numInSet)
PERMUT.
Definition: Statistical.php:2707
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\_ifCondition
static _ifCondition($condition)
Definition: Functions.php:309
PHPExcel_Calculation_Statistical\LOGINV
static LOGINV($probability, $mean, $stdDev)
LOGINV.
Definition: Statistical.php:2074
e
e($cmd)
Definition: flush.php:14
PHPExcel_Calculation_Statistical\BETAINV
static BETAINV($probability, $alpha, $beta, $rMin=0, $rMax=1)
BETAINV.
Definition: Statistical.php:922
PHPExcel_Calculation_Functions\NULL
static NULL()
Definition: Functions.php:275
PHPExcel_Calculation_Statistical\_incompleteGamma
static _incompleteGamma($a, $x)
Definition: Statistical.php:425
PHPExcel_Calculation_Statistical\_incompleteBeta
static _incompleteBeta($x, $p, $q)
Incomplete beta function.
Definition: Statistical.php:120
PHPExcel_Calculation_Statistical\GAMMALN
static GAMMALN($value)
GAMMALN.
Definition: Statistical.php:1681
PHPExcel_Calculation_Statistical\NORMSDIST
static NORMSDIST($value)
NORMSDIST.
Definition: Statistical.php:2578
PHPExcel_Calculation_Statistical\INTERCEPT
static INTERCEPT($yValues, $xValues)
INTERCEPT.
Definition: Statistical.php:1848
PHPExcel_Calculation_Statistical\NORMSINV
static NORMSINV($value)
NORMSINV.
Definition: Statistical.php:2593
PHPExcel_Calculation_Statistical\STDEVPA
static STDEVPA()
Definition: Statistical.php:3143
PHPExcel_Calculation_Functions\isCellValue
static isCellValue($idx)
Definition: Functions.php:304
PHPExcel_Calculation_Functions\isMatrixValue
static isMatrixValue($idx)
Definition: Functions.php:294
PHPExcel_Calculation_Statistical\TDIST
static TDIST($value, $degrees, $tails)
TDIST.
Definition: Statistical.php:3219
PHPExcel_Calculation_Statistical\COVAR
static COVAR($yValues, $xValues)
COVAR.
Definition: Statistical.php:1293
PHPExcel_Calculation_Statistical\CONFIDENCE
static CONFIDENCE($alpha, $stdDev, $size)
CONFIDENCE.
Definition: Statistical.php:1104
PHPExcel_Calculation_Statistical\COUNTIF
static COUNTIF($aArgs, $condition)
Definition: Statistical.php:1263
$n
$n
Definition: RandomTest.php:80
PHPExcel_Calculation_Statistical\GEOMEAN
static GEOMEAN()
Definition: Statistical.php:1709
PHPExcel_Calculation_Statistical\HYPGEOMDIST
static HYPGEOMDIST($sampleSuccesses, $sampleNumber, $populationSuccesses, $populationNumber)
HYPGEOMDIST.
Definition: Statistical.php:1815
PHPExcel_Calculation_Functions\NA
static NA()
Definition: Functions.php:219
PHPExcel_Calculation_Statistical\TINV
static TINV($probability, $degrees)
TINV.
Definition: Statistical.php:3279
PHPExcel_Calculation_Functions\COMPATIBILITY_OPENOFFICE
const COMPATIBILITY_OPENOFFICE
Definition: Functions.php:64
PHPExcel_Calculation_Functions\isValue
static isValue($idx)
Definition: Functions.php:299
PHPExcel_Calculation_Statistical\VARFunc
static VARFunc()
Definition: Statistical.php:3414
PHPExcel_Calculation_Statistical\$_logGammaCache_x
static $_logGammaCache_x
Definition: Statistical.php:260
array
Create styles array
The data for the language used.
Definition: 40duplicateStyle.php:19
PHPExcel_Calculation_MathTrig\COMBIN
static COMBIN($numObjs, $numInSet)
Definition: MathTrig.php:176
PHPExcel_Calculation_Statistical\EXPONDIST
static EXPONDIST($value, $lambda, $cumulative)
EXPONDIST.
Definition: Statistical.php:1482
PHPExcel_Calculation_Functions\getCompatibilityMode
static getCompatibilityMode()
Definition: Functions.php:138
PHPExcel_Calculation_Statistical\LOGNORMDIST
static LOGNORMDIST($value, $mean, $stdDev)
LOGNORMDIST.
Definition: Statistical.php:2100
PHPExcel_Calculation_Statistical\TRIMMEAN
static TRIMMEAN()
Definition: Statistical.php:3372
PHPExcel_Calculation_Statistical\MAXIF
static MAXIF($aArgs, $condition, $sumArgs=array())
Definition: Statistical.php:2207
PHPExcel_Calculation_Functions\NaN
static NaN()
Definition: Functions.php:233
PHPExcel_Calculation_Statistical\GROWTH
static GROWTH($yValues, $xValues=array(), $newValues=array(), $const=True)
GROWTH.
Definition: Statistical.php:1734
PHPExcel_Calculation_Statistical\GAMMADIST
static GAMMADIST($value, $a, $b, $cumulative)
GAMMADIST.
Definition: Statistical.php:1591
PHPExcel_Calculation_Statistical\AVERAGE
static AVERAGE()
Definition: Statistical.php:748
PHPExcel_Calculation\getInstance
static getInstance(PHPExcel $workbook=NULL)
Get an instance of this class.
Definition: Calculation.php:1765
PHPExcel_Calculation_Statistical\HARMEAN
static HARMEAN()
Definition: Statistical.php:1768
trendClass\TREND_LINEAR
const TREND_LINEAR
Definition: trendClass.php:45
PHPExcel_Calculation_Statistical\_beta
static _beta($p, $q)
Beta function.
Definition: Statistical.php:99
PHPExcel_Calculation_Statistical\MINIF
static MINIF($aArgs, $condition, $sumArgs=array())
Definition: Statistical.php:2369
PHPExcel_Calculation_Statistical\CRITBINOM
static CRITBINOM($trials, $probability, $alpha)
CRITBINOM.
Definition: Statistical.php:1330
PHPExcel_Calculation_Statistical\QUARTILE
static QUARTILE()
Definition: Statistical.php:2773
PHPExcel_Calculation_Statistical\LOGEST
static LOGEST($yValues, $xValues=null, $const=True, $stats=False)
LOGEST.
Definition: Statistical.php:2013
M_2DIVPI
const M_2DIVPI
2 / PI
Definition: Functions.php:43
PHPExcel_Calculation_Statistical\KURT
static KURT()
KURT.
Definition: Statistical.php:1877
PHPExcel_Calculation_Statistical\BETADIST
static BETADIST($value, $alpha, $beta, $rMin=0, $rMax=1)
BETADIST.
Definition: Statistical.php:884
PHPExcel_Calculation_Statistical\$_logGammaCache_result
static $_logGammaCache_result
logGamma function
Definition: Statistical.php:259
PHPExcel_Calculation_Statistical\_modeCalc
static _modeCalc($data)
Definition: Statistical.php:2399
PHPExcel_Calculation_Statistical\WEIBULL
static WEIBULL($value, $alpha, $beta, $cumulative)
WEIBULL.
Definition: Statistical.php:3604
PHPExcel_Calculation_Functions\COMPATIBILITY_GNUMERIC
const COMPATIBILITY_GNUMERIC
Definition: Functions.php:63
defined
defined( 'APPLICATION_ENV')||define( 'APPLICATION_ENV'
Definition: bootstrap.php:27
PHPExcel_Calculation_Statistical\FORECAST
static FORECAST($xValue, $yValues, $xValues)
FORECAST.
Definition: Statistical.php:1556
PHPExcel_Calculation_Statistical\COUNTA
static COUNTA()
Definition: Statistical.php:1200
PHPExcel_Calculation_Statistical\VARA
static VARA()
Definition: Statistical.php:3456
PHPExcel_Calculation_Statistical\FISHERINV
static FISHERINV($value)
FISHERINV.
Definition: Statistical.php:1536
PHPExcel_Calculation_Statistical\BINOMDIST
static BINOMDIST($value, $trials, $probability, $cumulative)
BINOMDIST.
Definition: Statistical.php:980
PHPExcel_Calculation_Statistical\POISSON
static POISSON($value, $mean, $cumulative)
POISSON.
Definition: Statistical.php:2735
PHPExcel_Calculation_MathTrig\PRODUCT
static PRODUCT()
Definition: MathTrig.php:811
PHPExcel_Calculation_Statistical\SMALL
static SMALL()
Definition: Statistical.php:2932
PHPExcel_Calculation_Statistical\CHIDIST
static CHIDIST($value, $degrees)
CHIDIST.
Definition: Statistical.php:1017