/branches/v1.7.2/Classes/PHPExcel/Calculation/Functions.php

Large files files are truncated, but you can click here to view the full file

<?php
/**
 * PHPExcel
 *
 * Copyright (c) 2006 - 2010 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 - 2010 PHPExcel (http://www.codeplex.com/PHPExcel)
 * @license		http://www.gnu.org/licenses/old-licenses/lgpl-2.1.txt	LGPL
 * @version		##VERSION##, ##DATE##
 */


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

/** MAX_VALUE */
define('MAX_VALUE', 1.2e308);

/** LOG_GAMMA_X_MAX_VALUE */
define('LOG_GAMMA_X_MAX_VALUE', 2.55e305);

/** SQRT2PI */
define('SQRT2PI', 2.5066282746310005024157652848110452530069867406099);

/** 2 / PI */
define('M_2DIVPI', 0.63661977236758134307553505349006);

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

/** MAX_ITERATIONS */
define('MAX_ITERATIONS', 256);
/** FINANCIAL_MAX_ITERATIONS */
define('FINANCIAL_MAX_ITERATIONS', 128);

/** PRECISION */
define('PRECISION', 8.88E-016);
/** FINANCIAL_PRECISION */
define('FINANCIAL_PRECISION', 1.0e-08);

/** EULER */
define('EULER', 2.71828182845904523536);

$savedPrecision = ini_get('precision');
if ($savedPrecision < 16) {
	ini_set('precision',16);
}


/** PHPExcel root directory */
if (!defined('PHPEXCEL_ROOT')) {
	/**
	 * @ignore
	 */
	define('PHPEXCEL_ROOT', dirname(__FILE__) . '/../../');
}

/** PHPExcel_Cell */
require_once PHPEXCEL_ROOT . 'PHPExcel/Cell.php';

/** PHPExcel_Calculation */
require_once PHPEXCEL_ROOT . 'PHPExcel/Calculation.php';

/** PHPExcel_Cell_DataType */
require_once PHPEXCEL_ROOT . 'PHPExcel/Cell/DataType.php';

/** PHPExcel_Style_NumberFormat */
require_once PHPEXCEL_ROOT . 'PHPExcel/Style/NumberFormat.php';

/** PHPExcel_Shared_Date */
require_once PHPEXCEL_ROOT . 'PHPExcel/Shared/Date.php';

/** Matrix */
require_once PHPEXCEL_ROOT . 'PHPExcel/Shared/JAMA/Matrix.php';
require_once PHPEXCEL_ROOT . 'PHPExcel/Shared/trend/trendClass.php';


/**
 * PHPExcel_Calculation_Functions
 *
 * @category	PHPExcel
 * @package		PHPExcel_Calculation
 * @copyright	Copyright (c) 2006 - 2010 PHPExcel (http://www.codeplex.com/PHPExcel)
 */
class PHPExcel_Calculation_Functions {

	/** constants */
	const COMPATIBILITY_EXCEL		= 'Excel';
	const COMPATIBILITY_GNUMERIC	= 'Gnumeric';
	const COMPATIBILITY_OPENOFFICE	= 'OpenOfficeCalc';

	const RETURNDATE_PHP_NUMERIC	= 'P';
	const RETURNDATE_PHP_OBJECT		= 'O';
	const RETURNDATE_EXCEL			= 'E';


	/**
	 *	Compatibility mode to use for error checking and responses
	 *
	 *	@access	private
	 *	@var string
	 */
	private static $compatibilityMode	= self::COMPATIBILITY_EXCEL;

	/**
	 *	Data Type to use when returning date values
	 *
	 *	@access	private
	 *	@var integer
	 */
	private static $ReturnDateType	= self::RETURNDATE_EXCEL;

	/**
	 *	List of error codes
	 *
	 *	@access	private
	 *	@var array
	 */
	private static $_errorCodes	= array( 'null'				=> '#NULL!',
										 'divisionbyzero'	=> '#DIV/0!',
										 'value'			=> '#VALUE!',
										 'reference'		=> '#REF!',
										 'name'				=> '#NAME?',
										 'num'				=> '#NUM!',
										 'na'				=> '#N/A',
										 'gettingdata'		=> '#GETTING_DATA'
									   );


	/**
	 *	Set the Compatibility Mode
	 *
	 *	@access	public
	 *	@category Function Configuration
	 *	@param	 string		$compatibilityMode		Compatibility Mode
	 *												Permitted values are:
	 *													PHPExcel_Calculation_Functions::COMPATIBILITY_EXCEL			'Excel'
	 *													PHPExcel_Calculation_Functions::COMPATIBILITY_GNUMERIC		'Gnumeric'
	 *													PHPExcel_Calculation_Functions::COMPATIBILITY_OPENOFFICE	'OpenOfficeCalc'
	 *	@return	 boolean	(Success or Failure)
	 */
	public static function setCompatibilityMode($compatibilityMode) {
		if (($compatibilityMode == self::COMPATIBILITY_EXCEL) ||
			($compatibilityMode == self::COMPATIBILITY_GNUMERIC) ||
			($compatibilityMode == self::COMPATIBILITY_OPENOFFICE)) {
			self::$compatibilityMode = $compatibilityMode;
			return True;
		}
		return False;
	}	//	function setCompatibilityMode()


	/**
	 *	Return the current Compatibility Mode
	 *
	 *	@access	public
	 *	@category Function Configuration
	 *	@return	 string		Compatibility Mode
	 *							Possible Return values are:
	 *								PHPExcel_Calculation_Functions::COMPATIBILITY_EXCEL			'Excel'
	 *								PHPExcel_Calculation_Functions::COMPATIBILITY_GNUMERIC		'Gnumeric'
	 *								PHPExcel_Calculation_Functions::COMPATIBILITY_OPENOFFICE	'OpenOfficeCalc'
	 */
	public static function getCompatibilityMode() {
		return self::$compatibilityMode;
	}	//	function getCompatibilityMode()


	/**
	 *	Set the Return Date Format used by functions that return a date/time (Excel, PHP Serialized Numeric or PHP Object)
	 *
	 *	@access	public
	 *	@category Function Configuration
	 *	@param	 string	$returnDateType			Return Date Format
	 *												Permitted values are:
	 *													PHPExcel_Calculation_Functions::RETURNDATE_PHP_NUMERIC		'P'
	 *													PHPExcel_Calculation_Functions::RETURNDATE_PHP_OBJECT		'O'
	 *													PHPExcel_Calculation_Functions::RETURNDATE_EXCEL			'E'
	 *	@return	 boolean							Success or failure
	 */
	public static function setReturnDateType($returnDateType) {
		if (($returnDateType == self::RETURNDATE_PHP_NUMERIC) ||
			($returnDateType == self::RETURNDATE_PHP_OBJECT) ||
			($returnDateType == self::RETURNDATE_EXCEL)) {
			self::$ReturnDateType = $returnDateType;
			return True;
		}
		return False;
	}	//	function setReturnDateType()


	/**
	 *	Return the current Return Date Format for functions that return a date/time (Excel, PHP Serialized Numeric or PHP Object)
	 *
	 *	@access	public
	 *	@category Function Configuration
	 *	@return	 string		Return Date Format
	 *							Possible Return values are:
	 *								PHPExcel_Calculation_Functions::RETURNDATE_PHP_NUMERIC		'P'
	 *								PHPExcel_Calculation_Functions::RETURNDATE_PHP_OBJECT		'O'
	 *								PHPExcel_Calculation_Functions::RETURNDATE_EXCEL			'E'
	 */
	public static function getReturnDateType() {
		return self::$ReturnDateType;
	}	//	function getReturnDateType()


	/**
	 *	DUMMY
	 *
	 *	@access	public
	 *	@category Error Returns
	 *	@return	string	#Not Yet Implemented
	 */
	public static function DUMMY() {
		return '#Not Yet Implemented';
	}	//	function DUMMY()


	/**
	 *	NA
	 *
	 *	@access	public
	 *	@category Error Returns
	 *	@return	string	#N/A!
	 */
	public static function NA() {
		return self::$_errorCodes['na'];
	}	//	function NA()


	/**
	 *	NAN
	 *
	 *	@access	public
	 *	@category Error Returns
	 *	@return	string	#NUM!
	 */
	public static function NaN() {
		return self::$_errorCodes['num'];
	}	//	function NAN()


	/**
	 *	NAME
	 *
	 *	@access	public
	 *	@category Error Returns
	 *	@return	string	#NAME!
	 */
	public static function NAME() {
		return self::$_errorCodes['name'];
	}	//	function NAME()


	/**
	 *	REF
	 *
	 *	@access	public
	 *	@category Error Returns
	 *	@return	string	#REF!
	 */
	public static function REF() {
		return self::$_errorCodes['reference'];
	}	//	function REF()


	/**
	 *	VALUE
	 *
	 *	@access	public
	 *	@category Error Returns
	 *	@return	string	#VALUE!
	 */
	public static function VALUE() {
		return self::$_errorCodes['value'];
	}	//	function VALUE()


	private static function isMatrixValue($idx) {
		return ((substr_count($idx,'.') <= 1) || (preg_match('/\.[A-Z]/',$idx) > 0));
	}


	private static function isValue($idx) {
		return (substr_count($idx,'.') == 0);
	}


	private static function isCellValue($idx) {
		return (substr_count($idx,'.') > 1);
	}


	/**
	 *	LOGICAL_AND
	 *
	 *	Returns boolean TRUE if all its arguments are TRUE; returns FALSE if one or more argument is FALSE.
	 *
	 *	Excel Function:
	 *		=AND(logical1[,logical2[, ...]])
	 *
	 *		The arguments must evaluate to logical values such as TRUE or FALSE, or the arguments must be arrays
	 *			or references that contain logical values.
	 *
	 *		Boolean arguments are treated as True or False as appropriate
	 *		Integer or floating point arguments are treated as True, except for 0 or 0.0 which are False
	 *		If any argument value is a string, or a Null, the function returns a #VALUE! error, unless the string holds
	 *			the value TRUE or FALSE, in which case it is evaluated as the corresponding boolean value
	 *
	 *	@access	public
	 *	@category Logical Functions
	 *	@param	mixed		$arg,...		Data values
	 *	@return	boolean		The logical AND of the arguments.
	 */
	public static function LOGICAL_AND() {
		// Return value
		$returnValue = True;

		// Loop through the arguments
		$aArgs = self::flattenArray(func_get_args());
		$argCount = 0;
		foreach ($aArgs as $arg) {
			// Is it a boolean value?
			if (is_bool($arg)) {
				$returnValue = $returnValue && $arg;
			} elseif ((is_numeric($arg)) && (!is_string($arg))) {
				$returnValue = $returnValue && ($arg != 0);
			} elseif (is_string($arg)) {
				$arg = strtoupper($arg);
				if ($arg == 'TRUE') {
					$arg = 1;
				} elseif ($arg == 'FALSE') {
					$arg = 0;
				} else {
					return self::$_errorCodes['value'];
				}
				$returnValue = $returnValue && ($arg != 0);
			}
			++$argCount;
		}

		// Return
		if ($argCount == 0) {
			return self::$_errorCodes['value'];
		}
		return $returnValue;
	}	//	function LOGICAL_AND()


	/**
	 *	LOGICAL_OR
	 *
	 *	Returns boolean TRUE if any argument is TRUE; returns FALSE if all arguments are FALSE.
	 *
	 *	Excel Function:
	 *		=OR(logical1[,logical2[, ...]])
	 *
	 *		The arguments must evaluate to logical values such as TRUE or FALSE, or the arguments must be arrays
	 *			or references that contain logical values.
	 *
	 *		Boolean arguments are treated as True or False as appropriate
	 *		Integer or floating point arguments are treated as True, except for 0 or 0.0 which are False
	 *		If any argument value is a string, or a Null, the function returns a #VALUE! error, unless the string holds
	 *			the value TRUE or FALSE, in which case it is evaluated as the corresponding boolean value
	 *
	 *	@access	public
	 *	@category Logical Functions
	 *	@param	mixed		$arg,...		Data values
	 *	@return	boolean		The logical OR of the arguments.
	 */
	public static function LOGICAL_OR() {
		// Return value
		$returnValue = False;

		// Loop through the arguments
		$aArgs = self::flattenArray(func_get_args());
		$argCount = 0;
		foreach ($aArgs as $arg) {
			// Is it a boolean value?
			if (is_bool($arg)) {
				$returnValue = $returnValue || $arg;
			} elseif ((is_numeric($arg)) && (!is_string($arg))) {
				$returnValue = $returnValue || ($arg != 0);
			} elseif (is_string($arg)) {
				$arg = strtoupper($arg);
				if ($arg == 'TRUE') {
					$arg = 1;
				} elseif ($arg == 'FALSE') {
					$arg = 0;
				} else {
					return self::$_errorCodes['value'];
				}
				$returnValue = $returnValue || ($arg != 0);
			}
			++$argCount;
		}

		// Return
		if ($argCount == 0) {
			return self::$_errorCodes['value'];
		}
		return $returnValue;
	}	//	function LOGICAL_OR()


	/**
	 *	LOGICAL_FALSE
	 *
	 *	Returns the boolean FALSE.
	 *
	 *	Excel Function:
	 *		=FALSE()
	 *
	 *	@access	public
	 *	@category Logical Functions
	 *	@return	boolean		False
	 */
	public static function LOGICAL_FALSE() {
		return False;
	}	//	function LOGICAL_FALSE()


	/**
	 *	LOGICAL_TRUE
	 *
	 *	Returns the boolean TRUE.
	 *
	 *	Excel Function:
	 *		=TRUE()
	 *
	 *	@access	public
	 *	@category Logical Functions
	 *	@return	boolean		True
	 */
	public static function LOGICAL_TRUE() {
		return True;
	}	//	function LOGICAL_TRUE()


	/**
	 *	LOGICAL_NOT
	 *
	 *	Returns the boolean inverse of the argument.
	 *
	 *	Excel Function:
	 *		=NOT(logical)
	 *
	 *		The argument must evaluate to a logical value such as TRUE or FALSE
	 *
	 *		Boolean arguments are treated as True or False as appropriate
	 *		Integer or floating point arguments are treated as True, except for 0 or 0.0 which are False
	 *		If any argument value is a string, or a Null, the function returns a #VALUE! error, unless the string holds
	 *			the value TRUE or FALSE, in which case it is evaluated as the corresponding boolean value
	 *
	 *	@access	public
	 *	@category Logical Functions
	 *	@param	mixed		$logical	A value or expression that can be evaluated to TRUE or FALSE
	 *	@return	boolean		The boolean inverse of the argument.
	 */
	public static function LOGICAL_NOT($logical) {
		$logical = self::flattenSingleValue($logical);
		if (is_string($logical)) {
			$logical = strtoupper($logical);
			if ($logical == 'TRUE') {
				return False;
			} elseif ($logical == 'FALSE') {
				return True;
			} else {
				return self::$_errorCodes['value'];
			}
		}

		return !$logical;
	}	//	function LOGICAL_NOT()


	/**
	 *	STATEMENT_IF
	 *
	 *	Returns one value if a condition you specify evaluates to TRUE and another value if it evaluates to FALSE.
	 *
	 *	Excel Function:
	 *		=IF(condition[,returnIfTrue[,returnIfFalse]])
	 *
	 *		Condition is any value or expression that can be evaluated to TRUE or FALSE.
	 *			For example, A10=100 is a logical expression; if the value in cell A10 is equal to 100,
	 *			the expression evaluates to TRUE. Otherwise, the expression evaluates to FALSE.
	 *			This argument can use any comparison calculation operator.
	 *		ReturnIfTrue is the value that is returned if condition evaluates to TRUE.
	 *			For example, if this argument is the text string "Within budget" and the condition argument evaluates to TRUE,
	 *			then the IF function returns the text "Within budget"
	 *			If condition is TRUE and ReturnIfTrue is blank, this argument returns 0 (zero). To display the word TRUE, use
	 *			the logical value TRUE for this argument.
	 *			ReturnIfTrue can be another formula.
	 *		ReturnIfFalse is the value that is returned if condition evaluates to FALSE.
	 *			For example, if this argument is the text string "Over budget" and the condition argument evaluates to FALSE,
	 *			then the IF function returns the text "Over budget".
	 *			If condition is FALSE and ReturnIfFalse is omitted, then the logical value FALSE is returned.
	 *			If condition is FALSE and ReturnIfFalse is blank, then the value 0 (zero) is returned.
	 *			ReturnIfFalse can be another formula.
	 *
	 *	@access	public
	 *	@category Logical Functions
	 *	@param	mixed	$condition		Condition to evaluate
	 *	@param	mixed	$returnIfTrue	Value to return when condition is true
	 *	@param	mixed	$returnIfFalse	Optional value to return when condition is false
	 *	@return	mixed	The value of returnIfTrue or returnIfFalse determined by condition
	 */
	public static function STATEMENT_IF($condition = true, $returnIfTrue = 0, $returnIfFalse = False) {
		$condition		= (is_null($condition))		? True :	(boolean) self::flattenSingleValue($condition);
		$returnIfTrue	= (is_null($returnIfTrue))	? 0 :		self::flattenSingleValue($returnIfTrue);
		$returnIfFalse	= (is_null($returnIfFalse))	? False :	self::flattenSingleValue($returnIfFalse);

		return ($condition ? $returnIfTrue : $returnIfFalse);
	}	//	function STATEMENT_IF()


	/**
	 *	STATEMENT_IFERROR
	 *
	 *	Excel Function:
	 *		=IFERROR(testValue,errorpart)
	 *
	 *	@access	public
	 *	@category Logical Functions
	 *	@param	mixed	$testValue	Value to check, is also the value returned when no error
	 *	@param	mixed	$errorpart	Value to return when testValue is an error condition
	 *	@return	mixed	The value of errorpart or testValue determined by error condition
	 */
	public static function STATEMENT_IFERROR($testValue = '', $errorpart = '') {
		$testValue	= (is_null($testValue))	? '' :	self::flattenSingleValue($testValue);
		$errorpart	= (is_null($errorpart))	? '' :	self::flattenSingleValue($errorpart);

		return self::STATEMENT_IF(self::IS_ERROR($testValue), $errorpart, $testValue);
	}	//	function STATEMENT_IFERROR()


	/**
	 *	ATAN2
	 *
	 *	This function calculates the arc tangent of the two variables x and y. It is similar to
	 *		calculating the arc tangent of y ÷ x, except that the signs of both arguments are used
	 *		to determine the quadrant of the result.
	 *	The arctangent is the angle from the x-axis to a line containing the origin (0, 0) and a
	 *		point with coordinates (xCoordinate, yCoordinate). The angle is given in radians between
	 *		-pi and pi, excluding -pi.
	 *
	 *	Note that the Excel ATAN2() function accepts its arguments in the reverse order to the standard
	 *		PHP atan2() function, so we need to reverse them here before calling the PHP atan() function.
	 *
	 *	Excel Function:
	 *		ATAN2(xCoordinate,yCoordinate)
	 *
	 *	@access	public
	 *	@category Mathematical and Trigonometric Functions
	 *	@param	float	$xCoordinate		The x-coordinate of the point.
	 *	@param	float	$yCoordinate		The y-coordinate of the point.
	 *	@return	float	The inverse tangent of the specified x- and y-coordinates.
	 */
	public static function REVERSE_ATAN2($xCoordinate, $yCoordinate) {
		$xCoordinate	= (float) self::flattenSingleValue($xCoordinate);
		$yCoordinate	= (float) self::flattenSingleValue($yCoordinate);

		if (($xCoordinate == 0) && ($yCoordinate == 0)) {
			return self::$_errorCodes['divisionbyzero'];
		}

		return atan2($yCoordinate, $xCoordinate);
	}	//	function REVERSE_ATAN2()


	/**
	 *	LOG_BASE
	 *
	 *	Returns the logarithm of a number to a specified base. The default base is 10.
	 *
	 *	Excel Function:
	 *		LOG(number[,base])
	 *
	 *	@access	public
	 *	@category Mathematical and Trigonometric Functions
	 *	@param	float	$value		The positive real number for which you want the logarithm
	 *	@param	float	$base		The base of the logarithm. If base is omitted, it is assumed to be 10.
	 *	@return	float
	 */
	public static function LOG_BASE($number, $base=10) {
		$number	= self::flattenSingleValue($number);
		$base	= (is_null($base))	? 10 :	(float) self::flattenSingleValue($base);

		return log($number, $base);
	}	//	function LOG_BASE()


	/**
	 *	SUM
	 *
	 *	SUM computes the sum of all the values and cells referenced in the argument list.
	 *
	 *	Excel Function:
	 *		SUM(value1[,value2[, ...]])
	 *
	 *	@access	public
	 *	@category Mathematical and Trigonometric Functions
	 *	@param	mixed		$arg,...		Data values
	 *	@return	float
	 */
	public static function SUM() {
		// Return value
		$returnValue = 0;

		// Loop through the arguments
		$aArgs = self::flattenArray(func_get_args());
		foreach ($aArgs as $arg) {
			// Is it a numeric value?
			if ((is_numeric($arg)) && (!is_string($arg))) {
				$returnValue += $arg;
			}
		}

		// Return
		return $returnValue;
	}	//	function SUM()


	/**
	 *	SUMSQ
	 *
	 *	SUMSQ returns the sum of the squares of the arguments
	 *
	 *	Excel Function:
	 *		SUMSQ(value1[,value2[, ...]])
	 *
	 *	@access	public
	 *	@category Mathematical and Trigonometric Functions
	 *	@param	mixed		$arg,...		Data values
	 *	@return	float
	 */
	public static function SUMSQ() {
		// Return value
		$returnValue = 0;

		// Loop through arguments
		$aArgs = self::flattenArray(func_get_args());
		foreach ($aArgs as $arg) {
			// Is it a numeric value?
			if ((is_numeric($arg)) && (!is_string($arg))) {
				$returnValue += ($arg * $arg);
			}
		}

		// Return
		return $returnValue;
	}	//	function SUMSQ()


	/**
	 *	PRODUCT
	 *
	 *	PRODUCT returns the product of all the values and cells referenced in the argument list.
	 *
	 *	Excel Function:
	 *		PRODUCT(value1[,value2[, ...]])
	 *
	 *	@access	public
	 *	@category Mathematical and Trigonometric Functions
	 *	@param	mixed		$arg,...		Data values
	 *	@return	float
	 */
	public static function PRODUCT() {
		// Return value
		$returnValue = null;

		// Loop through arguments
		$aArgs = self::flattenArray(func_get_args());
		foreach ($aArgs as $arg) {
			// Is it a numeric value?
			if ((is_numeric($arg)) && (!is_string($arg))) {
				if (is_null($returnValue)) {
					$returnValue = $arg;
				} else {
					$returnValue *= $arg;
				}
			}
		}

		// Return
		if (is_null($returnValue)) {
			return 0;
		}
		return $returnValue;
	}	//	function PRODUCT()


	/**
	 *	QUOTIENT
	 *
	 *	QUOTIENT function returns the integer portion of a division. Numerator is the divided number
	 *		and denominator is the divisor.
	 *
	 *	Excel Function:
	 *		QUOTIENT(value1[,value2[, ...]])
	 *
	 *	@access	public
	 *	@category Mathematical and Trigonometric Functions
	 *	@param	mixed		$arg,...		Data values
	 *	@return	float
	 */
	public static function QUOTIENT() {
		// Return value
		$returnValue = null;

		// Loop through arguments
		$aArgs = self::flattenArray(func_get_args());
		foreach ($aArgs as $arg) {
			// Is it a numeric value?
			if ((is_numeric($arg)) && (!is_string($arg))) {
				if (is_null($returnValue)) {
					$returnValue = ($arg == 0) ? 0 : $arg;
				} else {
					if (($returnValue == 0) || ($arg == 0)) {
						$returnValue = 0;
					} else {
						$returnValue /= $arg;
					}
				}
			}
		}

		// Return
		return intval($returnValue);
	}	//	function QUOTIENT()


