1: <?php
   2: /**
   3:  * PHPExcel
   4:  *
   5:  * Copyright (c) 2006 - 2014 PHPExcel
   6:  *
   7:  * This library is free software; you can redistribute it and/or
   8:  * modify it under the terms of the GNU Lesser General Public
   9:  * License as published by the Free Software Foundation; either
  10:  * version 2.1 of the License, or (at your option) any later version.
  11:  *
  12:  * This library is distributed in the hope that it will be useful,
  13:  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14:  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
  15:  * Lesser General Public License for more details.
  16:  *
  17:  * You should have received a copy of the GNU Lesser General Public
  18:  * License along with this library; if not, write to the Free Software
  19:  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
  20:  *
  21:  * @category    PHPExcel
  22:  * @package     PHPExcel_Calculation
  23:  * @copyright   Copyright (c) 2006 - 2014 PHPExcel (http://www.codeplex.com/PHPExcel)
  24:  * @license     http://www.gnu.org/licenses/old-licenses/lgpl-2.1.txt   LGPL
  25:  * @version     1.8.0, 2014-03-02
  26:  */
  27: 
  28: 
  29: /** PHPExcel root directory */
  30: if (!defined('PHPEXCEL_ROOT')) {
  31:     /**
  32:      * @ignore
  33:      */
  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: 
  42: /** LOG_GAMMA_X_MAX_VALUE */
  43: define('LOG_GAMMA_X_MAX_VALUE', 2.55e305);
  44: 
  45: /** XMININ */
  46: define('XMININ', 2.23e-308);
  47: 
  48: /** EPS */
  49: define('EPS', 2.22e-16);
  50: 
  51: /** SQRT2PI */
  52: define('SQRT2PI', 2.5066282746310005024157652848110452530069867406099);
  53: 
  54: 
  55: /**
  56:  * PHPExcel_Calculation_Statistical
  57:  *
  58:  * @category    PHPExcel
  59:  * @package     PHPExcel_Calculation
  60:  * @copyright   Copyright (c) 2006 - 2014 PHPExcel (http://www.codeplex.com/PHPExcel)
  61:  */
  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: 
  90:     /**
  91:      * Beta function.
  92:      *
  93:      * @author Jaco van Kooten
  94:      *
  95:      * @param p require p>0
  96:      * @param q require q>0
  97:      * @return 0 if p<=0, q<=0 or p+q>2.55E305 to avoid errors and over/underflow
  98:      */
  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: 
 108:     /**
 109:      * Incomplete beta function
 110:      *
 111:      * @author Jaco van Kooten
 112:      * @author Paul Meagher
 113:      *
 114:      * The computation is based on formulas from Numerical Recipes, Chapter 6.4 (W.H. Press et al, 1992).
 115:      * @param x require 0<=x<=1
 116:      * @param p require p>0
 117:      * @param q require q>0
 118:      * @return 0 if x<0, p<=0, q<=0 or p+q>2.55E305 and 1 if x>1 to avoid errors and over/underflow
 119:      */
 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: 
 142:     /**
 143:      * The natural logarithm of the beta function.
 144:      *
 145:      * @param p require p>0
 146:      * @param q require q>0
 147:      * @return 0 if p<=0, q<=0 or p+q>2.55E305 to avoid errors and over/underflow
 148:      * @author Jaco van Kooten
 149:      */
 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: 
 164:     /**
 165:      * Evaluates of continued fraction part of incomplete beta function.
 166:      * Based on an idea from Numerical Recipes (W.H. Press et al, 1992).
 167:      * @author Jaco van Kooten
 168:      */
 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: 
 215:     /**
 216:      * logGamma function
 217:      *
 218:      * @version 1.1
 219:      * @author Jaco van Kooten
 220:      *
 221:      * Original author was Jaco van Kooten. Ported to PHP by Paul Meagher.
 222:      *
 223:      * The natural logarithm of the gamma function. <br />
 224:      * Based on public domain NETLIB (Fortran) code by W. J. Cody and L. Stoltz <br />
 225:      * Applied Mathematics Division <br />
 226:      * Argonne National Laboratory <br />
 227:      * Argonne, IL 60439 <br />
 228:      * <p>
 229:      * References:
 230:      * <ol>
 231:      * <li>W. J. Cody and K. E. Hillstrom, 'Chebyshev Approximations for the Natural
 232:      *   Logarithm of the Gamma Function,' Math. Comp. 21, 1967, pp. 198-203.</li>
 233:      * <li>K. E. Hillstrom, ANL/AMD Program ANLC366S, DGAMMA/DLGAMA, May, 1969.</li>
 234:      * <li>Hart, Et. Al., Computer Approximations, Wiley and sons, New York, 1968.</li>
 235:      * </ol>
 236:      * </p>
 237:      * <p>
 238:      * From the original documentation:
 239:      * </p>
 240:      * <p>
 241:      * This routine calculates the LOG(GAMMA) function for a positive real argument X.
 242:      * Computation is based on an algorithm outlined in references 1 and 2.
 243:      * The program uses rational functions that theoretically approximate LOG(GAMMA)
 244:      * to at least 18 significant decimal digits. The approximation for X > 12 is from
 245:      * reference 3, while approximations for X < 12.0 are similar to those in reference
 246:      * 1, but are unpublished. The accuracy achieved depends on the arithmetic system,
 247:      * the compiler, the intrinsic functions, and proper selection of the
 248:      * machine-dependent constants.
 249:      * </p>
 250:      * <p>
 251:      * Error returns: <br />
 252:      * The program returns the value XINF for X .LE. 0.0 or when overflow would occur.
 253:      * The computation is believed to be free of underflow and overflow.
 254:      * </p>
 255:      * @return MAX_VALUE for x < 0.0 or when overflow would occur, i.e. x > 2.55E305
 256:      */
 257: 
 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: 
 686:     /**
 687:      * AVEDEV
 688:      *
 689:      * Returns the average of the absolute deviations of data points from their mean.
 690:      * AVEDEV is a measure of the variability in a data set.
 691:      *
 692:      * Excel Function:
 693:      *      AVEDEV(value1[,value2[, ...]])
 694:      *
 695:      * @access  public
 696:      * @category Statistical Functions
 697:      * @param   mixed       $arg,...        Data values
 698:      * @return  float
 699:      */
 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: 
 735:     /**
 736:      * AVERAGE
 737:      *
 738:      * Returns the average (arithmetic mean) of the arguments
 739:      *
 740:      * Excel Function:
 741:      *      AVERAGE(value1[,value2[, ...]])
 742:      *
 743:      * @access  public
 744:      * @category Statistical Functions
 745:      * @param   mixed       $arg,...        Data values
 746:      * @return  float
 747:      */
 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: 
 777:     /**
 778:      * AVERAGEA
 779:      *
 780:      * Returns the average of its arguments, including numbers, text, and logical values
 781:      *
 782:      * Excel Function:
 783:      *      AVERAGEA(value1[,value2[, ...]])
 784:      *
 785:      * @access  public
 786:      * @category Statistical Functions
 787:      * @param   mixed       $arg,...        Data values
 788:      * @return  float
 789:      */
 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: 
 825:     /**
 826:      * AVERAGEIF
 827:      *
 828:      * Returns the average value from a range of cells that contain numbers within the list of arguments
 829:      *
 830:      * Excel Function:
 831:      *      AVERAGEIF(value1[,value2[, ...]],condition)
 832:      *
 833:      * @access  public
 834:      * @category Mathematical and Trigonometric Functions
 835:      * @param   mixed       $arg,...        Data values
 836:      * @param   string      $condition      The criteria that defines which cells will be checked.
 837:      * @param   mixed[]     $averageArgs    Data values
 838:      * @return  float
 839:      */
 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: 
 872:     /**
 873:      * BETADIST
 874:      *
 875:      * Returns the beta distribution.
 876:      *
 877:      * @param   float       $value          Value at which you want to evaluate the distribution
 878:      * @param   float       $alpha          Parameter to the distribution
 879:      * @param   float       $beta           Parameter to the distribution
 880:      * @param   boolean     $cumulative
 881:      * @return  float
 882:      *
 883:      */
 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: 
 908:     /**
 909:      * BETAINV
 910:      *
 911:      * Returns the inverse of the beta distribution.
 912:      *
 913:      * @param   float       $probability    Probability at which you want to evaluate the distribution
 914:      * @param   float       $alpha          Parameter to the distribution
 915:      * @param   float       $beta           Parameter to the distribution
 916:      * @param   float       $rMin           Minimum value
 917:      * @param   float       $rMax           Maximum value
 918:      * @param   boolean     $cumulative
 919:      * @return  float
 920:      *
 921:      */
 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: 
 962:     /**
 963:      * BINOMDIST
 964:      *
 965:      * Returns the individual term binomial distribution probability. Use BINOMDIST in problems with
 966:      *      a fixed number of tests or trials, when the outcomes of any trial are only success or failure,
 967:      *      when trials are independent, and when the probability of success is constant throughout the
 968:      *      experiment. For example, BINOMDIST can calculate the probability that two of the next three
 969:      *      babies born are male.
 970:      *
 971:      * @param   float       $value          Number of successes in trials
 972:      * @param   float       $trials         Number of trials
 973:      * @param   float       $probability    Probability of success on each trial
 974:      * @param   boolean     $cumulative
 975:      * @return  float
 976:      *
 977:      * @todo    Cumulative distribution function
 978:      *
 979:      */
 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: 
1008:     /**
1009:      * CHIDIST
1010:      *
1011:      * Returns the one-tailed probability of the chi-squared distribution.
1012:      *
1013:      * @param   float       $value          Value for the function
1014:      * @param   float       $degrees        degrees of freedom
1015:      * @return  float
1016:      */
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: 
1037:     /**
1038:      * CHIINV
1039:      *
1040:      * Returns the one-tailed probability of the chi-squared distribution.
1041:      *
1042:      * @param   float       $probability    Probability for the function
1043:      * @param   float       $degrees        degrees of freedom
1044:      * @return  float
1045:      */
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: 
1093:     /**
1094:      * CONFIDENCE
1095:      *
1096:      * Returns the confidence interval for a population mean
1097:      *
1098:      * @param   float       $alpha
1099:      * @param   float       $stdDev     Standard Deviation
1100:      * @param   float       $size
1101:      * @return  float
1102:      *
1103:      */
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: 
1122:     /**
1123:      * CORREL
1124:      *
1125:      * Returns covariance, the average of the products of deviations for each data point pair.
1126:      *
1127:      * @param   array of mixed      Data Series Y
1128:      * @param   array of mixed      Data Series X
1129:      * @return  float
1130:      */
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: 
1152:     /**
1153:      * COUNT
1154:      *
1155:      * Counts the number of cells that contain numbers within the list of arguments
1156:      *
1157:      * Excel Function:
1158:      *      COUNT(value1[,value2[, ...]])
1159:      *
1160:      * @access  public
1161:      * @category Statistical Functions
1162:      * @param   mixed       $arg,...        Data values
1163:      * @return  int
1164:      */
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: 
1187:     /**
1188:      * COUNTA
1189:      *
1190:      * Counts the number of cells that are not empty within the list of arguments
1191:      *
1192:      * Excel Function:
1193:      *      COUNTA(value1[,value2[, ...]])
1194:      *
1195:      * @access  public
1196:      * @category Statistical Functions
1197:      * @param   mixed       $arg,...        Data values
1198:      * @return  int
1199:      */
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: 
1218:     /**
1219:      * COUNTBLANK
1220:      *
1221:      * Counts the number of empty cells within the list of arguments
1222:      *
1223:      * Excel Function:
1224:      *      COUNTBLANK(value1[,value2[, ...]])
1225:      *
1226:      * @access  public
1227:      * @category Statistical Functions
1228:      * @param   mixed       $arg,...        Data values
1229:      * @return  int
1230:      */
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: 
1249:     /**
1250:      * COUNTIF
1251:      *
1252:      * Counts the number of cells that contain numbers within the list of arguments
1253:      *
1254:      * Excel Function:
1255:      *      COUNTIF(value1[,value2[, ...]],condition)
1256:      *
1257:      * @access  public
1258:      * @category Statistical Functions
1259:      * @param   mixed       $arg,...        Data values
1260:      * @param   string      $condition      The criteria that defines which cells will be counted.
1261:      * @return  int
1262:      */
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: 
1284:     /**
1285:      * COVAR
1286:      *
1287:      * Returns covariance, the average of the products of deviations for each data point pair.
1288:      *
1289:      * @param   array of mixed      Data Series Y
1290:      * @param   array of mixed      Data Series X
1291:      * @return  float
1292:      */
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: 
1311:     /**
1312:      * CRITBINOM
1313:      *
1314:      * Returns the smallest value for which the cumulative binomial distribution is greater
1315:      *      than or equal to a criterion value
1316:      *
1317:      * See http://support.microsoft.com/kb/828117/ for details of the algorithm used
1318:      *
1319:      * @param   float       $trials         number of Bernoulli trials
1320:      * @param   float       $probability    probability of a success on each trial
1321:      * @param   float       $alpha          criterion value
1322:      * @return  int
1323:      *
1324:      * @todo    Warning. This implementation differs from the algorithm detailed on the MS
1325:      *          web site in that $CumPGuessMinus1 = $CumPGuess - 1 rather than $CumPGuess - $PGuess
1326:      *          This eliminates a potential endless loop error, but may have an adverse affect on the
1327:      *          accuracy of the function (although all my tests have so far returned correct results).
1328:      *
1329:      */
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: 
1421:     /**
1422:      * DEVSQ
1423:      *
1424:      * Returns the sum of squares of deviations of data points from their sample mean.
1425:      *
1426:      * Excel Function:
1427:      *      DEVSQ(value1[,value2[, ...]])
1428:      *
1429:      * @access  public
1430:      * @category Statistical Functions
1431:      * @param   mixed       $arg,...        Data values
1432:      * @return  float
1433:      */
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: 
1470:     /**
1471:      * EXPONDIST
1472:      *
1473:      *  Returns the exponential distribution. Use EXPONDIST to model the time between events,
1474:      *      such as how long an automated bank teller takes to deliver cash. For example, you can
1475:      *      use EXPONDIST to determine the probability that the process takes at most 1 minute.
1476:      *
1477:      * @param   float       $value          Value of the function
1478:      * @param   float       $lambda         The parameter value
1479:      * @param   boolean     $cumulative
1480:      * @return  float
1481:      */
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: 
1503:     /**
1504:      * FISHER
1505:      *
1506:      * Returns the Fisher transformation at x. This transformation produces a function that
1507:      *      is normally distributed rather than skewed. Use this function to perform hypothesis
1508:      *      testing on the correlation coefficient.
1509:      *
1510:      * @param   float       $value
1511:      * @return  float
1512:      */
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: 
1526:     /**
1527:      * FISHERINV
1528:      *
1529:      * Returns the inverse of the Fisher transformation. Use this transformation when
1530:      *      analyzing correlations between ranges or arrays of data. If y = FISHER(x), then
1531:      *      FISHERINV(y) = x.
1532:      *
1533:      * @param   float       $value
1534:      * @return  float
1535:      */
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: 
1546:     /**
1547:      * FORECAST
1548:      *
1549:      * Calculates, or predicts, a future value by using existing values. The predicted value is a y-value for a given x-value.
1550:      *
1551:      * @param   float               Value of X for which we want to find Y
1552:      * @param   array of mixed      Data Series Y
1553:      * @param   array of mixed      Data Series X
1554:      * @return  float
1555:      */
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: 
1579:     /**
1580:      * GAMMADIST
1581:      *
1582:      * Returns the gamma distribution.
1583:      *
1584:      * @param   float       $value          Value at which you want to evaluate the distribution
1585:      * @param   float       $a              Parameter to the distribution
1586:      * @param   float       $b              Parameter to the distribution
1587:      * @param   boolean     $cumulative
1588:      * @return  float
1589:      *
1590:      */
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: 
1612:     /**
1613:      * GAMMAINV
1614:      *
1615:      * Returns the inverse of the beta distribution.
1616:      *
1617:      * @param   float       $probability    Probability at which you want to evaluate the distribution
1618:      * @param   float       $alpha          Parameter to the distribution
1619:      * @param   float       $beta           Parameter to the distribution
1620:      * @return  float
1621:      *
1622:      */
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: 
1673:     /**
1674:      * GAMMALN
1675:      *
1676:      * Returns the natural logarithm of the gamma function.
1677:      *
1678:      * @param   float       $value
1679:      * @return  float
1680:      */
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: 
1694:     /**
1695:      * GEOMEAN
1696:      *
1697:      * Returns the geometric mean of an array or range of positive data. For example, you
1698:      *      can use GEOMEAN to calculate average growth rate given compound interest with
1699:      *      variable rates.
1700:      *
1701:      * Excel Function:
1702:      *      GEOMEAN(value1[,value2[, ...]])
1703:      *
1704:      * @access  public
1705:      * @category Statistical Functions
1706:      * @param   mixed       $arg,...        Data values
1707:      * @return  float
1708:      */
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: 
1723:     /**
1724:      * GROWTH
1725:      *
1726:      * Returns values along a predicted emponential trend
1727:      *
1728:      * @param   array of mixed      Data Series Y
1729:      * @param   array of mixed      Data Series X
1730:      * @param   array of mixed      Values of X for which we want to find Y
1731:      * @param   boolean             A logical value specifying whether to force the intersect to equal 0.
1732:      * @return  array of float
1733:      */
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: 
1754:     /**
1755:      * HARMEAN
1756:      *
1757:      * Returns the harmonic mean of a data set. The harmonic mean is the reciprocal of the
1758:      *      arithmetic mean of reciprocals.
1759:      *
1760:      * Excel Function:
1761:      *      HARMEAN(value1[,value2[, ...]])
1762:      *
1763:      * @access  public
1764:      * @category Statistical Functions
1765:      * @param   mixed       $arg,...        Data values
1766:      * @return  float
1767:      */
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: 
1802:     /**
1803:      * HYPGEOMDIST
1804:      *
1805:      * Returns the hypergeometric distribution. HYPGEOMDIST returns the probability of a given number of
1806:      * sample successes, given the sample size, population successes, and population size.
1807:      *
1808:      * @param   float       $sampleSuccesses        Number of successes in the sample
1809:      * @param   float       $sampleNumber           Size of the sample
1810:      * @param   float       $populationSuccesses    Number of successes in the population
1811:      * @param   float       $populationNumber       Population size
1812:      * @return  float
1813:      *
1814:      */
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: 
1839:     /**
1840:      * INTERCEPT
1841:      *
1842:      * Calculates the point at which a line will intersect the y-axis by using existing x-values and y-values.
1843:      *
1844:      * @param   array of mixed      Data Series Y
1845:      * @param   array of mixed      Data Series X
1846:      * @return  float
1847:      */
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: 
1866:     /**
1867:      * KURT
1868:      *
1869:      * Returns the kurtosis of a data set. Kurtosis characterizes the relative peakedness
1870:      * or flatness of a distribution compared with the normal distribution. Positive
1871:      * kurtosis indicates a relatively peaked distribution. Negative kurtosis indicates a
1872:      * relatively flat distribution.
1873:      *
1874:      * @param   array   Data Series
1875:      * @return  float
1876:      */
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: 
1906:     /**
1907:      * LARGE
1908:      *
1909:      * Returns the nth largest value in a data set. You can use this function to
1910:      *      select a value based on its relative standing.
1911:      *
1912:      * Excel Function:
1913:      *      LARGE(value1[,value2[, ...]],entry)
1914:      *
1915:      * @access  public
1916:      * @category Statistical Functions
1917:      * @param   mixed       $arg,...        Data values
1918:      * @param   int         $entry          Position (ordered from the largest) in the array or range of data to return
1919:      * @return  float
1920:      *
1921:      */
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: 
1948:     /**
1949:      * LINEST
1950:      *
1951:      * Calculates the statistics for a line by using the "least squares" method to calculate a straight line that best fits your data,
1952:      *      and then returns an array that describes the line.
1953:      *
1954:      * @param   array of mixed      Data Series Y
1955:      * @param   array of mixed      Data Series X
1956:      * @param   boolean             A logical value specifying whether to force the intersect to equal 0.
1957:      * @param   boolean             A logical value specifying whether to return additional regression statistics.
1958:      * @return  array
1959:      */
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: 
2001:     /**
2002:      * LOGEST
2003:      *
2004:      * Calculates an exponential curve that best fits the X and Y data series,
2005:      *      and then returns an array that describes the line.
2006:      *
2007:      * @param   array of mixed      Data Series Y
2008:      * @param   array of mixed      Data Series X
2009:      * @param   boolean             A logical value specifying whether to force the intersect to equal 0.
2010:      * @param   boolean             A logical value specifying whether to return additional regression statistics.
2011:      * @return  array
2012:      */
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: 
2060:     /**
2061:      * LOGINV
2062:      *
2063:      * Returns the inverse of the normal cumulative distribution
2064:      *
2065:      * @param   float       $probability
2066:      * @param   float       $mean
2067:      * @param   float       $stdDev
2068:      * @return  float
2069:      *
2070:      * @todo    Try implementing P J Acklam's refinement algorithm for greater
2071:      *          accuracy if I can get my head round the mathematics
2072:      *          (as described at) http://home.online.no/~pjacklam/notes/invnorm/
2073:      */
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: 
2089:     /**
2090:      * LOGNORMDIST
2091:      *
2092:      * Returns the cumulative lognormal distribution of x, where ln(x) is normally distributed
2093:      * with parameters mean and standard_dev.
2094:      *
2095:      * @param   float       $value
2096:      * @param   float       $mean
2097:      * @param   float       $stdDev
2098:      * @return  float
2099:      */
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: 
2115:     /**
2116:      * MAX
2117:      *
2118:      * MAX returns the value of the element of the values passed that has the highest value,
2119:      *      with negative numbers considered smaller than positive numbers.
2120:      *
2121:      * Excel Function:
2122:      *      MAX(value1[,value2[, ...]])
2123:      *
2124:      * @access  public
2125:      * @category Statistical Functions
2126:      * @param   mixed       $arg,...        Data values
2127:      * @return  float
2128:      */
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: 
2152:     /**
2153:      * MAXA
2154:      *
2155:      * Returns the greatest value in a list of arguments, including numbers, text, and logical values
2156:      *
2157:      * Excel Function:
2158:      *      MAXA(value1[,value2[, ...]])
2159:      *
2160:      * @access  public
2161:      * @category Statistical Functions
2162:      * @param   mixed       $arg,...        Data values
2163:      * @return  float
2164:      */
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: 
2193:     /**
2194:      * MAXIF
2195:      *
2196:      * Counts the maximum value within a range of cells that contain numbers within the list of arguments
2197:      *
2198:      * Excel Function:
2199:      *      MAXIF(value1[,value2[, ...]],condition)
2200:      *
2201:      * @access  public
2202:      * @category Mathematical and Trigonometric Functions
2203:      * @param   mixed       $arg,...        Data values
2204:      * @param   string      $condition      The criteria that defines which cells will be checked.
2205:      * @return  float
2206:      */
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: 
2233:     /**
2234:      * MEDIAN
2235:      *
2236:      * Returns the median of the given numbers. The median is the number in the middle of a set of numbers.
2237:      *
2238:      * Excel Function:
2239:      *      MEDIAN(value1[,value2[, ...]])
2240:      *
2241:      * @access  public
2242:      * @category Statistical Functions
2243:      * @param   mixed       $arg,...        Data values
2244:      * @return  float
2245:      */
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: 
2277:     /**
2278:      * MIN
2279:      *
2280:      * MIN returns the value of the element of the values passed that has the smallest value,
2281:      *      with negative numbers considered smaller than positive numbers.
2282:      *
2283:      * Excel Function:
2284:      *      MIN(value1[,value2[, ...]])
2285:      *
2286:      * @access  public
2287:      * @category Statistical Functions
2288:      * @param   mixed       $arg,...        Data values
2289:      * @return  float
2290:      */
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: 
2314:     /**
2315:      * MINA
2316:      *
2317:      * Returns the smallest value in a list of arguments, including numbers, text, and logical values
2318:      *
2319:      * Excel Function:
2320:      *      MINA(value1[,value2[, ...]])
2321:      *
2322:      * @access  public
2323:      * @category Statistical Functions
2324:      * @param   mixed       $arg,...        Data values
2325:      * @return  float
2326:      */
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: 
2355:     /**
2356:      * MINIF
2357:      *
2358:      * Returns the minimum value within a range of cells that contain numbers within the list of arguments
2359:      *
2360:      * Excel Function:
2361:      *      MINIF(value1[,value2[, ...]],condition)
2362:      *
2363:      * @access  public
2364:      * @category Mathematical and Trigonometric Functions
2365:      * @param   mixed       $arg,...        Data values
2366:      * @param   string      $condition      The criteria that defines which cells will be checked.
2367:      * @return  float
2368:      */
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: 
2429:     /**
2430:      * MODE
2431:      *
2432:      * Returns the most frequently occurring, or repetitive, value in an array or range of data
2433:      *
2434:      * Excel Function:
2435:      *      MODE(value1[,value2[, ...]])
2436:      *
2437:      * @access  public
2438:      * @category Statistical Functions
2439:      * @param   mixed       $arg,...        Data values
2440:      * @return  float
2441:      */
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: 
2466:     /**
2467:      * NEGBINOMDIST
2468:      *
2469:      * Returns the negative binomial distribution. NEGBINOMDIST returns the probability that
2470:      *      there will be number_f failures before the number_s-th success, when the constant
2471:      *      probability of a success is probability_s. This function is similar to the binomial
2472:      *      distribution, except that the number of successes is fixed, and the number of trials is
2473:      *      variable. Like the binomial, trials are assumed to be independent.
2474:      *
2475:      * @param   float       $failures       Number of Failures
2476:      * @param   float       $successes      Threshold number of Successes
2477:      * @param   float       $probability    Probability of success on each trial
2478:      * @return  float
2479:      *
2480:      */
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: 
2504:     /**
2505:      * NORMDIST
2506:      *
2507:      * Returns the normal distribution for the specified mean and standard deviation. This
2508:      * function has a very wide range of applications in statistics, including hypothesis
2509:      * testing.
2510:      *
2511:      * @param   float       $value
2512:      * @param   float       $mean       Mean Value
2513:      * @param   float       $stdDev     Standard Deviation
2514:      * @param   boolean     $cumulative
2515:      * @return  float
2516:      *
2517:      */
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: 
2539:     /**
2540:      * NORMINV
2541:      *
2542:      * Returns the inverse of the normal cumulative distribution for the specified mean and standard deviation.
2543:      *
2544:      * @param   float       $value
2545:      * @param   float       $mean       Mean Value
2546:      * @param   float       $stdDev     Standard Deviation
2547:      * @return  float
2548:      *
2549:      */
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: 
2568:     /**
2569:      * NORMSDIST
2570:      *
2571:      * Returns the standard normal cumulative distribution function. The distribution has
2572:      * a mean of 0 (zero) and a standard deviation of one. Use this function in place of a
2573:      * table of standard normal curve areas.
2574:      *
2575:      * @param   float       $value
2576:      * @return  float
2577:      */
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: 
2585:     /**
2586:      * NORMSINV
2587:      *
2588:      * Returns the inverse of the standard normal cumulative distribution
2589:      *
2590:      * @param   float       $value
2591:      * @return  float
2592:      */
2593:     public static function NORMSINV($value) {
2594:         return self::NORMINV($value, 0, 1);
2595:     }   //  function NORMSINV()
2596: 
2597: 
2598:     /**
2599:      * PERCENTILE
2600:      *
2601:      * Returns the nth percentile of values in a range..
2602:      *
2603:      * Excel Function:
2604:      *      PERCENTILE(value1[,value2[, ...]],entry)
2605:      *
2606:      * @access  public
2607:      * @category Statistical Functions
2608:      * @param   mixed       $arg,...        Data values
2609:      * @param   float       $entry          Percentile value in the range 0..1, inclusive.
2610:      * @return  float
2611:      */
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: 
2648:     /**
2649:      * PERCENTRANK
2650:      *
2651:      * Returns the rank of a value in a data set as a percentage of the data set.
2652:      *
2653:      * @param   array of number     An array of, or a reference to, a list of numbers.
2654:      * @param   number              The number whose rank you want to find.
2655:      * @param   number              The number of significant digits for the returned percentage value.
2656:      * @return  float
2657:      */
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: 
2694:     /**
2695:      * PERMUT
2696:      *
2697:      * Returns the number of permutations for a given number of objects that can be
2698:      *      selected from number objects. A permutation is any set or subset of objects or
2699:      *      events where internal order is significant. Permutations are different from
2700:      *      combinations, for which the internal order is not significant. Use this function
2701:      *      for lottery-style probability calculations.
2702:      *
2703:      * @param   int     $numObjs    Number of different objects
2704:      * @param   int     $numInSet   Number of objects in each permutation
2705:      * @return  int     Number of permutations
2706:      */
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: 
2722:     /**
2723:      * POISSON
2724:      *
2725:      * Returns the Poisson distribution. A common application of the Poisson distribution
2726:      * is predicting the number of events over a specific time, such as the number of
2727:      * cars arriving at a toll plaza in 1 minute.
2728:      *
2729:      * @param   float       $value
2730:      * @param   float       $mean       Mean Value
2731:      * @param   boolean     $cumulative
2732:      * @return  float
2733:      *
2734:      */
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: 
2759:     /**
2760:      * QUARTILE
2761:      *
2762:      * Returns the quartile of a data set.
2763:      *
2764:      * Excel Function:
2765:      *      QUARTILE(value1[,value2[, ...]],entry)
2766:      *
2767:      * @access  public
2768:      * @category Statistical Functions
2769:      * @param   mixed       $arg,...        Data values
2770:      * @param   int         $entry          Quartile value in the range 1..3, inclusive.
2771:      * @return  float
2772:      */
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: 
2790:     /**
2791:      * RANK
2792:      *
2793:      * Returns the rank of a number in a list of numbers.
2794:      *
2795:      * @param   number              The number whose rank you want to find.
2796:      * @param   array of number     An array of, or a reference to, a list of numbers.
2797:      * @param   mixed               Order to sort the values in the value set
2798:      * @return  float
2799:      */
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: 
2825:     /**
2826:      * RSQ
2827:      *
2828:      * Returns the square of the Pearson product moment correlation coefficient through data points in known_y's and known_x's.
2829:      *
2830:      * @param   array of mixed      Data Series Y
2831:      * @param   array of mixed      Data Series X
2832:      * @return  float
2833:      */
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: 
2852:     /**
2853:      * SKEW
2854:      *
2855:      * Returns the skewness of a distribution. Skewness characterizes the degree of asymmetry
2856:      * of a distribution around its mean. Positive skewness indicates a distribution with an
2857:      * asymmetric tail extending toward more positive values. Negative skewness indicates a
2858:      * distribution with an asymmetric tail extending toward more negative values.
2859:      *
2860:      * @param   array   Data Series
2861:      * @return  float
2862:      */
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: 
2890:     /**
2891:      * SLOPE
2892:      *
2893:      * Returns the slope of the linear regression line through data points in known_y's and known_x's.
2894:      *
2895:      * @param   array of mixed      Data Series Y
2896:      * @param   array of mixed      Data Series X
2897:      * @return  float
2898:      */
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: 
2917:     /**
2918:      * SMALL
2919:      *
2920:      * Returns the nth smallest value in a data set. You can use this function to
2921:      *      select a value based on its relative standing.
2922:      *
2923:      * Excel Function:
2924:      *      SMALL(value1[,value2[, ...]],entry)
2925:      *
2926:      * @access  public
2927:      * @category Statistical Functions
2928:      * @param   mixed       $arg,...        Data values
2929:      * @param   int         $entry          Position (ordered from the smallest) in the array or range of data to return
2930:      * @return  float
2931:      */
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: 
2958:     /**
2959:      * STANDARDIZE
2960:      *
2961:      * Returns a normalized value from a distribution characterized by mean and standard_dev.
2962:      *
2963:      * @param   float   $value      Value to normalize
2964:      * @param   float   $mean       Mean Value
2965:      * @param   float   $stdDev     Standard Deviation
2966:      * @return  float   Standardized value
2967:      */
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: 
2983:     /**
2984:      * STDEV
2985:      *
2986:      * Estimates standard deviation based on a sample. The standard deviation is a measure of how
2987:      *      widely values are dispersed from the average value (the mean).
2988:      *
2989:      * Excel Function:
2990:      *      STDEV(value1[,value2[, ...]])
2991:      *
2992:      * @access  public
2993:      * @category Statistical Functions
2994:      * @param   mixed       $arg,...        Data values
2995:      * @return  float
2996:      */
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: 
3031:     /**
3032:      * STDEVA
3033:      *
3034:      * Estimates standard deviation based on a sample, including numbers, text, and logical values
3035:      *
3036:      * Excel Function:
3037:      *      STDEVA(value1[,value2[, ...]])
3038:      *
3039:      * @access  public
3040:      * @category Statistical Functions
3041:      * @param   mixed       $arg,...        Data values
3042:      * @return  float
3043:      */
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: 
3083:     /**
3084:      * STDEVP
3085:      *
3086:      * Calculates standard deviation based on the entire population
3087:      *
3088:      * Excel Function:
3089:      *      STDEVP(value1[,value2[, ...]])
3090:      *
3091:      * @access  public
3092:      * @category Statistical Functions
3093:      * @param   mixed       $arg,...        Data values
3094:      * @return  float
3095:      */
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: 
3130:     /**
3131:      * STDEVPA
3132:      *
3133:      * Calculates standard deviation based on the entire population, including numbers, text, and logical values
3134:      *
3135:      * Excel Function:
3136:      *      STDEVPA(value1[,value2[, ...]])
3137:      *
3138:      * @access  public
3139:      * @category Statistical Functions
3140:      * @param   mixed       $arg,...        Data values
3141:      * @return  float
3142:      */
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: 
3182:     /**
3183:      * STEYX
3184:      *
3185:      * Returns the standard error of the predicted y-value for each x in the regression.
3186:      *
3187:      * @param   array of mixed      Data Series Y
3188:      * @param   array of mixed      Data Series X
3189:      * @return  float
3190:      */
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: 
3209:     /**
3210:      * TDIST
3211:      *
3212:      * Returns the probability of Student's T distribution.
3213:      *
3214:      * @param   float       $value          Value for the function
3215:      * @param   float       $degrees        degrees of freedom
3216:      * @param   float       $tails          number of tails (1 or 2)
3217:      * @return  float
3218:      */
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: 
3270:     /**
3271:      * TINV
3272:      *
3273:      * Returns the one-tailed probability of the chi-squared distribution.
3274:      *
3275:      * @param   float       $probability    Probability for the function
3276:      * @param   float       $degrees        degrees of freedom
3277:      * @return  float
3278:      */
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: 
3325:     /**
3326:      * TREND
3327:      *
3328:      * Returns values along a linear trend
3329:      *
3330:      * @param   array of mixed      Data Series Y
3331:      * @param   array of mixed      Data Series X
3332:      * @param   array of mixed      Values of X for which we want to find Y
3333:      * @param   boolean             A logical value specifying whether to force the intersect to equal 0.
3334:      * @return  array of float
3335:      */
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: 
3356:     /**
3357:      * TRIMMEAN
3358:      *
3359:      * Returns the mean of the interior of a data set. TRIMMEAN calculates the mean
3360:      *      taken by excluding a percentage of data points from the top and bottom tails
3361:      *      of a data set.
3362:      *
3363:      * Excel Function:
3364:      *      TRIMEAN(value1[,value2[, ...]],$discard)
3365:      *
3366:      * @access  public
3367:      * @category Statistical Functions
3368:      * @param   mixed       $arg,...        Data values
3369:      * @param   float       $discard        Percentage to discard
3370:      * @return  float
3371:      */
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: 
3401:     /**
3402:      * VARFunc
3403:      *
3404:      * Estimates variance based on a sample.
3405:      *
3406:      * Excel Function:
3407:      *      VAR(value1[,value2[, ...]])
3408:      *
3409:      * @access  public
3410:      * @category Statistical Functions
3411:      * @param   mixed       $arg,...        Data values
3412:      * @return  float
3413:      */
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: 
3443:     /**
3444:      * VARA
3445:      *
3446:      * Estimates variance based on a sample, including numbers, text, and logical values
3447:      *
3448:      * Excel Function:
3449:      *      VARA(value1[,value2[, ...]])
3450:      *
3451:      * @access  public
3452:      * @category Statistical Functions
3453:      * @param   mixed       $arg,...        Data values
3454:      * @return  float
3455:      */
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: 
3496:     /**
3497:      * VARP
3498:      *
3499:      * Calculates variance based on the entire population
3500:      *
3501:      * Excel Function:
3502:      *      VARP(value1[,value2[, ...]])
3503:      *
3504:      * @access  public
3505:      * @category Statistical Functions
3506:      * @param   mixed       $arg,...        Data values
3507:      * @return  float
3508:      */
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: 
3538:     /**
3539:      * VARPA
3540:      *
3541:      * Calculates variance based on the entire population, including numbers, text, and logical values
3542:      *
3543:      * Excel Function:
3544:      *      VARPA(value1[,value2[, ...]])
3545:      *
3546:      * @access  public
3547:      * @category Statistical Functions
3548:      * @param   mixed       $arg,...        Data values
3549:      * @return  float
3550:      */
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: 
3591:     /**
3592:      * WEIBULL
3593:      *
3594:      * Returns the Weibull distribution. Use this distribution in reliability
3595:      * analysis, such as calculating a device's mean time to failure.
3596:      *
3597:      * @param   float       $value
3598:      * @param   float       $alpha      Alpha Parameter
3599:      * @param   float       $beta       Beta Parameter
3600:      * @param   boolean     $cumulative
3601:      * @return  float
3602:      *
3603:      */
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: 
3625:     /**
3626:      * ZTEST
3627:      *
3628:      * Returns the Weibull distribution. Use this distribution in reliability
3629:      * analysis, such as calculating a device's mean time to failure.
3630:      *
3631:      * @param   float       $dataSet
3632:      * @param   float       $m0     Alpha Parameter
3633:      * @param   float       $sigma  Beta Parameter
3634:      * @param   boolean     $cumulative
3635:      * @return  float
3636:      *
3637:      */
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
3652: