$value) { if ((is_bool($value)) || (is_string($value)) || (is_null($value))) { unset($array1[$key]); unset($array2[$key]); } } foreach ($array2 as $key => $value) { if ((is_bool($value)) || (is_string($value)) || (is_null($value))) { unset($array1[$key]); unset($array2[$key]); } } $array1 = array_merge($array1); $array2 = array_merge($array2); return true; } /** * Beta function. * * @author Jaco van Kooten * * @param p require p>0 * @param q require q>0 * @return 0 if p<=0, q<=0 or p+q>2.55E305 to avoid errors and over/underflow */ private static function beta($p, $q) { if ($p <= 0.0 || $q <= 0.0 || ($p + $q) > LOG_GAMMA_X_MAX_VALUE) { return 0.0; } else { return exp(self::logBeta($p, $q)); } } /** * Incomplete beta function * * @author Jaco van Kooten * @author Paul Meagher * * The computation is based on formulas from Numerical Recipes, Chapter 6.4 (W.H. Press et al, 1992). * @param x require 0<=x<=1 * @param p require p>0 * @param q require q>0 * @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 */ private static function incompleteBeta($x, $p, $q) { if ($x <= 0.0) { return 0.0; } elseif ($x >= 1.0) { return 1.0; } elseif (($p <= 0.0) || ($q <= 0.0) || (($p + $q) > LOG_GAMMA_X_MAX_VALUE)) { return 0.0; } $beta_gam = exp((0 - self::logBeta($p, $q)) + $p * log($x) + $q * log(1.0 - $x)); if ($x < ($p + 1.0) / ($p + $q + 2.0)) { return $beta_gam * self::betaFraction($x, $p, $q) / $p; } else { return 1.0 - ($beta_gam * self::betaFraction(1 - $x, $q, $p) / $q); } } // Function cache for logBeta function private static $logBetaCacheP = 0.0; private static $logBetaCacheQ = 0.0; private static $logBetaCacheResult = 0.0; /** * The natural logarithm of the beta function. * * @param p require p>0 * @param q require q>0 * @return 0 if p<=0, q<=0 or p+q>2.55E305 to avoid errors and over/underflow * @author Jaco van Kooten */ private static function logBeta($p, $q) { if ($p != self::$logBetaCacheP || $q != self::$logBetaCacheQ) { self::$logBetaCacheP = $p; self::$logBetaCacheQ = $q; if (($p <= 0.0) || ($q <= 0.0) || (($p + $q) > LOG_GAMMA_X_MAX_VALUE)) { self::$logBetaCacheResult = 0.0; } else { self::$logBetaCacheResult = self::logGamma($p) + self::logGamma($q) - self::logGamma($p + $q); } } return self::$logBetaCacheResult; } /** * Evaluates of continued fraction part of incomplete beta function. * Based on an idea from Numerical Recipes (W.H. Press et al, 1992). * @author Jaco van Kooten */ private static function betaFraction($x, $p, $q) { $c = 1.0; $sum_pq = $p + $q; $p_plus = $p + 1.0; $p_minus = $p - 1.0; $h = 1.0 - $sum_pq * $x / $p_plus; if (abs($h) < XMININ) { $h = XMININ; } $h = 1.0 / $h; $frac = $h; $m = 1; $delta = 0.0; while ($m <= MAX_ITERATIONS && abs($delta-1.0) > PRECISION) { $m2 = 2 * $m; // even index for d $d = $m * ($q - $m) * $x / ( ($p_minus + $m2) * ($p + $m2)); $h = 1.0 + $d * $h; if (abs($h) < XMININ) { $h = XMININ; } $h = 1.0 / $h; $c = 1.0 + $d / $c; if (abs($c) < XMININ) { $c = XMININ; } $frac *= $h * $c; // odd index for d $d = -($p + $m) * ($sum_pq + $m) * $x / (($p + $m2) * ($p_plus + $m2)); $h = 1.0 + $d * $h; if (abs($h) < XMININ) { $h = XMININ; } $h = 1.0 / $h; $c = 1.0 + $d / $c; if (abs($c) < XMININ) { $c = XMININ; } $delta = $h * $c; $frac *= $delta; ++$m; } return $frac; } /** * logGamma function * * @version 1.1 * @author Jaco van Kooten * * Original author was Jaco van Kooten. Ported to PHP by Paul Meagher. * * The natural logarithm of the gamma function.
* Based on public domain NETLIB (Fortran) code by W. J. Cody and L. Stoltz
* Applied Mathematics Division
* Argonne National Laboratory
* Argonne, IL 60439
*

* References: *

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

*

* From the original documentation: *

*

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

*

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