	/**
	 *	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 = self::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 = self::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()


	/**
	 *	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 = self::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 self::$_errorCodes['num'];
			}
			sort($mArgs);
			return $mArgs[$entry];
		}
		return self::$_errorCodes['value'];
	}	//	function SMALL()


	/**
	 *	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 = self::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 = self::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()


	/**
	 *	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 = self::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 self::$_errorCodes['num'];
			}
			rsort($mArgs);
			return $mArgs[$entry];
		}
		return self::$_errorCodes['value'];
	}	//	function LARGE()


	/**
	 *	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 = self::flattenArray(func_get_args());

		// Calculate
		$entry = array_pop($aArgs);

		if ((is_numeric($entry)) && (!is_string($entry))) {
			if (($entry < 0) || ($entry > 1)) {
				return self::$_errorCodes['num'];
			}
			$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 self::$_errorCodes['value'];
	}	//	function PERCENTILE()


	/**
	 *	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 = self::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 self::$_errorCodes['num'];
			}
			return self::PERCENTILE($aArgs,$entry);
		}
		return self::$_errorCodes['value'];
	}	//	function QUARTILE()


	/**
	 *	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 = self::flattenArrayIndexed(func_get_args());
		foreach ($aArgs as $k => $arg) {
			if ((is_bool($arg)) &&
				((!self::isCellValue($k)) || (self::$compatibilityMode == self::COMPATIBILITY_OPENOFFICE))) {
				$arg = (integer) $arg;
			}
			// Is it a numeric value?
			if ((is_numeric($arg)) && (!is_string($arg))) {
				++$returnValue;
			}
		}

		// Return
		return $returnValue;
	}	//	function COUNT()


	/**
	 *	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 = self::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()


	/**
	 *	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 = self::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()


	/**
	 *	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 = self::flattenArray($aArgs);
		$condition	= self::flattenSingleValue($condition);
		if (!in_array($condition{0},array('>', '<', '='))) {
			if (!is_numeric($condition)) { $condition = PHPExcel_Calculation::_wrapResult(strtoupper($condition)); }
			$condition = '='.$condition;
		} else {
			preg_match('/([<>=]+)(.*)/',$condition,$matches);
			list(,$operator,$operand) = $matches;
			if (!is_numeric($operand)) { $operand = PHPExcel_Calculation::_wrapResult(strtoupper($operand)); }
			$condition = $operator.$operand;
		}
		// 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()


	/**
	 *	SUMIF
	 *
	 *	Counts the number of cells that contain numbers within the list of arguments
	 *
	 *	Excel Function:
	 *		SUMIF(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 summed.
	 *	@return	float
	 */
	public static function SUMIF($aArgs,$condition,$sumArgs = array()) {
		// Return value
		$returnValue = 0;

		$aArgs = self::flattenArray($aArgs);
		$sumArgs = self::flattenArray($sumArgs);
		if (count($sumArgs) == 0) {
			$sumArgs = $aArgs;
		}
		if (!in_array($condition{0},array('>', '<', '='))) {
			if (!is_numeric($condition)) { $condition = PHPExcel_Calculation::_wrapResult(strtoupper($condition)); }
			$condition = '='.$condition;
		} else {
			preg_match('/([<>=]+)(.*)/',$condition,$matches);
			list(,$operator,$operand) = $matches;
			if (!is_numeric($operand)) { $operand = PHPExcel_Calculation::_wrapResult(strtoupper($operand)); }
			$condition = $operator.$operand;
		}
		// 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)) {
				// Is it a value within our criteria
				$returnValue += $sumArgs[$key];
			}
		}

		// Return
		return $returnValue;
	}	//	function SUMIF()


	/**
	 *	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() {
		$aArgs = self::flattenArrayIndexed(func_get_args());

		$returnValue = $aCount = 0;
		// Loop through arguments
		foreach ($aArgs as $k => $arg) {
			if ((is_bool($arg)) &&
				((!self::isCellValue($k)) || (self::$compatibilityMode == self::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 self::$_errorCodes['divisionbyzero'];
		}
	}	//	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;

		// Loop through arguments
		$aArgs = self::flattenArrayIndexed(func_get_args());
		$aCount = 0;
		foreach ($aArgs as $k => $arg) {
			if ((is_bool($arg)) &&
				(!self::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 self::$_errorCodes['divisionbyzero'];
		}
	}	//	function AVERAGEA()


	/**
	 *	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 = self::$_errorCodes['num'];

		$mArgs = array();
		// Loop through arguments
		$aArgs = self::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()


	//
	//	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 self::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 = self::NA();

		// Loop through arguments
		$aArgs = self::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 (count($mArgs) > 0) {
			return self::_modeCalc($mArgs);
		}

		// Return
		return $returnValue;
	}	//	function MODE()


	/**
	 *	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 = self::flattenArrayIndexed(func_get_args());

		// Return value
		$returnValue = null;

		$aMean = self::AVERAGE($aArgs);
		if ($aMean != self::$_errorCodes['divisionbyzero']) {
			$aCount = -1;
			foreach ($aArgs as $k => $arg) {
				// Is it a numeric value?
				if ((is_bool($arg)) &&
					((!self::isCellValue($k)) || (self::$compatibilityMode == self::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 self::$_errorCodes['num'];
			} else {
				return $returnValue;
			}
		}
		return self::NA();
	}	//	function DEVSQ()


	/**
	 *	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 = self::flattenArrayIndexed(func_get_args());

		// Return value
		$returnValue = null;

		$aMean = self::AVERAGE($aArgs);
		if ($aMean != self::$_errorCodes['divisionbyzero']) {
			$aCount = 0;
			foreach ($aArgs as $k => $arg) {
				if ((is_bool($arg)) &&
					((!self::isCellValue($k)) || (self::$compatibilityMode == self::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 self::$_errorCodes['divisionbyzero'];
			}
			return $returnValue / $aCount;
		}
		return self::$_errorCodes['num'];
	}	//	function AVEDEV()


	/**
	 *	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 = self::flattenArray(func_get_args());

		$aMean = self::PRODUCT($aArgs);
		if (is_numeric($aMean) && ($aMean > 0)) {
			$aCount = self::COUNT($aArgs) ;
			if (self::MIN($aArgs) > 0) {
				return pow($aMean, (1 / $aCount));
			}
		}
		return self::$_errorCodes['num'];
	}	//	GEOMEAN()


	/**
	 *	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 = self::NA();

		// Loop through arguments
		$aArgs = self::flattenArray(func_get_args());
		if (self::MIN($aArgs) < 0) {
			return self::$_errorCodes['num'];
		}
		$aCount = 0;
		foreach ($aArgs as $arg) {
			// Is it a numeric value?
			if ((is_numeric($arg)) && (!is_string($arg))) {
				if ($arg <= 0) {
					return self::$_errorCodes['num'];
				}
				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()


	/**
	 *	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 = self::flattenArray(func_get_args());

		// Calculate
		$percent = array_pop($aArgs);

		if ((is_numeric($percent)) && (!is_string($percent))) {
			if (($percent < 0) || ($percent > 1)) {
				return self::$_errorCodes['num'];
			}
			$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 self::$_errorCodes['value'];
	}	//	function TRIMMEAN()


	/**
	 *	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 = self::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)) &&
					((!self::isCellValue($k)) || (self::$compatibilityMode == self::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 self::$_errorCodes['divisionbyzero'];
	}	//	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 = self::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)) &&
					(!self::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 self::$_errorCodes['divisionbyzero'];
	}	//	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 = self::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)) &&
					((!self::isCellValue($k)) || (self::$compatibilityMode == self::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 self::$_errorCodes['divisionbyzero'];
	}	//	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 = self::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)) &&
					(!self::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 self::$_errorCodes['divisionbyzero'];
	}	//	function STDEVPA()


	/**
	 *	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 = self::$_errorCodes['divisionbyzero'];

		$summerA = $summerB = 0;

		// Loop through arguments
		$aArgs = self::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		$a…