HEADmaster

1 files changed, 0 insertions, 3644 deletions

diff --git a/admin/survey/excel/PHPExcel/Calculation/Statistical.php b/admin/survey/excel/PHPExcel/Calculation/Statistical.php
deleted file mode 100644
index b2a4f43..0000000
--- a/admin/survey/excel/PHPExcel/Calculation/Statistical.php
+++ /dev/null
@@ -1,3644 +0,0 @@
-<?php

-/**

- * PHPExcel

- *

- * Copyright (c) 2006 - 2012 PHPExcel

- *

- * This library is free software; you can redistribute it and/or

- * modify it under the terms of the GNU Lesser General Public

- * License as published by the Free Software Foundation; either

- * version 2.1 of the License, or (at your option) any later version.

- *

- * This library is distributed in the hope that it will be useful,

- * but WITHOUT ANY WARRANTY; without even the implied warranty of

- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU

- * Lesser General Public License for more details.

- *

- * You should have received a copy of the GNU Lesser General Public

- * License along with this library; if not, write to the Free Software

- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA

- *

- * @category	PHPExcel

- * @package		PHPExcel_Calculation

- * @copyright	Copyright (c) 2006 - 2012 PHPExcel (http://www.codeplex.com/PHPExcel)

- * @license		http://www.gnu.org/licenses/old-licenses/lgpl-2.1.txt	LGPL

- * @version		1.7.8, 2012-10-12

- */

-

-

-/** PHPExcel root directory */

-if (!defined('PHPEXCEL_ROOT')) {

-	/**

-	 * @ignore

-	 */

-	define('PHPEXCEL_ROOT', dirname(__FILE__) . '/../../');

-	require(PHPEXCEL_ROOT . 'PHPExcel/Autoloader.php');

-}

-

-

-require_once PHPEXCEL_ROOT . 'PHPExcel/Shared/trend/trendClass.php';

-

-

-/** LOG_GAMMA_X_MAX_VALUE */

-define('LOG_GAMMA_X_MAX_VALUE', 2.55e305);

-

-/** XMININ */

-define('XMININ', 2.23e-308);

-

-/** EPS */

-define('EPS', 2.22e-16);

-

-/** SQRT2PI */

-define('SQRT2PI', 2.5066282746310005024157652848110452530069867406099);

-

-

-/**

- * PHPExcel_Calculation_Statistical

- *

- * @category	PHPExcel

- * @package		PHPExcel_Calculation

- * @copyright	Copyright (c) 2006 - 2012 PHPExcel (http://www.codeplex.com/PHPExcel)

- */

-class PHPExcel_Calculation_Statistical {

-

-

-	private static function _checkTrendArrays(&$array1,&$array2) {

-		if (!is_array($array1)) { $array1 = array($array1); }

-		if (!is_array($array2)) { $array2 = array($array2); }

-

-		$array1 = PHPExcel_Calculation_Functions::flattenArray($array1);

-		$array2 = PHPExcel_Calculation_Functions::flattenArray($array2);

-		foreach($array1 as $key => $value) {

-			if ((is_bool($value)) || (is_string($value)) || (is_null($value))) {

-				unset($array1[$key]);

-				unset($array2[$key]);

-			}

-		}

-		foreach($array2 as $key => $value) {

-			if ((is_bool($value)) || (is_string($value)) || (is_null($value))) {

-				unset($array1[$key]);

-				unset($array2[$key]);

-			}

-		}

-		$array1 = array_merge($array1);

-		$array2 = array_merge($array2);

-

-		return True;

-	}	//	function _checkTrendArrays()

-

-

-	/**

-	 * 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));

-		}

-	}	//	function _beta()

-

-

-	/**

-	 * 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 _incompleteBeta()

-

-

-	// Function cache for _logBeta function

-	private static $_logBetaCache_p			= 0.0;

-	private static $_logBetaCache_q			= 0.0;

-	private static $_logBetaCache_result	= 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::$_logBetaCache_p || $q != self::$_logBetaCache_q) {

-			self::$_logBetaCache_p = $p;

-			self::$_logBetaCache_q = $q;

-			if (($p <= 0.0) || ($q <= 0.0) || (($p + $q) > LOG_GAMMA_X_MAX_VALUE)) {

-				self::$_logBetaCache_result = 0.0;

-			} else {

-				self::$_logBetaCache_result = self::_logGamma($p) + self::_logGamma($q) - self::_logGamma($p + $q);

-			}

-		}

-		return self::$_logBetaCache_result;

-	}	//	function _logBeta()

-

-

-	/**

-	 * 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;

-	}	//	function _betaFraction()

-

-

-	/**

-	 * 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. <br />

-	 * Based on public domain NETLIB (Fortran) code by W. J. Cody and L. Stoltz <br />

-	 * Applied Mathematics Division <br />

-	 * Argonne National Laboratory <br />

-	 * Argonne, IL 60439 <br />

-	 * <p>

-	 * References:

-	 * <ol>

-	 * <li>W. J. Cody and K. E. Hillstrom, 'Chebyshev Approximations for the Natural

-	 *	 Logarithm of the Gamma Function,' Math. Comp. 21, 1967, pp. 198-203.</li>

-	 * <li>K. E. Hillstrom, ANL/AMD Program ANLC366S, DGAMMA/DLGAMA, May, 1969.</li>

-	 * <li>Hart, Et. Al., Computer Approximations, Wiley and sons, New York, 1968.</li>

-	 * </ol>

-	 * </p>

-	 * <p>

-	 * From the original documentation:

-	 * </p>

-	 * <p>

-	 * 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.

-	 * </p>

-	 * <p>

-	 * Error returns: <br />

-	 * 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.

-	 * </p>

-	 * @return MAX_VALUE for x < 0.0 or when overflow would occur, i.e. x > 2.55E305

-	 */

-

-	// Function cache for logGamma

-	private static $_logGammaCache_result	= 0.0;

-	private static $_logGammaCache_x		= 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::$_logGammaCache_x) {

-		return self::$_logGammaCache_result;

-	}