* @return MAX_VALUE for x < 0.0 or when overflow would occur, i.e. x > 2.55E305 */ // Function cache for logGamma private static $logGammaCacheResult = 0.0; private static $logGammaCacheX = 0.0; private static function logGamma($x) { // Log Gamma related constants static $lg_d1 = -0.5772156649015328605195174; static $lg_d2 = 0.4227843350984671393993777; static $lg_d4 = 1.791759469228055000094023; static $lg_p1 = array( 4.945235359296727046734888, 201.8112620856775083915565, 2290.838373831346393026739, 11319.67205903380828685045, 28557.24635671635335736389, 38484.96228443793359990269, 26377.48787624195437963534, 7225.813979700288197698961 ); static $lg_p2 = array( 4.974607845568932035012064, 542.4138599891070494101986, 15506.93864978364947665077, 184793.2904445632425417223, 1088204.76946882876749847, 3338152.967987029735917223, 5106661.678927352456275255, 3074109.054850539556250927 ); static $lg_p4 = array( 14745.02166059939948905062, 2426813.369486704502836312, 121475557.4045093227939592, 2663432449.630976949898078, 29403789566.34553899906876, 170266573776.5398868392998, 492612579337.743088758812, 560625185622.3951465078242 ); static $lg_q1 = array( 67.48212550303777196073036, 1113.332393857199323513008, 7738.757056935398733233834, 27639.87074403340708898585, 54993.10206226157329794414, 61611.22180066002127833352, 36351.27591501940507276287, 8785.536302431013170870835 ); static $lg_q2 = array( 183.0328399370592604055942, 7765.049321445005871323047, 133190.3827966074194402448, 1136705.821321969608938755, 5267964.117437946917577538, 13467014.54311101692290052, 17827365.30353274213975932, 9533095.591844353613395747 ); static $lg_q4 = array( 2690.530175870899333379843, 639388.5654300092398984238, 41355999.30241388052042842, 1120872109.61614794137657, 14886137286.78813811542398, 101680358627.2438228077304, 341747634550.7377132798597, 446315818741.9713286462081 ); static $lg_c = array( -0.001910444077728, 8.4171387781295e-4, -5.952379913043012e-4, 7.93650793500350248e-4, -0.002777777777777681622553, 0.08333333333333333331554247, 0.0057083835261 ); // Rough estimate of the fourth root of logGamma_xBig static $lg_frtbig = 2.25e76; static $pnt68 = 0.6796875; if ($x == self::$logGammaCacheX) { return self::$logGammaCacheResult; } $y = $x; if ($y > 0.0 && $y <= LOG_GAMMA_X_MAX_VALUE) { if ($y <= EPS) { $res = -log(y); } elseif ($y <= 1.5) { // --------------------- // EPS .LT. X .LE. 1.5 // --------------------- if ($y < $pnt68) { $corr = -log($y); $xm1 = $y; } else { $corr = 0.0; $xm1 = $y - 1.0; } if ($y <= 0.5 || $y >= $pnt68) { $xden = 1.0; $xnum = 0.0; for ($i = 0; $i < 8; ++$i) { $xnum = $xnum * $xm1 + $lg_p1[$i]; $xden = $xden * $xm1 + $lg_q1[$i]; } $res = $corr + $xm1 * ($lg_d1 + $xm1 * ($xnum / $xden)); } else { $xm2 = $y - 1.0; $xden = 1.0; $xnum = 0.0; for ($i = 0; $i < 8; ++$i) { $xnum = $xnum * $xm2 + $lg_p2[$i]; $xden = $xden * $xm2 + $lg_q2[$i]; } $res = $corr + $xm2 * ($lg_d2 + $xm2 * ($xnum / $xden)); } } elseif ($y <= 4.0) { // --------------------- // 1.5 .LT. X .LE. 4.0 // --------------------- $xm2 = $y - 2.0; $xden = 1.0; $xnum = 0.0; for ($i = 0; $i < 8; ++$i) { $xnum = $xnum * $xm2 + $lg_p2[$i]; $xden = $xden * $xm2 + $lg_q2[$i]; } $res = $xm2 * ($lg_d2 + $xm2 * ($xnum / $xden)); } elseif ($y <= 12.0) { // ---------------------- // 4.0 .LT. X .LE. 12.0 // ---------------------- $xm4 = $y - 4.0; $xden = -1.0; $xnum = 0.0; for ($i = 0; $i < 8; ++$i) { $xnum = $xnum * $xm4 + $lg_p4[$i]; $xden = $xden * $xm4 + $lg_q4[$i]; } $res = $lg_d4 + $xm4 * ($xnum / $xden); } else { // --------------------------------- // Evaluate for argument .GE. 12.0 // --------------------------------- $res = 0.0; if ($y <= $lg_frtbig) { $res = $lg_c[6]; $ysq = $y * $y; for ($i = 0; $i < 6; ++$i) { $res = $res / $ysq + $lg_c[$i]; } $res /= $y; $corr = log($y); $res = $res + log(SQRT2PI) - 0.5 * $corr; $res += $y * ($corr - 1.0); } } } else { // -------------------------- // Return for bad arguments // -------------------------- $res = MAX_VALUE; } // ------------------------------ // Final adjustments and return // ------------------------------ self::$logGammaCacheX = $x; self::$logGammaCacheResult = $res; return $res; } // // Private implementation of the incomplete Gamma function // private static function incompleteGamma($a, $x) { static $max = 32; $summer = 0; for ($n=0; $n<=$max; ++$n) { $divisor = $a; for ($i=1; $i<=$n; ++$i) { $divisor *= ($a + $i); } $summer += (pow($x, $n) / $divisor); } return pow($x, $a) * exp(0-$x) * $summer; } // // Private implementation of the Gamma function // private static function gamma($data) { if ($data == 0.0) { return 0; } static $p0 = 1.000000000190015; static $p = array( 1 => 76.18009172947146, 2 => -86.50532032941677, 3 => 24.01409824083091, 4 => -1.231739572450155, 5 => 1.208650973866179e-3, 6 => -5.395239384953e-6 ); $y = $x = $data; $tmp = $x + 5.5; $tmp -= ($x + 0.5) * log($tmp); $summer = $p0; for ($j=1; $j<=6; ++$j) { $summer += ($p[$j] / ++$y); } return exp(0 - $tmp + log(SQRT2PI * $summer / $x)); } /*************************************************************************** * inverse_ncdf.php * ------------------- * begin : Friday, January 16, 2004 * copyright : (C) 2004 Michael Nickerson * email : nickersonm@yahoo.com * ***************************************************************************/ private static function inverseNcdf($p) { // Inverse ncdf approximation by Peter J. Acklam, implementation adapted to // PHP by Michael Nickerson, using Dr. Thomas Ziegler's C implementation as // a guide. http://home.online.no/~pjacklam/notes/invnorm/index.html // I have not checked the accuracy of this implementation. Be aware that PHP // will truncate the coeficcients to 14 digits. // You have permission to use and distribute this function freely for // whatever purpose you want, but please show common courtesy and give credit // where credit is due. // Input paramater is $p - probability - where 0 < p < 1. // Coefficients in rational approximations static $a = array( 1 => -3.969683028665376e+01, 2 => 2.209460984245205e+02, 3 => -2.759285104469687e+02, 4 => 1.383577518672690e+02, 5 => -3.066479806614716e+01, 6 => 2.506628277459239e+00 ); static $b = array( 1 => -5.447609879822406e+01, 2 => 1.615858368580409e+02, 3 => -1.556989798598866e+02, 4 => 6.680131188771972e+01, 5 => -1.328068155288572e+01 ); static $c = array( 1 => -7.784894002430293e-03, 2 => -3.223964580411365e-01, 3 => -2.400758277161838e+00, 4 => -2.549732539343734e+00, 5 => 4.374664141464968e+00, 6 => 2.938163982698783e+00 ); static $d = array( 1 => 7.784695709041462e-03, 2 => 3.224671290700398e-01, 3 => 2.445134137142996e+00, 4 => 3.754408661907416e+00 ); // Define lower and upper region break-points. $p_low = 0.02425; //Use lower region approx. below this $p_high = 1 - $p_low; //Use upper region approx. above this if (0 < $p && $p < $p_low) { // Rational approximation for lower region. $q = sqrt(-2 * log($p)); return ((((($c[1] * $q + $c[2]) * $q + $c[3]) * $q + $c[4]) * $q + $c[5]) * $q + $c[6]) / (((($d[1] * $q + $d[2]) * $q + $d[3]) * $q + $d[4]) * $q + 1); } elseif ($p_low <= $p && $p <= $p_high) { // Rational approximation for central region. $q = $p - 0.5; $r = $q * $q; return ((((($a[1] * $r + $a[2]) * $r + $a[3]) * $r + $a[4]) * $r + $a[5]) * $r + $a[6]) * $q / ((((($b[1] * $r + $b[2]) * $r + $b[3]) * $r + $b[4]) * $r + $b[5]) * $r + 1); } elseif ($p_high < $p && $p < 1) { // Rational approximation for upper region. $q = sqrt(-2 * log(1 - $p)); return -((((($c[1] * $q + $c[2]) * $q + $c[3]) * $q + $c[4]) * $q + $c[5]) * $q + $c[6]) / (((($d[1] * $q + $d[2]) * $q + $d[3]) * $q + $d[4]) * $q + 1); } // If 0 < p < 1, return a null value return PHPExcel_Calculation_Functions::NULL(); } private static function inverseNcdf2($prob) { // Approximation of inverse standard normal CDF developed by // B. Moro, "The Full Monte," Risk 8(2), Feb 1995, 57-58. $a1 = 2.50662823884; $a2 = -18.61500062529; $a3 = 41.39119773534; $a4 = -25.44106049637; $b1 = -8.4735109309; $b2 = 23.08336743743; $b3 = -21.06224101826; $b4 = 3.13082909833; $c1 = 0.337475482272615; $c2 = 0.976169019091719; $c3 = 0.160797971491821; $c4 = 2.76438810333863E-02; $c5 = 3.8405729373609E-03; $c6 = 3.951896511919E-04; $c7 = 3.21767881768E-05; $c8 = 2.888167364E-07; $c9 = 3.960315187E-07; $y = $prob - 0.5; if (abs($y) < 0.42) { $z = ($y * $y); $z = $y * ((($a4 * $z + $a3) * $z + $a2) * $z + $a1) / (((($b4 * $z + $b3) * $z + $b2) * $z + $b1) * $z + 1); } else { if ($y > 0) { $z = log(-log(1 - $prob)); } else { $z = log(-log($prob)); } $z = $c1 + $z * ($c2 + $z * ($c3 + $z * ($c4 + $z * ($c5 + $z * ($c6 + $z * ($c7 + $z * ($c8 + $z * $c9))))))); if ($y < 0) { $z = -$z; } } return $z; } // function inverseNcdf2() private static function inverseNcdf3($p) { // ALGORITHM AS241 APPL. STATIST. (1988) VOL. 37, NO. 3. // Produces the normal deviate Z corresponding to a given lower // tail area of P; Z is accurate to about 1 part in 10**16. // // This is a PHP version of the original FORTRAN code that can // be found at http://lib.stat.cmu.edu/apstat/ $split1 = 0.425; $split2 = 5; $const1 = 0.180625; $const2 = 1.6; // coefficients for p close to 0.5 $a0 = 3.3871328727963666080; $a1 = 1.3314166789178437745E+2; $a2 = 1.9715909503065514427E+3; $a3 = 1.3731693765509461125E+4; $a4 = 4.5921953931549871457E+4; $a5 = 6.7265770927008700853E+4; $a6 = 3.3430575583588128105E+4; $a7 = 2.5090809287301226727E+3; $b1 = 4.2313330701600911252E+1; $b2 = 6.8718700749205790830E+2; $b3 = 5.3941960214247511077E+3; $b4 = 2.1213794301586595867E+4; $b5 = 3.9307895800092710610E+4; $b6 = 2.8729085735721942674E+4; $b7 = 5.2264952788528545610E+3; // coefficients for p not close to 0, 0.5 or 1. $c0 = 1.42343711074968357734; $c1 = 4.63033784615654529590; $c2 = 5.76949722146069140550; $c3 = 3.64784832476320460504; $c4 = 1.27045825245236838258; $c5 = 2.41780725177450611770E-1; $c6 = 2.27238449892691845833E-2; $c7 = 7.74545014278341407640E-4; $d1 = 2.05319162663775882187; $d2 = 1.67638483018380384940; $d3 = 6.89767334985100004550E-1; $d4 = 1.48103976427480074590E-1; $d5 = 1.51986665636164571966E-2; $d6 = 5.47593808499534494600E-4; $d7 = 1.05075007164441684324E-9; // coefficients for p near 0 or 1. $e0 = 6.65790464350110377720; $e1 = 5.46378491116411436990; $e2 = 1.78482653991729133580; $e3 = 2.96560571828504891230E-1; $e4 = 2.65321895265761230930E-2; $e5 = 1.24266094738807843860E-3; $e6 = 2.71155556874348757815E-5; $e7 = 2.01033439929228813265E-7; $f1 = 5.99832206555887937690E-1; $f2 = 1.36929880922735805310E-1; $f3 = 1.48753612908506148525E-2; $f4 = 7.86869131145613259100E-4; $f5 = 1.84631831751005468180E-5; $f6 = 1.42151175831644588870E-7; $f7 = 2.04426310338993978564E-15; $q = $p - 0.5; // computation for p close to 0.5 if (abs($q) <= split1) { $R = $const1 - $q * $q; $z = $q * ((((((($a7 * $R + $a6) * $R + $a5) * $R + $a4) * $R + $a3) * $R + $a2) * $R + $a1) * $R + $a0) / ((((((($b7 * $R + $b6) * $R + $b5) * $R + $b4) * $R + $b3) * $R + $b2) * $R + $b1) * $R + 1); } else { if ($q < 0) { $R = $p; } else { $R = 1 - $p; } $R = pow(-log($R), 2); // computation for p not close to 0, 0.5 or 1. if ($R <= $split2) { $R = $R - $const2; $z = ((((((($c7 * $R + $c6) * $R + $c5) * $R + $c4) * $R + $c3) * $R + $c2) * $R + $c1) * $R + $c0) / ((((((($d7 * $R + $d6) * $R + $d5) * $R + $d4) * $R + $d3) * $R + $d2) * $R + $d1) * $R + 1); } else { // computation for p near 0 or 1. $R = $R - $split2; $z = ((((((($e7 * $R + $e6) * $R + $e5) * $R + $e4) * $R + $e3) * $R + $e2) * $R + $e1) * $R + $e0) / ((((((($f7 * $R + $f6) * $R + $f5) * $R + $f4) * $R + $f3) * $R + $f2) * $R + $f1) * $R + 1); } if ($q < 0) { $z = -$z; } } return $z; } /** * AVEDEV * * Returns the average of the absolute deviations of data points from their mean. * AVEDEV is a measure of the variability in a data set. * * Excel Function: * AVEDEV(value1[,value2[, ...]]) * * @access public * @category Statistical Functions * @param mixed $arg,... Data values * @return float */ public static function AVEDEV() { $aArgs = PHPExcel_Calculation_Functions::flattenArrayIndexed(func_get_args()); // Return value $returnValue = null; $aMean = self::AVERAGE($aArgs); if ($aMean != PHPExcel_Calculation_Functions::DIV0()) { $aCount = 0; foreach ($aArgs as $k => $arg) { if ((is_bool($arg)) && ((!PHPExcel_Calculation_Functions::isCellValue($k)) || (PHPExcel_Calculation_Functions::getCompatibilityMode() == PHPExcel_Calculation_Functions::COMPATIBILITY_OPENOFFICE))) { $arg = (integer) $arg; } // Is it a numeric value? if ((is_numeric($arg)) && (!is_string($arg))) { if (is_null($returnValue)) { $returnValue = abs($arg - $aMean); } else { $returnValue += abs($arg - $aMean); } ++$aCount; } } // Return if ($aCount == 0) { return PHPExcel_Calculation_Functions::DIV0(); } return $returnValue / $aCount; } return PHPExcel_Calculation_Functions::NaN(); } /** * AVERAGE * * Returns the average (arithmetic mean) of the arguments * * Excel Function: * AVERAGE(value1[,value2[, ...]]) * * @access public * @category Statistical Functions * @param mixed $arg,... Data values * @return float */ public static function AVERAGE() { $returnValue = $aCount = 0; // Loop through arguments foreach (PHPExcel_Calculation_Functions::flattenArrayIndexed(func_get_args()) as $k => $arg) { if ((is_bool($arg)) && ((!PHPExcel_Calculation_Functions::isCellValue($k)) || (PHPExcel_Calculation_Functions::getCompatibilityMode() == PHPExcel_Calculation_Functions::COMPATIBILITY_OPENOFFICE))) { $arg = (integer) $arg; } // Is it a numeric value? if ((is_numeric($arg)) && (!is_string($arg))) { if (is_null($returnValue)) { $returnValue = $arg; } else { $returnValue += $arg; } ++$aCount; } } // Return if ($aCount > 0) { return $returnValue / $aCount; } else { return PHPExcel_Calculation_Functions::DIV0(); } } /** * AVERAGEA * * Returns the average of its arguments, including numbers, text, and logical values * * Excel Function: * AVERAGEA(value1[,value2[, ...]]) * * @access public * @category Statistical Functions * @param mixed $arg,... Data values * @return float */ public static function AVERAGEA() { $returnValue = null; $aCount = 0; // Loop through arguments foreach (PHPExcel_Calculation_Functions::flattenArrayIndexed(func_get_args()) as $k => $arg) { if ((is_bool($arg)) && (!PHPExcel_Calculation_Functions::isMatrixValue($k))) { } else { if ((is_numeric($arg)) || (is_bool($arg)) || ((is_string($arg) && ($arg != '')))) { if (is_bool($arg)) { $arg = (integer) $arg; } elseif (is_string($arg)) { $arg = 0; } if (is_null($returnValue)) { $returnValue = $arg; } else { $returnValue += $arg; } ++$aCount; } } } if ($aCount > 0) { return $returnValue / $aCount; } else { return PHPExcel_Calculation_Functions::DIV0(); } } /** * AVERAGEIF * * Returns the average value from a range of cells that contain numbers within the list of arguments * * Excel Function: * AVERAGEIF(value1[,value2[, ...]],condition) * * @access public * @category Mathematical and Trigonometric Functions * @param mixed $arg,... Data values * @param string $condition The criteria that defines which cells will be checked. * @param mixed[] $averageArgs Data values * @return float */ public static function AVERAGEIF($aArgs, $condition, $averageArgs = array()) { $returnValue = 0; $aArgs = PHPExcel_Calculation_Functions::flattenArray($aArgs); $averageArgs = PHPExcel_Calculation_Functions::flattenArray($averageArgs); if (empty($averageArgs)) { $averageArgs = $aArgs; } $condition = PHPExcel_Calculation_Functions::ifCondition($condition); // Loop through arguments $aCount = 0; foreach ($aArgs as $key => $arg) { if (!is_numeric($arg)) { $arg = PHPExcel_Calculation::wrapResult(strtoupper($arg)); } $testCondition = '='.$arg.$condition; if (PHPExcel_Calculation::getInstance()->_calculateFormulaValue($testCondition)) { if ((is_null($returnValue)) || ($arg > $returnValue)) { $returnValue += $arg; ++$aCount; } } } if ($aCount > 0) { return $returnValue / $aCount; } return PHPExcel_Calculation_Functions::DIV0(); } /** * BETADIST * * Returns the beta distribution. * * @param float $value Value at which you want to evaluate the distribution * @param float $alpha Parameter to the distribution * @param float $beta Parameter to the distribution * @param boolean $cumulative * @return float * */ public static function BETADIST($value, $alpha, $beta, $rMin = 0, $rMax = 1) { $value = PHPExcel_Calculation_Functions::flattenSingleValue($value); $alpha = PHPExcel_Calculation_Functions::flattenSingleValue($alpha); $beta = PHPExcel_Calculation_Functions::flattenSingleValue($beta); $rMin = PHPExcel_Calculation_Functions::flattenSingleValue($rMin); $rMax = PHPExcel_Calculation_Functions::flattenSingleValue($rMax); if ((is_numeric($value)) && (is_numeric($alpha)) && (is_numeric($beta)) && (is_numeric($rMin)) && (is_numeric($rMax))) { if (($value < $rMin) || ($value > $rMax) || ($alpha <= 0) || ($beta <= 0) || ($rMin == $rMax)) { return PHPExcel_Calculation_Functions::NaN(); } if ($rMin > $rMax) { $tmp = $rMin; $rMin = $rMax; $rMax = $tmp; } $value -= $rMin; $value /= ($rMax - $rMin); return self::incompleteBeta($value, $alpha, $beta); } return PHPExcel_Calculation_Functions::VALUE(); } /** * BETAINV * * Returns the inverse of the beta distribution. * * @param float $probability Probability at which you want to evaluate the distribution * @param float $alpha Parameter to the distribution * @param float $beta Parameter to the distribution * @param float $rMin Minimum value * @param float $rMax Maximum value * @param boolean $cumulative * @return float * */ public static function BETAINV($probability, $alpha, $beta, $rMin = 0, $rMax = 1) { $probability = PHPExcel_Calculation_Functions::flattenSingleValue($probability); $alpha = PHPExcel_Calculation_Functions::flattenSingleValue($alpha); $beta = PHPExcel_Calculation_Functions::flattenSingleValue($beta); $rMin = PHPExcel_Calculation_Functions::flattenSingleValue($rMin); $rMax = PHPExcel_Calculation_Functions::flattenSingleValue($rMax); if ((is_numeric($probability)) && (is_numeric($alpha)) && (is_numeric($beta)) && (is_numeric($rMin)) && (is_numeric($rMax))) { if (($alpha <= 0) || ($beta <= 0) || ($rMin == $rMax) || ($probability <= 0) || ($probability > 1)) { return PHPExcel_Calculation_Functions::NaN(); } if ($rMin > $rMax) { $tmp = $rMin; $rMin = $rMax; $rMax = $tmp; } $a = 0; $b = 2; $i = 0; while ((($b - $a) > PRECISION) && ($i++ < MAX_ITERATIONS)) { $guess = ($a + $b) / 2; $result = self::BETADIST($guess, $alpha, $beta); if (($result == $probability) || ($result == 0)) { $b = $a; } elseif ($result > $probability) { $b = $guess; } else { $a = $guess; } } if ($i == MAX_ITERATIONS) { return PHPExcel_Calculation_Functions::NA(); } return round($rMin + $guess * ($rMax - $rMin), 12); } return PHPExcel_Calculation_Functions::VALUE(); } /** * BINOMDIST * * Returns the individual term binomial distribution probability. Use BINOMDIST in problems with * a fixed number of tests or trials, when the outcomes of any trial are only success or failure, * when trials are independent, and when the probability of success is constant throughout the * experiment. For example, BINOMDIST can calculate the probability that two of the next three * babies born are male. * * @param float $value Number of successes in trials * @param float $trials Number of trials * @param float $probability Probability of success on each trial * @param boolean $cumulative * @return float * * @todo Cumulative distribution function * */ public static function BINOMDIST($value, $trials, $probability, $cumulative) { $value = floor(PHPExcel_Calculation_Functions::flattenSingleValue($value)); $trials = floor(PHPExcel_Calculation_Functions::flattenSingleValue($trials)); $probability = PHPExcel_Calculation_Functions::flattenSingleValue($probability); if ((is_numeric($value)) && (is_numeric($trials)) && (is_numeric($probability))) { if (($value < 0) || ($value > $trials)) { return PHPExcel_Calculation_Functions::NaN(); } if (($probability < 0) || ($probability > 1)) { return PHPExcel_Calculation_Functions::NaN(); } if ((is_numeric($cumulative)) || (is_bool($cumulative))) { if ($cumulative) { $summer = 0; for ($i = 0; $i <= $value; ++$i) { $summer += PHPExcel_Calculation_MathTrig::COMBIN($trials, $i) * pow($probability, $i) * pow(1 - $probability, $trials - $i); } return $summer; } else { return PHPExcel_Calculation_MathTrig::COMBIN($trials, $value) * pow($probability, $value) * pow(1 - $probability, $trials - $value) ; } } } return PHPExcel_Calculation_Functions::VALUE(); } /** * CHIDIST * * Returns the one-tailed probability of the chi-squared distribution. * * @param float $value Value for the function * @param float $degrees degrees of freedom * @return float */ public static function CHIDIST($value, $degrees) { $value = PHPExcel_Calculation_Functions::flattenSingleValue($value); $degrees = floor(PHPExcel_Calculation_Functions::flattenSingleValue($degrees)); if ((is_numeric($value)) && (is_numeric($degrees))) { if ($degrees < 1) { return PHPExcel_Calculation_Functions::NaN(); } if ($value < 0) { if (PHPExcel_Calculation_Functions::getCompatibilityMode() == PHPExcel_Calculation_Functions::COMPATIBILITY_GNUMERIC) { return 1; } return PHPExcel_Calculation_Functions::NaN(); } return 1 - (self::incompleteGamma($degrees/2, $value/2) / self::gamma($degrees/2)); } return PHPExcel_Calculation_Functions::VALUE(); } /** * CHIINV * * Returns the one-tailed probability of the chi-squared distribution. * * @param float $probability Probability for the function * @param float $degrees degrees of freedom * @return float */ public static function CHIINV($probability, $degrees) { $probability = PHPExcel_Calculation_Functions::flattenSingleValue($probability); $degrees = floor(PHPExcel_Calculation_Functions::flattenSingleValue($degrees)); if ((is_numeric($probability)) && (is_numeric($degrees))) { $xLo = 100; $xHi = 0; $x = $xNew = 1; $dx = 1; $i = 0; while ((abs($dx) > PRECISION) && ($i++ < MAX_ITERATIONS)) { // Apply Newton-Raphson step $result = self::CHIDIST($x, $degrees); $error = $result - $probability; if ($error == 0.0) { $dx = 0; } elseif ($error < 0.0) { $xLo = $x; } else { $xHi = $x; } // Avoid division by zero if ($result != 0.0) { $dx = $error / $result; $xNew = $x - $dx; } // If the NR fails to converge (which for example may be the // case if the initial guess is too rough) we apply a bisection // step to determine a more narrow interval around the root. if (($xNew < $xLo) || ($xNew > $xHi) || ($result == 0.0)) { $xNew = ($xLo + $xHi) / 2; $dx = $xNew - $x; } $x = $xNew; } if ($i == MAX_ITERATIONS) { return PHPExcel_Calculation_Functions::NA(); } return round($x, 12); } return PHPExcel_Calculation_Functions::VALUE(); } /** * CONFIDENCE * * Returns the confidence interval for a population mean * * @param float $alpha * @param float $stdDev Standard Deviation * @param float $size * @return float * */ public static function CONFIDENCE($alpha, $stdDev, $size) { $alpha = PHPExcel_Calculation_Functions::flattenSingleValue($alpha); $stdDev = PHPExcel_Calculation_Functions::flattenSingleValue($stdDev); $size = floor(PHPExcel_Calculation_Functions::flattenSingleValue($size)); if ((is_numeric($alpha)) && (is_numeric($stdDev)) && (is_numeric($size))) { if (($alpha <= 0) || ($alpha >= 1)) { return PHPExcel_Calculation_Functions::NaN(); } if (($stdDev <= 0) || ($size < 1)) { return PHPExcel_Calculation_Functions::NaN(); } return self::NORMSINV(1 - $alpha / 2) * $stdDev / sqrt($size); } return PHPExcel_Calculation_Functions::VALUE(); } /** * CORREL * * Returns covariance, the average of the products of deviations for each data point pair. * * @param array of mixed Data Series Y * @param array of mixed Data Series X * @return float */ public static function CORREL($yValues, $xValues = null) { if ((is_null($xValues)) || (!is_array($yValues)) || (!is_array($xValues))) { return PHPExcel_Calculation_Functions::VALUE(); } if (!self::checkTrendArrays($yValues, $xValues)) { return PHPExcel_Calculation_Functions::VALUE(); } $yValueCount = count($yValues); $xValueCount = count($xValues); if (($yValueCount == 0) || ($yValueCount != $xValueCount)) { return PHPExcel_Calculation_Functions::NA(); } elseif ($yValueCount == 1) { return PHPExcel_Calculation_Functions::DIV0(); } $bestFitLinear = trendClass::calculate(trendClass::TREND_LINEAR, $yValues, $xValues); return $bestFitLinear->getCorrelation(); } /** * COUNT * * Counts the number of cells that contain numbers within the list of arguments * * Excel Function: * COUNT(value1[,value2[, ...]]) * * @access public * @category Statistical Functions * @param mixed $arg,... Data values * @return int */ public static function COUNT() { $returnValue = 0; // Loop through arguments $aArgs = PHPExcel_Calculation_Functions::flattenArrayIndexed(func_get_args()); foreach ($aArgs as $k => $arg) { if ((is_bool($arg)) && ((!PHPExcel_Calculation_Functions::isCellValue($k)) || (PHPExcel_Calculation_Functions::getCompatibilityMode() == PHPExcel_Calculation_Functions::COMPATIBILITY_OPENOFFICE))) { $arg = (integer) $arg; } // Is it a numeric value? if ((is_numeric($arg)) && (!is_string($arg))) { ++$returnValue; } } return $returnValue; } /** * COUNTA * * Counts the number of cells that are not empty within the list of arguments * * Excel Function: * COUNTA(value1[,value2[, ...]]) * * @access public * @category Statistical Functions * @param mixed $arg,... Data values * @return int */ public static function COUNTA() { $returnValue = 0; // Loop through arguments $aArgs = PHPExcel_Calculation_Functions::flattenArray(func_get_args()); foreach ($aArgs as $arg) { // Is it a numeric, boolean or string value? if ((is_numeric($arg)) || (is_bool($arg)) || ((is_string($arg) && ($arg != '')))) { ++$returnValue; } } return $returnValue; } /** * COUNTBLANK * * Counts the number of empty cells within the list of arguments * * Excel Function: * COUNTBLANK(value1[,value2[, ...]]) * * @access public * @category Statistical Functions * @param mixed $arg,... Data values * @return int */ public static function COUNTBLANK() { $returnValue = 0; // Loop through arguments $aArgs = PHPExcel_Calculation_Functions::flattenArray(func_get_args()); foreach ($aArgs as $arg) { // Is it a blank cell? if ((is_null($arg)) || ((is_string($arg)) && ($arg == ''))) { ++$returnValue; } } return $returnValue; } /** * COUNTIF * * Counts the number of cells that contain numbers within the list of arguments * * Excel Function: * COUNTIF(value1[,value2[, ...]],condition) * * @access public * @category Statistical Functions * @param mixed $arg,... Data values * @param string $condition The criteria that defines which cells will be counted. * @return int */ public static function COUNTIF($aArgs, $condition) { $returnValue = 0; $aArgs = PHPExcel_Calculation_Functions::flattenArray($aArgs); $condition = PHPExcel_Calculation_Functions::ifCondition($condition); // Loop through arguments foreach ($aArgs as $arg) { if (!is_numeric($arg)) { $arg = PHPExcel_Calculation::wrapResult(strtoupper($arg)); } $testCondition = '='.$arg.$condition; if (PHPExcel_Calculation::getInstance()->_calculateFormulaValue($testCondition)) { // Is it a value within our criteria ++$returnValue; } } return $returnValue; } /** * COVAR * * Returns covariance, the average of the products of deviations for each data point pair. * * @param array of mixed Data Series Y * @param array of mixed Data Series X * @return float */ public static function COVAR($yValues, $xValues) { if (!self::checkTrendArrays($yValues, $xValues)) { return PHPExcel_Calculation_Functions::VALUE(); } $yValueCount = count($yValues); $xValueCount = count($xValues); if (($yValueCount == 0) || ($yValueCount != $xValueCount)) { return PHPExcel_Calculation_Functions::NA(); } elseif ($yValueCount == 1) { return PHPExcel_Calculation_Functions::DIV0(); } $bestFitLinear = trendClass::calculate(trendClass::TREND_LINEAR, $yValues, $xValues); return $bestFitLinear->getCovariance(); } /** * CRITBINOM * * Returns the smallest value for which the cumulative binomial distribution is greater * than or equal to a criterion value * * See http://support.microsoft.com/kb/828117/ for details of the algorithm used * * @param float $trials number of Bernoulli trials * @param float $probability probability of a success on each trial * @param float $alpha criterion value * @return int * * @todo Warning. This implementation differs from the algorithm detailed on the MS * web site in that $CumPGuessMinus1 = $CumPGuess - 1 rather than $CumPGuess - $PGuess * This eliminates a potential endless loop error, but may have an adverse affect on the * accuracy of the function (although all my tests have so far returned correct results). * */ public static function CRITBINOM($trials, $probability, $alpha) { $trials = floor(PHPExcel_Calculation_Functions::flattenSingleValue($trials)); $probability = PHPExcel_Calculation_Functions::flattenSingleValue($probability); $alpha = PHPExcel_Calculation_Functions::flattenSingleValue($alpha); if ((is_numeric($trials)) && (is_numeric($probability)) && (is_numeric($alpha))) { if ($trials < 0) { return PHPExcel_Calculation_Functions::NaN(); } elseif (($probability < 0) || ($probability > 1)) { return PHPExcel_Calculation_Functions::NaN(); } elseif (($alpha < 0) || ($alpha > 1)) { return PHPExcel_Calculation_Functions::NaN(); } elseif ($alpha <= 0.5) { $t = sqrt(log(1 / ($alpha * $alpha))); $trialsApprox = 0 - ($t + (2.515517 + 0.802853 * $t + 0.010328 * $t * $t) / (1 + 1.432788 * $t + 0.189269 * $t * $t + 0.001308 * $t * $t * $t)); } else { $t = sqrt(log(1 / pow(1 - $alpha, 2))); $trialsApprox = $t - (2.515517 + 0.802853 * $t + 0.010328 * $t * $t) / (1 + 1.432788 * $t + 0.189269 * $t * $t + 0.001308 * $t * $t * $t); } $Guess = floor($trials * $probability + $trialsApprox * sqrt($trials * $probability * (1 - $probability))); if ($Guess < 0) { $Guess = 0; } elseif ($Guess > $trials) { $Guess = $trials; } $TotalUnscaledProbability = $UnscaledPGuess = $UnscaledCumPGuess = 0.0; $EssentiallyZero = 10e-12; $m = floor($trials * $probability); ++$TotalUnscaledProbability; if ($m == $Guess) { ++$UnscaledPGuess; } if ($m <= $Guess) { ++$UnscaledCumPGuess; } $PreviousValue = 1; $Done = false; $k = $m + 1; while ((!$Done) && ($k <= $trials)) { $CurrentValue = $PreviousValue * ($trials - $k + 1) * $probability / ($k * (1 - $probability)); $TotalUnscaledProbability += $CurrentValue; if ($k == $Guess) { $UnscaledPGuess += $CurrentValue; } if ($k <= $Guess) { $UnscaledCumPGuess += $CurrentValue; } if ($CurrentValue <= $EssentiallyZero) { $Done = true; } $PreviousValue = $CurrentValue; ++$k; } $PreviousValue = 1; $Done = false; $k = $m - 1; while ((!$Done) && ($k >= 0)) { $CurrentValue = $PreviousValue * $k + 1 * (1 - $probability) / (($trials - $k) * $probability); $TotalUnscaledProbability += $CurrentValue; if ($k == $Guess) { $UnscaledPGuess += $CurrentValue; } if ($k <= $Guess) { $UnscaledCumPGuess += $CurrentValue; } if ($CurrentValue <= $EssentiallyZero) { $Done = true; } $PreviousValue = $CurrentValue; --$k; } $PGuess = $UnscaledPGuess / $TotalUnscaledProbability; $CumPGuess = $UnscaledCumPGuess / $TotalUnscaledProbability; // $CumPGuessMinus1 = $CumPGuess - $PGuess; $CumPGuessMinus1 = $CumPGuess - 1; while (true) { if (($CumPGuessMinus1 < $alpha) && ($CumPGuess >= $alpha)) { return $Guess; } elseif (($CumPGuessMinus1 < $alpha) && ($CumPGuess < $alpha)) { $PGuessPlus1 = $PGuess * ($trials - $Guess) * $probability / $Guess / (1 - $probability); $CumPGuessMinus1 = $CumPGuess; $CumPGuess = $CumPGuess + $PGuessPlus1; $PGuess = $PGuessPlus1; ++$Guess; } elseif (($CumPGuessMinus1 >= $alpha) && ($CumPGuess >= $alpha)) { $PGuessMinus1 = $PGuess * $Guess * (1 - $probability) / ($trials - $Guess + 1) / $probability; $CumPGuess = $CumPGuessMinus1; $CumPGuessMinus1 = $CumPGuessMinus1 - $PGuess; $PGuess = $PGuessMinus1; --$Guess; } } } return PHPExcel_Calculation_Functions::VALUE(); } /** * DEVSQ * * Returns the sum of squares of deviations of data points from their sample mean. * * Excel Function: * DEVSQ(value1[,value2[, ...]]) * * @access public * @category Statistical Functions * @param mixed $arg,... Data values * @return float */ public static function DEVSQ() { $aArgs = PHPExcel_Calculation_Functions::flattenArrayIndexed(func_get_args()); // Return value $returnValue = null; $aMean = self::AVERAGE($aArgs); if ($aMean != PHPExcel_Calculation_Functions::DIV0()) { $aCount = -1; foreach ($aArgs as $k => $arg) { // Is it a numeric value? if ((is_bool($arg)) && ((!PHPExcel_Calculation_Functions::isCellValue($k)) || (PHPExcel_Calculation_Functions::getCompatibilityMode() == PHPExcel_Calculation_Functions::COMPATIBILITY_OPENOFFICE))) { $arg = (integer) $arg; } if ((is_numeric($arg)) && (!is_string($arg))) { if (is_null($returnValue)) { $returnValue = pow(($arg - $aMean), 2); } else { $returnValue += pow(($arg - $aMean), 2); } ++$aCount; } } // Return if (is_null($returnValue)) { return PHPExcel_Calculation_Functions::NaN(); } else { return $returnValue; } } return self::NA(); } /** * EXPONDIST * * Returns the exponential distribution. Use EXPONDIST to model the time between events, * such as how long an automated bank teller takes to deliver cash. For example, you can * use EXPONDIST to determine the probability that the process takes at most 1 minute. * * @param float $value Value of the function * @param float $lambda The parameter value * @param boolean $cumulative * @return float */ public static function EXPONDIST($value, $lambda, $cumulative) { $value = PHPExcel_Calculation_Functions::flattenSingleValue($value); $lambda = PHPExcel_Calculation_Functions::flattenSingleValue($lambda); $cumulative = PHPExcel_Calculation_Functions::flattenSingleValue($cumulative); if ((is_numeric($value)) && (is_numeric($lambda))) { if (($value < 0) || ($lambda < 0)) { return PHPExcel_Calculation_Functions::NaN(); } if ((is_numeric($cumulative)) || (is_bool($cumulative))) { if ($cumulative) { return 1 - exp(0-$value*$lambda); } else { return $lambda * exp(0-$value*$lambda); } } } return PHPExcel_Calculation_Functions::VALUE(); } /** * FISHER * * Returns the Fisher transformation at x. This transformation produces a function that * is normally distributed rather than skewed. Use this function to perform hypothesis * testing on the correlation coefficient. * * @param float $value * @return float */ public static function FISHER($value) { $value = PHPExcel_Calculation_Functions::flattenSingleValue($value); if (is_numeric($value)) { if (($value <= -1) || ($value >= 1)) { return PHPExcel_Calculation_Functions::NaN(); } return 0.5 * log((1+$value)/(1-$value)); } return PHPExcel_Calculation_Functions::VALUE(); } /** * FISHERINV * * Returns the inverse of the Fisher transformation. Use this transformation when * analyzing correlations between ranges or arrays of data. If y = FISHER(x), then * FISHERINV(y) = x. * * @param float $value * @return float */ public static function FISHERINV($value) { $value = PHPExcel_Calculation_Functions::flattenSingleValue($value); if (is_numeric($value)) { return (exp(2 * $value) - 1) / (exp(2 * $value) + 1); } return PHPExcel_Calculation_Functions::VALUE(); } /** * FORECAST * * Calculates, or predicts, a future value by using existing values. The predicted value is a y-value for a given x-value. * * @param float Value of X for which we want to find Y * @param array of mixed Data Series Y * @param array of mixed Data Series X * @return float */ public static function FORECAST($xValue, $yValues, $xValues) { $xValue = PHPExcel_Calculation_Functions::flattenSingleValue($xValue); if (!is_numeric($xValue)) { return PHPExcel_Calculation_Functions::VALUE(); } elseif (!self::checkTrendArrays($yValues, $xValues)) { return PHPExcel_Calculation_Functions::VALUE(); } $yValueCount = count($yValues); $xValueCount = count($xValues); if (($yValueCount == 0) || ($yValueCount != $xValueCount)) { return PHPExcel_Calculation_Functions::NA(); } elseif ($yValueCount == 1) { return PHPExcel_Calculation_Functions::DIV0(); } $bestFitLinear = trendClass::calculate(trendClass::TREND_LINEAR, $yValues, $xValues); return $bestFitLinear->getValueOfYForX($xValue); } /** * GAMMADIST * * Returns the gamma distribution. * * @param float $value Value at which you want to evaluate the distribution * @param float $a Parameter to the distribution * @param float $b Parameter to the distribution * @param boolean $cumulative * @return float * */ public static function GAMMADIST($value, $a, $b, $cumulative) { $value = PHPExcel_Calculation_Functions::flattenSingleValue($value); $a = PHPExcel_Calculation_Functions::flattenSingleValue($a); $b = PHPExcel_Calculation_Functions::flattenSingleValue($b); if ((is_numeric($value)) && (is_numeric($a)) && (is_numeric($b))) { if (($value < 0) || ($a <= 0) || ($b <= 0)) { return PHPExcel_Calculation_Functions::NaN(); } if ((is_numeric($cumulative)) || (is_bool($cumulative))) { if ($cumulative) { return self::incompleteGamma($a, $value / $b) / self::gamma($a); } else { return (1 / (pow($b, $a) * self::gamma($a))) * pow($value, $a-1) * exp(0-($value / $b)); } } } return PHPExcel_Calculation_Functions::VALUE(); } /** * GAMMAINV * * Returns the inverse of the beta distribution. * * @param float $probability Probability at which you want to evaluate the distribution * @param float $alpha Parameter to the distribution * @param float $beta Parameter to the distribution * @return float * */ public static function GAMMAINV($probability, $alpha, $beta) { $probability = PHPExcel_Calculation_Functions::flattenSingleValue($probability); $alpha = PHPExcel_Calculation_Functions::flattenSingleValue($alpha); $beta = PHPExcel_Calculation_Functions::flattenSingleValue($beta); if ((is_numeric($probability)) && (is_numeric($alpha)) && (is_numeric($beta))) { if (($alpha <= 0) || ($beta <= 0) || ($probability < 0) || ($probability > 1)) { return PHPExcel_Calculation_Functions::NaN(); } $xLo = 0; $xHi = $alpha * $beta * 5; $x = $xNew = 1; $error = $pdf = 0; $dx = 1024; $i = 0; while ((abs($dx) > PRECISION) && ($i++ < MAX_ITERATIONS)) { // Apply Newton-Raphson step $error = self::GAMMADIST($x, $alpha, $beta, true) - $probability; if ($error < 0.0) { $xLo = $x; } else { $xHi = $x; } $pdf = self::GAMMADIST($x, $alpha, $beta, false); // Avoid division by zero if ($pdf != 0.0) { $dx = $error / $pdf; $xNew = $x - $dx; } // If the NR fails to converge (which for example may be the // case if the initial guess is too rough) we apply a bisection // step to determine a more narrow interval around the root. if (($xNew < $xLo) || ($xNew > $xHi) || ($pdf == 0.0)) { $xNew = ($xLo + $xHi) / 2; $dx = $xNew - $x; } $x = $xNew; } if ($i == MAX_ITERATIONS) { return PHPExcel_Calculation_Functions::NA(); } return $x; } return PHPExcel_Calculation_Functions::VALUE(); } /** * GAMMALN * * Returns the natural logarithm of the gamma function. * * @param float $value * @return float */ public static function GAMMALN($value) { $value = PHPExcel_Calculation_Functions::flattenSingleValue($value); if (is_numeric($value)) { if ($value <= 0) { return PHPExcel_Calculation_Functions::NaN(); } return log(self::gamma($value)); } return PHPExcel_Calculation_Functions::VALUE(); } /** * GEOMEAN * * Returns the geometric mean of an array or range of positive data. For example, you * can use GEOMEAN to calculate average growth rate given compound interest with * variable rates. * * Excel Function: * GEOMEAN(value1[,value2[, ...]]) * * @access public * @category Statistical Functions * @param mixed $arg,... Data values * @return float */ public static function GEOMEAN() { $aArgs = PHPExcel_Calculation_Functions::flattenArray(func_get_args()); $aMean = PHPExcel_Calculation_MathTrig::PRODUCT($aArgs); if (is_numeric($aMean) && ($aMean > 0)) { $aCount = self::COUNT($aArgs) ; if (self::MIN($aArgs) > 0) { return pow($aMean, (1 / $aCount)); } } return PHPExcel_Calculation_Functions::NaN(); } /** * GROWTH * * Returns values along a predicted emponential trend * * @param array of mixed Data Series Y * @param array of mixed Data Series X * @param array of mixed Values of X for which we want to find Y * @param boolean A logical value specifying whether to force the intersect to equal 0. * @return array of float */ public static function GROWTH($yValues, $xValues = array(), $newValues = array(), $const = true) { $yValues = PHPExcel_Calculation_Functions::flattenArray($yValues); $xValues = PHPExcel_Calculation_Functions::flattenArray($xValues); $newValues = PHPExcel_Calculation_Functions::flattenArray($newValues); $const = (is_null($const)) ? true : (boolean) PHPExcel_Calculation_Functions::flattenSingleValue($const); $bestFitExponential = trendClass::calculate(trendClass::TREND_EXPONENTIAL, $yValues, $xValues, $const); if (empty($newValues)) { $newValues = $bestFitExponential->getXValues(); } $returnArray = array(); foreach ($newValues as $xValue) { $returnArray[0][] = $bestFitExponential->getValueOfYForX($xValue); } return $returnArray; } /** * HARMEAN * * Returns the harmonic mean of a data set. The harmonic mean is the reciprocal of the * arithmetic mean of reciprocals. * * Excel Function: * HARMEAN(value1[,value2[, ...]]) * * @access public * @category Statistical Functions * @param mixed $arg,... Data values * @return float */ public static function HARMEAN() { // Return value $returnValue = PHPExcel_Calculation_Functions::NA(); // Loop through arguments $aArgs = PHPExcel_Calculation_Functions::flattenArray(func_get_args()); if (self::MIN($aArgs) < 0) { return PHPExcel_Calculation_Functions::NaN(); } $aCount = 0; foreach ($aArgs as $arg) { // Is it a numeric value? if ((is_numeric($arg)) && (!is_string($arg))) { if ($arg <= 0) { return PHPExcel_Calculation_Functions::NaN(); } if (is_null($returnValue)) { $returnValue = (1 / $arg); } else { $returnValue += (1 / $arg); } ++$aCount; } } // Return if ($aCount > 0) { return 1 / ($returnValue / $aCount); } else { return $returnValue; } } /** * HYPGEOMDIST * * Returns the hypergeometric distribution. HYPGEOMDIST returns the probability of a given number of * sample successes, given the sample size, population successes, and population size. * * @param float $sampleSuccesses Number of successes in the sample * @param float $sampleNumber Size of the sample * @param float $populationSuccesses Number of successes in the population * @param float $populationNumber Population size * @return float * */ public static function HYPGEOMDIST($sampleSuccesses, $sampleNumber, $populationSuccesses, $populationNumber) { $sampleSuccesses = floor(PHPExcel_Calculation_Functions::flattenSingleValue($sampleSuccesses)); $sampleNumber = floor(PHPExcel_Calculation_Functions::flattenSingleValue($sampleNumber)); $populationSuccesses = floor(PHPExcel_Calculation_Functions::flattenSingleValue($populationSuccesses)); $populationNumber = floor(PHPExcel_Calculation_Functions::flattenSingleValue($populationNumber)); if ((is_numeric($sampleSuccesses)) && (is_numeric($sampleNumber)) && (is_numeric($populationSuccesses)) && (is_numeric($populationNumber))) { if (($sampleSuccesses < 0) || ($sampleSuccesses > $sampleNumber) || ($sampleSuccesses > $populationSuccesses)) { return PHPExcel_Calculation_Functions::NaN(); } if (($sampleNumber <= 0) || ($sampleNumber > $populationNumber)) { return PHPExcel_Calculation_Functions::NaN(); } if (($populationSuccesses <= 0) || ($populationSuccesses > $populationNumber)) { return PHPExcel_Calculation_Functions::NaN(); } return PHPExcel_Calculation_MathTrig::COMBIN($populationSuccesses, $sampleSuccesses) * PHPExcel_Calculation_MathTrig::COMBIN($populationNumber - $populationSuccesses, $sampleNumber - $sampleSuccesses) / PHPExcel_Calculation_MathTrig::COMBIN($populationNumber, $sampleNumber); } return PHPExcel_Calculation_Functions::VALUE(); } /** * INTERCEPT * * Calculates the point at which a line will intersect the y-axis by using existing x-values and y-values. * * @param array of mixed Data Series Y * @param array of mixed Data Series X * @return float */ public static function INTERCEPT($yValues, $xValues) { if (!self::checkTrendArrays($yValues, $xValues)) { return PHPExcel_Calculation_Functions::VALUE(); } $yValueCount = count($yValues); $xValueCount = count($xValues); if (($yValueCount == 0) || ($yValueCount != $xValueCount)) { return PHPExcel_Calculation_Functions::NA(); } elseif ($yValueCount == 1) { return PHPExcel_Calculation_Functions::DIV0(); } $bestFitLinear = trendClass::calculate(trendClass::TREND_LINEAR, $yValues, $xValues); return $bestFitLinear->getIntersect(); } /** * KURT * * Returns the kurtosis of a data set. Kurtosis characterizes the relative peakedness * or flatness of a distribution compared with the normal distribution. Positive * kurtosis indicates a relatively peaked distribution. Negative kurtosis indicates a * relatively flat distribution. * * @param array Data Series * @return float */ public static function KURT() { $aArgs = PHPExcel_Calculation_Functions::flattenArrayIndexed(func_get_args()); $mean = self::AVERAGE($aArgs); $stdDev = self::STDEV($aArgs); if ($stdDev > 0) { $count = $summer = 0; // Loop through arguments foreach ($aArgs as $k => $arg) { if ((is_bool($arg)) && (!PHPExcel_Calculation_Functions::isMatrixValue($k))) { } else { // Is it a numeric value? if ((is_numeric($arg)) && (!is_string($arg))) { $summer += pow((($arg - $mean) / $stdDev), 4); ++$count; } } } // Return if ($count > 3) { return $summer * ($count * ($count+1) / (($count-1) * ($count-2) * ($count-3))) - (3 * pow($count-1, 2) / (($count-2) * ($count-3))); } } return PHPExcel_Calculation_Functions::DIV0(); } /** * LARGE * * Returns the nth largest value in a data set. You can use this function to * select a value based on its relative standing. * * Excel Function: * LARGE(value1[,value2[, ...]],entry) * * @access public * @category Statistical Functions * @param mixed $arg,... Data values * @param int $entry Position (ordered from the largest) in the array or range of data to return * @return float * */ public static function LARGE() { $aArgs = PHPExcel_Calculation_Functions::flattenArray(func_get_args()); // Calculate $entry = floor(array_pop($aArgs)); if ((is_numeric($entry)) && (!is_string($entry))) { $mArgs = array(); foreach ($aArgs as $arg) { // Is it a numeric value? if ((is_numeric($arg)) && (!is_string($arg))) { $mArgs[] = $arg; } } $count = self::COUNT($mArgs); $entry = floor(--$entry); if (($entry < 0) || ($entry >= $count) || ($count == 0)) { return PHPExcel_Calculation_Functions::NaN(); } rsort($mArgs); return $mArgs[$entry]; } return PHPExcel_Calculation_Functions::VALUE(); } /** * LINEST * * Calculates the statistics for a line by using the "least squares" method to calculate a straight line that best fits your data, * and then returns an array that describes the line. * * @param array of mixed Data Series Y * @param array of mixed Data Series X * @param boolean A logical value specifying whether to force the intersect to equal 0. * @param boolean A logical value specifying whether to return additional regression statistics. * @return array */ public static function LINEST($yValues, $xValues = null, $const = true, $stats = false) { $const = (is_null($const)) ? true : (boolean) PHPExcel_Calculation_Functions::flattenSingleValue($const); $stats = (is_null($stats)) ? false : (boolean) PHPExcel_Calculation_Functions::flattenSingleValue($stats); if (is_null($xValues)) { $xValues = range(1, count(PHPExcel_Calculation_Functions::flattenArray($yValues))); } if (!self::checkTrendArrays($yValues, $xValues)) { return PHPExcel_Calculation_Functions::VALUE(); } $yValueCount = count($yValues); $xValueCount = count($xValues); if (($yValueCount == 0) || ($yValueCount != $xValueCount)) { return PHPExcel_Calculation_Functions::NA(); } elseif ($yValueCount == 1) { return 0; } $bestFitLinear = trendClass::calculate(trendClass::TREND_LINEAR, $yValues, $xValues, $const); if ($stats) { return array( array( $bestFitLinear->getSlope(), $bestFitLinear->getSlopeSE(), $bestFitLinear->getGoodnessOfFit(), $bestFitLinear->getF(), $bestFitLinear->getSSRegression(), ), array( $bestFitLinear->getIntersect(), $bestFitLinear->getIntersectSE(), $bestFitLinear->getStdevOfResiduals(), $bestFitLinear->getDFResiduals(), $bestFitLinear->getSSResiduals() ) ); } else { return array( $bestFitLinear->getSlope(), $bestFitLinear->getIntersect() ); } } /** * LOGEST * * Calculates an exponential curve that best fits the X and Y data series, * and then returns an array that describes the line. * * @param array of mixed Data Series Y * @param array of mixed Data Series X * @param boolean A logical value specifying whether to force the intersect to equal 0. * @param boolean A logical value specifying whether to return additional regression statistics. * @return array */ public static function LOGEST($yValues, $xValues = null, $const = true, $stats = false) { $const = (is_null($const)) ? true : (boolean) PHPExcel_Calculation_Functions::flattenSingleValue($const); $stats = (is_null($stats)) ? false : (boolean) PHPExcel_Calculation_Functions::flattenSingleValue($stats); if (is_null($xValues)) { $xValues = range(1, count(PHPExcel_Calculation_Functions::flattenArray($yValues))); } if (!self::checkTrendArrays($yValues, $xValues)) { return PHPExcel_Calculation_Functions::VALUE(); } $yValueCount = count($yValues); $xValueCount = count($xValues); foreach ($yValues as $value) { if ($value <= 0.0) { return PHPExcel_Calculation_Functions::NaN(); } } if (($yValueCount == 0) || ($yValueCount != $xValueCount)) { return PHPExcel_Calculation_Functions::NA(); } elseif ($yValueCount == 1) { return 1; } $bestFitExponential = trendClass::calculate(trendClass::TREND_EXPONENTIAL, $yValues, $xValues, $const); if ($stats) { return array( array( $bestFitExponential->getSlope(), $bestFitExponential->getSlopeSE(), $bestFitExponential->getGoodnessOfFit(), $bestFitExponential->getF(), $bestFitExponential->getSSRegression(), ), array( $bestFitExponential->getIntersect(), $bestFitExponential->getIntersectSE(), $bestFitExponential->getStdevOfResiduals(), $bestFitExponential->getDFResiduals(), $bestFitExponential->getSSResiduals() ) ); } else { return array( $bestFitExponential->getSlope(), $bestFitExponential->getIntersect() ); } } /** * LOGINV * * Returns the inverse of the normal cumulative distribution * * @param float $probability * @param float $mean * @param float $stdDev * @return float * * @todo Try implementing P J Acklam's refinement algorithm for greater * accuracy if I can get my head round the mathematics * (as described at) http://home.online.no/~pjacklam/notes/invnorm/ */ public static function LOGINV($probability, $mean, $stdDev) { $probability = PHPExcel_Calculation_Functions::flattenSingleValue($probability); $mean = PHPExcel_Calculation_Functions::flattenSingleValue($mean); $stdDev = PHPExcel_Calculation_Functions::flattenSingleValue($stdDev); if ((is_numeric($probability)) && (is_numeric($mean)) && (is_numeric($stdDev))) { if (($probability < 0) || ($probability > 1) || ($stdDev <= 0)) { return PHPExcel_Calculation_Functions::NaN(); } return exp($mean + $stdDev * self::NORMSINV($probability)); } return PHPExcel_Calculation_Functions::VALUE(); } /** * LOGNORMDIST * * Returns the cumulative lognormal distribution of x, where ln(x) is normally distributed * with parameters mean and standard_dev. * * @param float $value * @param float $mean * @param float $stdDev * @return float */ public static function LOGNORMDIST($value, $mean, $stdDev) { $value = PHPExcel_Calculation_Functions::flattenSingleValue($value); $mean = PHPExcel_Calculation_Functions::flattenSingleValue($mean); $stdDev = PHPExcel_Calculation_Functions::flattenSingleValue($stdDev); if ((is_numeric($value)) && (is_numeric($mean)) && (is_numeric($stdDev))) { if (($value <= 0) || ($stdDev <= 0)) { return PHPExcel_Calculation_Functions::NaN(); } return self::NORMSDIST((log($value) - $mean) / $stdDev); } return PHPExcel_Calculation_Functions::VALUE(); } /** * MAX * * MAX returns the value of the element of the values passed that has the highest value, * with negative numbers considered smaller than positive numbers. * * Excel Function: * MAX(value1[,value2[, ...]]) * * @access public * @category Statistical Functions * @param mixed $arg,... Data values * @return float */ public static function MAX() { $returnValue = null; // Loop through arguments $aArgs = PHPExcel_Calculation_Functions::flattenArray(func_get_args()); foreach ($aArgs as $arg) { // Is it a numeric value? if ((is_numeric($arg)) && (!is_string($arg))) { if ((is_null($returnValue)) || ($arg > $returnValue)) { $returnValue = $arg; } } } if (is_null($returnValue)) { return 0; } return $returnValue; } /** * MAXA * * Returns the greatest value in a list of arguments, including numbers, text, and logical values * * Excel Function: * MAXA(value1[,value2[, ...]]) * * @access public * @category Statistical Functions * @param mixed $arg,... Data values * @return float */ public static function MAXA() { $returnValue = null; // Loop through arguments $aArgs = PHPExcel_Calculation_Functions::flattenArray(func_get_args()); foreach ($aArgs as $arg) { // Is it a numeric value? if ((is_numeric($arg)) || (is_bool($arg)) || ((is_string($arg) && ($arg != '')))) { if (is_bool($arg)) { $arg = (integer) $arg; } elseif (is_string($arg)) { $arg = 0; } if ((is_null($returnValue)) || ($arg > $returnValue)) { $returnValue = $arg; } } } if (is_null($returnValue)) { return 0; } return $returnValue; } /** * MAXIF * * Counts the maximum value within a range of cells that contain numbers within the list of arguments * * Excel Function: * MAXIF(value1[,value2[, ...]],condition) * * @access public * @category Mathematical and Trigonometric Functions * @param mixed $arg,... Data values * @param string $condition The criteria that defines which cells will be checked. * @return float */ public static function MAXIF($aArgs, $condition, $sumArgs = array()) { $returnValue = null; $aArgs = PHPExcel_Calculation_Functions::flattenArray($aArgs); $sumArgs = PHPExcel_Calculation_Functions::flattenArray($sumArgs); if (empty($sumArgs)) { $sumArgs = $aArgs; } $condition = PHPExcel_Calculation_Functions::ifCondition($condition); // Loop through arguments foreach ($aArgs as $key => $arg) { if (!is_numeric($arg)) { $arg = PHPExcel_Calculation::wrapResult(strtoupper($arg)); } $testCondition = '='.$arg.$condition; if (PHPExcel_Calculation::getInstance()->_calculateFormulaValue($testCondition)) { if ((is_null($returnValue)) || ($arg > $returnValue)) { $returnValue = $arg; } } } return $returnValue; } /** * MEDIAN * * Returns the median of the given numbers. The median is the number in the middle of a set of numbers. * * Excel Function: * MEDIAN(value1[,value2[, ...]]) * * @access public * @category Statistical Functions * @param mixed $arg,... Data values * @return float */ public static function MEDIAN() { $returnValue = PHPExcel_Calculation_Functions::NaN(); $mArgs = array(); // Loop through arguments $aArgs = PHPExcel_Calculation_Functions::flattenArray(func_get_args()); foreach ($aArgs as $arg) { // Is it a numeric value? if ((is_numeric($arg)) && (!is_string($arg))) { $mArgs[] = $arg; } } $mValueCount = count($mArgs); if ($mValueCount > 0) { sort($mArgs, SORT_NUMERIC); $mValueCount = $mValueCount / 2; if ($mValueCount == floor($mValueCount)) { $returnValue = ($mArgs[$mValueCount--] + $mArgs[$mValueCount]) / 2; } else { $mValueCount = floor($mValueCount); $returnValue = $mArgs[$mValueCount]; } } return $returnValue; } /** * MIN * * MIN returns the value of the element of the values passed that has the smallest value, * with negative numbers considered smaller than positive numbers. * * Excel Function: * MIN(value1[,value2[, ...]]) * * @access public * @category Statistical Functions * @param mixed $arg,... Data values * @return float */ public static function MIN() { $returnValue = null; // Loop through arguments $aArgs = PHPExcel_Calculation_Functions::flattenArray(func_get_args()); foreach ($aArgs as $arg) { // Is it a numeric value? if ((is_numeric($arg)) && (!is_string($arg))) { if ((is_null($returnValue)) || ($arg < $returnValue)) { $returnValue = $arg; } } } if (is_null($returnValue)) { return 0; } return $returnValue; } /** * MINA * * Returns the smallest value in a list of arguments, including numbers, text, and logical values * * Excel Function: * MINA(value1[,value2[, ...]]) * * @access public * @category Statistical Functions * @param mixed $arg,... Data values * @return float */ public static function MINA() { $returnValue = null; // Loop through arguments $aArgs = PHPExcel_Calculation_Functions::flattenArray(func_get_args()); foreach ($aArgs as $arg) { // Is it a numeric value? if ((is_numeric($arg)) || (is_bool($arg)) || ((is_string($arg) && ($arg != '')))) { if (is_bool($arg)) { $arg = (integer) $arg; } elseif (is_string($arg)) { $arg = 0; } if ((is_null($returnValue)) || ($arg < $returnValue)) { $returnValue = $arg; } } } if (is_null($returnValue)) { return 0; } return $returnValue; } /** * MINIF * * Returns the minimum value within a range of cells that contain numbers within the list of arguments * * Excel Function: * MINIF(value1[,value2[, ...]],condition) * * @access public * @category Mathematical and Trigonometric Functions * @param mixed $arg,... Data values * @param string $condition The criteria that defines which cells will be checked. * @return float */ public static function MINIF($aArgs, $condition, $sumArgs = array()) { $returnValue = null; $aArgs = PHPExcel_Calculation_Functions::flattenArray($aArgs); $sumArgs = PHPExcel_Calculation_Functions::flattenArray($sumArgs); if (empty($sumArgs)) { $sumArgs = $aArgs; } $condition = PHPExcel_Calculation_Functions::ifCondition($condition); // Loop through arguments foreach ($aArgs as $key => $arg) { if (!is_numeric($arg)) { $arg = PHPExcel_Calculation::wrapResult(strtoupper($arg)); } $testCondition = '='.$arg.$condition; if (PHPExcel_Calculation::getInstance()->_calculateFormulaValue($testCondition)) { if ((is_null($returnValue)) || ($arg < $returnValue)) { $returnValue = $arg; } } } return $returnValue; } // // Special variant of array_count_values that isn't limited to strings and integers, // but can work with floating point numbers as values // private static function modeCalc($data) { $frequencyArray = array(); foreach ($data as $datum) { $found = false; foreach ($frequencyArray as $key => $value) { if ((string) $value['value'] == (string) $datum) { ++$frequencyArray[$key]['frequency']; $found = true; break; } } if (!$found) { $frequencyArray[] = array( 'value' => $datum, 'frequency' => 1 ); } } foreach ($frequencyArray as $key => $value) { $frequencyList[$key] = $value['frequency']; $valueList[$key] = $value['value']; } array_multisort($frequencyList, SORT_DESC, $valueList, SORT_ASC, SORT_NUMERIC, $frequencyArray); if ($frequencyArray[0]['frequency'] == 1) { return PHPExcel_Calculation_Functions::NA(); } return $frequencyArray[0]['value']; } /** * MODE * * Returns the most frequently occurring, or repetitive, value in an array or range of data * * Excel Function: * MODE(value1[,value2[, ...]]) * * @access public * @category Statistical Functions * @param mixed $arg,... Data values * @return float */ public static function MODE() { $returnValue = PHPExcel_Calculation_Functions::NA(); // Loop through arguments $aArgs = PHPExcel_Calculation_Functions::flattenArray(func_get_args()); $mArgs = array(); foreach ($aArgs as $arg) { // Is it a numeric value? if ((is_numeric($arg)) && (!is_string($arg))) { $mArgs[] = $arg; } } if (!empty($mArgs)) { return self::modeCalc($mArgs); } return $returnValue; } /** * NEGBINOMDIST * * Returns the negative binomial distribution. NEGBINOMDIST returns the probability that * there will be number_f failures before the number_s-th success, when the constant * probability of a success is probability_s. This function is similar to the binomial * distribution, except that the number of successes is fixed, and the number of trials is * variable. Like the binomial, trials are assumed to be independent. * * @param float $failures Number of Failures * @param float $successes Threshold number of Successes * @param float $probability Probability of success on each trial * @return float * */ public static function NEGBINOMDIST($failures, $successes, $probability) { $failures = floor(PHPExcel_Calculation_Functions::flattenSingleValue($failures)); $successes = floor(PHPExcel_Calculation_Functions::flattenSingleValue($successes)); $probability = PHPExcel_Calculation_Functions::flattenSingleValue($probability); if ((is_numeric($failures)) && (is_numeric($successes)) && (is_numeric($probability))) { if (($failures < 0) || ($successes < 1)) { return PHPExcel_Calculation_Functions::NaN(); } elseif (($probability < 0) || ($probability > 1)) { return PHPExcel_Calculation_Functions::NaN(); } if (PHPExcel_Calculation_Functions::getCompatibilityMode() == PHPExcel_Calculation_Functions::COMPATIBILITY_GNUMERIC) { if (($failures + $successes - 1) <= 0) { return PHPExcel_Calculation_Functions::NaN(); } } return (PHPExcel_Calculation_MathTrig::COMBIN($failures + $successes - 1, $successes - 1)) * (pow($probability, $successes)) * (pow(1 - $probability, $failures)); } return PHPExcel_Calculation_Functions::VALUE(); } /** * NORMDIST * * Returns the normal distribution for the specified mean and standard deviation. This * function has a very wide range of applications in statistics, including hypothesis * testing. * * @param float $value * @param float $mean Mean Value * @param float $stdDev Standard Deviation * @param boolean $cumulative * @return float * */ public static function NORMDIST($value, $mean, $stdDev, $cumulative) { $value = PHPExcel_Calculation_Functions::flattenSingleValue($value); $mean = PHPExcel_Calculation_Functions::flattenSingleValue($mean); $stdDev = PHPExcel_Calculation_Functions::flattenSingleValue($stdDev); if ((is_numeric($value)) && (is_numeric($mean)) && (is_numeric($stdDev))) { if ($stdDev < 0) { return PHPExcel_Calculation_Functions::NaN(); } if ((is_numeric($cumulative)) || (is_bool($cumulative))) { if ($cumulative) { return 0.5 * (1 + PHPExcel_Calculation_Engineering::erfVal(($value - $mean) / ($stdDev * sqrt(2)))); } else { return (1 / (SQRT2PI * $stdDev)) * exp(0 - (pow($value - $mean, 2) / (2 * ($stdDev * $stdDev)))); } } } return PHPExcel_Calculation_Functions::VALUE(); } /** * NORMINV * * Returns the inverse of the normal cumulative distribution for the specified mean and standard deviation. * * @param float $value * @param float $mean Mean Value * @param float $stdDev Standard Deviation * @return float * */ public static function NORMINV($probability, $mean, $stdDev) { $probability = PHPExcel_Calculation_Functions::flattenSingleValue($probability); $mean = PHPExcel_Calculation_Functions::flattenSingleValue($mean); $stdDev = PHPExcel_Calculation_Functions::flattenSingleValue($stdDev); if ((is_numeric($probability)) && (is_numeric($mean)) && (is_numeric($stdDev))) { if (($probability < 0) || ($probability > 1)) { return PHPExcel_Calculation_Functions::NaN(); } if ($stdDev < 0) { return PHPExcel_Calculation_Functions::NaN(); } return (self::inverseNcdf($probability) * $stdDev) + $mean; } return PHPExcel_Calculation_Functions::VALUE(); } /** * NORMSDIST * * Returns the standard normal cumulative distribution function. The distribution has * a mean of 0 (zero) and a standard deviation of one. Use this function in place of a * table of standard normal curve areas. * * @param float $value * @return float */ public static function NORMSDIST($value) { $value = PHPExcel_Calculation_Functions::flattenSingleValue($value); return self::NORMDIST($value, 0, 1, true); } /** * NORMSINV * * Returns the inverse of the standard normal cumulative distribution * * @param float $value * @return float */ public static function NORMSINV($value) { return self::NORMINV($value, 0, 1); } /** * PERCENTILE * * Returns the nth percentile of values in a range.. * * Excel Function: * PERCENTILE(value1[,value2[, ...]],entry) * * @access public * @category Statistical Functions * @param mixed $arg,... Data values * @param float $entry Percentile value in the range 0..1, inclusive. * @return float */ public static function PERCENTILE() { $aArgs = PHPExcel_Calculation_Functions::flattenArray(func_get_args()); // Calculate $entry = array_pop($aArgs); if ((is_numeric($entry)) && (!is_string($entry))) { if (($entry < 0) || ($entry > 1)) { return PHPExcel_Calculation_Functions::NaN(); } $mArgs = array(); foreach ($aArgs as $arg) { // Is it a numeric value? if ((is_numeric($arg)) && (!is_string($arg))) { $mArgs[] = $arg; } } $mValueCount = count($mArgs); if ($mValueCount > 0) { sort($mArgs); $count = self::COUNT($mArgs); $index = $entry * ($count-1); $iBase = floor($index); if ($index == $iBase) { return $mArgs[$index]; } else { $iNext = $iBase + 1; $iProportion = $index - $iBase; return $mArgs[$iBase] + (($mArgs[$iNext] - $mArgs[$iBase]) * $iProportion) ; } } } return PHPExcel_Calculation_Functions::VALUE(); } /** * PERCENTRANK * * Returns the rank of a value in a data set as a percentage of the data set. * * @param array of number An array of, or a reference to, a list of numbers. * @param number The number whose rank you want to find. * @param number The number of significant digits for the returned percentage value. * @return float */ public static function PERCENTRANK($valueSet, $value, $significance = 3) { $valueSet = PHPExcel_Calculation_Functions::flattenArray($valueSet); $value = PHPExcel_Calculation_Functions::flattenSingleValue($value); $significance = (is_null($significance)) ? 3 : (integer) PHPExcel_Calculation_Functions::flattenSingleValue($significance); foreach ($valueSet as $key => $valueEntry) { if (!is_numeric($valueEntry)) { unset($valueSet[$key]); } } sort($valueSet, SORT_NUMERIC); $valueCount = count($valueSet); if ($valueCount == 0) { return PHPExcel_Calculation_Functions::NaN(); } $valueAdjustor = $valueCount - 1; if (($value < $valueSet[0]) || ($value > $valueSet[$valueAdjustor])) { return PHPExcel_Calculation_Functions::NA(); } $pos = array_search($value, $valueSet); if ($pos === false) { $pos = 0; $testValue = $valueSet[0]; while ($testValue < $value) { $testValue = $valueSet[++$pos]; } --$pos; $pos += (($value - $valueSet[$pos]) / ($testValue - $valueSet[$pos])); } return round($pos / $valueAdjustor, $significance); } /** * PERMUT * * Returns the number of permutations for a given number of objects that can be * selected from number objects. A permutation is any set or subset of objects or * events where internal order is significant. Permutations are different from * combinations, for which the internal order is not significant. Use this function * for lottery-style probability calculations. * * @param int $numObjs Number of different objects * @param int $numInSet Number of objects in each permutation * @return int Number of permutations */ public static function PERMUT($numObjs, $numInSet) { $numObjs = PHPExcel_Calculation_Functions::flattenSingleValue($numObjs); $numInSet = PHPExcel_Calculation_Functions::flattenSingleValue($numInSet); if ((is_numeric($numObjs)) && (is_numeric($numInSet))) { $numInSet = floor($numInSet); if ($numObjs < $numInSet) { return PHPExcel_Calculation_Functions::NaN(); } return round(PHPExcel_Calculation_MathTrig::FACT($numObjs) / PHPExcel_Calculation_MathTrig::FACT($numObjs - $numInSet)); } return PHPExcel_Calculation_Functions::VALUE(); } /** * POISSON * * Returns the Poisson distribution. A common application of the Poisson distribution * is predicting the number of events over a specific time, such as the number of * cars arriving at a toll plaza in 1 minute. * * @param float $value * @param float $mean Mean Value * @param boolean $cumulative * @return float * */ public static function POISSON($value, $mean, $cumulative) { $value = PHPExcel_Calculation_Functions::flattenSingleValue($value); $mean = PHPExcel_Calculation_Functions::flattenSingleValue($mean); if ((is_numeric($value)) && (is_numeric($mean))) { if (($value < 0) || ($mean <= 0)) { return PHPExcel_Calculation_Functions::NaN(); } if ((is_numeric($cumulative)) || (is_bool($cumulative))) { if ($cumulative) { $summer = 0; for ($i = 0; $i <= floor($value); ++$i) { $summer += pow($mean, $i) / PHPExcel_Calculation_MathTrig::FACT($i); } return exp(0-$mean) * $summer; } else { return (exp(0-$mean) * pow($mean, $value)) / PHPExcel_Calculation_MathTrig::FACT($value); } } } return PHPExcel_Calculation_Functions::VALUE(); } /** * QUARTILE * * Returns the quartile of a data set. * * Excel Function: * QUARTILE(value1[,value2[, ...]],entry) * * @access public * @category Statistical Functions * @param mixed $arg,... Data values * @param int $entry Quartile value in the range 1..3, inclusive. * @return float */ public static function QUARTILE() { $aArgs = PHPExcel_Calculation_Functions::flattenArray(func_get_args()); // Calculate $entry = floor(array_pop($aArgs)); if ((is_numeric($entry)) && (!is_string($entry))) { $entry /= 4; if (($entry < 0) || ($entry > 1)) { return PHPExcel_Calculation_Functions::NaN(); } return self::PERCENTILE($aArgs, $entry); } return PHPExcel_Calculation_Functions::VALUE(); } /** * RANK * * Returns the rank of a number in a list of numbers. * * @param number The number whose rank you want to find. * @param array of number An array of, or a reference to, a list of numbers. * @param mixed Order to sort the values in the value set * @return float */ public static function RANK($value, $valueSet, $order = 0) { $value = PHPExcel_Calculation_Functions::flattenSingleValue($value); $valueSet = PHPExcel_Calculation_Functions::flattenArray($valueSet); $order = (is_null($order)) ? 0 : (integer) PHPExcel_Calculation_Functions::flattenSingleValue($order); foreach ($valueSet as $key => $valueEntry) { if (!is_numeric($valueEntry)) { unset($valueSet[$key]); } } if ($order == 0) { rsort($valueSet, SORT_NUMERIC); } else { sort($valueSet, SORT_NUMERIC); } $pos = array_search($value, $valueSet); if ($pos === false) { return PHPExcel_Calculation_Functions::NA(); } return ++$pos; } /** * RSQ * * Returns the square of the Pearson product moment correlation coefficient through data points in known_y's and known_x's. * * @param array of mixed Data Series Y * @param array of mixed Data Series X * @return float */ public static function RSQ($yValues, $xValues) { if (!self::checkTrendArrays($yValues, $xValues)) { return PHPExcel_Calculation_Functions::VALUE(); } $yValueCount = count($yValues); $xValueCount = count($xValues); if (($yValueCount == 0) || ($yValueCount != $xValueCount)) { return PHPExcel_Calculation_Functions::NA(); } elseif ($yValueCount == 1) { return PHPExcel_Calculation_Functions::DIV0(); } $bestFitLinear = trendClass::calculate(trendClass::TREND_LINEAR, $yValues, $xValues); return $bestFitLinear->getGoodnessOfFit(); } /** * SKEW * * Returns the skewness of a distribution. Skewness characterizes the degree of asymmetry * of a distribution around its mean. Positive skewness indicates a distribution with an * asymmetric tail extending toward more positive values. Negative skewness indicates a * distribution with an asymmetric tail extending toward more negative values. * * @param array Data Series * @return float */ public static function SKEW() { $aArgs = PHPExcel_Calculation_Functions::flattenArrayIndexed(func_get_args()); $mean = self::AVERAGE($aArgs); $stdDev = self::STDEV($aArgs); $count = $summer = 0; // Loop through arguments foreach ($aArgs as $k => $arg) { if ((is_bool($arg)) && (!PHPExcel_Calculation_Functions::isMatrixValue($k))) { } else { // Is it a numeric value? if ((is_numeric($arg)) && (!is_string($arg))) { $summer += pow((($arg - $mean) / $stdDev), 3); ++$count; } } } if ($count > 2) { return $summer * ($count / (($count-1) * ($count-2))); } return PHPExcel_Calculation_Functions::DIV0(); } /** * SLOPE * * Returns the slope of the linear regression line through data points in known_y's and known_x's. * * @param array of mixed Data Series Y * @param array of mixed Data Series X * @return float */ public static function SLOPE($yValues, $xValues) { if (!self::checkTrendArrays($yValues, $xValues)) { return PHPExcel_Calculation_Functions::VALUE(); } $yValueCount = count($yValues); $xValueCount = count($xValues); if (($yValueCount == 0) || ($yValueCount != $xValueCount)) { return PHPExcel_Calculation_Functions::NA(); } elseif ($yValueCount == 1) { return PHPExcel_Calculation_Functions::DIV0(); } $bestFitLinear = trendClass::calculate(trendClass::TREND_LINEAR, $yValues, $xValues); return $bestFitLinear->getSlope(); } /** * SMALL * * Returns the nth smallest value in a data set. You can use this function to * select a value based on its relative standing. * * Excel Function: * SMALL(value1[,value2[, ...]],entry) * * @access public * @category Statistical Functions * @param mixed $arg,... Data values * @param int $entry Position (ordered from the smallest) in the array or range of data to return * @return float */ public static function SMALL() { $aArgs = PHPExcel_Calculation_Functions::flattenArray(func_get_args()); // Calculate $entry = array_pop($aArgs); if ((is_numeric($entry)) && (!is_string($entry))) { $mArgs = array(); foreach ($aArgs as $arg) { // Is it a numeric value? if ((is_numeric($arg)) && (!is_string($arg))) { $mArgs[] = $arg; } } $count = self::COUNT($mArgs); $entry = floor(--$entry); if (($entry < 0) || ($entry >= $count) || ($count == 0)) { return PHPExcel_Calculation_Functions::NaN(); } sort($mArgs); return $mArgs[$entry]; } return PHPExcel_Calculation_Functions::VALUE(); } /** * STANDARDIZE * * Returns a normalized value from a distribution characterized by mean and standard_dev. * * @param float $value Value to normalize * @param float $mean Mean Value * @param float $stdDev Standard Deviation * @return float Standardized value */ public static function STANDARDIZE($value, $mean, $stdDev) { $value = PHPExcel_Calculation_Functions::flattenSingleValue($value); $mean = PHPExcel_Calculation_Functions::flattenSingleValue($mean); $stdDev = PHPExcel_Calculation_Functions::flattenSingleValue($stdDev); if ((is_numeric($value)) && (is_numeric($mean)) && (is_numeric($stdDev))) { if ($stdDev <= 0) { return PHPExcel_Calculation_Functions::NaN(); } return ($value - $mean) / $stdDev ; } return PHPExcel_Calculation_Functions::VALUE(); } /** * STDEV * * Estimates standard deviation based on a sample. The standard deviation is a measure of how * widely values are dispersed from the average value (the mean). * * Excel Function: * STDEV(value1[,value2[, ...]]) * * @access public * @category Statistical Functions * @param mixed $arg,... Data values * @return float */ public static function STDEV() { $aArgs = PHPExcel_Calculation_Functions::flattenArrayIndexed(func_get_args()); // Return value $returnValue = null; $aMean = self::AVERAGE($aArgs); if (!is_null($aMean)) { $aCount = -1; foreach ($aArgs as $k => $arg) { if ((is_bool($arg)) && ((!PHPExcel_Calculation_Functions::isCellValue($k)) || (PHPExcel_Calculation_Functions::getCompatibilityMode() == PHPExcel_Calculation_Functions::COMPATIBILITY_OPENOFFICE))) { $arg = (integer) $arg; } // Is it a numeric value? if ((is_numeric($arg)) && (!is_string($arg))) { if (is_null($returnValue)) { $returnValue = pow(($arg - $aMean), 2); } else { $returnValue += pow(($arg - $aMean), 2); } ++$aCount; } } // Return if (($aCount > 0) && ($returnValue >= 0)) { return sqrt($returnValue / $aCount); } } return PHPExcel_Calculation_Functions::DIV0(); } /** * STDEVA * * Estimates standard deviation based on a sample, including numbers, text, and logical values * * Excel Function: * STDEVA(value1[,value2[, ...]]) * * @access public * @category Statistical Functions * @param mixed $arg,... Data values * @return float */ public static function STDEVA() { $aArgs = PHPExcel_Calculation_Functions::flattenArrayIndexed(func_get_args()); $returnValue = null; $aMean = self::AVERAGEA($aArgs); if (!is_null($aMean)) { $aCount = -1; foreach ($aArgs as $k => $arg) { if ((is_bool($arg)) && (!PHPExcel_Calculation_Functions::isMatrixValue($k))) { } else { // Is it a numeric value? if ((is_numeric($arg)) || (is_bool($arg)) || ((is_string($arg) & ($arg != '')))) { if (is_bool($arg)) { $arg = (integer) $arg; } elseif (is_string($arg)) { $arg = 0; } if (is_null($returnValue)) { $returnValue = pow(($arg - $aMean), 2); } else { $returnValue += pow(($arg - $aMean), 2); } ++$aCount; } } } if (($aCount > 0) && ($returnValue >= 0)) { return sqrt($returnValue / $aCount); } } return PHPExcel_Calculation_Functions::DIV0(); } /** * STDEVP * * Calculates standard deviation based on the entire population * * Excel Function: * STDEVP(value1[,value2[, ...]]) * * @access public * @category Statistical Functions * @param mixed $arg,... Data values * @return float */ public static function STDEVP() { $aArgs = PHPExcel_Calculation_Functions::flattenArrayIndexed(func_get_args()); $returnValue = null; $aMean = self::AVERAGE($aArgs); if (!is_null($aMean)) { $aCount = 0; foreach ($aArgs as $k => $arg) { if ((is_bool($arg)) && ((!PHPExcel_Calculation_Functions::isCellValue($k)) || (PHPExcel_Calculation_Functions::getCompatibilityMode() == PHPExcel_Calculation_Functions::COMPATIBILITY_OPENOFFICE))) { $arg = (integer) $arg; } // Is it a numeric value? if ((is_numeric($arg)) && (!is_string($arg))) { if (is_null($returnValue)) { $returnValue = pow(($arg - $aMean), 2); } else { $returnValue += pow(($arg - $aMean), 2); } ++$aCount; } } if (($aCount > 0) && ($returnValue >= 0)) { return sqrt($returnValue / $aCount); } } return PHPExcel_Calculation_Functions::DIV0(); } /** * STDEVPA * * Calculates standard deviation based on the entire population, including numbers, text, and logical values * * Excel Function: * STDEVPA(value1[,value2[, ...]]) * * @access public * @category Statistical Functions * @param mixed $arg,... Data values * @return float */ public static function STDEVPA() { $aArgs = PHPExcel_Calculation_Functions::flattenArrayIndexed(func_get_args()); $returnValue = null; $aMean = self::AVERAGEA($aArgs); if (!is_null($aMean)) { $aCount = 0; foreach ($aArgs as $k => $arg) { if ((is_bool($arg)) && (!PHPExcel_Calculation_Functions::isMatrixValue($k))) { } else { // Is it a numeric value? if ((is_numeric($arg)) || (is_bool($arg)) || ((is_string($arg) & ($arg != '')))) { if (is_bool($arg)) { $arg = (integer) $arg; } elseif (is_string($arg)) { $arg = 0; } if (is_null($returnValue)) { $returnValue = pow(($arg - $aMean), 2); } else { $returnValue += pow(($arg - $aMean), 2); } ++$aCount; } } } if (($aCount > 0) && ($returnValue >= 0)) { return sqrt($returnValue / $aCount); } } return PHPExcel_Calculation_Functions::DIV0(); } /** * STEYX * * Returns the standard error of the predicted y-value for each x in the regression. * * @param array of mixed Data Series Y * @param array of mixed Data Series X * @return float */ public static function STEYX($yValues, $xValues) { if (!self::checkTrendArrays($yValues, $xValues)) { return PHPExcel_Calculation_Functions::VALUE(); } $yValueCount = count($yValues); $xValueCount = count($xValues); if (($yValueCount == 0) || ($yValueCount != $xValueCount)) { return PHPExcel_Calculation_Functions::NA(); } elseif ($yValueCount == 1) { return PHPExcel_Calculation_Functions::DIV0(); } $bestFitLinear = trendClass::calculate(trendClass::TREND_LINEAR, $yValues, $xValues); return $bestFitLinear->getStdevOfResiduals(); } /** * TDIST * * Returns the probability of Student's T distribution. * * @param float $value Value for the function * @param float $degrees degrees of freedom * @param float $tails number of tails (1 or 2) * @return float */ public static function TDIST($value, $degrees, $tails) { $value = PHPExcel_Calculation_Functions::flattenSingleValue($value); $degrees = floor(PHPExcel_Calculation_Functions::flattenSingleValue($degrees)); $tails = floor(PHPExcel_Calculation_Functions::flattenSingleValue($tails)); if ((is_numeric($value)) && (is_numeric($degrees)) && (is_numeric($tails))) { if (($value < 0) || ($degrees < 1) || ($tails < 1) || ($tails > 2)) { return PHPExcel_Calculation_Functions::NaN(); } // tdist, which finds the probability that corresponds to a given value // of t with k degrees of freedom. This algorithm is translated from a // pascal function on p81 of "Statistical Computing in Pascal" by D // Cooke, A H Craven & G M Clark (1985: Edward Arnold (Pubs.) Ltd: // London). The above Pascal algorithm is itself a translation of the // fortran algoritm "AS 3" by B E Cooper of the Atlas Computer // Laboratory as reported in (among other places) "Applied Statistics // Algorithms", editied by P Griffiths and I D Hill (1985; Ellis // Horwood Ltd.; W. Sussex, England). $tterm = $degrees; $ttheta = atan2($value, sqrt($tterm)); $tc = cos($ttheta); $ts = sin($ttheta); $tsum = 0; if (($degrees % 2) == 1) { $ti = 3; $tterm = $tc; } else { $ti = 2; $tterm = 1; } $tsum = $tterm; while ($ti < $degrees) { $tterm *= $tc * $tc * ($ti - 1) / $ti; $tsum += $tterm; $ti += 2; } $tsum *= $ts; if (($degrees % 2) == 1) { $tsum = M_2DIVPI * ($tsum + $ttheta); } $tValue = 0.5 * (1 + $tsum); if ($tails == 1) { return 1 - abs($tValue); } else { return 1 - abs((1 - $tValue) - $tValue); } } return PHPExcel_Calculation_Functions::VALUE(); } /** * TINV * * Returns the one-tailed probability of the chi-squared distribution. * * @param float $probability Probability for the function * @param float $degrees degrees of freedom * @return float */ public static function TINV($probability, $degrees) { $probability = PHPExcel_Calculation_Functions::flattenSingleValue($probability); $degrees = floor(PHPExcel_Calculation_Functions::flattenSingleValue($degrees)); if ((is_numeric($probability)) && (is_numeric($degrees))) { $xLo = 100; $xHi = 0; $x = $xNew = 1; $dx = 1; $i = 0; while ((abs($dx) > PRECISION) && ($i++ < MAX_ITERATIONS)) { // Apply Newton-Raphson step $result = self::TDIST($x, $degrees, 2); $error = $result - $probability; if ($error == 0.0) { $dx = 0; } elseif ($error < 0.0) { $xLo = $x; } else { $xHi = $x; } // Avoid division by zero if ($result != 0.0) { $dx = $error / $result; $xNew = $x - $dx; } // If the NR fails to converge (which for example may be the // case if the initial guess is too rough) we apply a bisection // step to determine a more narrow interval around the root. if (($xNew < $xLo) || ($xNew > $xHi) || ($result == 0.0)) { $xNew = ($xLo + $xHi) / 2; $dx = $xNew - $x; } $x = $xNew; } if ($i == MAX_ITERATIONS) { return PHPExcel_Calculation_Functions::NA(); } return round($x, 12); } return PHPExcel_Calculation_Functions::VALUE(); } /** * TREND * * Returns values along a linear trend * * @param array of mixed Data Series Y * @param array of mixed Data Series X * @param array of mixed Values of X for which we want to find Y * @param boolean A logical value specifying whether to force the intersect to equal 0. * @return array of float */ public static function TREND($yValues, $xValues = array(), $newValues = array(), $const = true) { $yValues = PHPExcel_Calculation_Functions::flattenArray($yValues); $xValues = PHPExcel_Calculation_Functions::flattenArray($xValues); $newValues = PHPExcel_Calculation_Functions::flattenArray($newValues); $const = (is_null($const)) ? true : (boolean) PHPExcel_Calculation_Functions::flattenSingleValue($const); $bestFitLinear = trendClass::calculate(trendClass::TREND_LINEAR, $yValues, $xValues, $const); if (empty($newValues)) { $newValues = $bestFitLinear->getXValues(); } $returnArray = array(); foreach ($newValues as $xValue) { $returnArray[0][] = $bestFitLinear->getValueOfYForX($xValue); } return $returnArray; } /** * TRIMMEAN * * Returns the mean of the interior of a data set. TRIMMEAN calculates the mean * taken by excluding a percentage of data points from the top and bottom tails * of a data set. * * Excel Function: * TRIMEAN(value1[,value2[, ...]], $discard) * * @access public * @category Statistical Functions * @param mixed $arg,... Data values * @param float $discard Percentage to discard * @return float */ public static function TRIMMEAN() { $aArgs = PHPExcel_Calculation_Functions::flattenArray(func_get_args()); // Calculate $percent = array_pop($aArgs); if ((is_numeric($percent)) && (!is_string($percent))) { if (($percent < 0) || ($percent > 1)) { return PHPExcel_Calculation_Functions::NaN(); } $mArgs = array(); foreach ($aArgs as $arg) { // Is it a numeric value? if ((is_numeric($arg)) && (!is_string($arg))) { $mArgs[] = $arg; } } $discard = floor(self::COUNT($mArgs) * $percent / 2); sort($mArgs); for ($i=0; $i < $discard; ++$i) { array_pop($mArgs); array_shift($mArgs); } return self::AVERAGE($mArgs); } return PHPExcel_Calculation_Functions::VALUE(); } /** * VARFunc * * Estimates variance based on a sample. * * Excel Function: * VAR(value1[,value2[, ...]]) * * @access public * @category Statistical Functions * @param mixed $arg,... Data values * @return float */ public static function VARFunc() { $returnValue = PHPExcel_Calculation_Functions::DIV0(); $summerA = $summerB = 0; // Loop through arguments $aArgs = PHPExcel_Calculation_Functions::flattenArray(func_get_args()); $aCount = 0; foreach ($aArgs as $arg) { if (is_bool($arg)) { $arg = (integer) $arg; } // Is it a numeric value? if ((is_numeric($arg)) && (!is_string($arg))) { $summerA += ($arg * $arg); $summerB += $arg; ++$aCount; } } if ($aCount > 1) { $summerA *= $aCount; $summerB *= $summerB; $returnValue = ($summerA - $summerB) / ($aCount * ($aCount - 1)); } return $returnValue; } /** * VARA * * Estimates variance based on a sample, including numbers, text, and logical values * * Excel Function: * VARA(value1[,value2[, ...]]) * * @access public * @category Statistical Functions * @param mixed $arg,... Data values * @return float */ public static function VARA() { $returnValue = PHPExcel_Calculation_Functions::DIV0(); $summerA = $summerB = 0; // Loop through arguments $aArgs = PHPExcel_Calculation_Functions::flattenArrayIndexed(func_get_args()); $aCount = 0; foreach ($aArgs as $k => $arg) { if ((is_string($arg)) && (PHPExcel_Calculation_Functions::isValue($k))) { return PHPExcel_Calculation_Functions::VALUE(); } elseif ((is_string($arg)) && (!PHPExcel_Calculation_Functions::isMatrixValue($k))) { } else { // Is it a numeric value? if ((is_numeric($arg)) || (is_bool($arg)) || ((is_string($arg) & ($arg != '')))) { if (is_bool($arg)) { $arg = (integer) $arg; } elseif (is_string($arg)) { $arg = 0; } $summerA += ($arg * $arg); $summerB += $arg; ++$aCount; } } } if ($aCount > 1) { $summerA *= $aCount; $summerB *= $summerB; $returnValue = ($summerA - $summerB) / ($aCount * ($aCount - 1)); } return $returnValue; } /** * VARP * * Calculates variance based on the entire population * * Excel Function: * VARP(value1[,value2[, ...]]) * * @access public * @category Statistical Functions * @param mixed $arg,... Data values * @return float */ public static function VARP() { // Return value $returnValue = PHPExcel_Calculation_Functions::DIV0(); $summerA = $summerB = 0; // Loop through arguments $aArgs = PHPExcel_Calculation_Functions::flattenArray(func_get_args()); $aCount = 0; foreach ($aArgs as $arg) { if (is_bool($arg)) { $arg = (integer) $arg; } // Is it a numeric value? if ((is_numeric($arg)) && (!is_string($arg))) { $summerA += ($arg * $arg); $summerB += $arg; ++$aCount; } } if ($aCount > 0) { $summerA *= $aCount; $summerB *= $summerB; $returnValue = ($summerA - $summerB) / ($aCount * $aCount); } return $returnValue; } /** * VARPA * * Calculates variance based on the entire population, including numbers, text, and logical values * * Excel Function: * VARPA(value1[,value2[, ...]]) * * @access public * @category Statistical Functions * @param mixed $arg,... Data values * @return float */ public static function VARPA() { $returnValue = PHPExcel_Calculation_Functions::DIV0(); $summerA = $summerB = 0; // Loop through arguments $aArgs = PHPExcel_Calculation_Functions::flattenArrayIndexed(func_get_args()); $aCount = 0; foreach ($aArgs as $k => $arg) { if ((is_string($arg)) && (PHPExcel_Calculation_Functions::isValue($k))) { return PHPExcel_Calculation_Functions::VALUE(); } elseif ((is_string($arg)) && (!PHPExcel_Calculation_Functions::isMatrixValue($k))) { } else { // Is it a numeric value? if ((is_numeric($arg)) || (is_bool($arg)) || ((is_string($arg) & ($arg != '')))) { if (is_bool($arg)) { $arg = (integer) $arg; } elseif (is_string($arg)) { $arg = 0; } $summerA += ($arg * $arg); $summerB += $arg; ++$aCount; } } } if ($aCount > 0) { $summerA *= $aCount; $summerB *= $summerB; $returnValue = ($summerA - $summerB) / ($aCount * $aCount); } return $returnValue; } /** * WEIBULL * * Returns the Weibull distribution. Use this distribution in reliability * analysis, such as calculating a device's mean time to failure. * * @param float $value * @param float $alpha Alpha Parameter * @param float $beta Beta Parameter * @param boolean $cumulative * @return float * */ public static function WEIBULL($value, $alpha, $beta, $cumulative) { $value = PHPExcel_Calculation_Functions::flattenSingleValue($value); $alpha = PHPExcel_Calculation_Functions::flattenSingleValue($alpha); $beta = PHPExcel_Calculation_Functions::flattenSingleValue($beta); if ((is_numeric($value)) && (is_numeric($alpha)) && (is_numeric($beta))) { if (($value < 0) || ($alpha <= 0) || ($beta <= 0)) { return PHPExcel_Calculation_Functions::NaN(); } if ((is_numeric($cumulative)) || (is_bool($cumulative))) { if ($cumulative) { return 1 - exp(0 - pow($value / $beta, $alpha)); } else { return ($alpha / pow($beta, $alpha)) * pow($value, $alpha - 1) * exp(0 - pow($value / $beta, $alpha)); } } } return PHPExcel_Calculation_Functions::VALUE(); } /** * ZTEST * * Returns the Weibull distribution. Use this distribution in reliability * analysis, such as calculating a device's mean time to failure. * * @param float $dataSet * @param float $m0 Alpha Parameter * @param float $sigma Beta Parameter * @param boolean $cumulative * @return float * */ public static function ZTEST($dataSet, $m0, $sigma = null) { $dataSet = PHPExcel_Calculation_Functions::flattenArrayIndexed($dataSet); $m0 = PHPExcel_Calculation_Functions::flattenSingleValue($m0); $sigma = PHPExcel_Calculation_Functions::flattenSingleValue($sigma); if (is_null($sigma)) { $sigma = self::STDEV($dataSet); } $n = count($dataSet); return 1 - self::NORMSDIST((self::AVERAGE($dataSet) - $m0) / ($sigma / SQRT($n))); } }