-	$y = $x;

-	if ($y > 0.0 && $y <= LOG_GAMMA_X_MAX_VALUE) {

-		if ($y <= EPS) {

-			$res = -log(y);

-		} elseif ($y <= 1.5) {

-			// ---------------------

-			//	EPS .LT. X .LE. 1.5

-			// ---------------------

-			if ($y < $pnt68) {

-				$corr = -log($y);

-				$xm1 = $y;

-			} else {

-				$corr = 0.0;

-				$xm1 = $y - 1.0;

-			}

-			if ($y <= 0.5 || $y >= $pnt68) {

-				$xden = 1.0;

-				$xnum = 0.0;

-				for ($i = 0; $i < 8; ++$i) {

-					$xnum = $xnum * $xm1 + $lg_p1[$i];

-					$xden = $xden * $xm1 + $lg_q1[$i];

-				}

-				$res = $corr + $xm1 * ($lg_d1 + $xm1 * ($xnum / $xden));

-			} else {

-				$xm2 = $y - 1.0;

-				$xden = 1.0;

-				$xnum = 0.0;

-				for ($i = 0; $i < 8; ++$i) {

-					$xnum = $xnum * $xm2 + $lg_p2[$i];

-					$xden = $xden * $xm2 + $lg_q2[$i];

-				}

-				$res = $corr + $xm2 * ($lg_d2 + $xm2 * ($xnum / $xden));

-			}

-		} elseif ($y <= 4.0) {

-			// ---------------------

-			//	1.5 .LT. X .LE. 4.0

-			// ---------------------

-			$xm2 = $y - 2.0;

-			$xden = 1.0;

-			$xnum = 0.0;

-			for ($i = 0; $i < 8; ++$i) {

-				$xnum = $xnum * $xm2 + $lg_p2[$i];

-				$xden = $xden * $xm2 + $lg_q2[$i];

-			}

-			$res = $xm2 * ($lg_d2 + $xm2 * ($xnum / $xden));

-		} elseif ($y <= 12.0) {

-			// ----------------------

-			//	4.0 .LT. X .LE. 12.0

-			// ----------------------

-			$xm4 = $y - 4.0;

-			$xden = -1.0;

-			$xnum = 0.0;

-			for ($i = 0; $i < 8; ++$i) {

-				$xnum = $xnum * $xm4 + $lg_p4[$i];

-				$xden = $xden * $xm4 + $lg_q4[$i];

-			}

-			$res = $lg_d4 + $xm4 * ($xnum / $xden);

-		} else {

-			// ---------------------------------

-			//	Evaluate for argument .GE. 12.0

-			// ---------------------------------

-			$res = 0.0;

-			if ($y <= $lg_frtbig) {

-				$res = $lg_c[6];

-				$ysq = $y * $y;

-				for ($i = 0; $i < 6; ++$i)

-					$res = $res / $ysq + $lg_c[$i];

-				}

-				$res /= $y;

-				$corr = log($y);

-				$res = $res + log(SQRT2PI) - 0.5 * $corr;

-				$res += $y * ($corr - 1.0);

-			}

-		} else {

-			// --------------------------

-			//	Return for bad arguments

-			// --------------------------

-			$res = MAX_VALUE;

-		}

-		// ------------------------------

-		//	Final adjustments and return

-		// ------------------------------

-		self::$_logGammaCache_x = $x;

-		self::$_logGammaCache_result = $res;

-		return $res;

-	}	//	function _logGamma()

-

-

-	//

-	//	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;

-	}	//	function _incompleteGamma()

-

-

-	//

-	//	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));

-	}	//	function _gamma()

-

-

-	/***************************************************************************

-	 *								inverse_ncdf.php

-	 *							-------------------

-	 *	begin				: Friday, January 16, 2004

-	 *	copyright			: (C) 2004 Michael Nickerson

-	 *	email				: nickersonm@yahoo.com

-	 *

-	 ***************************************************************************/

-	private static function _inverse_ncdf($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();

-	}	//	function _inverse_ncdf()

-

-

-	private static function _inverse_ncdf2($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 _inverse_ncdf2()

-

-

-	private static function _inverse_ncdf3($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;

-	}	//	function _inverse_ncdf3()

-

-

-	/**

-	 * 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();

-	}	//	function AVEDEV()

-

-

-	/**

-	 * 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();

-		}

-	}	//	function AVERAGE()

-

-

-	/**

-	 * 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() {

-		// Return value

-		$returnValue = null;

-

-		$aCount = 0;

-		// Loop through arguments

-		foreach (PHPExcel_Calculation_Functions::flattenArrayIndexed(func_get_args()) as $k => $arg) {

-			if ((is_bool($arg)) &&

-				(!PHPExcel_Calculation_Functions::isMatrixValue($k))) {

-			} else {

-				if ((is_numeric($arg)) || (is_bool($arg)) || ((is_string($arg) && ($arg != '')))) {

-					if (is_bool($arg)) {

-						$arg = (integer) $arg;

-					} elseif (is_string($arg)) {

-						$arg = 0;

-					}

-					if (is_null($returnValue)) {

-						$returnValue = $arg;

-					} else {

-						$returnValue += $arg;

-					}

-					++$aCount;

-				}

-			}

-		}

-

-		// Return

-		if ($aCount > 0) {

-			return $returnValue / $aCount;

-		} else {

-			return PHPExcel_Calculation_Functions::DIV0();

-		}

-	}	//	function AVERAGEA()

-

-

-	/**

-	 * 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.

-	 * @return	float

-	 */

-	public static function AVERAGEIF($aArgs,$condition,$averageArgs = array()) {

-		// Return value

-		$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;

-				}

-			}

-		}

-

-		// Return

-		if ($aCount > 0) {

-			return $returnValue / $aCount;

-		} else {

-			return PHPExcel_Calculation_Functions::DIV0();

-		}

-	}	//	function AVERAGEIF()

-

-

-	/**

-	 * 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();

-	}	//	function BETADIST()

-

-

-	/**

-	 * 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	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();

-	}	//	function BETAINV()

-

-

-	/**

-	 * 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();

-	}	//	function BINOMDIST()

-

-

-	/**

-	 * 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();

-	}	//	function CHIDIST()

-

-

-	/**

-	 * 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();

-	}	//	function CHIINV()

-

-

-	/**

-	 * 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();

-	}	//	function CONFIDENCE()

-

-

-	/**

-	 * 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();

-	}	//	function CORREL()

-

-

-	/**

-	 * 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() {

-		// Return value

-		$returnValue = 0;

-

-		// Loop through arguments

-		$aArgs = PHPExcel_Calculation_Functions::flattenArrayIndexed(func_get_args());

-		foreach ($aArgs as $k => $arg) {

-			if ((is_bool($arg)) &&

-				((!PHPExcel_Calculation_Functions::isCellValue($k)) || (PHPExcel_Calculation_Functions::getCompatibilityMode() == PHPExcel_Calculation_Functions::COMPATIBILITY_OPENOFFICE))) {

-				$arg = (integer) $arg;

-			}

-			// Is it a numeric value?

-			if ((is_numeric($arg)) && (!is_string($arg))) {

-				++$returnValue;

-			}

-		}

-

-		// Return

-		return $returnValue;

-	}	//	function COUNT()

-

-

-	/**

-	 * 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() {

-		// Return value

-		$returnValue = 0;

-

-		// Loop through arguments

-		$aArgs = PHPExcel_Calculation_Functions::flattenArray(func_get_args());

-		foreach ($aArgs as $arg) {

-			// Is it a numeric, boolean or string value?

-			if ((is_numeric($arg)) || (is_bool($arg)) || ((is_string($arg) && ($arg != '')))) {

-				++$returnValue;

-			}

-		}

-

-		// Return

-		return $returnValue;

-	}	//	function COUNTA()

-

-

-	/**

-	 * 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() {

-		// Return value

-		$returnValue = 0;

-

-		// Loop through arguments

-		$aArgs = PHPExcel_Calculation_Functions::flattenArray(func_get_args());

-		foreach ($aArgs as $arg) {

-			// Is it a blank cell?

-			if ((is_null($arg)) || ((is_string($arg)) && ($arg == ''))) {

-				++$returnValue;

-			}

-		}

-

-		// Return

-		return $returnValue;

-	}	//	function COUNTBLANK()

-

-

-	/**

-	 * 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) {

-		// Return value

-		$returnValue = 0;

-

-		$aArgs = PHPExcel_Calculation_Functions::flattenArray($aArgs);

-		$condition = PHPExcel_Calculation_Functions::_ifCondition($condition);

-		// Loop through arguments

-		foreach ($aArgs as $arg) {

-			if (!is_numeric($arg)) { $arg = PHPExcel_Calculation::_wrapResult(strtoupper($arg)); }

-			$testCondition = '='.$arg.$condition;

-			if (PHPExcel_Calculation::getInstance()->_calculateFormulaValue($testCondition)) {

-				// Is it a value within our criteria

-				++$returnValue;

-			}

-		}

-

-		// Return

-		return $returnValue;

-	}	//	function COUNTIF()

-

-

-	/**

-	 * 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();

-	}	//	function COVAR()

-

-

-	/**

-	 * 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();

-			}

-			if (($probability < 0) || ($probability > 1)) {

-				return PHPExcel_Calculation_Functions::NaN();

-			}

-			if (($alpha < 0) || ($alpha > 1)) {

-				return PHPExcel_Calculation_Functions::NaN();

-			}

-			if ($alpha <= 0.5) {

-				$t = sqrt(log(1 / ($alpha * $alpha)));

-				$trialsApprox = 0 - ($t + (2.515517 + 0.802853 * $t + 0.010328 * $t * $t) / (1 + 1.432788 * $t + 0.189269 * $t * $t + 0.001308 * $t * $t * $t));

-			} else {

-				$t = sqrt(log(1 / pow(1 - $alpha,2)));

-				$trialsApprox = $t - (2.515517 + 0.802853 * $t + 0.010328 * $t * $t) / (1 + 1.432788 * $t + 0.189269 * $t * $t + 0.001308 * $t * $t * $t);

-			}

-			$Guess = floor($trials * $probability + $trialsApprox * sqrt($trials * $probability * (1 - $probability)));

-			if ($Guess < 0) {

-				$Guess = 0;

-			} elseif ($Guess > $trials) {

-				$Guess = $trials;

-			}

-

-			$TotalUnscaledProbability = $UnscaledPGuess = $UnscaledCumPGuess = 0.0;

-			$EssentiallyZero = 10e-12;

-

-			$m = floor($trials * $probability);

-			++$TotalUnscaledProbability;

-			if ($m == $Guess) { ++$UnscaledPGuess; }

-			if ($m <= $Guess) { ++$UnscaledCumPGuess; }

-

-			$PreviousValue = 1;

-			$Done = False;

-			$k = $m + 1;

-			while ((!$Done) && ($k <= $trials)) {

-				$CurrentValue = $PreviousValue * ($trials - $k + 1) * $probability / ($k * (1 - $probability));

-				$TotalUnscaledProbability += $CurrentValue;

-				if ($k == $Guess) { $UnscaledPGuess += $CurrentValue; }

-				if ($k <= $Guess) { $UnscaledCumPGuess += $CurrentValue; }

-				if ($CurrentValue <= $EssentiallyZero) { $Done = True; }

-				$PreviousValue = $CurrentValue;

-				++$k;

-			}

-

-			$PreviousValue = 1;

-			$Done = False;

-			$k = $m - 1;

-			while ((!$Done) && ($k >= 0)) {

-				$CurrentValue = $PreviousValue * $k + 1 * (1 - $probability) / (($trials - $k) * $probability);

-				$TotalUnscaledProbability += $CurrentValue;

-				if ($k == $Guess) { $UnscaledPGuess += $CurrentValue; }

-				if ($k <= $Guess) { $UnscaledCumPGuess += $CurrentValue; }

-				if ($CurrentValue <= $EssentiallyZero) { $Done = True; }

-				$PreviousValue = $CurrentValue;

-				--$k;

-			}

-

-			$PGuess = $UnscaledPGuess / $TotalUnscaledProbability;

-			$CumPGuess = $UnscaledCumPGuess / $TotalUnscaledProbability;

-

-//			$CumPGuessMinus1 = $CumPGuess - $PGuess;

-			$CumPGuessMinus1 = $CumPGuess - 1;

-

-			while (True) {

-				if (($CumPGuessMinus1 < $alpha) && ($CumPGuess >= $alpha)) {

-					return $Guess;

-				} elseif (($CumPGuessMinus1 < $alpha) && ($CumPGuess < $alpha)) {

-					$PGuessPlus1 = $PGuess * ($trials - $Guess) * $probability / $Guess / (1 - $probability);

-					$CumPGuessMinus1 = $CumPGuess;

-					$CumPGuess = $CumPGuess + $PGuessPlus1;

-					$PGuess = $PGuessPlus1;

-					++$Guess;

-				} elseif (($CumPGuessMinus1 >= $alpha) && ($CumPGuess >= $alpha)) {

-					$PGuessMinus1 = $PGuess * $Guess * (1 - $probability) / ($trials - $Guess + 1) / $probability;

-					$CumPGuess = $CumPGuessMinus1;

-					$CumPGuessMinus1 = $CumPGuessMinus1 - $PGuess;

-					$PGuess = $PGuessMinus1;

-					--$Guess;

-				}

-			}

-		}

-		return PHPExcel_Calculation_Functions::VALUE();

-	}	//	function CRITBINOM()

-

-

-	/**

-	 * 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();

-	}	//	function DEVSQ()

-

-

-	/**

-	 * 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();

-	}	//	function EXPONDIST()

-

-

-	/**

-	 * 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();

-	}	//	function FISHER()

-

-

-	/**

-	 * 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();

-	}	//	function FISHERINV()

-

-

-	/**

-	 * 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();

-		}

-

-		if (!self::_checkTrendArrays($yValues,$xValues)) {

-			return PHPExcel_Calculation_Functions::VALUE();

-		}

-		$yValueCount = count($yValues);

-		$xValueCount = count($xValues);

-

-		if (($yValueCount == 0) || ($yValueCount != $xValueCount)) {

-			return PHPExcel_Calculation_Functions::NA();

-		} elseif ($yValueCount == 1) {

-			return PHPExcel_Calculation_Functions::DIV0();

-		}

-

-		$bestFitLinear = trendClass::calculate(trendClass::TREND_LINEAR,$yValues,$xValues);

-		return $bestFitLinear->getValueOfYForX($xValue);

-	}	//	function FORECAST()

-

-

-	/**

-	 * 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();

-	}	//	function GAMMADIST()

-

-

-	/**

-	 * 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();

-	}	//	function GAMMAINV()

-

-

-	/**

-	 * 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();

-	}	//	function GAMMALN()

-

-

-	/**

-	 * 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();

-	}	//	GEOMEAN()

-

-

-	/**

-	 * 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;

-	}	//	function GROWTH()

-

-

-	/**

-	 * 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;

-		}

-	}	//	function HARMEAN()

-

-

-	/**

-	 * 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();

-	}	//	function HYPGEOMDIST()

-

-

-	/**

-	 * 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();

-	}	//	function INTERCEPT()

-

-

-	/**

-	 * 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();

-	}	//	function KURT()

-

-

-	/**

-	 * 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();

-	}	//	function LARGE()

-

-

-	/**

-	 * 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()

-						);

-		}

-	}	//	function LINEST()

-

-

-	/**

-	 * 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()

-						);

-		}

-	}	//	function LOGEST()

-

-

-	/**

-	 * LOGINV

-	 *

-	 * Returns the inverse of the normal cumulative distribution

-	 *

-	 * @param	float		$value

-	 * @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();

-	}	//	function LOGINV()

-

-

-	/**

-	 * LOGNORMDIST

-	 *

-	 * Returns the cumulative lognormal distribution of x, where ln(x) is normally distributed

-	 * with parameters mean and standard_dev.

-	 *

-	 * @param	float		$value

-	 * @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();

-	}	//	function LOGNORMDIST()

-

-

-	/**

-	 * 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() {

-		// Return value

-		$returnValue = null;

-

-		// Loop through arguments

-		$aArgs = PHPExcel_Calculation_Functions::flattenArray(func_get_args());

-		foreach ($aArgs as $arg) {

-			// Is it a numeric value?

-			if ((is_numeric($arg)) && (!is_string($arg))) {

-				if ((is_null($returnValue)) || ($arg > $returnValue)) {

-					$returnValue = $arg;

-				}

-			}

-		}

-

-		// Return

-		if(is_null($returnValue)) {

-			return 0;

-		}

-		return $returnValue;

-	}	//	function MAX()

-

-

-	/**

-	 * 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() {

-		// Return value

-		$returnValue = null;

-

-		// Loop through arguments

-		$aArgs = PHPExcel_Calculation_Functions::flattenArray(func_get_args());

-		foreach ($aArgs as $arg) {

-			// Is it a numeric value?

-			if ((is_numeric($arg)) || (is_bool($arg)) || ((is_string($arg) && ($arg != '')))) {

-				if (is_bool($arg)) {

-					$arg = (integer) $arg;

-				} elseif (is_string($arg)) {

-					$arg = 0;

-				}

-				if ((is_null($returnValue)) || ($arg > $returnValue)) {

-					$returnValue = $arg;

-				}

-			}

-		}

-

-		// Return

-		if(is_null($returnValue)) {

-			return 0;

-		}

-		return $returnValue;

-	}	//	function MAXA()

-

-

-	/**

-	 * 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()) {

-		// Return value

-		$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

-		return $returnValue;

-	}	//	function MAXIF()

-

-

-	/**

-	 * 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() {

-		// Return value

-		$returnValue = PHPExcel_Calculation_Functions::NaN();

-

-		$mArgs = array();

-		// Loop through arguments

-		$aArgs = PHPExcel_Calculation_Functions::flattenArray(func_get_args());

-		foreach ($aArgs as $arg) {

-			// Is it a numeric value?

-			if ((is_numeric($arg)) && (!is_string($arg))) {

-				$mArgs[] = $arg;

-			}

-		}

-

-		$mValueCount = count($mArgs);

-		if ($mValueCount > 0) {

-			sort($mArgs,SORT_NUMERIC);

-			$mValueCount = $mValueCount / 2;

-			if ($mValueCount == floor($mValueCount)) {

-				$returnValue = ($mArgs[$mValueCount--] + $mArgs[$mValueCount]) / 2;

-			} else {

-				$mValueCount == floor($mValueCount);

-				$returnValue = $mArgs[$mValueCount];

-			}

-		}

-

-		// Return

-		return $returnValue;

-	}	//	function MEDIAN()

-

-

-	/**

-	 * 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() {

-		// Return value

-		$returnValue = null;

-

-		// Loop through arguments

-		$aArgs = PHPExcel_Calculation_Functions::flattenArray(func_get_args());

-		foreach ($aArgs as $arg) {

-			// Is it a numeric value?

-			if ((is_numeric($arg)) && (!is_string($arg))) {

-				if ((is_null($returnValue)) || ($arg < $returnValue)) {

-					$returnValue = $arg;

-				}

-			}

-		}

-

-		// Return

-		if(is_null($returnValue)) {

-			return 0;

-		}

-		return $returnValue;

-	}	//	function MIN()

-

-

-	/**

-	 * 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() {

-		// Return value

-		$returnValue = null;

-

-		// Loop through arguments

-		$aArgs = PHPExcel_Calculation_Functions::flattenArray(func_get_args());

-		foreach ($aArgs as $arg) {

-			// Is it a numeric value?

-			if ((is_numeric($arg)) || (is_bool($arg)) || ((is_string($arg) && ($arg != '')))) {

-				if (is_bool($arg)) {

-					$arg = (integer) $arg;

-				} elseif (is_string($arg)) {

-					$arg = 0;

-				}

-				if ((is_null($returnValue)) || ($arg < $returnValue)) {

-					$returnValue = $arg;

-				}

-			}

-		}

-

-		// Return

-		if(is_null($returnValue)) {

-			return 0;

-		}

-		return $returnValue;

-	}	//	function MINA()

-

-

-	/**

-	 * 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()) {

-		// Return value

-		$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

-		return $returnValue;

-	}	//	function MINIF()

-

-

-	//

-	//	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'];

-	}	//	function _modeCalc()

-

-

-	/**

-	 * 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() {

-		// Return value

-		$returnValue = PHPExcel_Calculation_Functions::NA();

-

-		// Loop through arguments

-		$aArgs = PHPExcel_Calculation_Functions::flattenArray(func_get_args());

-

-		$mArgs = array();

-		foreach ($aArgs as $arg) {

-			// Is it a numeric value?

-			if ((is_numeric($arg)) && (!is_string($arg))) {

-				$mArgs[] = $arg;

-			}

-		}

-

-		if (!empty($mArgs)) {

-			return self::_modeCalc($mArgs);

-		}

-

-		// Return

-		return $returnValue;

-	}	//	function MODE()

-

-

-	/**

-	 * 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();

-			}

-			if (($probability < 0) || ($probability > 1)) {

-				return PHPExcel_Calculation_Functions::NaN();

-			}

-			if (PHPExcel_Calculation_Functions::getCompatibilityMode() == PHPExcel_Calculation_Functions::COMPATIBILITY_GNUMERIC) {

-				if (($failures + $successes - 1) <= 0) {

-					return PHPExcel_Calculation_Functions::NaN();

-				}

-			}

-			return (PHPExcel_Calculation_MathTrig::COMBIN($failures + $successes - 1,$successes - 1)) * (pow($probability,$successes)) * (pow(1 - $probability,$failures)) ;

-		}

-		return PHPExcel_Calculation_Functions::VALUE();

-	}	//	function NEGBINOMDIST()

-

-

-	/**

-	 * 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();

-	}	//	function NORMDIST()

-

-

-	/**

-	 * 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::_inverse_ncdf($probability) * $stdDev) + $mean;

-		}

-		return PHPExcel_Calculation_Functions::VALUE();

-	}	//	function NORMINV()

-

-

-	/**

-	 * 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);

-	}	//	function NORMSDIST()

-

-

-	/**

-	 * 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);

-	}	//	function NORMSINV()

-

-

-	/**

-	 * 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();

-	}	//	function PERCENTILE()

-

-

-	/**

-	 * 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);

-	}	//	function PERCENTRANK()

-

-

-	/**

-	 * 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();

-	}	//	function PERMUT()

-

-

-	/**

-	 * 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();

-	}	//	function POISSON()

-

-

-	/**

-	 * 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();

-	}	//	function QUARTILE()

-

-

-	/**

-	 * 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;

-	}	//	function RANK()

-

-

-	/**

-	 * 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();

-	}	//	function RSQ()

-

-

-	/**

-	 * 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;

-				}

-			}

-		}

-

-		// Return

-		if ($count > 2) {

-			return $summer * ($count / (($count-1) * ($count-2)));

-		}

-		return PHPExcel_Calculation_Functions::DIV0();

-	}	//	function SKEW()

-

-

-	/**

-	 * 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();

-	}	//	function SLOPE()

-

-

-	/**

-	 * 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();

-	}	//	function SMALL()

-

-

-	/**

-	 * 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();

-	}	//	function STANDARDIZE()

-

-

-	/**

-	 * 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();

-	}	//	function STDEV()

-

-

-	/**

-	 * 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());

-

-		// Return value

-		$returnValue = null;

-

-		$aMean = self::AVERAGEA($aArgs);

-		if (!is_null($aMean)) {

-			$aCount = -1;

-			foreach ($aArgs as $k => $arg) {

-				if ((is_bool($arg)) &&

-					(!PHPExcel_Calculation_Functions::isMatrixValue($k))) {

-				} else {

-					// Is it a numeric value?

-					if ((is_numeric($arg)) || (is_bool($arg)) || ((is_string($arg) & ($arg != '')))) {

-						if (is_bool($arg)) {

-							$arg = (integer) $arg;

-						} elseif (is_string($arg)) {

-							$arg = 0;

-						}

-						if (is_null($returnValue)) {

-							$returnValue = pow(($arg - $aMean),2);

-						} else {

-							$returnValue += pow(($arg - $aMean),2);

-						}

-						++$aCount;

-					}

-				}

-			}

-

-			// Return

-			if (($aCount > 0) && ($returnValue >= 0)) {

-				return sqrt($returnValue / $aCount);

-			}

-		}

-		return PHPExcel_Calculation_Functions::DIV0();

-	}	//	function STDEVA()

-

-

-	/**

-	 * 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());

-

-		// Return value

-		$returnValue = null;

-

-		$aMean = self::AVERAGE($aArgs);

-		if (!is_null($aMean)) {

-			$aCount = 0;

-			foreach ($aArgs as $k => $arg) {

-				if ((is_bool($arg)) &&

-					((!PHPExcel_Calculation_Functions::isCellValue($k)) || (PHPExcel_Calculation_Functions::getCompatibilityMode() == PHPExcel_Calculation_Functions::COMPATIBILITY_OPENOFFICE))) {

-					$arg = (integer) $arg;

-				}

-				// Is it a numeric value?

-				if ((is_numeric($arg)) && (!is_string($arg))) {

-					if (is_null($returnValue)) {

-						$returnValue = pow(($arg - $aMean),2);

-					} else {

-						$returnValue += pow(($arg - $aMean),2);

-					}

-					++$aCount;

-				}

-			}

-

-			// Return

-			if (($aCount > 0) && ($returnValue >= 0)) {

-				return sqrt($returnValue / $aCount);

-			}

-		}

-		return PHPExcel_Calculation_Functions::DIV0();

-	}	//	function STDEVP()

-

-

-	/**

-	 * 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());

-

-		// Return value

-		$returnValue = null;

-

-		$aMean = self::AVERAGEA($aArgs);

-		if (!is_null($aMean)) {

-			$aCount = 0;

-			foreach ($aArgs as $k => $arg) {

-				if ((is_bool($arg)) &&

-					(!PHPExcel_Calculation_Functions::isMatrixValue($k))) {

-				} else {

-					// Is it a numeric value?

-					if ((is_numeric($arg)) || (is_bool($arg)) || ((is_string($arg) & ($arg != '')))) {

-						if (is_bool($arg)) {

-							$arg = (integer) $arg;

-						} elseif (is_string($arg)) {

-							$arg = 0;

-						}

-						if (is_null($returnValue)) {

-							$returnValue = pow(($arg - $aMean),2);

-						} else {

-							$returnValue += pow(($arg - $aMean),2);

-						}

-						++$aCount;

-					}

-				}

-			}

-

-			// Return

-			if (($aCount > 0) && ($returnValue >= 0)) {

-				return sqrt($returnValue / $aCount);

-			}

-		}

-		return PHPExcel_Calculation_Functions::DIV0();

-	}	//	function STDEVPA()

-

-

-	/**

-	 * 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();

-	}	//	function STEYX()

-

-

-	/**

-	 * 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();

-	}	//	function TDIST()

-

-

-	/**

-	 * 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();

-	}	//	function TINV()

-

-

-	/**

-	 * 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;

-	}	//	function TREND()

-

-

-	/**

-	 * 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();

-	}	//	function TRIMMEAN()

-

-

-	/**

-	 * 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() {

-		// Return value

-		$returnValue = PHPExcel_Calculation_Functions::DIV0();

-

-		$summerA = $summerB = 0;

-

-		// Loop through arguments

-		$aArgs = PHPExcel_Calculation_Functions::flattenArray(func_get_args());

-		$aCount = 0;

-		foreach ($aArgs as $arg) {

-			if (is_bool($arg)) { $arg = (integer) $arg; }

-			// Is it a numeric value?

-			if ((is_numeric($arg)) && (!is_string($arg))) {

-				$summerA += ($arg * $arg);

-				$summerB += $arg;

-				++$aCount;

-			}

-		}

-

-		// Return

-		if ($aCount > 1) {

-			$summerA *= $aCount;

-			$summerB *= $summerB;

-			$returnValue = ($summerA - $summerB) / ($aCount * ($aCount - 1));

-		}

-		return $returnValue;

-	}	//	function VARFunc()

-

-

-	/**

-	 * 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() {

-		// Return value

-		$returnValue = PHPExcel_Calculation_Functions::DIV0();

-

-		$summerA = $summerB = 0;

-

-		// Loop through arguments

-		$aArgs = PHPExcel_Calculation_Functions::flattenArrayIndexed(func_get_args());

-		$aCount = 0;

-		foreach ($aArgs as $k => $arg) {

-			if ((is_string($arg)) &&

-				(PHPExcel_Calculation_Functions::isValue($k))) {

-				return PHPExcel_Calculation_Functions::VALUE();

-			} elseif ((is_string($arg)) &&

-				(!PHPExcel_Calculation_Functions::isMatrixValue($k))) {

-			} else {

-				// Is it a numeric value?

-				if ((is_numeric($arg)) || (is_bool($arg)) || ((is_string($arg) & ($arg != '')))) {

-					if (is_bool($arg)) {

-						$arg = (integer) $arg;

-					} elseif (is_string($arg)) {

-						$arg = 0;

-					}

-					$summerA += ($arg * $arg);

-					$summerB += $arg;

-					++$aCount;

-				}

-			}

-		}

-

-		// Return

-		if ($aCount > 1) {

-			$summerA *= $aCount;

-			$summerB *= $summerB;

-			$returnValue = ($summerA - $summerB) / ($aCount * ($aCount - 1));

-		}

-		return $returnValue;

-	}	//	function VARA()

-

-

-	/**

-	 * 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;

-			}

-		}

-

-		// Return

-		if ($aCount > 0) {

-			$summerA *= $aCount;

-			$summerB *= $summerB;

-			$returnValue = ($summerA - $summerB) / ($aCount * $aCount);

-		}

-		return $returnValue;

-	}	//	function VARP()

-

-

-	/**

-	 * 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() {

-		// Return value

-		$returnValue = PHPExcel_Calculation_Functions::DIV0();

-

-		$summerA = $summerB = 0;

-

-		// Loop through arguments

-		$aArgs = PHPExcel_Calculation_Functions::flattenArrayIndexed(func_get_args());

-		$aCount = 0;

-		foreach ($aArgs as $k => $arg) {

-			if ((is_string($arg)) &&

-				(PHPExcel_Calculation_Functions::isValue($k))) {

-				return PHPExcel_Calculation_Functions::VALUE();

-			} elseif ((is_string($arg)) &&

-				(!PHPExcel_Calculation_Functions::isMatrixValue($k))) {

-			} else {

-				// Is it a numeric value?

-				if ((is_numeric($arg)) || (is_bool($arg)) || ((is_string($arg) & ($arg != '')))) {

-					if (is_bool($arg)) {

-						$arg = (integer) $arg;

-					} elseif (is_string($arg)) {

-						$arg = 0;

-					}

-					$summerA += ($arg * $arg);

-					$summerB += $arg;

-					++$aCount;

-				}

-			}

-		}

-

-		// Return

-		if ($aCount > 0) {

-			$summerA *= $aCount;

-			$summerB *= $summerB;

-			$returnValue = ($summerA - $summerB) / ($aCount * $aCount);

-		}

-		return $returnValue;

-	}	//	function VARPA()

-

-

-	/**

-	 * 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();

-	}	//	function WEIBULL()

-

-

-	/**

-	 * ZTEST

-	 *

-	 * 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 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)));

-	}	//	function ZTEST()

-

-}	//	class PHPExcel_Calculation_Statistical