<?php

/**

 * PHPExcel

 *

 * Copyright (c) 2006 - 2014 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 - 2014 PHPExcel (http://www.codeplex.com/PHPExcel)

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

 * @version	1.8.0, 2014-03-02

 */





/** PHPExcel root directory */

if (!defined('PHPEXCEL_ROOT')) {

	/**

	 * @ignore

	 */

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

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

}





if (!defined('CALCULATION_REGEXP_CELLREF')) {

	//	Test for support of \P (multibyte options) in PCRE

	if(defined('PREG_BAD_UTF8_ERROR')) {

		//	Cell reference (cell or range of cells, with or without a sheet reference)

		define('CALCULATION_REGEXP_CELLREF','((([^\s,!&%^\/\*\+<>=-]*)|(\'[^\']*\')|(\"[^\"]*\"))!)?\$?([a-z]{1,3})\$?(\d{1,7})');

		//	Named Range of cells

		define('CALCULATION_REGEXP_NAMEDRANGE','((([^\s,!&%^\/\*\+<>=-]*)|(\'[^\']*\')|(\"[^\"]*\"))!)?([_A-Z][_A-Z0-9\.]*)');

	} else {

		//	Cell reference (cell or range of cells, with or without a sheet reference)

		define('CALCULATION_REGEXP_CELLREF','(((\w*)|(\'[^\']*\')|(\"[^\"]*\"))!)?\$?([a-z]{1,3})\$?(\d+)');

		//	Named Range of cells

		define('CALCULATION_REGEXP_NAMEDRANGE','(((\w*)|(\'.*\')|(\".*\"))!)?([_A-Z][_A-Z0-9\.]*)');

	}

}





/**

 * PHPExcel_Calculation (Multiton)

 *

 * @category	PHPExcel

 * @package		PHPExcel_Calculation

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

 */

class PHPExcel_Calculation {



	/** Constants				*/

	/** Regular Expressions		*/

	//	Numeric operand

	const CALCULATION_REGEXP_NUMBER		= '[-+]?\d*\.?\d+(e[-+]?\d+)?';

	//	String operand

	const CALCULATION_REGEXP_STRING		= '"(?:[^"]|"")*"';

	//	Opening bracket

	const CALCULATION_REGEXP_OPENBRACE	= '\(';

	//	Function (allow for the old @ symbol that could be used to prefix a function, but we'll ignore it)

	const CALCULATION_REGEXP_FUNCTION	= '@?([A-Z][A-Z0-9\.]*)[\s]*\(';

	//	Cell reference (cell or range of cells, with or without a sheet reference)

	const CALCULATION_REGEXP_CELLREF	= CALCULATION_REGEXP_CELLREF;

	//	Named Range of cells

	const CALCULATION_REGEXP_NAMEDRANGE	= CALCULATION_REGEXP_NAMEDRANGE;

	//	Error

	const CALCULATION_REGEXP_ERROR		= '\#[A-Z][A-Z0_\/]*[!\?]?';





	/** constants */

	const RETURN_ARRAY_AS_ERROR = 'error';

	const RETURN_ARRAY_AS_VALUE = 'value';

	const RETURN_ARRAY_AS_ARRAY = 'array';



	private static $returnArrayAsType	= self::RETURN_ARRAY_AS_VALUE;





	/**

	 * Instance of this class

	 *

	 * @access	private

	 * @var PHPExcel_Calculation

	 */

	private static $_instance;





	/**

	 * Instance of the workbook this Calculation Engine is using

	 *

	 * @access	private

	 * @var PHPExcel

	 */

    private $_workbook;



	/**

	 * List of instances of the calculation engine that we've instantiated for individual workbooks

	 *

	 * @access	private

	 * @var PHPExcel_Calculation[]

	 */

    private static $_workbookSets;



	/**

	 * Calculation cache

	 *

	 * @access	private

	 * @var array

	 */

	private $_calculationCache = array ();





	/**

	 * Calculation cache enabled

	 *

	 * @access	private

	 * @var boolean

	 */

	private $_calculationCacheEnabled = TRUE;





	/**

	 * List of operators that can be used within formulae

	 * The true/false value indicates whether it is a binary operator or a unary operator

	 *

	 * @access	private

	 * @var array

	 */

	private static $_operators			= array('+' => TRUE,	'-' => TRUE,	'*' => TRUE,	'/' => TRUE,

												'^' => TRUE,	'&' => TRUE,	'%' => FALSE,	'~' => FALSE,

												'>' => TRUE,	'<' => TRUE,	'=' => TRUE,	'>=' => TRUE,

												'<=' => TRUE,	'<>' => TRUE,	'|' => TRUE,	':' => TRUE

											   );





	/**

	 * List of binary operators (those that expect two operands)

	 *

	 * @access	private

	 * @var array

	 */

	private static $_binaryOperators	= array('+' => TRUE,	'-' => TRUE,	'*' => TRUE,	'/' => TRUE,

												'^' => TRUE,	'&' => TRUE,	'>' => TRUE,	'<' => TRUE,

												'=' => TRUE,	'>=' => TRUE,	'<=' => TRUE,	'<>' => TRUE,

												'|' => TRUE,	':' => TRUE

											   );



	/**

	 * The debug log generated by the calculation engine

	 *

	 * @access	private

	 * @var PHPExcel_CalcEngine_Logger

	 *

	 */

	private $debugLog;



	/**

	 * Flag to determine how formula errors should be handled

	 *		If true, then a user error will be triggered

	 *		If false, then an exception will be thrown

	 *

	 * @access	public

	 * @var boolean

	 *

	 */

	public $suppressFormulaErrors = FALSE;



	/**

	 * Error message for any error that was raised/thrown by the calculation engine

	 *

	 * @access	public

	 * @var string

	 *

	 */

	public $formulaError = NULL;



	/**

	 * An array of the nested cell references accessed by the calculation engine, used for the debug log

	 *

	 * @access	private

	 * @var array of string

	 *

	 */

	private $_cyclicReferenceStack;



	/**

	 * Current iteration counter for cyclic formulae

	 * If the value is 0 (or less) then cyclic formulae will throw an exception,

	 *    otherwise they will iterate to the limit defined here before returning a result

	 *

	 * @var integer

	 *

	 */

	private $_cyclicFormulaCount = 0;



	private $_cyclicFormulaCell = '';



	/**

	 * Number of iterations for cyclic formulae

	 *

	 * @var integer

	 *

	 */

	public $cyclicFormulaCount = 0;



	/**

	 * Precision used for calculations

	 *

	 * @var integer

	 *

	 */

	private $_savedPrecision	= 14;





	/**

	 * The current locale setting

	 *

	 * @var string

	 *

	 */

	private static $_localeLanguage = 'en_us';					//	US English	(default locale)



	/**

	 * List of available locale settings

	 * Note that this is read for the locale subdirectory only when requested

	 *

	 * @var string[]

	 *

	 */

	private static $_validLocaleLanguages = array(	'en'		//	English		(default language)

												 );

	/**

	 * Locale-specific argument separator for function arguments

	 *

	 * @var string

	 *

	 */

	private static $_localeArgumentSeparator = ',';

	private static $_localeFunctions = array();



	/**

	 * Locale-specific translations for Excel constants (True, False and Null)

	 *

	 * @var string[]

	 *

	 */

	public static $_localeBoolean = array(	'TRUE'	=> 'TRUE',

											'FALSE'	=> 'FALSE',

											'NULL'	=> 'NULL'

										  );





	/**

	 * Excel constant string translations to their PHP equivalents

	 * Constant conversion from text name/value to actual (datatyped) value

	 *

	 * @var string[]

	 *

	 */

	private static $_ExcelConstants = array('TRUE'	=> TRUE,

											'FALSE'	=> FALSE,

											'NULL'	=> NULL

										   );



	//	PHPExcel functions

	private static $_PHPExcelFunctions = array(	// PHPExcel functions

				'ABS'					=> array('category'			=>	PHPExcel_Calculation_Function::CATEGORY_MATH_AND_TRIG,

												 'functionCall'		=>	'abs',

												 'argumentCount'	=>	'1'

												),

				'ACCRINT'				=> array('category'			=>	PHPExcel_Calculation_Function::CATEGORY_FINANCIAL,

												 'functionCall'		=>	'PHPExcel_Calculation_Financial::ACCRINT',

												 'argumentCount'	=>	'4-7'

												),

				'ACCRINTM'				=> array('category'			=>	PHPExcel_Calculation_Function::CATEGORY_FINANCIAL,

												 'functionCall'		=>	'PHPExcel_Calculation_Financial::ACCRINTM',

												 'argumentCount'	=>	'3-5'

												),

				'ACOS'					=> array('category'			=>	PHPExcel_Calculation_Function::CATEGORY_MATH_AND_TRIG,

												 'functionCall'		=>	'acos',

												 'argumentCount'	=>	'1'

												),

				'ACOSH'					=> array('category'			=>	PHPExcel_Calculation_Function::CATEGORY_MATH_AND_TRIG,

												 'functionCall'		=>	'acosh',

												 'argumentCount'	=>	'1'

												),

				'ADDRESS'				=> array('category'			=>	PHPExcel_Calculation_Function::CATEGORY_LOOKUP_AND_REFERENCE,

												 'functionCall'		=>	'PHPExcel_Calculation_LookupRef::CELL_ADDRESS',

												 'argumentCount'	=>	'2-5'

												),

				'AMORDEGRC'				=> array('category'			=>	PHPExcel_Calculation_Function::CATEGORY_FINANCIAL,

												 'functionCall'		=>	'PHPExcel_Calculation_Financial::AMORDEGRC',

												 'argumentCount'	=>	'6,7'

												),

				'AMORLINC'				=> array('category'			=>	PHPExcel_Calculation_Function::CATEGORY_FINANCIAL,

												 'functionCall'		=>	'PHPExcel_Calculation_Financial::AMORLINC',

												 'argumentCount'	=>	'6,7'

												),

				'AND'					=> array('category'			=>	PHPExcel_Calculation_Function::CATEGORY_LOGICAL,

												 'functionCall'		=>	'PHPExcel_Calculation_Logical::LOGICAL_AND',

												 'argumentCount'	=>	'1+'

												),

				'AREAS'					=> array('category'			=>	PHPExcel_Calculation_Function::CATEGORY_LOOKUP_AND_REFERENCE,

												 'functionCall'		=>	'PHPExcel_Calculation_Functions::DUMMY',

												 'argumentCount'	=>	'1'

												),

				'ASC'					=> array('category'			=>	PHPExcel_Calculation_Function::CATEGORY_TEXT_AND_DATA,

												 'functionCall'		=>	'PHPExcel_Calculation_Functions::DUMMY',

												 'argumentCount'	=>	'1'

												),

				'ASIN'					=> array('category'			=>	PHPExcel_Calculation_Function::CATEGORY_MATH_AND_TRIG,

												 'functionCall'		=>	'asin',

												 'argumentCount'	=>	'1'

												),

				'ASINH'					=> array('category'			=>	PHPExcel_Calculation_Function::CATEGORY_MATH_AND_TRIG,

												 'functionCall'		=>	'asinh',

												 'argumentCount'	=>	'1'

												),

				'ATAN'					=> array('category'			=>	PHPExcel_Calculation_Function::CATEGORY_MATH_AND_TRIG,

												 'functionCall'		=>	'atan',

												 'argumentCount'	=>	'1'

												),

				'ATAN2'					=> array('category'			=>	PHPExcel_Calculation_Function::CATEGORY_MATH_AND_TRIG,

												 'functionCall'		=>	'PHPExcel_Calculation_MathTrig::ATAN2',

												 'argumentCount'	=>	'2'

												),

				'ATANH'					=> array('category'			=>	PHPExcel_Calculation_Function::CATEGORY_MATH_AND_TRIG,

												 'functionCall'		=>	'atanh',

												 'argumentCount'	=>	'1'

												),

				'AVEDEV'				=> array('category'			=>	PHPExcel_Calculation_Function::CATEGORY_STATISTICAL,

												 'functionCall'		=>	'PHPExcel_Calculation_Statistical::AVEDEV',

												 'argumentCount'	=>	'1+'

												),

				'AVERAGE'				=> array('category'			=>	PHPExcel_Calculation_Function::CATEGORY_STATISTICAL,

												 'functionCall'		=>	'PHPExcel_Calculation_Statistical::AVERAGE',

												 'argumentCount'	=>	'1+'

												),

				'AVERAGEA'				=> array('category'			=>	PHPExcel_Calculation_Function::CATEGORY_STATISTICAL,

												 'functionCall'		=>	'PHPExcel_Calculation_Statistical::AVERAGEA',

												 'argumentCount'	=>	'1+'

												),

				'AVERAGEIF'				=> array('category'			=>	PHPExcel_Calculation_Function::CATEGORY_STATISTICAL,

												 'functionCall'		=>	'PHPExcel_Calculation_Statistical::AVERAGEIF',

												 'argumentCount'	=>	'2,3'

												),

				'AVERAGEIFS'			=> array('category'			=>	PHPExcel_Calculation_Function::CATEGORY_STATISTICAL,

												 'functionCall'		=>	'PHPExcel_Calculation_Functions::DUMMY',

												 'argumentCount'	=>	'3+'

												),

				'BAHTTEXT'				=> array('category'			=>	PHPExcel_Calculation_Function::CATEGORY_TEXT_AND_DATA,

												 'functionCall'		=>	'PHPExcel_Calculation_Functions::DUMMY',

												 'argumentCount'	=>	'1'

												),

				'BESSELI'				=> array('category'			=>	PHPExcel_Calculation_Function::CATEGORY_ENGINEERING,

												 'functionCall'		=>	'PHPExcel_Calculation_Engineering::BESSELI',

												 'argumentCount'	=>	'2'

												),

				'BESSELJ'				=> array('category'			=>	PHPExcel_Calculation_Function::CATEGORY_ENGINEERING,

												 'functionCall'		=>	'PHPExcel_Calculation_Engineering::BESSELJ',

												 'argumentCount'	=>	'2'

												),

				'BESSELK'				=> array('category'			=>	PHPExcel_Calculation_Function::CATEGORY_ENGINEERING,

												 'functionCall'		=>	'PHPExcel_Calculation_Engineering::BESSELK',

												 'argumentCount'	=>	'2'

												),

				'BESSELY'				=> array('category'			=>	PHPExcel_Calculation_Function::CATEGORY_ENGINEERING,

												 'functionCall'		=>	'PHPExcel_Calculation_Engineering::BESSELY',

												 'argumentCount'	=>	'2'

												),

				'BETADIST'				=> array('category'			=>	PHPExcel_Calculation_Function::CATEGORY_STATISTICAL,

												 'functionCall'		=>	'PHPExcel_Calculation_Statistical::BETADIST',

												 'argumentCount'	=>	'3-5'

												),

				'BETAINV'				=> array('category'			=>	PHPExcel_Calculation_Function::CATEGORY_STATISTICAL,

												 'functionCall'		=>	'PHPExcel_Calculation_Statistical::BETAINV',

												 'argumentCount'	=>	'3-5'

												),

				'BIN2DEC'				=> array('category'			=>	PHPExcel_Calculation_Function::CATEGORY_ENGINEERING,

												 'functionCall'		=>	'PHPExcel_Calculation_Engineering::BINTODEC',

												 'argumentCount'	=>	'1'

												),

				'BIN2HEX'				=> array('category'			=>	PHPExcel_Calculation_Function::CATEGORY_ENGINEERING,

												 'functionCall'		=>	'PHPExcel_Calculation_Engineering::BINTOHEX',

												 'argumentCount'	=>	'1,2'

												),

				'BIN2OCT'				=> array('category'			=>	PHPExcel_Calculation_Function::CATEGORY_ENGINEERING,

												 'functionCall'		=>	'PHPExcel_Calculation_Engineering::BINTOOCT',

												 'argumentCount'	=>	'1,2'

												),

				'BINOMDIST'				=> array('category'			=>	PHPExcel_Calculation_Function::CATEGORY_STATISTICAL,

												 'functionCall'		=>	'PHPExcel_Calculation_Statistical::BINOMDIST',

												 'argumentCount'	=>	'4'

												),

				'CEILING'				=> array('category'			=>	PHPExcel_Calculation_Function::CATEGORY_MATH_AND_TRIG,

												 'functionCall'		=>	'PHPExcel_Calculation_MathTrig::CEILING',

												 'argumentCount'	=>	'2'

												),

				'CELL'					=> array('category'			=>	PHPExcel_Calculation_Function::CATEGORY_INFORMATION,

												 'functionCall'		=>	'PHPExcel_Calculation_Functions::DUMMY',

												 'argumentCount'	=>	'1,2'

												),

				'CHAR'					=> array('category'			=>	PHPExcel_Calculation_Function::CATEGORY_TEXT_AND_DATA,

												 'functionCall'		=>	'PHPExcel_Calculation_TextData::CHARACTER',

												 'argumentCount'	=>	'1'

												),

				'CHIDIST'				=> array('category'			=>	PHPExcel_Calculation_Function::CATEGORY_STATISTICAL,

												 'functionCall'		=>	'PHPExcel_Calculation_Statistical::CHIDIST',

												 'argumentCount'	=>	'2'

												),

				'CHIINV'				=> array('category'			=>	PHPExcel_Calculation_Function::CATEGORY_STATISTICAL,

												 'functionCall'		=>	'PHPExcel_Calculation_Statistical::CHIINV',

												 'argumentCount'	=>	'2'

												),

				'CHITEST'				=> array('category'			=>	PHPExcel_Calculation_Function::CATEGORY_STATISTICAL,

												 'functionCall'		=>	'PHPExcel_Calculation_Functions::DUMMY',

												 'argumentCount'	=>	'2'

												),

				'CHOOSE'				=> array('category'			=>	PHPExcel_Calculation_Function::CATEGORY_LOOKUP_AND_REFERENCE,

												 'functionCall'		=>	'PHPExcel_Calculation_LookupRef::CHOOSE',

												 'argumentCount'	=>	'2+'

												),

				'CLEAN'					=> array('category'			=>	PHPExcel_Calculation_Function::CATEGORY_TEXT_AND_DATA,

												 'functionCall'		=>	'PHPExcel_Calculation_TextData::TRIMNONPRINTABLE',

												 'argumentCount'	=>	'1'

												),

				'CODE'					=> array('category'			=>	PHPExcel_Calculation_Function::CATEGORY_TEXT_AND_DATA,

												 'functionCall'		=>	'PHPExcel_Calculation_TextData::ASCIICODE',

												 'argumentCount'	=>	'1'

												),

				'COLUMN'				=> array('category'			=>	PHPExcel_Calculation_Function::CATEGORY_LOOKUP_AND_REFERENCE,

												 'functionCall'		=>	'PHPExcel_Calculation_LookupRef::COLUMN',

												 'argumentCount'	=>	'-1',

												 'passByReference'	=>	array(TRUE)

												),

				'COLUMNS'				=> array('category'			=>	PHPExcel_Calculation_Function::CATEGORY_LOOKUP_AND_REFERENCE,

												 'functionCall'		=>	'PHPExcel_Calculation_LookupRef::COLUMNS',

												 'argumentCount'	=>	'1'

												),

				'COMBIN'				=> array('category'			=>	PHPExcel_Calculation_Function::CATEGORY_MATH_AND_TRIG,

												 'functionCall'		=>	'PHPExcel_Calculation_MathTrig::COMBIN',

												 'argumentCount'	=>	'2'

												),

				'COMPLEX'				=> array('category'			=>	PHPExcel_Calculation_Function::CATEGORY_ENGINEERING,

												 'functionCall'		=>	'PHPExcel_Calculation_Engineering::COMPLEX',

												 'argumentCount'	=>	'2,3'

												),

				'CONCATENATE'			=> array('category'			=>	PHPExcel_Calculation_Function::CATEGORY_TEXT_AND_DATA,

												 'functionCall'		=>	'PHPExcel_Calculation_TextData::CONCATENATE',

												 'argumentCount'	=>	'1+'

												),

				'CONFIDENCE'			=> array('category'			=>	PHPExcel_Calculation_Function::CATEGORY_STATISTICAL,

												 'functionCall'		=>	'PHPExcel_Calculation_Statistical::CONFIDENCE',

												 'argumentCount'	=>	'3'

												),

				'CONVERT'				=> array('category'			=>	PHPExcel_Calculation_Function::CATEGORY_ENGINEERING,

												 'functionCall'		=>	'PHPExcel_Calculation_Engineering::CONVERTUOM',

												 'argumentCount'	=>	'3'

												),

				'CORREL'				=> array('category'			=>	PHPExcel_Calculation_Function::CATEGORY_STATISTICAL,

												 'functionCall'		=>	'PHPExcel_Calculation_Statistical::CORREL',

												 'argumentCount'	=>	'2'

												),

				'COS'					=> array('category'			=>	PHPExcel_Calculation_Function::CATEGORY_MATH_AND_TRIG,

												 'functionCall'		=>	'cos',

												 'argumentCount'	=>	'1'

												),

				'COSH'					=> array('category'			=>	PHPExcel_Calculation_Function::CATEGORY_MATH_AND_TRIG,

												 'functionCall'		=>	'cosh',

												 'argumentCount'	=>	'1'

												),

				'COUNT'					=> array('category'			=>	PHPExcel_Calculation_Function::CATEGORY_STATISTICAL,

												 'functionCall'		=>	'PHPExcel_Calculation_Statistical::COUNT',

												 'argumentCount'	=>	'1+'

												),

				'COUNTA'				=> array('category'			=>	PHPExcel_Calculation_Function::CATEGORY_STATISTICAL,

												 'functionCall'		=>	'PHPExcel_Calculation_Statistical::COUNTA',

												 'argumentCount'	=>	'1+'

												),

				'COUNTBLANK'			=> array('category'			=>	PHPExcel_Calculation_Function::CATEGORY_STATISTICAL,

												 'functionCall'		=>	'PHPExcel_Calculation_Statistical::COUNTBLANK',

												 'argumentCount'	=>	'1'

												),

				'COUNTIF'				=> array('category'			=>	PHPExcel_Calculation_Function::CATEGORY_STATISTICAL,

												 'functionCall'		=>	'PHPExcel_Calculation_Statistical::COUNTIF',

												 'argumentCount'	=>	'2'

												),

				'COUNTIFS'				=> array('category'			=>	PHPExcel_Calculation_Function::CATEGORY_STATISTICAL,

												 'functionCall'		=>	'PHPExcel_Calculation_Functions::DUMMY',

												 'argumentCount'	=>	'2'

												),

				'COUPDAYBS'				=> array('category'			=>	PHPExcel_Calculation_Function::CATEGORY_FINANCIAL,

												 'functionCall'		=>	'PHPExcel_Calculation_Financial::COUPDAYBS',

												 'argumentCount'	=>	'3,4'

												),

				'COUPDAYS'				=> array('category'			=>	PHPExcel_Calculation_Function::CATEGORY_FINANCIAL,

												 'functionCall'		=>	'PHPExcel_Calculation_Financial::COUPDAYS',

												 'argumentCount'	=>	'3,4'

												),

				'COUPDAYSNC'			=> array('category'			=>	PHPExcel_Calculation_Function::CATEGORY_FINANCIAL,

												 'functionCall'		=>	'PHPExcel_Calculation_Financial::COUPDAYSNC',

												 'argumentCount'	=>	'3,4'

												),

				'COUPNCD'				=> array('category'			=>	PHPExcel_Calculation_Function::CATEGORY_FINANCIAL,

												 'functionCall'		=>	'PHPExcel_Calculation_Financial::COUPNCD',

												 'argumentCount'	=>	'3,4'

												),

				'COUPNUM'				=> array('category'			=>	PHPExcel_Calculation_Function::CATEGORY_FINANCIAL,

												 'functionCall'		=>	'PHPExcel_Calculation_Financial::COUPNUM',

												 'argumentCount'	=>	'3,4'

												),

				'COUPPCD'				=> array('category'			=>	PHPExcel_Calculation_Function::CATEGORY_FINANCIAL,

												 'functionCall'		=>	'PHPExcel_Calculation_Financial::COUPPCD',

												 'argumentCount'	=>	'3,4'

												),

				'COVAR'					=> array('category'			=>	PHPExcel_Calculation_Function::CATEGORY_STATISTICAL,

												 'functionCall'		=>	'PHPExcel_Calculation_Statistical::COVAR',

												 'argumentCount'	=>	'2'

												),

				'CRITBINOM'				=> array('category'			=>	PHPExcel_Calculation_Function::CATEGORY_STATISTICAL,

												 'functionCall'		=>	'PHPExcel_Calculation_Statistical::CRITBINOM',

												 'argumentCount'	=>	'3'

												),

				'CUBEKPIMEMBER'			=> array('category'			=>	PHPExcel_Calculation_Function::CATEGORY_CUBE,

												 'functionCall'		=>	'PHPExcel_Calculation_Functions::DUMMY',

												 'argumentCount'	=>	'?'

												),

				'CUBEMEMBER'			=> array('category'			=>	PHPExcel_Calculation_Function::CATEGORY_CUBE,

												 'functionCall'		=>	'PHPExcel_Calculation_Functions::DUMMY',

												 'argumentCount'	=>	'?'

												),

				'CUBEMEMBERPROPERTY'	=> array('category'			=>	PHPExcel_Calculation_Function::CATEGORY_CUBE,

												 'functionCall'		=>	'PHPExcel_Calculation_Functions::DUMMY',

												 'argumentCount'	=>	'?'

												),

				'CUBERANKEDMEMBER'		=> array('category'			=>	PHPExcel_Calculation_Function::CATEGORY_CUBE,

												 'functionCall'		=>	'PHPExcel_Calculation_Functions::DUMMY',

												 'argumentCount'	=>	'?'

												),

				'CUBESET'				=> array('category'			=>	PHPExcel_Calculation_Function::CATEGORY_CUBE,

												 'functionCall'		=>	'PHPExcel_Calculation_Functions::DUMMY',

												 'argumentCount'	=>	'?'

												),

				'CUBESETCOUNT'			=> array('category'			=>	PHPExcel_Calculation_Function::CATEGORY_CUBE,

												 'functionCall'		=>	'PHPExcel_Calculation_Functions::DUMMY',

												 'argumentCount'	=>	'?'

												),

				'CUBEVALUE'				=> array('category'			=>	PHPExcel_Calculation_Function::CATEGORY_CUBE,

												 'functionCall'		=>	'PHPExcel_Calculation_Functions::DUMMY',

												 'argumentCount'	=>	'?'

												),

				'CUMIPMT'				=> array('category'			=>	PHPExcel_Calculation_Function::CATEGORY_FINANCIAL,

												 'functionCall'		=>	'PHPExcel_Calculation_Financial::CUMIPMT',

												 'argumentCount'	=>	'6'

												),

				'CUMPRINC'				=> array('category'			=>	PHPExcel_Calculation_Function::CATEGORY_FINANCIAL,

												 'functionCall'		=>	'PHPExcel_Calculation_Financial::CUMPRINC',

												 'argumentCount'	=>	'6'

												),

				'DATE'					=> array('category'			=>	PHPExcel_Calculation_Function::CATEGORY_DATE_AND_TIME,

												 'functionCall'		=>	'PHPExcel_Calculation_DateTime::DATE',

												 'argumentCount'	=>	'3'

												),

				'DATEDIF'				=> array('category'			=>	PHPExcel_Calculation_Function::CATEGORY_DATE_AND_TIME,

												 'functionCall'		=>	'PHPExcel_Calculation_DateTime::DATEDIF',

												 'argumentCount'	=>	'2,3'

												),

				'DATEVALUE'				=> array('category'			=>	PHPExcel_Calculation_Function::CATEGORY_DATE_AND_TIME,

												 'functionCall'		=>	'PHPExcel_Calculation_DateTime::DATEVALUE',

												 'argumentCount'	=>	'1'

												),

				'DAVERAGE'				=> array('category'			=>	PHPExcel_Calculation_Function::CATEGORY_DATABASE,

												 'functionCall'		=>	'PHPExcel_Calculation_Database::DAVERAGE',

												 'argumentCount'	=>	'3'

												),

				'DAY'					=> array('category'			=>	PHPExcel_Calculation_Function::CATEGORY_DATE_AND_TIME,

												 'functionCall'		=>	'PHPExcel_Calculation_DateTime::DAYOFMONTH',

												 'argumentCount'	=>	'1'

												),

				'DAYS360'				=> array('category'			=>	PHPExcel_Calculation_Function::CATEGORY_DATE_AND_TIME,

												 'functionCall'		=>	'PHPExcel_Calculation_DateTime::DAYS360',

												 'argumentCount'	=>	'2,3'

												),

				'DB'					=> array('category'			=>	PHPExcel_Calculation_Function::CATEGORY_FINANCIAL,

												 'functionCall'		=>	'PHPExcel_Calculation_Financial::DB',

												 'argumentCount'	=>	'4,5'

												),

				'DCOUNT'				=> array('category'			=>	PHPExcel_Calculation_Function::CATEGORY_DATABASE,

												 'functionCall'		=>	'PHPExcel_Calculation_Database::DCOUNT',

												 'argumentCount'	=>	'3'

												),

				'DCOUNTA'				=> array('category'			=>	PHPExcel_Calculation_Function::CATEGORY_DATABASE,

												 'functionCall'		=>	'PHPExcel_Calculation_Database::DCOUNTA',

												 'argumentCount'	=>	'3'

												),

				'DDB'					=> array('category'			=>	PHPExcel_Calculation_Function::CATEGORY_FINANCIAL,

												 'functionCall'		=>	'PHPExcel_Calculation_Financial::DDB',

												 'argumentCount'	=>	'4,5'

												),

				'DEC2BIN'				=> array('category'			=>	PHPExcel_Calculation_Function::CATEGORY_ENGINEERING,

												 'functionCall'		=>	'PHPExcel_Calculation_Engineering::DECTOBIN',

												 'argumentCount'	=>	'1,2'

												),

				'DEC2HEX'				=> array('category'			=>	PHPExcel_Calculation_Function::CATEGORY_ENGINEERING,

												 'functionCall'		=>	'PHPExcel_Calculation_Engineering::DECTOHEX',

												 'argumentCount'	=>	'1,2'

												),

				'DEC2OCT'				=> array('category'			=>	PHPExcel_Calculation_Function::CATEGORY_ENGINEERING,

												 'functionCall'		=>	'PHPExcel_Calculation_Engineering::DECTOOCT',

												 'argumentCount'	=>	'1,2'

												),

				'DEGREES'				=> array('category'			=>	PHPExcel_Calculation_Function::CATEGORY_MATH_AND_TRIG,

												 'functionCall'		=>	'rad2deg',

												 'argumentCount'	=>	'1'

												),

				'DELTA'					=> array('category'			=>	PHPExcel_Calculation_Function::CATEGORY_ENGINEERING,

												 'functionCall'		=>	'PHPExcel_Calculation_Engineering::DELTA',

												 'argumentCount'	=>	'1,2'

												),

				'DEVSQ'					=> array('category'			=>	PHPExcel_Calculation_Function::CATEGORY_STATISTICAL,

												 'functionCall'		=>	'PHPExcel_Calculation_Statistical::DEVSQ',

												 'argumentCount'	=>	'1+'

												),

				'DGET'					=> array('category'			=>	PHPExcel_Calculation_Function::CATEGORY_DATABASE,

												 'functionCall'		=>	'PHPExcel_Calculation_Database::DGET',

												 'argumentCount'	=>	'3'

												),

				'DISC'					=> array('category'			=>	PHPExcel_Calculation_Function::CATEGORY_FINANCIAL,

												 'functionCall'		=>	'PHPExcel_Calculation_Financial::DISC',

												 'argumentCount'	=>	'4,5'

												),

				'DMAX'					=> array('category'			=>	PHPExcel_Calculation_Function::CATEGORY_DATABASE,

												 'functionCall'		=>	'PHPExcel_Calculation_Database::DMAX',

												 'argumentCount'	=>	'3'

												),

				'DMIN'					=> array('category'			=>	PHPExcel_Calculation_Function::CATEGORY_DATABASE,

												 'functionCall'		=>	'PHPExcel_Calculation_Database::DMIN',

												 'argumentCount'	=>	'3'

												),

				'DOLLAR'				=> array('category'			=>	PHPExcel_Calculation_Function::CATEGORY_TEXT_AND_DATA,

												 'functionCall'		=>	'PHPExcel_Calculation_TextData::DOLLAR',

												 'argumentCount'	=>	'1,2'

												),

				'DOLLARDE'				=> array('category'			=>	PHPExcel_Calculation_Function::CATEGORY_FINANCIAL,

												 'functionCall'		=>	'PHPExcel_Calculation_Financial::DOLLARDE',

												 'argumentCount'	=>	'2'

												),

				'DOLLARFR'				=> array('category'			=>	PHPExcel_Calculation_Function::CATEGORY_FINANCIAL,

												 'functionCall'		=>	'PHPExcel_Calculation_Financial::DOLLARFR',

												 'argumentCount'	=>	'2'

												),

				'DPRODUCT'				=> array('category'			=>	PHPExcel_Calculation_Function::CATEGORY_DATABASE,

												 'functionCall'		=>	'PHPExcel_Calculation_Database::DPRODUCT',

												 'argumentCount'	=>	'3'

												),

				'DSTDEV'				=> array('category'			=>	PHPExcel_Calculation_Function::CATEGORY_DATABASE,

												 'functionCall'		=>	'PHPExcel_Calculation_Database::DSTDEV',

												 'argumentCount'	=>	'3'

												),

				'DSTDEVP'				=> array('category'			=>	PHPExcel_Calculation_Function::CATEGORY_DATABASE,

												 'functionCall'		=>	'PHPExcel_Calculation_Database::DSTDEVP',

												 'argumentCount'	=>	'3'

												),

				'DSUM'					=> array('category'			=>	PHPExcel_Calculation_Function::CATEGORY_DATABASE,

												 'functionCall'		=>	'PHPExcel_Calculation_Database::DSUM',

												 'argumentCount'	=>	'3'

												),

				'DURATION'				=> array('category'			=>	PHPExcel_Calculation_Function::CATEGORY_FINANCIAL,

												 'functionCall'		=>	'PHPExcel_Calculation_Functions::DUMMY',

												 'argumentCount'	=>	'5,6'

												),

				'DVAR'					=> array('category'			=>	PHPExcel_Calculation_Function::CATEGORY_DATABASE,

												 'functionCall'		=>	'PHPExcel_Calculation_Database::DVAR',

												 'argumentCount'	=>	'3'

												),

				'DVARP'					=> array('category'			=>	PHPExcel_Calculation_Function::CATEGORY_DATABASE,

												 'functionCall'		=>	'PHPExcel_Calculation_Database::DVARP',

												 'argumentCount'	=>	'3'

												),

				'EDATE'					=> array('category'			=>	PHPExcel_Calculation_Function::CATEGORY_DATE_AND_TIME,

												 'functionCall'		=>	'PHPExcel_Calculation_DateTime::EDATE',

												 'argumentCount'	=>	'2'

												),

				'EFFECT'				=> array('category'			=>	PHPExcel_Calculation_Function::CATEGORY_FINANCIAL,

												 'functionCall'		=>	'PHPExcel_Calculation_Financial::EFFECT',

												 'argumentCount'	=>	'2'

												),

				'EOMONTH'				=> array('category'			=>	PHPExcel_Calculation_Function::CATEGORY_DATE_AND_TIME,

												 'functionCall'		=>	'PHPExcel_Calculation_DateTime::EOMONTH',

												 'argumentCount'	=>	'2'

												),

				'ERF'					=> array('category'			=>	PHPExcel_Calculation_Function::CATEGORY_ENGINEERING,

												 'functionCall'		=>	'PHPExcel_Calculation_Engineering::ERF',

												 'argumentCount'	=>	'1,2'

												),

				'ERFC'					=> array('category'			=>	PHPExcel_Calculation_Function::CATEGORY_ENGINEERING,

												 'functionCall'		=>	'PHPExcel_Calculation_Engineering::ERFC',

												 'argumentCount'	=>	'1'

												),

				'ERROR.TYPE'			=> array('category'			=>	PHPExcel_Calculation_Function::CATEGORY_INFORMATION,

												 'functionCall'		=>	'PHPExcel_Calculation_Functions::ERROR_TYPE',

												 'argumentCount'	=>	'1'

												),

				'EVEN'					=> array('category'			=>	PHPExcel_Calculation_Function::CATEGORY_MATH_AND_TRIG,

												 'functionCall'		=>	'PHPExcel_Calculation_MathTrig::EVEN',

												 'argumentCount'	=>	'1'

												),

				'EXACT'					=> array('category'			=>	PHPExcel_Calculation_Function::CATEGORY_TEXT_AND_DATA,

												 'functionCall'		=>	'PHPExcel_Calculation_Functions::DUMMY',

												 'argumentCount'	=>	'2'

												),

				'EXP'					=> array('category'			=>	PHPExcel_Calculation_Function::CATEGORY_MATH_AND_TRIG,

												 'functionCall'		=>	'exp',

												 'argumentCount'	=>	'1'

												),

				'EXPONDIST'				=> array('category'			=>	PHPExcel_Calculation_Function::CATEGORY_STATISTICAL,

												 'functionCall'		=>	'PHPExcel_Calculation_Statistical::EXPONDIST',

												 'argumentCount'	=>	'3'

												),

				'FACT'					=> array('category'			=>	PHPExcel_Calculation_Function::CATEGORY_MATH_AND_TRIG,

												 'functionCall'		=>	'PHPExcel_Calculation_MathTrig::FACT',

												 'argumentCount'	=>	'1'

												),

				'FACTDOUBLE'			=> array('category'			=>	PHPExcel_Calculation_Function::CATEGORY_MATH_AND_TRIG,

												 'functionCall'		=>	'PHPExcel_Calculation_MathTrig::FACTDOUBLE',

												 'argumentCount'	=>	'1'

												),

				'FALSE'					=> array('category'			=>	PHPExcel_Calculation_Function::CATEGORY_LOGICAL,

												 'functionCall'		=>	'PHPExcel_Calculation_Logical::FALSE',

												 'argumentCount'	=>	'0'

												),

				'FDIST'					=> array('category'			=>	PHPExcel_Calculation_Function::CATEGORY_STATISTICAL,

												 'functionCall'		=>	'PHPExcel_Calculation_Functions::DUMMY',

												 'argumentCount'	=>	'3'

												),

				'FIND'					=> array('category'			=>	PHPExcel_Calculation_Function::CATEGORY_TEXT_AND_DATA,

												 'functionCall'		=>	'PHPExcel_Calculation_TextData::SEARCHSENSITIVE',

												 'argumentCount'	=>	'2,3'

												),

				'FINDB'					=> array('category'			=>	PHPExcel_Calculation_Function::CATEGORY_TEXT_AND_DATA,

												 'functionCall'		=>	'PHPExcel_Calculation_TextData::SEARCHSENSITIVE',

												 'argumentCount'	=>	'2,3'

												),

				'FINV'					=> array('category'			=>	PHPExcel_Calculation_Function::CATEGORY_STATISTICAL,

												 'functionCall'		=>	'PHPExcel_Calculation_Functions::DUMMY',

												 'argumentCount'	=>	'3'

												),

				'FISHER'				=> array('category'			=>	PHPExcel_Calculation_Function::CATEGORY_STATISTICAL,

												 'functionCall'		=>	'PHPExcel_Calculation_Statistical::FISHER',

												 'argumentCount'	=>	'1'

												),

				'FISHERINV'				=> array('category'			=>	PHPExcel_Calculation_Function::CATEGORY_STATISTICAL,

												 'functionCall'		=>	'PHPExcel_Calculation_Statistical::FISHERINV',

												 'argumentCount'	=>	'1'

												),

				'FIXED'					=> array('category'			=>	PHPExcel_Calculation_Function::CATEGORY_TEXT_AND_DATA,

												 'functionCall'		=>	'PHPExcel_Calculation_TextData::FIXEDFORMAT',

												 'argumentCount'	=>	'1-3'

												),

				'FLOOR'					=> array('category'			=>	PHPExcel_Calculation_Function::CATEGORY_MATH_AND_TRIG,

												 'functionCall'		=>	'PHPExcel_Calculation_MathTrig::FLOOR',

												 'argumentCount'	=>	'2'

												),

				'FORECAST'				=> array('category'			=>	PHPExcel_Calculation_Function::CATEGORY_STATISTICAL,

												 'functionCall'		=>	'PHPExcel_Calculation_Statistical::FORECAST',

												 'argumentCount'	=>	'3'

												),

				'FREQUENCY'				=> array('category'			=>	PHPExcel_Calculation_Function::CATEGORY_STATISTICAL,

												 'functionCall'		=>	'PHPExcel_Calculation_Functions::DUMMY',

												 'argumentCount'	=>	'2'

												),

				'FTEST'					=> array('category'			=>	PHPExcel_Calculation_Function::CATEGORY_STATISTICAL,

												 'functionCall'		=>	'PHPExcel_Calculation_Functions::DUMMY',

												 'argumentCount'	=>	'2'

												),

				'FV'					=> array('category'			=>	PHPExcel_Calculation_Function::CATEGORY_FINANCIAL,

												 'functionCall'		=>	'PHPExcel_Calculation_Financial::FV',

												 'argumentCount'	=>	'3-5'

												),

				'FVSCHEDULE'			=> array('category'			=>	PHPExcel_Calculation_Function::CATEGORY_FINANCIAL,

												 'functionCall'		=>	'PHPExcel_Calculation_Financial::FVSCHEDULE',

												 'argumentCount'	=>	'2'

												),

				'GAMMADIST'				=> array('category'			=>	PHPExcel_Calculation_Function::CATEGORY_STATISTICAL,

												 'functionCall'		=>	'PHPExcel_Calculation_Statistical::GAMMADIST',

												 'argumentCount'	=>	'4'

												),

				'GAMMAINV'				=> array('category'			=>	PHPExcel_Calculation_Function::CATEGORY_STATISTICAL,

												 'functionCall'		=>	'PHPExcel_Calculation_Statistical::GAMMAINV',

												 'argumentCount'	=>	'3'

												),

				'GAMMALN'				=> array('category'			=>	PHPExcel_Calculation_Function::CATEGORY_STATISTICAL,

												 'functionCall'		=>	'PHPExcel_Calculation_Statistical::GAMMALN',

												 'argumentCount'	=>	'1'

												),

				'GCD'					=> array('category'			=>	PHPExcel_Calculation_Function::CATEGORY_MATH_AND_TRIG,

												 'functionCall'		=>	'PHPExcel_Calculation_MathTrig::GCD',

												 'argumentCount'	=>	'1+'

												),

				'GEOMEAN'				=> array('category'			=>	PHPExcel_Calculation_Function::CATEGORY_STATISTICAL,

												 'functionCall'		=>	'PHPExcel_Calculation_Statistical::GEOMEAN',

												 'argumentCount'	=>	'1+'

												),

				'GESTEP'				=> array('category'			=>	PHPExcel_Calculation_Function::CATEGORY_ENGINEERING,

												 'functionCall'		=>	'PHPExcel_Calculation_Engineering::GESTEP',

												 'argumentCount'	=>	'1,2'

												),

				'GETPIVOTDATA'			=> array('category'			=>	PHPExcel_Calculation_Function::CATEGORY_LOOKUP_AND_REFERENCE,

												 'functionCall'		=>	'PHPExcel_Calculation_Functions::DUMMY',

												 'argumentCount'	=>	'2+'

												),

				'GROWTH'				=> array('category'			=>	PHPExcel_Calculation_Function::CATEGORY_STATISTICAL,

												 'functionCall'		=>	'PHPExcel_Calculation_Statistical::GROWTH',

												 'argumentCount'	=>	'1-4'

												),

				'HARMEAN'				=> array('category'			=>	PHPExcel_Calculation_Function::CATEGORY_STATISTICAL,

												 'functionCall'		=>	'PHPExcel_Calculation_Statistical::HARMEAN',

												 'argumentCount'	=>	'1+'

												),

				'HEX2BIN'				=> array('category'			=>	PHPExcel_Calculation_Function::CATEGORY_ENGINEERING,

												 'functionCall'		=>	'PHPExcel_Calculation_Engineering::HEXTOBIN',

												 'argumentCount'	=>	'1,2'

												),

				'HEX2DEC'				=> array('category'			=>	PHPExcel_Calculation_Function::CATEGORY_ENGINEERING,

												 'functionCall'		=>	'PHPExcel_Calculation_Engineering::HEXTODEC',

												 'argumentCount'	=>	'1'

												),

				'HEX2OCT'				=> array('category'			=>	PHPExcel_Calculation_Function::CATEGORY_ENGINEERING,

												 'functionCall'		=>	'PHPExcel_Calculation_Engineering::HEXTOOCT',

												 'argumentCount'	=>	'1,2'

												),

				'HLOOKUP'				=> array('category'			=>	PHPExcel_Calculation_Function::CATEGORY_LOOKUP_AND_REFERENCE,

												 'functionCall'		=>	'PHPExcel_Calculation_LookupRef::HLOOKUP',

												 'argumentCount'	=>	'3,4'

												),

				'HOUR'					=> array('category'			=>	PHPExcel_Calculation_Function::CATEGORY_DATE_AND_TIME,

												 'functionCall'		=>	'PHPExcel_Calculation_DateTime::HOUROFDAY',

												 'argumentCount'	=>	'1'

												),

				'HYPERLINK'				=> array('category'			=>	PHPExcel_Calculation_Function::CATEGORY_LOOKUP_AND_REFERENCE,

												 'functionCall'		=>	'PHPExcel_Calculation_LookupRef::HYPERLINK',

												 'argumentCount'	=>	'1,2',

												 'passCellReference'=>	TRUE

												),

				'HYPGEOMDIST'			=> array('category'			=>	PHPExcel_Calculation_Function::CATEGORY_STATISTICAL,

												 'functionCall'		=>	'PHPExcel_Calculation_Statistical::HYPGEOMDIST',

												 'argumentCount'	=>	'4'

												),

				'IF'					=> array('category'			=>	PHPExcel_Calculation_Function::CATEGORY_LOGICAL,

												 'functionCall'		=>	'PHPExcel_Calculation_Logical::STATEMENT_IF',

												 'argumentCount'	=>	'1-3'

												),

				'IFERROR'				=> array('category'			=>	PHPExcel_Calculation_Function::CATEGORY_LOGICAL,

												 'functionCall'		=>	'PHPExcel_Calculation_Logical::IFERROR',

												 'argumentCount'	=>	'2'

												),

				'IMABS'					=> array('category'			=>	PHPExcel_Calculation_Function::CATEGORY_ENGINEERING,

												 'functionCall'		=>	'PHPExcel_Calculation_Engineering::IMABS',

												 'argumentCount'	=>	'1'

												),

				'IMAGINARY'				=> array('category'			=>	PHPExcel_Calculation_Function::CATEGORY_ENGINEERING,

												 'functionCall'		=>	'PHPExcel_Calculation_Engineering::IMAGINARY',

												 'argumentCount'	=>	'1'

												),

				'IMARGUMENT'			=> array('category'			=>	PHPExcel_Calculation_Function::CATEGORY_ENGINEERING,

												 'functionCall'		=>	'PHPExcel_Calculation_Engineering::IMARGUMENT',

												 'argumentCount'	=>	'1'

												),

				'IMCONJUGATE'			=> array('category'			=>	PHPExcel_Calculation_Function::CATEGORY_ENGINEERING,

												 'functionCall'		=>	'PHPExcel_Calculation_Engineering::IMCONJUGATE',

												 'argumentCount'	=>	'1'

												),

				'IMCOS'					=> array('category'			=>	PHPExcel_Calculation_Function::CATEGORY_ENGINEERING,

												 'functionCall'		=>	'PHPExcel_Calculation_Engineering::IMCOS',

												 'argumentCount'	=>	'1'

												),

				'IMDIV'					=> array('category'			=>	PHPExcel_Calculation_Function::CATEGORY_ENGINEERING,

												 'functionCall'		=>	'PHPExcel_Calculation_Engineering::IMDIV',

												 'argumentCount'	=>	'2'

												),

				'IMEXP'					=> array('category'			=>	PHPExcel_Calculation_Function::CATEGORY_ENGINEERING,

												 'functionCall'		=>	'PHPExcel_Calculation_Engineering::IMEXP',

												 'argumentCount'	=>	'1'

												),

				'IMLN'					=> array('category'			=>	PHPExcel_Calculation_Function::CATEGORY_ENGINEERING,

												 'functionCall'		=>	'PHPExcel_Calculation_Engineering::IMLN',

												 'argumentCount'	=>	'1'

												),

				'IMLOG10'				=> array('category'			=>	PHPExcel_Calculation_Function::CATEGORY_ENGINEERING,

												 'functionCall'		=>	'PHPExcel_Calculation_Engineering::IMLOG10',

												 'argumentCount'	=>	'1'

												),

				'IMLOG2'				=> array('category'			=>	PHPExcel_Calculation_Function::CATEGORY_ENGINEERING,

												 'functionCall'		=>	'PHPExcel_Calculation_Engineering::IMLOG2',

												 'argumentCount'	=>	'1'

												),

				'IMPOWER'				=> array('category'			=>	PHPExcel_Calculation_Function::CATEGORY_ENGINEERING,

												 'functionCall'		=>	'PHPExcel_Calculation_Engineering::IMPOWER',

												 'argumentCount'	=>	'2'

												),

				'IMPRODUCT'				=> array('category'			=>	PHPExcel_Calculation_Function::CATEGORY_ENGINEERING,

												 'functionCall'		=>	'PHPExcel_Calculation_Engineering::IMPRODUCT',

												 'argumentCount'	=>	'1+'

												),

				'IMREAL'				=> array('category'			=>	PHPExcel_Calculation_Function::CATEGORY_ENGINEERING,

												 'functionCall'		=>	'PHPExcel_Calculation_Engineering::IMREAL',

												 'argumentCount'	=>	'1'

												),

				'IMSIN'					=> array('category'			=>	PHPExcel_Calculation_Function::CATEGORY_ENGINEERING,

												 'functionCall'		=>	'PHPExcel_Calculation_Engineering::IMSIN',

												 'argumentCount'	=>	'1'

												),

				'IMSQRT'				=> array('category'			=>	PHPExcel_Calculation_Function::CATEGORY_ENGINEERING,

												 'functionCall'		=>	'PHPExcel_Calculation_Engineering::IMSQRT',

												 'argumentCount'	=>	'1'

												),

				'IMSUB'					=> array('category'			=>	PHPExcel_Calculation_Function::CATEGORY_ENGINEERING,

												 'functionCall'		=>	'PHPExcel_Calculation_Engineering::IMSUB',

												 'argumentCount'	=>	'2'

												),

				'IMSUM'					=> array('category'			=>	PHPExcel_Calculation_Function::CATEGORY_ENGINEERING,

												 'functionCall'		=>	'PHPExcel_Calculation_Engineering::IMSUM',

												 'argumentCount'	=>	'1+'

												),

				'INDEX'					=> array('category'			=>	PHPExcel_Calculation_Function::CATEGORY_LOOKUP_AND_REFERENCE,

												 'functionCall'		=>	'PHPExcel_Calculation_LookupRef::INDEX',

												 'argumentCount'	=>	'1-4'

												),

				'INDIRECT'				=> array('category'			=>	PHPExcel_Calculation_Function::CATEGORY_LOOKUP_AND_REFERENCE,

												 'functionCall'		=>	'PHPExcel_Calculation_LookupRef::INDIRECT',

												 'argumentCount'	=>	'1,2',

												 'passCellReference'=>	TRUE

												),

				'INFO'					=> array('category'			=>	PHPExcel_Calculation_Function::CATEGORY_INFORMATION,

												 'functionCall'		=>	'PHPExcel_Calculation_Functions::DUMMY',

												 'argumentCount'	=>	'1'

												),

				'INT'					=> array('category'			=>	PHPExcel_Calculation_Function::CATEGORY_MATH_AND_TRIG,

												 'functionCall'		=>	'PHPExcel_Calculation_MathTrig::INT',

												 'argumentCount'	=>	'1'

												),

				'INTERCEPT'				=> array('category'			=>	PHPExcel_Calculation_Function::CATEGORY_STATISTICAL,

												 'functionCall'		=>	'PHPExcel_Calculation_Statistical::INTERCEPT',

												 'argumentCount'	=>	'2'

												),

				'INTRATE'				=> array('category'			=>	PHPExcel_Calculation_Function::CATEGORY_FINANCIAL,

												 'functionCall'		=>	'PHPExcel_Calculation_Financial::INTRATE',

												 'argumentCount'	=>	'4,5'

												),

				'IPMT'					=> array('category'			=>	PHPExcel_Calculation_Function::CATEGORY_FINANCIAL,

												 'functionCall'		=>	'PHPExcel_Calculation_Financial::IPMT',

												 'argumentCount'	=>	'4-6'

												),

				'IRR'					=> array('category'			=>	PHPExcel_Calculation_Function::CATEGORY_FINANCIAL,

												 'functionCall'		=>	'PHPExcel_Calculation_Financial::IRR',

												 'argumentCount'	=>	'1,2'

												),

				'ISBLANK'				=> array('category'			=>	PHPExcel_Calculation_Function::CATEGORY_INFORMATION,

												 'functionCall'		=>	'PHPExcel_Calculation_Functions::IS_BLANK',

												 'argumentCount'	=>	'1'

												),

				'ISERR'					=> array('category'			=>	PHPExcel_Calculation_Function::CATEGORY_INFORMATION,

												 'functionCall'		=>	'PHPExcel_Calculation_Functions::IS_ERR',

												 'argumentCount'	=>	'1'

												),

				'ISERROR'				=> array('category'			=>	PHPExcel_Calculation_Function::CATEGORY_INFORMATION,

												 'functionCall'		=>	'PHPExcel_Calculation_Functions::IS_ERROR',

												 'argumentCount'	=>	'1'

												),

				'ISEVEN'				=> array('category'			=>	PHPExcel_Calculation_Function::CATEGORY_INFORMATION,

												 'functionCall'		=>	'PHPExcel_Calculation_Functions::IS_EVEN',

												 'argumentCount'	=>	'1'

												),

				'ISLOGICAL'				=> array('category'			=>	PHPExcel_Calculation_Function::CATEGORY_INFORMATION,

												 'functionCall'		=>	'PHPExcel_Calculation_Functions::IS_LOGICAL',

												 'argumentCount'	=>	'1'

												),

				'ISNA'					=> array('category'			=>	PHPExcel_Calculation_Function::CATEGORY_INFORMATION,

												 'functionCall'		=>	'PHPExcel_Calculation_Functions::IS_NA',

												 'argumentCount'	=>	'1'

												),

				'ISNONTEXT'				=> array('category'			=>	PHPExcel_Calculation_Function::CATEGORY_INFORMATION,

												 'functionCall'		=>	'PHPExcel_Calculation_Functions::IS_NONTEXT',

												 'argumentCount'	=>	'1'

												),

				'ISNUMBER'				=> array('category'			=>	PHPExcel_Calculation_Function::CATEGORY_INFORMATION,

												 'functionCall'		=>	'PHPExcel_Calculation_Functions::IS_NUMBER',

												 'argumentCount'	=>	'1'

												),

				'ISODD'					=> array('category'			=>	PHPExcel_Calculation_Function::CATEGORY_INFORMATION,

												 'functionCall'		=>	'PHPExcel_Calculation_Functions::IS_ODD',

												 'argumentCount'	=>	'1'

												),

				'ISPMT'					=> array('category'			=>	PHPExcel_Calculation_Function::CATEGORY_FINANCIAL,

												 'functionCall'		=>	'PHPExcel_Calculation_Financial::ISPMT',

												 'argumentCount'	=>	'4'

												),

				'ISREF'					=> array('category'			=>	PHPExcel_Calculation_Function::CATEGORY_INFORMATION,

												 'functionCall'		=>	'PHPExcel_Calculation_Functions::DUMMY',

												 'argumentCount'	=>	'1'

												),

				'ISTEXT'				=> array('category'			=>	PHPExcel_Calculation_Function::CATEGORY_INFORMATION,

												 'functionCall'		=>	'PHPExcel_Calculation_Functions::IS_TEXT',

												 'argumentCount'	=>	'1'

												),

				'JIS'					=> array('category'			=>	PHPExcel_Calculation_Function::CATEGORY_TEXT_AND_DATA,

												 'functionCall'		=>	'PHPExcel_Calculation_Functions::DUMMY',

												 'argumentCount'	=>	'1'

												),

				'KURT'					=> array('category'			=>	PHPExcel_Calculation_Function::CATEGORY_STATISTICAL,

												 'functionCall'		=>	'PHPExcel_Calculation_Statistical::KURT',

												 'argumentCount'	=>	'1+'

												),

				'LARGE'					=> array('category'			=>	PHPExcel_Calculation_Function::CATEGORY_STATISTICAL,

												 'functionCall'		=>	'PHPExcel_Calculation_Statistical::LARGE',

												 'argumentCount'	=>	'2'

												),

				'LCM'					=> array('category'			=>	PHPExcel_Calculation_Function::CATEGORY_MATH_AND_TRIG,

												 'functionCall'		=>	'PHPExcel_Calculation_MathTrig::LCM',

												 'argumentCount'	=>	'1+'

												),

				'LEFT'					=> array('category'			=>	PHPExcel_Calculation_Function::CATEGORY_TEXT_AND_DATA,

												 'functionCall'		=>	'PHPExcel_Calculation_TextData::LEFT',

												 'argumentCount'	=>	'1,2'

												),

				'LEFTB'					=> array('category'			=>	PHPExcel_Calculation_Function::CATEGORY_TEXT_AND_DATA,

												 'functionCall'		=>	'PHPExcel_Calculation_TextData::LEFT',

												 'argumentCount'	=>	'1,2'

												),

				'LEN'					=> array('category'			=>	PHPExcel_Calculation_Function::CATEGORY_TEXT_AND_DATA,

												 'functionCall'		=>	'PHPExcel_Calculation_TextData::STRINGLENGTH',

												 'argumentCount'	=>	'1'

												),

				'LENB'					=> array('category'			=>	PHPExcel_Calculation_Function::CATEGORY_TEXT_AND_DATA,

												 'functionCall'		=>	'PHPExcel_Calculation_TextData::STRINGLENGTH',

												 'argumentCount'	=>	'1'

												),

				'LINEST'				=> array('category'			=>	PHPExcel_Calculation_Function::CATEGORY_STATISTICAL,

												 'functionCall'		=>	'PHPExcel_Calculation_Statistical::LINEST',

												 'argumentCount'	=>	'1-4'

												),

				'LN'					=> array('category'			=>	PHPExcel_Calculation_Function::CATEGORY_MATH_AND_TRIG,

												 'functionCall'		=>	'log',

												 'argumentCount'	=>	'1'

												),

				'LOG'					=> array('category'			=>	PHPExcel_Calculation_Function::CATEGORY_MATH_AND_TRIG,

												 'functionCall'		=>	'PHPExcel_Calculation_MathTrig::LOG_BASE',

												 'argumentCount'	=>	'1,2'

												),

				'LOG10'					=> array('category'			=>	PHPExcel_Calculation_Function::CATEGORY_MATH_AND_TRIG,

												 'functionCall'		=>	'log10',

												 'argumentCount'	=>	'1'

												),

				'LOGEST'				=> array('category'			=>	PHPExcel_Calculation_Function::CATEGORY_STATISTICAL,

												 'functionCall'		=>	'PHPExcel_Calculation_Statistical::LOGEST',

												 'argumentCount'	=>	'1-4'

												),

				'LOGINV'				=> array('category'			=>	PHPExcel_Calculation_Function::CATEGORY_STATISTICAL,

												 'functionCall'		=>	'PHPExcel_Calculation_Statistical::LOGINV',

												 'argumentCount'	=>	'3'

												),

				'LOGNORMDIST'			=> array('category'			=>	PHPExcel_Calculation_Function::CATEGORY_STATISTICAL,

												 'functionCall'		=>	'PHPExcel_Calculation_Statistical::LOGNORMDIST',

												 'argumentCount'	=>	'3'

												),

				'LOOKUP'				=> array('category'			=>	PHPExcel_Calculation_Function::CATEGORY_LOOKUP_AND_REFERENCE,

												 'functionCall'		=>	'PHPExcel_Calculation_LookupRef::LOOKUP',

												 'argumentCount'	=>	'2,3'

												),

				'LOWER'					=> array('category'			=>	PHPExcel_Calculation_Function::CATEGORY_TEXT_AND_DATA,

												 'functionCall'		=>	'PHPExcel_Calculation_TextData::LOWERCASE',

												 'argumentCount'	=>	'1'

												),

				'MATCH'					=> array('category'			=>	PHPExcel_Calculation_Function::CATEGORY_LOOKUP_AND_REFERENCE,

												 'functionCall'		=>	'PHPExcel_Calculation_LookupRef::MATCH',

												 'argumentCount'	=>	'2,3'

												),

				'MAX'					=> array('category'			=>	PHPExcel_Calculation_Function::CATEGORY_STATISTICAL,

												 'functionCall'		=>	'PHPExcel_Calculation_Statistical::MAX',

												 'argumentCount'	=>	'1+'

												),

				'MAXA'					=> array('category'			=>	PHPExcel_Calculation_Function::CATEGORY_STATISTICAL,

												 'functionCall'		=>	'PHPExcel_Calculation_Statistical::MAXA',

												 'argumentCount'	=>	'1+'

												),

				'MAXIF'					=> array('category'			=>	PHPExcel_Calculation_Function::CATEGORY_STATISTICAL,

												 'functionCall'		=>	'PHPExcel_Calculation_Statistical::MAXIF',

												 'argumentCount'	=>	'2+'

												),

				'MDETERM'				=> array('category'			=>	PHPExcel_Calculation_Function::CATEGORY_MATH_AND_TRIG,

												 'functionCall'		=>	'PHPExcel_Calculation_MathTrig::MDETERM',

												 'argumentCount'	=>	'1'

												),

				'MDURATION'				=> array('category'			=>	PHPExcel_Calculation_Function::CATEGORY_FINANCIAL,

												 'functionCall'		=>	'PHPExcel_Calculation_Functions::DUMMY',

												 'argumentCount'	=>	'5,6'

												),

				'MEDIAN'				=> array('category'			=>	PHPExcel_Calculation_Function::CATEGORY_STATISTICAL,

												 'functionCall'		=>	'PHPExcel_Calculation_Statistical::MEDIAN',

												 'argumentCount'	=>	'1+'

												),

				'MEDIANIF'				=> array('category'			=>	PHPExcel_Calculation_Function::CATEGORY_STATISTICAL,

												 'functionCall'		=>	'PHPExcel_Calculation_Functions::DUMMY',

												 'argumentCount'	=>	'2+'

												),

				'MID'					=> array('category'			=>	PHPExcel_Calculation_Function::CATEGORY_TEXT_AND_DATA,

												 'functionCall'		=>	'PHPExcel_Calculation_TextData::MID',

												 'argumentCount'	=>	'3'

												),

				'MIDB'					=> array('category'			=>	PHPExcel_Calculation_Function::CATEGORY_TEXT_AND_DATA,

												 'functionCall'		=>	'PHPExcel_Calculation_TextData::MID',

												 'argumentCount'	=>	'3'

												),

				'MIN'					=> array('category'			=>	PHPExcel_Calculation_Function::CATEGORY_STATISTICAL,

												 'functionCall'		=>	'PHPExcel_Calculation_Statistical::MIN',

												 'argumentCount'	=>	'1+'

												),

				'MINA'					=> array('category'			=>	PHPExcel_Calculation_Function::CATEGORY_STATISTICAL,

												 'functionCall'		=>	'PHPExcel_Calculation_Statistical::MINA',

												 'argumentCount'	=>	'1+'

												),

				'MINIF'					=> array('category'			=>	PHPExcel_Calculation_Function::CATEGORY_STATISTICAL,

												 'functionCall'		=>	'PHPExcel_Calculation_Statistical::MINIF',

												 'argumentCount'	=>	'2+'

												),

				'MINUTE'				=> array('category'			=>	PHPExcel_Calculation_Function::CATEGORY_DATE_AND_TIME,

												 'functionCall'		=>	'PHPExcel_Calculation_DateTime::MINUTEOFHOUR',

												 'argumentCount'	=>	'1'

												),

				'MINVERSE'				=> array('category'			=>	PHPExcel_Calculation_Function::CATEGORY_MATH_AND_TRIG,

												 'functionCall'		=>	'PHPExcel_Calculation_MathTrig::MINVERSE',

												 'argumentCount'	=>	'1'

												),

				'MIRR'					=> array('category'			=>	PHPExcel_Calculation_Function::CATEGORY_FINANCIAL,

												 'functionCall'		=>	'PHPExcel_Calculation_Financial::MIRR',

												 'argumentCount'	=>	'3'

												),

				'MMULT'					=> array('category'			=>	PHPExcel_Calculation_Function::CATEGORY_MATH_AND_TRIG,

												 'functionCall'		=>	'PHPExcel_Calculation_MathTrig::MMULT',

												 'argumentCount'	=>	'2'

												),

				'MOD'					=> array('category'			=>	PHPExcel_Calculation_Function::CATEGORY_MATH_AND_TRIG,

												 'functionCall'		=>	'PHPExcel_Calculation_MathTrig::MOD',

												 'argumentCount'	=>	'2'

												),

				'MODE'					=> array('category'			=>	PHPExcel_Calculation_Function::CATEGORY_STATISTICAL,

												 'functionCall'		=>	'PHPExcel_Calculation_Statistical::MODE',

												 'argumentCount'	=>	'1+'

												),

				'MONTH'					=> array('category'			=>	PHPExcel_Calculation_Function::CATEGORY_DATE_AND_TIME,

												 'functionCall'		=>	'PHPExcel_Calculation_DateTime::MONTHOFYEAR',

												 'argumentCount'	=>	'1'

												),

				'MROUND'				=> array('category'			=>	PHPExcel_Calculation_Function::CATEGORY_MATH_AND_TRIG,

												 'functionCall'		=>	'PHPExcel_Calculation_MathTrig::MROUND',

												 'argumentCount'	=>	'2'

												),

				'MULTINOMIAL'			=> array('category'			=>	PHPExcel_Calculation_Function::CATEGORY_MATH_AND_TRIG,

												 'functionCall'		=>	'PHPExcel_Calculation_MathTrig::MULTINOMIAL',

												 'argumentCount'	=>	'1+'

												),

				'N'						=> array('category'			=>	PHPExcel_Calculation_Function::CATEGORY_INFORMATION,

												 'functionCall'		=>	'PHPExcel_Calculation_Functions::N',

												 'argumentCount'	=>	'1'

												),

				'NA'					=> array('category'			=>	PHPExcel_Calculation_Function::CATEGORY_INFORMATION,

												 'functionCall'		=>	'PHPExcel_Calculation_Functions::NA',

												 'argumentCount'	=>	'0'

												),

				'NEGBINOMDIST'			=> array('category'			=>	PHPExcel_Calculation_Function::CATEGORY_STATISTICAL,

												 'functionCall'		=>	'PHPExcel_Calculation_Statistical::NEGBINOMDIST',

												 'argumentCount'	=>	'3'

												),

				'NETWORKDAYS'			=> array('category'			=>	PHPExcel_Calculation_Function::CATEGORY_DATE_AND_TIME,

												 'functionCall'		=>	'PHPExcel_Calculation_DateTime::NETWORKDAYS',

												 'argumentCount'	=>	'2+'

												),

				'NOMINAL'				=> array('category'			=>	PHPExcel_Calculation_Function::CATEGORY_FINANCIAL,

												 'functionCall'		=>	'PHPExcel_Calculation_Financial::NOMINAL',

												 'argumentCount'	=>	'2'

												),

				'NORMDIST'				=> array('category'			=>	PHPExcel_Calculation_Function::CATEGORY_STATISTICAL,

												 'functionCall'		=>	'PHPExcel_Calculation_Statistical::NORMDIST',

												 'argumentCount'	=>	'4'

												),

				'NORMINV'				=> array('category'			=>	PHPExcel_Calculation_Function::CATEGORY_STATISTICAL,

												 'functionCall'		=>	'PHPExcel_Calculation_Statistical::NORMINV',

												 'argumentCount'	=>	'3'

												),

				'NORMSDIST'				=> array('category'			=>	PHPExcel_Calculation_Function::CATEGORY_STATISTICAL,

												 'functionCall'		=>	'PHPExcel_Calculation_Statistical::NORMSDIST',

												 'argumentCount'	=>	'1'

												),

				'NORMSINV'				=> array('category'			=>	PHPExcel_Calculation_Function::CATEGORY_STATISTICAL,

												 'functionCall'		=>	'PHPExcel_Calculation_Statistical::NORMSINV',

												 'argumentCount'	=>	'1'

												),

				'NOT'					=> array('category'			=>	PHPExcel_Calculation_Function::CATEGORY_LOGICAL,

												 'functionCall'		=>	'PHPExcel_Calculation_Logical::NOT',

												 'argumentCount'	=>	'1'

												),

				'NOW'					=> array('category'			=>	PHPExcel_Calculation_Function::CATEGORY_DATE_AND_TIME,

												 'functionCall'		=>	'PHPExcel_Calculation_DateTime::DATETIMENOW',

												 'argumentCount'	=>	'0'

												),

				'NPER'					=> array('category'			=>	PHPExcel_Calculation_Function::CATEGORY_FINANCIAL,

												 'functionCall'		=>	'PHPExcel_Calculation_Financial::NPER',

												 'argumentCount'	=>	'3-5'

												),

				'NPV'					=> array('category'			=>	PHPExcel_Calculation_Function::CATEGORY_FINANCIAL,

												 'functionCall'		=>	'PHPExcel_Calculation_Financial::NPV',

												 'argumentCount'	=>	'2+'

												),

				'OCT2BIN'				=> array('category'			=>	PHPExcel_Calculation_Function::CATEGORY_ENGINEERING,

												 'functionCall'		=>	'PHPExcel_Calculation_Engineering::OCTTOBIN',

												 'argumentCount'	=>	'1,2'

												),

				'OCT2DEC'				=> array('category'			=>	PHPExcel_Calculation_Function::CATEGORY_ENGINEERING,

												 'functionCall'		=>	'PHPExcel_Calculation_Engineering::OCTTODEC',

												 'argumentCount'	=>	'1'

												),

				'OCT2HEX'				=> array('category'			=>	PHPExcel_Calculation_Function::CATEGORY_ENGINEERING,

												 'functionCall'		=>	'PHPExcel_Calculation_Engineering::OCTTOHEX',

												 'argumentCount'	=>	'1,2'

												),

				'ODD'					=> array('category'			=>	PHPExcel_Calculation_Function::CATEGORY_MATH_AND_TRIG,

												 'functionCall'		=>	'PHPExcel_Calculation_MathTrig::ODD',

												 'argumentCount'	=>	'1'

												),

				'ODDFPRICE'				=> array('category'			=>	PHPExcel_Calculation_Function::CATEGORY_FINANCIAL,

												 'functionCall'		=>	'PHPExcel_Calculation_Functions::DUMMY',

												 'argumentCount'	=>	'8,9'

												),

				'ODDFYIELD'				=> array('category'			=>	PHPExcel_Calculation_Function::CATEGORY_FINANCIAL,

												 'functionCall'		=>	'PHPExcel_Calculation_Functions::DUMMY',

												 'argumentCount'	=>	'8,9'

												),

				'ODDLPRICE'				=> array('category'			=>	PHPExcel_Calculation_Function::CATEGORY_FINANCIAL,

												 'functionCall'		=>	'PHPExcel_Calculation_Functions::DUMMY',

												 'argumentCount'	=>	'7,8'

												),

				'ODDLYIELD'				=> array('category'			=>	PHPExcel_Calculation_Function::CATEGORY_FINANCIAL,

												 'functionCall'		=>	'PHPExcel_Calculation_Functions::DUMMY',

												 'argumentCount'	=>	'7,8'

												),

				'OFFSET'				=> array('category'			=>	PHPExcel_Calculation_Function::CATEGORY_LOOKUP_AND_REFERENCE,

												 'functionCall'		=>	'PHPExcel_Calculation_LookupRef::OFFSET',

												 'argumentCount'	=>	'3,5',

												 'passCellReference'=>	TRUE,

												 'passByReference'	=>	array(TRUE)

												),

				'OR'					=> array('category'			=>	PHPExcel_Calculation_Function::CATEGORY_LOGICAL,

												 'functionCall'		=>	'PHPExcel_Calculation_Logical::LOGICAL_OR',

												 'argumentCount'	=>	'1+'

												),

				'PEARSON'				=> array('category'			=>	PHPExcel_Calculation_Function::CATEGORY_STATISTICAL,

												 'functionCall'		=>	'PHPExcel_Calculation_Statistical::CORREL',

												 'argumentCount'	=>	'2'

												),

				'PERCENTILE'			=> array('category'			=>	PHPExcel_Calculation_Function::CATEGORY_STATISTICAL,

												 'functionCall'		=>	'PHPExcel_Calculation_Statistical::PERCENTILE',

												 'argumentCount'	=>	'2'

												),

				'PERCENTRANK'			=> array('category'			=>	PHPExcel_Calculation_Function::CATEGORY_STATISTICAL,

												 'functionCall'		=>	'PHPExcel_Calculation_Statistical::PERCENTRANK',

												 'argumentCount'	=>	'2,3'

												),

				'PERMUT'				=> array('category'			=>	PHPExcel_Calculation_Function::CATEGORY_STATISTICAL,

												 'functionCall'		=>	'PHPExcel_Calculation_Statistical::PERMUT',

												 'argumentCount'	=>	'2'

												),

				'PHONETIC'				=> array('category'			=>	PHPExcel_Calculation_Function::CATEGORY_TEXT_AND_DATA,

												 'functionCall'		=>	'PHPExcel_Calculation_Functions::DUMMY',

												 'argumentCount'	=>	'1'

												),

				'PI'					=> array('category'			=>	PHPExcel_Calculation_Function::CATEGORY_MATH_AND_TRIG,

												 'functionCall'		=>	'pi',

												 'argumentCount'	=>	'0'

												),

				'PMT'					=> array('category'			=>	PHPExcel_Calculation_Function::CATEGORY_FINANCIAL,

												 'functionCall'		=>	'PHPExcel_Calculation_Financial::PMT',

												 'argumentCount'	=>	'3-5'

												),

				'POISSON'				=> array('category'			=>	PHPExcel_Calculation_Function::CATEGORY_STATISTICAL,

												 'functionCall'		=>	'PHPExcel_Calculation_Statistical::POISSON',

												 'argumentCount'	=>	'3'

												),

				'POWER'					=> array('category'			=>	PHPExcel_Calculation_Function::CATEGORY_MATH_AND_TRIG,

												 'functionCall'		=>	'PHPExcel_Calculation_MathTrig::POWER',

												 'argumentCount'	=>	'2'

												),

				'PPMT'					=> array('category'			=>	PHPExcel_Calculation_Function::CATEGORY_FINANCIAL,

												 'functionCall'		=>	'PHPExcel_Calculation_Financial::PPMT',

												 'argumentCount'	=>	'4-6'

												),

				'PRICE'					=> array('category'			=>	PHPExcel_Calculation_Function::CATEGORY_FINANCIAL,

												 'functionCall'		=>	'PHPExcel_Calculation_Financial::PRICE',

												 'argumentCount'	=>	'6,7'

												),

				'PRICEDISC'				=> array('category'			=>	PHPExcel_Calculation_Function::CATEGORY_FINANCIAL,

												 'functionCall'		=>	'PHPExcel_Calculation_Financial::PRICEDISC',

												 'argumentCount'	=>	'4,5'

												),

				'PRICEMAT'				=> array('category'			=>	PHPExcel_Calculation_Function::CATEGORY_FINANCIAL,

												 'functionCall'		=>	'PHPExcel_Calculation_Financial::PRICEMAT',

												 'argumentCount'	=>	'5,6'

												),

				'PROB'					=> array('category'			=>	PHPExcel_Calculation_Function::CATEGORY_STATISTICAL,

												 'functionCall'		=>	'PHPExcel_Calculation_Functions::DUMMY',

												 'argumentCount'	=>	'3,4'

												),

				'PRODUCT'				=> array('category'			=>	PHPExcel_Calculation_Function::CATEGORY_MATH_AND_TRIG,

												 'functionCall'		=>	'PHPExcel_Calculation_MathTrig::PRODUCT',

												 'argumentCount'	=>	'1+'

												),

				'PROPER'				=> array('category'			=>	PHPExcel_Calculation_Function::CATEGORY_TEXT_AND_DATA,

												 'functionCall'		=>	'PHPExcel_Calculation_TextData::PROPERCASE',

												 'argumentCount'	=>	'1'

												),

				'PV'					=> array('category'			=>	PHPExcel_Calculation_Function::CATEGORY_FINANCIAL,

												 'functionCall'		=>	'PHPExcel_Calculation_Financial::PV',

												 'argumentCount'	=>	'3-5'

												),

				'QUARTILE'				=> array('category'			=>	PHPExcel_Calculation_Function::CATEGORY_STATISTICAL,

												 'functionCall'		=>	'PHPExcel_Calculation_Statistical::QUARTILE',

												 'argumentCount'	=>	'2'

												),

				'QUOTIENT'				=> array('category'			=>	PHPExcel_Calculation_Function::CATEGORY_MATH_AND_TRIG,

												 'functionCall'		=>	'PHPExcel_Calculation_MathTrig::QUOTIENT',

												 'argumentCount'	=>	'2'

												),

				'RADIANS'				=> array('category'			=>	PHPExcel_Calculation_Function::CATEGORY_MATH_AND_TRIG,

												 'functionCall'		=>	'deg2rad',

												 'argumentCount'	=>	'1'

												),

				'RAND'					=> array('category'			=>	PHPExcel_Calculation_Function::CATEGORY_MATH_AND_TRIG,

												 'functionCall'		=>	'PHPExcel_Calculation_MathTrig::RAND',

												 'argumentCount'	=>	'0'

												),

				'RANDBETWEEN'			=> array('category'			=>	PHPExcel_Calculation_Function::CATEGORY_MATH_AND_TRIG,

												 'functionCall'		=>	'PHPExcel_Calculation_MathTrig::RAND',

												 'argumentCount'	=>	'2'

												),

				'RANK'					=> array('category'			=>	PHPExcel_Calculation_Function::CATEGORY_STATISTICAL,

												 'functionCall'		=>	'PHPExcel_Calculation_Statistical::RANK',

												 'argumentCount'	=>	'2,3'

												),

				'RATE'					=> array('category'			=>	PHPExcel_Calculation_Function::CATEGORY_FINANCIAL,

												 'functionCall'		=>	'PHPExcel_Calculation_Financial::RATE',

												 'argumentCount'	=>	'3-6'

												),

				'RECEIVED'				=> array('category'			=>	PHPExcel_Calculation_Function::CATEGORY_FINANCIAL,

												 'functionCall'		=>	'PHPExcel_Calculation_Financial::RECEIVED',

												 'argumentCount'	=>	'4-5'

												),

				'REPLACE'				=> array('category'			=>	PHPExcel_Calculation_Function::CATEGORY_TEXT_AND_DATA,

												 'functionCall'		=>	'PHPExcel_Calculation_TextData::REPLACE',

												 'argumentCount'	=>	'4'

												),

				'REPLACEB'				=> array('category'			=>	PHPExcel_Calculation_Function::CATEGORY_TEXT_AND_DATA,

												 'functionCall'		=>	'PHPExcel_Calculation_TextData::REPLACE',

												 'argumentCount'	=>	'4'

												),

				'REPT'					=> array('category'			=>	PHPExcel_Calculation_Function::CATEGORY_TEXT_AND_DATA,

												 'functionCall'		=>	'str_repeat',

												 'argumentCount'	=>	'2'

												),

				'RIGHT'					=> array('category'			=>	PHPExcel_Calculation_Function::CATEGORY_TEXT_AND_DATA,

												 'functionCall'		=>	'PHPExcel_Calculation_TextData::RIGHT',

												 'argumentCount'	=>	'1,2'

												),

				'RIGHTB'				=> array('category'			=>	PHPExcel_Calculation_Function::CATEGORY_TEXT_AND_DATA,

												 'functionCall'		=>	'PHPExcel_Calculation_TextData::RIGHT',

												 'argumentCount'	=>	'1,2'

												),

				'ROMAN'					=> array('category'			=>	PHPExcel_Calculation_Function::CATEGORY_MATH_AND_TRIG,

												 'functionCall'		=>	'PHPExcel_Calculation_MathTrig::ROMAN',

												 'argumentCount'	=>	'1,2'

												),

				'ROUND'					=> array('category'			=>	PHPExcel_Calculation_Function::CATEGORY_MATH_AND_TRIG,

												 'functionCall'		=>	'round',

												 'argumentCount'	=>	'2'

												),

				'ROUNDDOWN'				=> array('category'			=>	PHPExcel_Calculation_Function::CATEGORY_MATH_AND_TRIG,

												 'functionCall'		=>	'PHPExcel_Calculation_MathTrig::ROUNDDOWN',

												 'argumentCount'	=>	'2'

												),

				'ROUNDUP'				=> array('category'			=>	PHPExcel_Calculation_Function::CATEGORY_MATH_AND_TRIG,

												 'functionCall'		=>	'PHPExcel_Calculation_MathTrig::ROUNDUP',

												 'argumentCount'	=>	'2'

												),

				'ROW'					=> array('category'			=>	PHPExcel_Calculation_Function::CATEGORY_LOOKUP_AND_REFERENCE,

												 'functionCall'		=>	'PHPExcel_Calculation_LookupRef::ROW',

												 'argumentCount'	=>	'-1',

												 'passByReference'	=>	array(TRUE)

												),

				'ROWS'					=> array('category'			=>	PHPExcel_Calculation_Function::CATEGORY_LOOKUP_AND_REFERENCE,

												 'functionCall'		=>	'PHPExcel_Calculation_LookupRef::ROWS',

												 'argumentCount'	=>	'1'

												),

				'RSQ'					=> array('category'			=>	PHPExcel_Calculation_Function::CATEGORY_STATISTICAL,

												 'functionCall'		=>	'PHPExcel_Calculation_Statistical::RSQ',

												 'argumentCount'	=>	'2'

												),

				'RTD'					=> array('category'			=>	PHPExcel_Calculation_Function::CATEGORY_LOOKUP_AND_REFERENCE,

												 'functionCall'		=>	'PHPExcel_Calculation_Functions::DUMMY',

												 'argumentCount'	=>	'1+'

												),

				'SEARCH'				=> array('category'			=>	PHPExcel_Calculation_Function::CATEGORY_TEXT_AND_DATA,

												 'functionCall'		=>	'PHPExcel_Calculation_TextData::SEARCHINSENSITIVE',

												 'argumentCount'	=>	'2,3'

												),

				'SEARCHB'				=> array('category'			=>	PHPExcel_Calculation_Function::CATEGORY_TEXT_AND_DATA,

												 'functionCall'		=>	'PHPExcel_Calculation_TextData::SEARCHINSENSITIVE',

												 'argumentCount'	=>	'2,3'

												),

				'SECOND'				=> array('category'			=>	PHPExcel_Calculation_Function::CATEGORY_DATE_AND_TIME,

												 'functionCall'		=>	'PHPExcel_Calculation_DateTime::SECONDOFMINUTE',

												 'argumentCount'	=>	'1'

												),

				'SERIESSUM'				=> array('category'			=>	PHPExcel_Calculation_Function::CATEGORY_MATH_AND_TRIG,

												 'functionCall'		=>	'PHPExcel_Calculation_MathTrig::SERIESSUM',

												 'argumentCount'	=>	'4'

												),

				'SIGN'					=> array('category'			=>	PHPExcel_Calculation_Function::CATEGORY_MATH_AND_TRIG,

												 'functionCall'		=>	'PHPExcel_Calculation_MathTrig::SIGN',

												 'argumentCount'	=>	'1'

												),

				'SIN'					=> array('category'			=>	PHPExcel_Calculation_Function::CATEGORY_MATH_AND_TRIG,

												 'functionCall'		=>	'sin',

												 'argumentCount'	=>	'1'

												),

				'SINH'					=> array('category'			=>	PHPExcel_Calculation_Function::CATEGORY_MATH_AND_TRIG,

												 'functionCall'		=>	'sinh',

												 'argumentCount'	=>	'1'

												),

				'SKEW'					=> array('category'			=>	PHPExcel_Calculation_Function::CATEGORY_STATISTICAL,

												 'functionCall'		=>	'PHPExcel_Calculation_Statistical::SKEW',

												 'argumentCount'	=>	'1+'

												),

				'SLN'					=> array('category'			=>	PHPExcel_Calculation_Function::CATEGORY_FINANCIAL,

												 'functionCall'		=>	'PHPExcel_Calculation_Financial::SLN',

												 'argumentCount'	=>	'3'

												),

				'SLOPE'					=> array('category'			=>	PHPExcel_Calculation_Function::CATEGORY_STATISTICAL,

												 'functionCall'		=>	'PHPExcel_Calculation_Statistical::SLOPE',

												 'argumentCount'	=>	'2'

												),

				'SMALL'					=> array('category'			=>	PHPExcel_Calculation_Function::CATEGORY_STATISTICAL,

												 'functionCall'		=>	'PHPExcel_Calculation_Statistical::SMALL',

												 'argumentCount'	=>	'2'

												),

				'SQRT'					=> array('category'			=>	PHPExcel_Calculation_Function::CATEGORY_MATH_AND_TRIG,

												 'functionCall'		=>	'sqrt',

												 'argumentCount'	=>	'1'

												),

				'SQRTPI'				=> array('category'			=>	PHPExcel_Calculation_Function::CATEGORY_MATH_AND_TRIG,

												 'functionCall'		=>	'PHPExcel_Calculation_MathTrig::SQRTPI',

												 'argumentCount'	=>	'1'

												),

				'STANDARDIZE'			=> array('category'			=>	PHPExcel_Calculation_Function::CATEGORY_STATISTICAL,

												 'functionCall'		=>	'PHPExcel_Calculation_Statistical::STANDARDIZE',

												 'argumentCount'	=>	'3'

												),

				'STDEV'					=> array('category'			=>	PHPExcel_Calculation_Function::CATEGORY_STATISTICAL,

												 'functionCall'		=>	'PHPExcel_Calculation_Statistical::STDEV',

												 'argumentCount'	=>	'1+'

												),

				'STDEVA'				=> array('category'			=>	PHPExcel_Calculation_Function::CATEGORY_STATISTICAL,

												 'functionCall'		=>	'PHPExcel_Calculation_Statistical::STDEVA',

												 'argumentCount'	=>	'1+'

												),

				'STDEVP'				=> array('category'			=>	PHPExcel_Calculation_Function::CATEGORY_STATISTICAL,

												 'functionCall'		=>	'PHPExcel_Calculation_Statistical::STDEVP',

												 'argumentCount'	=>	'1+'

												),

				'STDEVPA'				=> array('category'			=>	PHPExcel_Calculation_Function::CATEGORY_STATISTICAL,

												 'functionCall'		=>	'PHPExcel_Calculation_Statistical::STDEVPA',

												 'argumentCount'	=>	'1+'

												),

				'STEYX'					=> array('category'			=>	PHPExcel_Calculation_Function::CATEGORY_STATISTICAL,

												 'functionCall'		=>	'PHPExcel_Calculation_Statistical::STEYX',

												 'argumentCount'	=>	'2'

												),

				'SUBSTITUTE'			=> array('category'			=>	PHPExcel_Calculation_Function::CATEGORY_TEXT_AND_DATA,

												 'functionCall'		=>	'PHPExcel_Calculation_TextData::SUBSTITUTE',

												 'argumentCount'	=>	'3,4'

												),

				'SUBTOTAL'				=> array('category'			=>	PHPExcel_Calculation_Function::CATEGORY_MATH_AND_TRIG,

												 'functionCall'		=>	'PHPExcel_Calculation_MathTrig::SUBTOTAL',

												 'argumentCount'	=>	'2+'

												),

				'SUM'					=> array('category'			=>	PHPExcel_Calculation_Function::CATEGORY_MATH_AND_TRIG,

												 'functionCall'		=>	'PHPExcel_Calculation_MathTrig::SUM',

												 'argumentCount'	=>	'1+'

												),

				'SUMIF'					=> array('category'			=>	PHPExcel_Calculation_Function::CATEGORY_MATH_AND_TRIG,

												 'functionCall'		=>	'PHPExcel_Calculation_MathTrig::SUMIF',

												 'argumentCount'	=>	'2,3'

												),

				'SUMIFS'				=> array('category'			=>	PHPExcel_Calculation_Function::CATEGORY_MATH_AND_TRIG,

												 'functionCall'		=>	'PHPExcel_Calculation_Functions::DUMMY',

												 'argumentCount'	=>	'?'

												),

				'SUMPRODUCT'			=> array('category'			=>	PHPExcel_Calculation_Function::CATEGORY_MATH_AND_TRIG,

												 'functionCall'		=>	'PHPExcel_Calculation_MathTrig::SUMPRODUCT',

												 'argumentCount'	=>	'1+'

												),

				'SUMSQ'					=> array('category'			=>	PHPExcel_Calculation_Function::CATEGORY_MATH_AND_TRIG,

												 'functionCall'		=>	'PHPExcel_Calculation_MathTrig::SUMSQ',

												 'argumentCount'	=>	'1+'

												),

				'SUMX2MY2'				=> array('category'			=>	PHPExcel_Calculation_Function::CATEGORY_MATH_AND_TRIG,

												 'functionCall'		=>	'PHPExcel_Calculation_MathTrig::SUMX2MY2',

												 'argumentCount'	=>	'2'

												),

				'SUMX2PY2'				=> array('category'			=>	PHPExcel_Calculation_Function::CATEGORY_MATH_AND_TRIG,

												 'functionCall'		=>	'PHPExcel_Calculation_MathTrig::SUMX2PY2',

												 'argumentCount'	=>	'2'

												),

				'SUMXMY2'				=> array('category'			=>	PHPExcel_Calculation_Function::CATEGORY_MATH_AND_TRIG,

												 'functionCall'		=>	'PHPExcel_Calculation_MathTrig::SUMXMY2',

												 'argumentCount'	=>	'2'

												),

				'SYD'					=> array('category'			=>	PHPExcel_Calculation_Function::CATEGORY_FINANCIAL,

												 'functionCall'		=>	'PHPExcel_Calculation_Financial::SYD',

												 'argumentCount'	=>	'4'

												),

				'T'						=> array('category'			=>	PHPExcel_Calculation_Function::CATEGORY_TEXT_AND_DATA,

												 'functionCall'		=>	'PHPExcel_Calculation_TextData::RETURNSTRING',

												 'argumentCount'	=>	'1'

												),

				'TAN'					=> array('category'			=>	PHPExcel_Calculation_Function::CATEGORY_MATH_AND_TRIG,

												 'functionCall'		=>	'tan',

												 'argumentCount'	=>	'1'

												),

				'TANH'					=> array('category'			=>	PHPExcel_Calculation_Function::CATEGORY_MATH_AND_TRIG,

												 'functionCall'		=>	'tanh',

												 'argumentCount'	=>	'1'

												),

				'TBILLEQ'				=> array('category'			=>	PHPExcel_Calculation_Function::CATEGORY_FINANCIAL,

												 'functionCall'		=>	'PHPExcel_Calculation_Financial::TBILLEQ',

												 'argumentCount'	=>	'3'

												),

				'TBILLPRICE'			=> array('category'			=>	PHPExcel_Calculation_Function::CATEGORY_FINANCIAL,

												 'functionCall'		=>	'PHPExcel_Calculation_Financial::TBILLPRICE',

												 'argumentCount'	=>	'3'

												),

				'TBILLYIELD'			=> array('category'			=>	PHPExcel_Calculation_Function::CATEGORY_FINANCIAL,

												 'functionCall'		=>	'PHPExcel_Calculation_Financial::TBILLYIELD',

												 'argumentCount'	=>	'3'

												),

				'TDIST'					=> array('category'			=>	PHPExcel_Calculation_Function::CATEGORY_STATISTICAL,

												 'functionCall'		=>	'PHPExcel_Calculation_Statistical::TDIST',

												 'argumentCount'	=>	'3'

												),

				'TEXT'					=> array('category'			=>	PHPExcel_Calculation_Function::CATEGORY_TEXT_AND_DATA,

												 'functionCall'		=>	'PHPExcel_Calculation_TextData::TEXTFORMAT',

												 'argumentCount'	=>	'2'

												),

				'TIME'					=> array('category'			=>	PHPExcel_Calculation_Function::CATEGORY_DATE_AND_TIME,

												 'functionCall'		=>	'PHPExcel_Calculation_DateTime::TIME',

												 'argumentCount'	=>	'3'

												),

				'TIMEVALUE'				=> array('category'			=>	PHPExcel_Calculation_Function::CATEGORY_DATE_AND_TIME,

												 'functionCall'		=>	'PHPExcel_Calculation_DateTime::TIMEVALUE',

												 'argumentCount'	=>	'1'

												),

				'TINV'					=> array('category'			=>	PHPExcel_Calculation_Function::CATEGORY_STATISTICAL,

												 'functionCall'		=>	'PHPExcel_Calculation_Statistical::TINV',

												 'argumentCount'	=>	'2'

												),

				'TODAY'					=> array('category'			=>	PHPExcel_Calculation_Function::CATEGORY_DATE_AND_TIME,

												 'functionCall'		=>	'PHPExcel_Calculation_DateTime::DATENOW',

												 'argumentCount'	=>	'0'

												),

				'TRANSPOSE'				=> array('category'			=>	PHPExcel_Calculation_Function::CATEGORY_LOOKUP_AND_REFERENCE,

												 'functionCall'		=>	'PHPExcel_Calculation_LookupRef::TRANSPOSE',

												 'argumentCount'	=>	'1'

												),

				'TREND'					=> array('category'			=>	PHPExcel_Calculation_Function::CATEGORY_STATISTICAL,

												 'functionCall'		=>	'PHPExcel_Calculation_Statistical::TREND',

												 'argumentCount'	=>	'1-4'

												),

				'TRIM'					=> array('category'			=>	PHPExcel_Calculation_Function::CATEGORY_TEXT_AND_DATA,

												 'functionCall'		=>	'PHPExcel_Calculation_TextData::TRIMSPACES',

												 'argumentCount'	=>	'1'

												),

				'TRIMMEAN'				=> array('category'			=>	PHPExcel_Calculation_Function::CATEGORY_STATISTICAL,

												 'functionCall'		=>	'PHPExcel_Calculation_Statistical::TRIMMEAN',

												 'argumentCount'	=>	'2'

												),

				'TRUE'					=> array('category'			=>	PHPExcel_Calculation_Function::CATEGORY_LOGICAL,

												 'functionCall'		=>	'PHPExcel_Calculation_Logical::TRUE',

												 'argumentCount'	=>	'0'

												),

				'TRUNC'					=> array('category'			=>	PHPExcel_Calculation_Function::CATEGORY_MATH_AND_TRIG,

												 'functionCall'		=>	'PHPExcel_Calculation_MathTrig::TRUNC',

												 'argumentCount'	=>	'1,2'

												),

				'TTEST'					=> array('category'			=>	PHPExcel_Calculation_Function::CATEGORY_STATISTICAL,

												 'functionCall'		=>	'PHPExcel_Calculation_Functions::DUMMY',

												 'argumentCount'	=>	'4'

												),

				'TYPE'					=> array('category'			=>	PHPExcel_Calculation_Function::CATEGORY_INFORMATION,

												 'functionCall'		=>	'PHPExcel_Calculation_Functions::TYPE',

												 'argumentCount'	=>	'1'

												),

				'UPPER'					=> array('category'			=>	PHPExcel_Calculation_Function::CATEGORY_TEXT_AND_DATA,

												 'functionCall'		=>	'PHPExcel_Calculation_TextData::UPPERCASE',

												 'argumentCount'	=>	'1'

												),

				'USDOLLAR'				=> array('category'			=>	PHPExcel_Calculation_Function::CATEGORY_FINANCIAL,

												 'functionCall'		=>	'PHPExcel_Calculation_Functions::DUMMY',

												 'argumentCount'	=>	'2'

												),

				'VALUE'					=> array('category'			=>	PHPExcel_Calculation_Function::CATEGORY_TEXT_AND_DATA,

												 'functionCall'		=>	'PHPExcel_Calculation_Functions::DUMMY',

												 'argumentCount'	=>	'1'

												),

				'VAR'					=> array('category'			=>	PHPExcel_Calculation_Function::CATEGORY_STATISTICAL,

												 'functionCall'		=>	'PHPExcel_Calculation_Statistical::VARFunc',

												 'argumentCount'	=>	'1+'

												),

				'VARA'					=> array('category'			=>	PHPExcel_Calculation_Function::CATEGORY_STATISTICAL,

												 'functionCall'		=>	'PHPExcel_Calculation_Statistical::VARA',

												 'argumentCount'	=>	'1+'

												),

				'VARP'					=> array('category'			=>	PHPExcel_Calculation_Function::CATEGORY_STATISTICAL,

												 'functionCall'		=>	'PHPExcel_Calculation_Statistical::VARP',

												 'argumentCount'	=>	'1+'

												),

				'VARPA'					=> array('category'			=>	PHPExcel_Calculation_Function::CATEGORY_STATISTICAL,

												 'functionCall'		=>	'PHPExcel_Calculation_Statistical::VARPA',

												 'argumentCount'	=>	'1+'

												),

				'VDB'					=> array('category'			=>	PHPExcel_Calculation_Function::CATEGORY_FINANCIAL,

												 'functionCall'		=>	'PHPExcel_Calculation_Functions::DUMMY',

												 'argumentCount'	=>	'5-7'

												),

				'VERSION'				=> array('category'			=>	PHPExcel_Calculation_Function::CATEGORY_INFORMATION,

												 'functionCall'		=>	'PHPExcel_Calculation_Functions::VERSION',

												 'argumentCount'	=>	'0'

												),

				'VLOOKUP'				=> array('category'			=>	PHPExcel_Calculation_Function::CATEGORY_LOOKUP_AND_REFERENCE,

												 'functionCall'		=>	'PHPExcel_Calculation_LookupRef::VLOOKUP',

												 'argumentCount'	=>	'3,4'

												),

				'WEEKDAY'				=> array('category'			=>	PHPExcel_Calculation_Function::CATEGORY_DATE_AND_TIME,

												 'functionCall'		=>	'PHPExcel_Calculation_DateTime::DAYOFWEEK',

												 'argumentCount'	=>	'1,2'

												),

				'WEEKNUM'				=> array('category'			=>	PHPExcel_Calculation_Function::CATEGORY_DATE_AND_TIME,

												 'functionCall'		=>	'PHPExcel_Calculation_DateTime::WEEKOFYEAR',

												 'argumentCount'	=>	'1,2'

												),

				'WEIBULL'				=> array('category'			=>	PHPExcel_Calculation_Function::CATEGORY_STATISTICAL,

												 'functionCall'		=>	'PHPExcel_Calculation_Statistical::WEIBULL',

												 'argumentCount'	=>	'4'

												),

				'WORKDAY'				=> array('category'			=>	PHPExcel_Calculation_Function::CATEGORY_DATE_AND_TIME,

												 'functionCall'		=>	'PHPExcel_Calculation_DateTime::WORKDAY',

												 'argumentCount'	=>	'2+'

												),

				'XIRR'					=> array('category'			=>	PHPExcel_Calculation_Function::CATEGORY_FINANCIAL,

												 'functionCall'		=>	'PHPExcel_Calculation_Financial::XIRR',

												 'argumentCount'	=>	'2,3'

												),

				'XNPV'					=> array('category'			=>	PHPExcel_Calculation_Function::CATEGORY_FINANCIAL,

												 'functionCall'		=>	'PHPExcel_Calculation_Financial::XNPV',

												 'argumentCount'	=>	'3'

												),

				'YEAR'					=> array('category'			=>	PHPExcel_Calculation_Function::CATEGORY_DATE_AND_TIME,

												 'functionCall'		=>	'PHPExcel_Calculation_DateTime::YEAR',

												 'argumentCount'	=>	'1'

												),

				'YEARFRAC'				=> array('category'			=>	PHPExcel_Calculation_Function::CATEGORY_DATE_AND_TIME,

												 'functionCall'		=>	'PHPExcel_Calculation_DateTime::YEARFRAC',

												 'argumentCount'	=>	'2,3'

												),

				'YIELD'					=> array('category'			=>	PHPExcel_Calculation_Function::CATEGORY_FINANCIAL,

												 'functionCall'		=>	'PHPExcel_Calculation_Functions::DUMMY',

												 'argumentCount'	=>	'6,7'

												),

				'YIELDDISC'				=> array('category'			=>	PHPExcel_Calculation_Function::CATEGORY_FINANCIAL,

												 'functionCall'		=>	'PHPExcel_Calculation_Financial::YIELDDISC',

												 'argumentCount'	=>	'4,5'

												),

				'YIELDMAT'				=> array('category'			=>	PHPExcel_Calculation_Function::CATEGORY_FINANCIAL,

												 'functionCall'		=>	'PHPExcel_Calculation_Financial::YIELDMAT',

												 'argumentCount'	=>	'5,6'

												),

				'ZTEST'					=> array('category'			=>	PHPExcel_Calculation_Function::CATEGORY_STATISTICAL,

												 'functionCall'		=>	'PHPExcel_Calculation_Statistical::ZTEST',

												 'argumentCount'	=>	'2-3'

												)

			);





	//	Internal functions used for special control purposes

	private static $_controlFunctions = array(

				'MKMATRIX'	=> array('argumentCount'	=>	'*',

									 'functionCall'		=>	'self::_mkMatrix'

									)

			);









	private function __construct(PHPExcel $workbook = NULL) {

		$setPrecision = (PHP_INT_SIZE == 4) ? 14 : 16;

		$this->_savedPrecision = ini_get('precision');

		if ($this->_savedPrecision < $setPrecision) {

			ini_set('precision',$setPrecision);

		}



		if ($workbook !== NULL) {

			self::$_workbookSets[$workbook->getID()] = $this;

		}



		$this->_workbook = $workbook;

		$this->_cyclicReferenceStack = new PHPExcel_CalcEngine_CyclicReferenceStack();

	    $this->_debugLog = new PHPExcel_CalcEngine_Logger($this->_cyclicReferenceStack);

	}	//	function __construct()





	public function __destruct() {

		if ($this->_savedPrecision != ini_get('precision')) {

			ini_set('precision',$this->_savedPrecision);

		}

	}



	private static function _loadLocales() {

		$localeFileDirectory = PHPEXCEL_ROOT.'PHPExcel/locale/';

		foreach (glob($localeFileDirectory.'/*',GLOB_ONLYDIR) as $filename) {

			$filename = substr($filename,strlen($localeFileDirectory)+1);

			if ($filename != 'en') {

				self::$_validLocaleLanguages[] = $filename;

			}

		}

	}



	/**

	 * Get an instance of this class

	 *

	 * @access	public

	 * @param   PHPExcel $workbook  Injected workbook for working with a PHPExcel object,

	 *									or NULL to create a standalone claculation engine

	 * @return PHPExcel_Calculation

	 */

	public static function getInstance(PHPExcel $workbook = NULL) {

		if ($workbook !== NULL) {

    		if (isset(self::$_workbookSets[$workbook->getID()])) {

    			return self::$_workbookSets[$workbook->getID()];

    		}

			return new PHPExcel_Calculation($workbook);

		}



		if (!isset(self::$_instance) || (self::$_instance === NULL)) {

			self::$_instance = new PHPExcel_Calculation();

		}



		return self::$_instance;

	}	//	function getInstance()



	/**

	 * Unset an instance of this class

	 *

	 * @access	public

	 * @param   PHPExcel $workbook  Injected workbook identifying the instance to unset

	 */

	public static function unsetInstance(PHPExcel $workbook = NULL) {

		if ($workbook !== NULL) {

    		if (isset(self::$_workbookSets[$workbook->getID()])) {

    			unset(self::$_workbookSets[$workbook->getID()]);

    		}

		}

    }



	/**

	 * Flush the calculation cache for any existing instance of this class

	 *		but only if a PHPExcel_Calculation instance exists

	 *

	 * @access	public

	 * @return null

	 */

	public function flushInstance() {

		$this->clearCalculationCache();

	}	//	function flushInstance()





	/**

	 * Get the debuglog for this claculation engine instance

	 *

	 * @access	public

	 * @return PHPExcel_CalcEngine_Logger

	 */

	public function getDebugLog() {

		return $this->_debugLog;

	}



	/**

	 * __clone implementation. Cloning should not be allowed in a Singleton!

	 *

	 * @access	public

	 * @throws	PHPExcel_Calculation_Exception

	 */

	public final function __clone() {

		throw new PHPExcel_Calculation_Exception ('Cloning the calculation engine is not allowed!');

	}	//	function __clone()





	/**

	 * Return the locale-specific translation of TRUE

	 *

	 * @access	public

	 * @return	 string		locale-specific translation of TRUE

	 */

	public static function getTRUE() {

		return self::$_localeBoolean['TRUE'];

	}



	/**

	 * Return the locale-specific translation of FALSE

	 *

	 * @access	public

	 * @return	 string		locale-specific translation of FALSE

	 */

	public static function getFALSE() {

		return self::$_localeBoolean['FALSE'];

	}



	/**

	 * Set the Array Return Type (Array or Value of first element in the array)

	 *

	 * @access	public

	 * @param	 string	$returnType			Array return type

	 * @return	 boolean					Success or failure

	 */

	public static function setArrayReturnType($returnType) {

		if (($returnType == self::RETURN_ARRAY_AS_VALUE) ||

			($returnType == self::RETURN_ARRAY_AS_ERROR) ||

			($returnType == self::RETURN_ARRAY_AS_ARRAY)) {

			self::$returnArrayAsType = $returnType;

			return TRUE;

		}

		return FALSE;

	}	//	function setArrayReturnType()





	/**

	 * Return the Array Return Type (Array or Value of first element in the array)

	 *

	 * @access	public

	 * @return	 string		$returnType			Array return type

	 */

	public static function getArrayReturnType() {

		return self::$returnArrayAsType;

	}	//	function getArrayReturnType()





	/**

	 * Is calculation caching enabled?

	 *

	 * @access	public

	 * @return boolean

	 */

	public function getCalculationCacheEnabled() {

		return $this->_calculationCacheEnabled;

	}	//	function getCalculationCacheEnabled()



	/**

	 * Enable/disable calculation cache

	 *

	 * @access	public

	 * @param boolean $pValue

	 */

	public function setCalculationCacheEnabled($pValue = TRUE) {

		$this->_calculationCacheEnabled = $pValue;

		$this->clearCalculationCache();

	}	//	function setCalculationCacheEnabled()





	/**

	 * Enable calculation cache

	 */

	public function enableCalculationCache() {

		$this->setCalculationCacheEnabled(TRUE);

	}	//	function enableCalculationCache()





	/**

	 * Disable calculation cache

	 */

	public function disableCalculationCache() {

		$this->setCalculationCacheEnabled(FALSE);

	}	//	function disableCalculationCache()





	/**

	 * Clear calculation cache

	 */

	public function clearCalculationCache() {

		$this->_calculationCache = array();

	}	//	function clearCalculationCache()



	/**

	 * Clear calculation cache for a specified worksheet

	 *

	 * @param string $worksheetName

	 */

	public function clearCalculationCacheForWorksheet($worksheetName) {

		if (isset($this->_calculationCache[$worksheetName])) {

			unset($this->_calculationCache[$worksheetName]);

		}

	}	//	function clearCalculationCacheForWorksheet()



	/**

	 * Rename calculation cache for a specified worksheet

	 *

	 * @param string $fromWorksheetName

	 * @param string $toWorksheetName

	 */

	public function renameCalculationCacheForWorksheet($fromWorksheetName, $toWorksheetName) {

		if (isset($this->_calculationCache[$fromWorksheetName])) {

			$this->_calculationCache[$toWorksheetName] = &$this->_calculationCache[$fromWorksheetName];

			unset($this->_calculationCache[$fromWorksheetName]);

		}

	}	//	function renameCalculationCacheForWorksheet()





	/**

	 * Get the currently defined locale code

	 *

	 * @return string

	 */

	public function getLocale() {

		return self::$_localeLanguage;

	}	//	function getLocale()





	/**

	 * Set the locale code

	 *

	 * @param string $locale  The locale to use for formula translation

	 * @return boolean

	 */

	public function setLocale($locale = 'en_us') {

		//	Identify our locale and language

		$language = $locale = strtolower($locale);

		if (strpos($locale,'_') !== FALSE) {

			list($language) = explode('_',$locale);

		}



		if (count(self::$_validLocaleLanguages) == 1)

			self::_loadLocales();



		//	Test whether we have any language data for this language (any locale)

		if (in_array($language,self::$_validLocaleLanguages)) {

			//	initialise language/locale settings

			self::$_localeFunctions = array();

			self::$_localeArgumentSeparator = ',';

			self::$_localeBoolean = array('TRUE' => 'TRUE', 'FALSE' => 'FALSE', 'NULL' => 'NULL');

			//	Default is English, if user isn't requesting english, then read the necessary data from the locale files

			if ($locale != 'en_us') {

				//	Search for a file with a list of function names for locale

				$functionNamesFile = PHPEXCEL_ROOT . 'PHPExcel'.DIRECTORY_SEPARATOR.'locale'.DIRECTORY_SEPARATOR.str_replace('_',DIRECTORY_SEPARATOR,$locale).DIRECTORY_SEPARATOR.'functions';

				if (!file_exists($functionNamesFile)) {

					//	If there isn't a locale specific function file, look for a language specific function file

					$functionNamesFile = PHPEXCEL_ROOT . 'PHPExcel'.DIRECTORY_SEPARATOR.'locale'.DIRECTORY_SEPARATOR.$language.DIRECTORY_SEPARATOR.'functions';

					if (!file_exists($functionNamesFile)) {

						return FALSE;

					}

				}

				//	Retrieve the list of locale or language specific function names

				$localeFunctions = file($functionNamesFile,FILE_IGNORE_NEW_LINES | FILE_SKIP_EMPTY_LINES);

				foreach ($localeFunctions as $localeFunction) {

					list($localeFunction) = explode('##',$localeFunction);	//	Strip out comments

					if (strpos($localeFunction,'=') !== FALSE) {

						list($fName,$lfName) = explode('=',$localeFunction);

						$fName = trim($fName);

						$lfName = trim($lfName);

						if ((isset(self::$_PHPExcelFunctions[$fName])) && ($lfName != '') && ($fName != $lfName)) {

							self::$_localeFunctions[$fName] = $lfName;

						}

					}

				}

				//	Default the TRUE and FALSE constants to the locale names of the TRUE() and FALSE() functions

				if (isset(self::$_localeFunctions['TRUE'])) { self::$_localeBoolean['TRUE'] = self::$_localeFunctions['TRUE']; }

				if (isset(self::$_localeFunctions['FALSE'])) { self::$_localeBoolean['FALSE'] = self::$_localeFunctions['FALSE']; }



				$configFile = PHPEXCEL_ROOT . 'PHPExcel'.DIRECTORY_SEPARATOR.'locale'.DIRECTORY_SEPARATOR.str_replace('_',DIRECTORY_SEPARATOR,$locale).DIRECTORY_SEPARATOR.'config';

				if (!file_exists($configFile)) {

					$configFile = PHPEXCEL_ROOT . 'PHPExcel'.DIRECTORY_SEPARATOR.'locale'.DIRECTORY_SEPARATOR.$language.DIRECTORY_SEPARATOR.'config';

				}

				if (file_exists($configFile)) {

					$localeSettings = file($configFile,FILE_IGNORE_NEW_LINES | FILE_SKIP_EMPTY_LINES);

					foreach ($localeSettings as $localeSetting) {

						list($localeSetting) = explode('##',$localeSetting);	//	Strip out comments

						if (strpos($localeSetting,'=') !== FALSE) {

							list($settingName,$settingValue) = explode('=',$localeSetting);

							$settingName = strtoupper(trim($settingName));

							switch ($settingName) {

								case 'ARGUMENTSEPARATOR' :

									self::$_localeArgumentSeparator = trim($settingValue);

									break;

							}

						}

					}

				}

			}



			self::$functionReplaceFromExcel = self::$functionReplaceToExcel =

			self::$functionReplaceFromLocale = self::$functionReplaceToLocale = NULL;

			self::$_localeLanguage = $locale;

			return TRUE;

		}

		return FALSE;

	}	//	function setLocale()







	public static function _translateSeparator($fromSeparator,$toSeparator,$formula,&$inBraces) {

		$strlen = mb_strlen($formula);

		for ($i = 0; $i < $strlen; ++$i) {

			$chr = mb_substr($formula,$i,1);

			switch ($chr) {

				case '{' :	$inBraces = TRUE;

							break;

				case '}' :	$inBraces = FALSE;

							break;

				case $fromSeparator :

							if (!$inBraces) {

								$formula = mb_substr($formula,0,$i).$toSeparator.mb_substr($formula,$i+1);

							}

			}

		}

		return $formula;

	}



	private static function _translateFormula($from,$to,$formula,$fromSeparator,$toSeparator) {

		//	Convert any Excel function names to the required language

		if (self::$_localeLanguage !== 'en_us') {

			$inBraces = FALSE;

			//	If there is the possibility of braces within a quoted string, then we don't treat those as matrix indicators

			if (strpos($formula,'"') !== FALSE) {

				//	So instead we skip replacing in any quoted strings by only replacing in every other array element after we've exploded

				//		the formula

				$temp = explode('"',$formula);

				$i = FALSE;

				foreach($temp as &$value) {

					//	Only count/replace in alternating array entries

					if ($i = !$i) {

						$value = preg_replace($from,$to,$value);

						$value = self::_translateSeparator($fromSeparator,$toSeparator,$value,$inBraces);

					}

				}

				unset($value);

				//	Then rebuild the formula string

				$formula = implode('"',$temp);

			} else {

				//	If there's no quoted strings, then we do a simple count/replace

				$formula = preg_replace($from,$to,$formula);

				$formula = self::_translateSeparator($fromSeparator,$toSeparator,$formula,$inBraces);

			}

		}



		return $formula;

	}



	private static $functionReplaceFromExcel	= NULL;

	private static $functionReplaceToLocale		= NULL;



	public function _translateFormulaToLocale($formula) {

		if (self::$functionReplaceFromExcel === NULL) {

			self::$functionReplaceFromExcel = array();

			foreach(array_keys(self::$_localeFunctions) as $excelFunctionName) {

				self::$functionReplaceFromExcel[] = '/(@?[^\w\.])'.preg_quote($excelFunctionName).'([\s]*\()/Ui';

			}

			foreach(array_keys(self::$_localeBoolean) as $excelBoolean) {

				self::$functionReplaceFromExcel[] = '/(@?[^\w\.])'.preg_quote($excelBoolean).'([^\w\.])/Ui';

			}



		}



		if (self::$functionReplaceToLocale === NULL) {

			self::$functionReplaceToLocale = array();

			foreach(array_values(self::$_localeFunctions) as $localeFunctionName) {

				self::$functionReplaceToLocale[] = '$1'.trim($localeFunctionName).'$2';

			}

			foreach(array_values(self::$_localeBoolean) as $localeBoolean) {

				self::$functionReplaceToLocale[] = '$1'.trim($localeBoolean).'$2';

			}

		}



		return self::_translateFormula(self::$functionReplaceFromExcel,self::$functionReplaceToLocale,$formula,',',self::$_localeArgumentSeparator);

	}	//	function _translateFormulaToLocale()





	private static $functionReplaceFromLocale	= NULL;

	private static $functionReplaceToExcel		= NULL;



	public function _translateFormulaToEnglish($formula) {

		if (self::$functionReplaceFromLocale === NULL) {

			self::$functionReplaceFromLocale = array();

			foreach(array_values(self::$_localeFunctions) as $localeFunctionName) {

				self::$functionReplaceFromLocale[] = '/(@?[^\w\.])'.preg_quote($localeFunctionName).'([\s]*\()/Ui';

			}

			foreach(array_values(self::$_localeBoolean) as $excelBoolean) {

				self::$functionReplaceFromLocale[] = '/(@?[^\w\.])'.preg_quote($excelBoolean).'([^\w\.])/Ui';

			}

		}



		if (self::$functionReplaceToExcel === NULL) {

			self::$functionReplaceToExcel = array();

			foreach(array_keys(self::$_localeFunctions) as $excelFunctionName) {

				self::$functionReplaceToExcel[] = '$1'.trim($excelFunctionName).'$2';

			}

			foreach(array_keys(self::$_localeBoolean) as $excelBoolean) {

				self::$functionReplaceToExcel[] = '$1'.trim($excelBoolean).'$2';

			}

		}



		return self::_translateFormula(self::$functionReplaceFromLocale,self::$functionReplaceToExcel,$formula,self::$_localeArgumentSeparator,',');

	}	//	function _translateFormulaToEnglish()





	public static function _localeFunc($function) {

		if (self::$_localeLanguage !== 'en_us') {

			$functionName = trim($function,'(');

			if (isset(self::$_localeFunctions[$functionName])) {

				$brace = ($functionName != $function);

				$function = self::$_localeFunctions[$functionName];

				if ($brace) { $function .= '('; }

			}

		}

		return $function;

	}









	/**

	 * Wrap string values in quotes

	 *

	 * @param mixed $value

	 * @return mixed

	 */

	public static function _wrapResult($value) {

		if (is_string($value)) {

			//	Error values cannot be "wrapped"

			if (preg_match('/^'.self::CALCULATION_REGEXP_ERROR.'$/i', $value, $match)) {

				//	Return Excel errors "as is"

				return $value;

			}

			//	Return strings wrapped in quotes

			return '"'.$value.'"';

		//	Convert numeric errors to NaN error

		} else if((is_float($value)) && ((is_nan($value)) || (is_infinite($value)))) {

			return PHPExcel_Calculation_Functions::NaN();

		}



		return $value;

	}	//	function _wrapResult()





	/**

	 * Remove quotes used as a wrapper to identify string values

	 *

	 * @param mixed $value

	 * @return mixed

	 */

	public static function _unwrapResult($value) {

		if (is_string($value)) {

			if ((isset($value{0})) && ($value{0} == '"') && (substr($value,-1) == '"')) {

				return substr($value,1,-1);

			}

		//	Convert numeric errors to NaN error

		} else if((is_float($value)) && ((is_nan($value)) || (is_infinite($value)))) {

			return PHPExcel_Calculation_Functions::NaN();

		}

		return $value;

	}	//	function _unwrapResult()









	/**

	 * Calculate cell value (using formula from a cell ID)

	 * Retained for backward compatibility

	 *

	 * @access	public

	 * @param	PHPExcel_Cell	$pCell	Cell to calculate

	 * @return	mixed

	 * @throws	PHPExcel_Calculation_Exception

	 */

	public function calculate(PHPExcel_Cell $pCell = NULL) {

		try {

			return $this->calculateCellValue($pCell);

		} catch (PHPExcel_Exception $e) {

			throw new PHPExcel_Calculation_Exception($e->getMessage());

		}

	}	//	function calculate()





	/**

	 * Calculate the value of a cell formula

	 *

	 * @access	public

	 * @param	PHPExcel_Cell	$pCell		Cell to calculate

	 * @param	Boolean			$resetLog	Flag indicating whether the debug log should be reset or not

	 * @return	mixed

	 * @throws	PHPExcel_Calculation_Exception

	 */

	public function calculateCellValue(PHPExcel_Cell $pCell = NULL, $resetLog = TRUE) {

		if ($pCell === NULL) {

			return NULL;

		}



		$returnArrayAsType = self::$returnArrayAsType;

		if ($resetLog) {

			//	Initialise the logging settings if requested

			$this->formulaError = null;

			$this->_debugLog->clearLog();

			$this->_cyclicReferenceStack->clear();

			$this->_cyclicFormulaCount = 1;



			self::$returnArrayAsType = self::RETURN_ARRAY_AS_ARRAY;

		}



		//	Execute the calculation for the cell formula

		try {

			$result = self::_unwrapResult($this->_calculateFormulaValue($pCell->getValue(), $pCell->getCoordinate(), $pCell));

		} catch (PHPExcel_Exception $e) {

			throw new PHPExcel_Calculation_Exception($e->getMessage());

		}



		if ((is_array($result)) && (self::$returnArrayAsType != self::RETURN_ARRAY_AS_ARRAY)) {

			self::$returnArrayAsType = $returnArrayAsType;

			$testResult = PHPExcel_Calculation_Functions::flattenArray($result);

			if (self::$returnArrayAsType == self::RETURN_ARRAY_AS_ERROR) {

				return PHPExcel_Calculation_Functions::VALUE();

			}

			//	If there's only a single cell in the array, then we allow it

			if (count($testResult) != 1) {

				//	If keys are numeric, then it's a matrix result rather than a cell range result, so we permit it

				$r = array_keys($result);

				$r = array_shift($r);

				if (!is_numeric($r)) { return PHPExcel_Calculation_Functions::VALUE(); }

				if (is_array($result[$r])) {

					$c = array_keys($result[$r]);

					$c = array_shift($c);

					if (!is_numeric($c)) {

						return PHPExcel_Calculation_Functions::VALUE();

					}

				}

			}

			$result = array_shift($testResult);

		}

		self::$returnArrayAsType = $returnArrayAsType;





		if ($result === NULL) {

			return 0;

		} elseif((is_float($result)) && ((is_nan($result)) || (is_infinite($result)))) {

			return PHPExcel_Calculation_Functions::NaN();

		}

		return $result;

	}	//	function calculateCellValue(





	/**

	 * Validate and parse a formula string

	 *

	 * @param	string		$formula		Formula to parse

	 * @return	array

	 * @throws	PHPExcel_Calculation_Exception

	 */

	public function parseFormula($formula) {

		//	Basic validation that this is indeed a formula

		//	We return an empty array if not

		$formula = trim($formula);

		if ((!isset($formula{0})) || ($formula{0} != '=')) return array();

		$formula = ltrim(substr($formula,1));

		if (!isset($formula{0})) return array();



		//	Parse the formula and return the token stack

		return $this->_parseFormula($formula);

	}	//	function parseFormula()





	/**

	 * Calculate the value of a formula

	 *

	 * @param	string			$formula	Formula to parse

	 * @param	string			$cellID		Address of the cell to calculate

	 * @param	PHPExcel_Cell	$pCell		Cell to calculate

	 * @return	mixed

	 * @throws	PHPExcel_Calculation_Exception

	 */

	public function calculateFormula($formula, $cellID=NULL, PHPExcel_Cell $pCell = NULL) {

		//	Initialise the logging settings

		$this->formulaError = null;

		$this->_debugLog->clearLog();

		$this->_cyclicReferenceStack->clear();



		//	Disable calculation cacheing because it only applies to cell calculations, not straight formulae

		//	But don't actually flush any cache

		$resetCache = $this->getCalculationCacheEnabled();

		$this->_calculationCacheEnabled = FALSE;

		//	Execute the calculation

		try {

			$result = self::_unwrapResult($this->_calculateFormulaValue($formula, $cellID, $pCell));

		} catch (PHPExcel_Exception $e) {

			throw new PHPExcel_Calculation_Exception($e->getMessage());

		}



		//	Reset calculation cacheing to its previous state

		$this->_calculationCacheEnabled = $resetCache;



		return $result;

	}	//	function calculateFormula()





    public function getValueFromCache($worksheetName, $cellID, &$cellValue) {

		// Is calculation cacheing enabled?

		// Is the value present in calculation cache?

//echo 'Test cache for ',$worksheetName,'!',$cellID,PHP_EOL;

		$this->_debugLog->writeDebugLog('Testing cache value for cell ', $worksheetName, '!', $cellID);

		if (($this->_calculationCacheEnabled) && (isset($this->_calculationCache[$worksheetName][$cellID]))) {

//echo 'Retrieve from cache',PHP_EOL;

			$this->_debugLog->writeDebugLog('Retrieving value for cell ', $worksheetName, '!', $cellID, ' from cache');

			// Return the cached result

			$cellValue = $this->_calculationCache[$worksheetName][$cellID];

			return TRUE;

		}

		return FALSE;

    }



    public function saveValueToCache($worksheetName, $cellID, $cellValue) {

		if ($this->_calculationCacheEnabled) {

			$this->_calculationCache[$worksheetName][$cellID] = $cellValue;

		}

	}



	/**

	 * Parse a cell formula and calculate its value

	 *

	 * @param	string			$formula	The formula to parse and calculate

	 * @param	string			$cellID		The ID (e.g. A3) of the cell that we are calculating

	 * @param	PHPExcel_Cell	$pCell		Cell to calculate

	 * @return	mixed

	 * @throws	PHPExcel_Calculation_Exception

	 */

	public function _calculateFormulaValue($formula, $cellID=null, PHPExcel_Cell $pCell = null) {

		$cellValue = '';



		//	Basic validation that this is indeed a formula

		//	We simply return the cell value if not

		$formula = trim($formula);

		if ($formula{0} != '=') return self::_wrapResult($formula);

		$formula = ltrim(substr($formula,1));

		if (!isset($formula{0})) return self::_wrapResult($formula);



		$pCellParent = ($pCell !== NULL) ? $pCell->getWorksheet() : NULL;

		$wsTitle = ($pCellParent !== NULL) ? $pCellParent->getTitle() : "\x00Wrk";



		if (($cellID !== NULL) && ($this->getValueFromCache($wsTitle, $cellID, $cellValue))) {

			return $cellValue;

		}



		if (($wsTitle{0} !== "\x00") && ($this->_cyclicReferenceStack->onStack($wsTitle.'!'.$cellID))) {

			if ($this->cyclicFormulaCount <= 0) {

				return $this->_raiseFormulaError('Cyclic Reference in Formula');

			} elseif (($this->_cyclicFormulaCount >= $this->cyclicFormulaCount) &&

					  ($this->_cyclicFormulaCell == $wsTitle.'!'.$cellID)) {

				return $cellValue;

			} elseif ($this->_cyclicFormulaCell == $wsTitle.'!'.$cellID) {

				++$this->_cyclicFormulaCount;

				if ($this->_cyclicFormulaCount >= $this->cyclicFormulaCount) {

					return $cellValue;

				}

			} elseif ($this->_cyclicFormulaCell == '') {

				$this->_cyclicFormulaCell = $wsTitle.'!'.$cellID;

				if ($this->_cyclicFormulaCount >= $this->cyclicFormulaCount) {

					return $cellValue;

				}

			}

		}



		//	Parse the formula onto the token stack and calculate the value

		$this->_cyclicReferenceStack->push($wsTitle.'!'.$cellID);

		$cellValue = $this->_processTokenStack($this->_parseFormula($formula, $pCell), $cellID, $pCell);

		$this->_cyclicReferenceStack->pop();



		// Save to calculation cache

		if ($cellID !== NULL) {

			$this->saveValueToCache($wsTitle, $cellID, $cellValue);

		}



		//	Return the calculated value

		return $cellValue;

	}	//	function _calculateFormulaValue()





	/**

	 * Ensure that paired matrix operands are both matrices and of the same size

	 *

	 * @param	mixed		&$operand1	First matrix operand

	 * @param	mixed		&$operand2	Second matrix operand

	 * @param	integer		$resize		Flag indicating whether the matrices should be resized to match

	 *										and (if so), whether the smaller dimension should grow or the

	 *										larger should shrink.

	 *											0 = no resize

	 *											1 = shrink to fit

	 *											2 = extend to fit

	 */

	private static function _checkMatrixOperands(&$operand1,&$operand2,$resize = 1) {

		//	Examine each of the two operands, and turn them into an array if they aren't one already

		//	Note that this function should only be called if one or both of the operand is already an array

		if (!is_array($operand1)) {

			list($matrixRows,$matrixColumns) = self::_getMatrixDimensions($operand2);

			$operand1 = array_fill(0,$matrixRows,array_fill(0,$matrixColumns,$operand1));

			$resize = 0;

		} elseif (!is_array($operand2)) {

			list($matrixRows,$matrixColumns) = self::_getMatrixDimensions($operand1);

			$operand2 = array_fill(0,$matrixRows,array_fill(0,$matrixColumns,$operand2));

			$resize = 0;

		}



		list($matrix1Rows,$matrix1Columns) = self::_getMatrixDimensions($operand1);

		list($matrix2Rows,$matrix2Columns) = self::_getMatrixDimensions($operand2);

		if (($matrix1Rows == $matrix2Columns) && ($matrix2Rows == $matrix1Columns)) {

			$resize = 1;

		}



		if ($resize == 2) {

			//	Given two matrices of (potentially) unequal size, convert the smaller in each dimension to match the larger

			self::_resizeMatricesExtend($operand1,$operand2,$matrix1Rows,$matrix1Columns,$matrix2Rows,$matrix2Columns);

		} elseif ($resize == 1) {

			//	Given two matrices of (potentially) unequal size, convert the larger in each dimension to match the smaller

			self::_resizeMatricesShrink($operand1,$operand2,$matrix1Rows,$matrix1Columns,$matrix2Rows,$matrix2Columns);

		}

		return array( $matrix1Rows,$matrix1Columns,$matrix2Rows,$matrix2Columns);

	}	//	function _checkMatrixOperands()





	/**

	 * Read the dimensions of a matrix, and re-index it with straight numeric keys starting from row 0, column 0

	 *

	 * @param	mixed		&$matrix		matrix operand

	 * @return	array		An array comprising the number of rows, and number of columns

	 */

	public static function _getMatrixDimensions(&$matrix) {

		$matrixRows = count($matrix);

		$matrixColumns = 0;

		foreach($matrix as $rowKey => $rowValue) {

			$matrixColumns = max(count($rowValue),$matrixColumns);

			if (!is_array($rowValue)) {

				$matrix[$rowKey] = array($rowValue);

			} else {

				$matrix[$rowKey] = array_values($rowValue);

			}

		}

		$matrix = array_values($matrix);

		return array($matrixRows,$matrixColumns);

	}	//	function _getMatrixDimensions()





	/**

	 * Ensure that paired matrix operands are both matrices of the same size

	 *

	 * @param	mixed		&$matrix1		First matrix operand

	 * @param	mixed		&$matrix2		Second matrix operand

	 * @param	integer		$matrix1Rows	Row size of first matrix operand

	 * @param	integer		$matrix1Columns	Column size of first matrix operand

	 * @param	integer		$matrix2Rows	Row size of second matrix operand

	 * @param	integer		$matrix2Columns	Column size of second matrix operand

	 */

	private static function _resizeMatricesShrink(&$matrix1,&$matrix2,$matrix1Rows,$matrix1Columns,$matrix2Rows,$matrix2Columns) {

		if (($matrix2Columns < $matrix1Columns) || ($matrix2Rows < $matrix1Rows)) {

			if ($matrix2Rows < $matrix1Rows) {

				for ($i = $matrix2Rows; $i < $matrix1Rows; ++$i) {

					unset($matrix1[$i]);

				}

			}

			if ($matrix2Columns < $matrix1Columns) {

				for ($i = 0; $i < $matrix1Rows; ++$i) {

					for ($j = $matrix2Columns; $j < $matrix1Columns; ++$j) {

						unset($matrix1[$i][$j]);

					}

				}

			}

		}



		if (($matrix1Columns < $matrix2Columns) || ($matrix1Rows < $matrix2Rows)) {

			if ($matrix1Rows < $matrix2Rows) {

				for ($i = $matrix1Rows; $i < $matrix2Rows; ++$i) {

					unset($matrix2[$i]);

				}

			}

			if ($matrix1Columns < $matrix2Columns) {

				for ($i = 0; $i < $matrix2Rows; ++$i) {

					for ($j = $matrix1Columns; $j < $matrix2Columns; ++$j) {

						unset($matrix2[$i][$j]);

					}

				}

			}

		}

	}	//	function _resizeMatricesShrink()





	/**

	 * Ensure that paired matrix operands are both matrices of the same size

	 *

	 * @param	mixed		&$matrix1	First matrix operand

	 * @param	mixed		&$matrix2	Second matrix operand

	 * @param	integer		$matrix1Rows	Row size of first matrix operand

	 * @param	integer		$matrix1Columns	Column size of first matrix operand

	 * @param	integer		$matrix2Rows	Row size of second matrix operand

	 * @param	integer		$matrix2Columns	Column size of second matrix operand

	 */

	private static function _resizeMatricesExtend(&$matrix1,&$matrix2,$matrix1Rows,$matrix1Columns,$matrix2Rows,$matrix2Columns) {

		if (($matrix2Columns < $matrix1Columns) || ($matrix2Rows < $matrix1Rows)) {

			if ($matrix2Columns < $matrix1Columns) {

				for ($i = 0; $i < $matrix2Rows; ++$i) {

					$x = $matrix2[$i][$matrix2Columns-1];

					for ($j = $matrix2Columns; $j < $matrix1Columns; ++$j) {

						$matrix2[$i][$j] = $x;

					}

				}

			}

			if ($matrix2Rows < $matrix1Rows) {

				$x = $matrix2[$matrix2Rows-1];

				for ($i = 0; $i < $matrix1Rows; ++$i) {

					$matrix2[$i] = $x;

				}

			}

		}



		if (($matrix1Columns < $matrix2Columns) || ($matrix1Rows < $matrix2Rows)) {

			if ($matrix1Columns < $matrix2Columns) {

				for ($i = 0; $i < $matrix1Rows; ++$i) {

					$x = $matrix1[$i][$matrix1Columns-1];

					for ($j = $matrix1Columns; $j < $matrix2Columns; ++$j) {

						$matrix1[$i][$j] = $x;

					}

				}

			}

			if ($matrix1Rows < $matrix2Rows) {

				$x = $matrix1[$matrix1Rows-1];

				for ($i = 0; $i < $matrix2Rows; ++$i) {

					$matrix1[$i] = $x;

				}

			}

		}

	}	//	function _resizeMatricesExtend()





	/**

	 * Format details of an operand for display in the log (based on operand type)

	 *

	 * @param	mixed		$value	First matrix operand

	 * @return	mixed

	 */

	private function _showValue($value) {

		if ($this->_debugLog->getWriteDebugLog()) {

			$testArray = PHPExcel_Calculation_Functions::flattenArray($value);

			if (count($testArray) == 1) {

				$value = array_pop($testArray);

			}



			if (is_array($value)) {

				$returnMatrix = array();

				$pad = $rpad = ', ';

				foreach($value as $row) {

					if (is_array($row)) {

						$returnMatrix[] = implode($pad,array_map(array($this,'_showValue'),$row));

						$rpad = '; ';

					} else {

						$returnMatrix[] = $this->_showValue($row);

					}

				}

				return '{ '.implode($rpad,$returnMatrix).' }';

			} elseif(is_string($value) && (trim($value,'"') == $value)) {

				return '"'.$value.'"';

			} elseif(is_bool($value)) {

				return ($value) ? self::$_localeBoolean['TRUE'] : self::$_localeBoolean['FALSE'];

			}

		}

		return PHPExcel_Calculation_Functions::flattenSingleValue($value);

	}	//	function _showValue()





	/**

	 * Format type and details of an operand for display in the log (based on operand type)

	 *

	 * @param	mixed		$value	First matrix operand

	 * @return	mixed

	 */

	private function _showTypeDetails($value) {

		if ($this->_debugLog->getWriteDebugLog()) {

			$testArray = PHPExcel_Calculation_Functions::flattenArray($value);

			if (count($testArray) == 1) {

				$value = array_pop($testArray);

			}



			if ($value === NULL) {

				return 'a NULL value';

			} elseif (is_float($value)) {

				$typeString = 'a floating point number';

			} elseif(is_int($value)) {

				$typeString = 'an integer number';

			} elseif(is_bool($value)) {

				$typeString = 'a boolean';

			} elseif(is_array($value)) {

				$typeString = 'a matrix';

			} else {

				if ($value == '') {

					return 'an empty string';

				} elseif ($value{0} == '#') {

					return 'a '.$value.' error';

				} else {

					$typeString = 'a string';

				}

			}

			return $typeString.' with a value of '.$this->_showValue($value);

		}

	}	//	function _showTypeDetails()





	private static function _convertMatrixReferences($formula) {

		static $matrixReplaceFrom = array('{',';','}');

		static $matrixReplaceTo = array('MKMATRIX(MKMATRIX(','),MKMATRIX(','))');



		//	Convert any Excel matrix references to the MKMATRIX() function

		if (strpos($formula,'{') !== FALSE) {

			//	If there is the possibility of braces within a quoted string, then we don't treat those as matrix indicators

			if (strpos($formula,'"') !== FALSE) {

				//	So instead we skip replacing in any quoted strings by only replacing in every other array element after we've exploded

				//		the formula

				$temp = explode('"',$formula);

				//	Open and Closed counts used for trapping mismatched braces in the formula

				$openCount = $closeCount = 0;

				$i = FALSE;

				foreach($temp as &$value) {

					//	Only count/replace in alternating array entries

					if ($i = !$i) {

						$openCount += substr_count($value,'{');

						$closeCount += substr_count($value,'}');

						$value = str_replace($matrixReplaceFrom,$matrixReplaceTo,$value);

					}

				}

				unset($value);

				//	Then rebuild the formula string

				$formula = implode('"',$temp);

			} else {

				//	If there's no quoted strings, then we do a simple count/replace

				$openCount = substr_count($formula,'{');

				$closeCount = substr_count($formula,'}');

				$formula = str_replace($matrixReplaceFrom,$matrixReplaceTo,$formula);

			}

			//	Trap for mismatched braces and trigger an appropriate error

			if ($openCount < $closeCount) {

				if ($openCount > 0) {

					return $this->_raiseFormulaError("Formula Error: Mismatched matrix braces '}'");

				} else {

					return $this->_raiseFormulaError("Formula Error: Unexpected '}' encountered");

				}

			} elseif ($openCount > $closeCount) {

				if ($closeCount > 0) {

					return $this->_raiseFormulaError("Formula Error: Mismatched matrix braces '{'");

				} else {

					return $this->_raiseFormulaError("Formula Error: Unexpected '{' encountered");

				}

			}

		}



		return $formula;

	}	//	function _convertMatrixReferences()





	private static function _mkMatrix() {

		return func_get_args();

	}	//	function _mkMatrix()





	//	Binary Operators

	//	These operators always work on two values

	//	Array key is the operator, the value indicates whether this is a left or right associative operator

	private static $_operatorAssociativity	= array(

		'^' => 0,															//	Exponentiation

		'*' => 0, '/' => 0, 												//	Multiplication and Division

		'+' => 0, '-' => 0,													//	Addition and Subtraction

		'&' => 0,															//	Concatenation

		'|' => 0, ':' => 0,													//	Intersect and Range

		'>' => 0, '<' => 0, '=' => 0, '>=' => 0, '<=' => 0, '<>' => 0		//	Comparison

	);



	//	Comparison (Boolean) Operators

	//	These operators work on two values, but always return a boolean result

	private static $_comparisonOperators	= array('>' => TRUE, '<' => TRUE, '=' => TRUE, '>=' => TRUE, '<=' => TRUE, '<>' => TRUE);



	//	Operator Precedence

	//	This list includes all valid operators, whether binary (including boolean) or unary (such as %)

	//	Array key is the operator, the value is its precedence

	private static $_operatorPrecedence	= array(

		':' => 8,																//	Range

		'|' => 7,																//	Intersect

		'~' => 6,																//	Negation

		'%' => 5,																//	Percentage

		'^' => 4,																//	Exponentiation

		'*' => 3, '/' => 3, 													//	Multiplication and Division

		'+' => 2, '-' => 2,														//	Addition and Subtraction

		'&' => 1,																//	Concatenation

		'>' => 0, '<' => 0, '=' => 0, '>=' => 0, '<=' => 0, '<>' => 0			//	Comparison

	);



	// Convert infix to postfix notation

	private function _parseFormula($formula, PHPExcel_Cell $pCell = NULL) {

		if (($formula = self::_convertMatrixReferences(trim($formula))) === FALSE) {

			return FALSE;

		}



		//	If we're using cell caching, then $pCell may well be flushed back to the cache (which detaches the parent worksheet),

		//		so we store the parent worksheet so that we can re-attach it when necessary

		$pCellParent = ($pCell !== NULL) ? $pCell->getWorksheet() : NULL;



		$regexpMatchString = '/^('.self::CALCULATION_REGEXP_FUNCTION.

							   '|'.self::CALCULATION_REGEXP_CELLREF.

							   '|'.self::CALCULATION_REGEXP_NUMBER.

							   '|'.self::CALCULATION_REGEXP_STRING.

							   '|'.self::CALCULATION_REGEXP_OPENBRACE.

							   '|'.self::CALCULATION_REGEXP_NAMEDRANGE.

							   '|'.self::CALCULATION_REGEXP_ERROR.

							 ')/si';



		//	Start with initialisation

		$index = 0;

		$stack = new PHPExcel_Calculation_Token_Stack;

		$output = array();

		$expectingOperator = FALSE;					//	We use this test in syntax-checking the expression to determine when a

													//		- is a negation or + is a positive operator rather than an operation

		$expectingOperand = FALSE;					//	We use this test in syntax-checking the expression to determine whether an operand

													//		should be null in a function call

		//	The guts of the lexical parser

		//	Loop through the formula extracting each operator and operand in turn

		while(TRUE) {

//echo 'Assessing Expression '.substr($formula, $index),PHP_EOL;

			$opCharacter = $formula{$index};	//	Get the first character of the value at the current index position

//echo 'Initial character of expression block is '.$opCharacter,PHP_EOL;

			if ((isset(self::$_comparisonOperators[$opCharacter])) && (strlen($formula) > $index) && (isset(self::$_comparisonOperators[$formula{$index+1}]))) {

				$opCharacter .= $formula{++$index};

//echo 'Initial character of expression block is comparison operator '.$opCharacter.PHP_EOL;

			}



			//	Find out if we're currently at the beginning of a number, variable, cell reference, function, parenthesis or operand

			$isOperandOrFunction = preg_match($regexpMatchString, substr($formula, $index), $match);

//echo '$isOperandOrFunction is '.(($isOperandOrFunction) ? 'True' : 'False').PHP_EOL;

//var_dump($match);



			if ($opCharacter == '-' && !$expectingOperator) {				//	Is it a negation instead of a minus?

//echo 'Element is a Negation operator',PHP_EOL;

				$stack->push('Unary Operator','~');							//	Put a negation on the stack

				++$index;													//		and drop the negation symbol

			} elseif ($opCharacter == '%' && $expectingOperator) {

//echo 'Element is a Percentage operator',PHP_EOL;

				$stack->push('Unary Operator','%');							//	Put a percentage on the stack

				++$index;

			} elseif ($opCharacter == '+' && !$expectingOperator) {			//	Positive (unary plus rather than binary operator plus) can be discarded?

//echo 'Element is a Positive number, not Plus operator',PHP_EOL;

				++$index;													//	Drop the redundant plus symbol

			} elseif ((($opCharacter == '~') || ($opCharacter == '|')) && (!$isOperandOrFunction)) {	//	We have to explicitly deny a tilde or pipe, because they are legal

				return $this->_raiseFormulaError("Formula Error: Illegal character '~'");				//		on the stack but not in the input expression



			} elseif ((isset(self::$_operators[$opCharacter]) or $isOperandOrFunction) && $expectingOperator) {	//	Are we putting an operator on the stack?

//echo 'Element with value '.$opCharacter.' is an Operator',PHP_EOL;

				while($stack->count() > 0 &&

					($o2 = $stack->last()) &&

					isset(self::$_operators[$o2['value']]) &&

					@(self::$_operatorAssociativity[$opCharacter] ? self::$_operatorPrecedence[$opCharacter] < self::$_operatorPrecedence[$o2['value']] : self::$_operatorPrecedence[$opCharacter] <= self::$_operatorPrecedence[$o2['value']])) {

					$output[] = $stack->pop();								//	Swap operands and higher precedence operators from the stack to the output

				}

				$stack->push('Binary Operator',$opCharacter);	//	Finally put our current operator onto the stack

				++$index;

				$expectingOperator = FALSE;



			} elseif ($opCharacter == ')' && $expectingOperator) {			//	Are we expecting to close a parenthesis?

//echo 'Element is a Closing bracket',PHP_EOL;

				$expectingOperand = FALSE;

				while (($o2 = $stack->pop()) && $o2['value'] != '(') {		//	Pop off the stack back to the last (

					if ($o2 === NULL) return $this->_raiseFormulaError('Formula Error: Unexpected closing brace ")"');

					else $output[] = $o2;

				}

				$d = $stack->last(2);

				if (preg_match('/^'.self::CALCULATION_REGEXP_FUNCTION.'$/i', $d['value'], $matches)) {	//	Did this parenthesis just close a function?

					$functionName = $matches[1];										//	Get the function name

//echo 'Closed Function is '.$functionName,PHP_EOL;

					$d = $stack->pop();

					$argumentCount = $d['value'];		//	See how many arguments there were (argument count is the next value stored on the stack)

//if ($argumentCount == 0) {

//	echo 'With no arguments',PHP_EOL;

//} elseif ($argumentCount == 1) {

//	echo 'With 1 argument',PHP_EOL;

//} else {

//	echo 'With '.$argumentCount.' arguments',PHP_EOL;

//}

					$output[] = $d;						//	Dump the argument count on the output

					$output[] = $stack->pop();			//	Pop the function and push onto the output

					if (isset(self::$_controlFunctions[$functionName])) {

//echo 'Built-in function '.$functionName,PHP_EOL;

						$expectedArgumentCount = self::$_controlFunctions[$functionName]['argumentCount'];

						$functionCall = self::$_controlFunctions[$functionName]['functionCall'];

					} elseif (isset(self::$_PHPExcelFunctions[$functionName])) {

//echo 'PHPExcel function '.$functionName,PHP_EOL;

						$expectedArgumentCount = self::$_PHPExcelFunctions[$functionName]['argumentCount'];

						$functionCall = self::$_PHPExcelFunctions[$functionName]['functionCall'];

					} else {	// did we somehow push a non-function on the stack? this should never happen

						return $this->_raiseFormulaError("Formula Error: Internal error, non-function on stack");

					}

					//	Check the argument count

					$argumentCountError = FALSE;

					if (is_numeric($expectedArgumentCount)) {

						if ($expectedArgumentCount < 0) {

//echo '$expectedArgumentCount is between 0 and '.abs($expectedArgumentCount),PHP_EOL;

							if ($argumentCount > abs($expectedArgumentCount)) {

								$argumentCountError = TRUE;

								$expectedArgumentCountString = 'no more than '.abs($expectedArgumentCount);

							}

						} else {

//echo '$expectedArgumentCount is numeric '.$expectedArgumentCount,PHP_EOL;

							if ($argumentCount != $expectedArgumentCount) {

								$argumentCountError = TRUE;

								$expectedArgumentCountString = $expectedArgumentCount;

							}

						}

					} elseif ($expectedArgumentCount != '*') {

						$isOperandOrFunction = preg_match('/(\d*)([-+,])(\d*)/',$expectedArgumentCount,$argMatch);

//print_r($argMatch);

//echo PHP_EOL;

						switch ($argMatch[2]) {

							case '+' :

								if ($argumentCount < $argMatch[1]) {

									$argumentCountError = TRUE;

									$expectedArgumentCountString = $argMatch[1].' or more ';

								}

								break;

							case '-' :

								if (($argumentCount < $argMatch[1]) || ($argumentCount > $argMatch[3])) {

									$argumentCountError = TRUE;

									$expectedArgumentCountString = 'between '.$argMatch[1].' and '.$argMatch[3];

								}

								break;

							case ',' :

								if (($argumentCount != $argMatch[1]) && ($argumentCount != $argMatch[3])) {

									$argumentCountError = TRUE;

									$expectedArgumentCountString = 'either '.$argMatch[1].' or '.$argMatch[3];

								}

								break;

						}

					}

					if ($argumentCountError) {

						return $this->_raiseFormulaError("Formula Error: Wrong number of arguments for $functionName() function: $argumentCount given, ".$expectedArgumentCountString." expected");

					}

				}

				++$index;



			} elseif ($opCharacter == ',') {			//	Is this the separator for function arguments?

//echo 'Element is a Function argument separator',PHP_EOL;

				while (($o2 = $stack->pop()) && $o2['value'] != '(') {		//	Pop off the stack back to the last (

					if ($o2 === NULL) return $this->_raiseFormulaError("Formula Error: Unexpected ,");

					else $output[] = $o2;	// pop the argument expression stuff and push onto the output

				}

				//	If we've a comma when we're expecting an operand, then what we actually have is a null operand;

				//		so push a null onto the stack

				if (($expectingOperand) || (!$expectingOperator)) {

					$output[] = array('type' => 'NULL Value', 'value' => self::$_ExcelConstants['NULL'], 'reference' => NULL);

				}

				// make sure there was a function

				$d = $stack->last(2);

				if (!preg_match('/^'.self::CALCULATION_REGEXP_FUNCTION.'$/i', $d['value'], $matches))

					return $this->_raiseFormulaError("Formula Error: Unexpected ,");

				$d = $stack->pop();

				$stack->push($d['type'],++$d['value'],$d['reference']);	// increment the argument count

				$stack->push('Brace', '(');	// put the ( back on, we'll need to pop back to it again

				$expectingOperator = FALSE;

				$expectingOperand = TRUE;

				++$index;



			} elseif ($opCharacter == '(' && !$expectingOperator) {

//				echo 'Element is an Opening Bracket<br />';

				$stack->push('Brace', '(');

				++$index;



			} elseif ($isOperandOrFunction && !$expectingOperator) {	// do we now have a function/variable/number?

				$expectingOperator = TRUE;

				$expectingOperand = FALSE;

				$val = $match[1];

				$length = strlen($val);

//				echo 'Element with value '.$val.' is an Operand, Variable, Constant, String, Number, Cell Reference or Function<br />';



				if (preg_match('/^'.self::CALCULATION_REGEXP_FUNCTION.'$/i', $val, $matches)) {

					$val = preg_replace('/\s/','',$val);

//					echo 'Element '.$val.' is a Function<br />';

					if (isset(self::$_PHPExcelFunctions[strtoupper($matches[1])]) || isset(self::$_controlFunctions[strtoupper($matches[1])])) {	// it's a function

						$stack->push('Function', strtoupper($val));

						$ax = preg_match('/^\s*(\s*\))/i', substr($formula, $index+$length), $amatch);

						if ($ax) {

							$stack->push('Operand Count for Function '.strtoupper($val).')', 0);

							$expectingOperator = TRUE;

						} else {

							$stack->push('Operand Count for Function '.strtoupper($val).')', 1);

							$expectingOperator = FALSE;

						}

						$stack->push('Brace', '(');

					} else {	// it's a var w/ implicit multiplication

						$output[] = array('type' => 'Value', 'value' => $matches[1], 'reference' => NULL);

					}

				} elseif (preg_match('/^'.self::CALCULATION_REGEXP_CELLREF.'$/i', $val, $matches)) {

//					echo 'Element '.$val.' is a Cell reference<br />';

					//	Watch for this case-change when modifying to allow cell references in different worksheets...

					//	Should only be applied to the actual cell column, not the worksheet name



					//	If the last entry on the stack was a : operator, then we have a cell range reference

					$testPrevOp = $stack->last(1);

					if ($testPrevOp['value'] == ':') {

						//	If we have a worksheet reference, then we're playing with a 3D reference

						if ($matches[2] == '') {

							//	Otherwise, we 'inherit' the worksheet reference from the start cell reference

							//	The start of the cell range reference should be the last entry in $output

							$startCellRef = $output[count($output)-1]['value'];

							preg_match('/^'.self::CALCULATION_REGEXP_CELLREF.'$/i', $startCellRef, $startMatches);

							if ($startMatches[2] > '') {

								$val = $startMatches[2].'!'.$val;

							}

						} else {

							return $this->_raiseFormulaError("3D Range references are not yet supported");

						}

					}



					$output[] = array('type' => 'Cell Reference', 'value' => $val, 'reference' => $val);

//					$expectingOperator = FALSE;

				} else {	// it's a variable, constant, string, number or boolean

//					echo 'Element is a Variable, Constant, String, Number or Boolean<br />';

					//	If the last entry on the stack was a : operator, then we may have a row or column range reference

					$testPrevOp = $stack->last(1);

					if ($testPrevOp['value'] == ':') {

						$startRowColRef = $output[count($output)-1]['value'];

						$rangeWS1 = '';

						if (strpos('!',$startRowColRef) !== FALSE) {

							list($rangeWS1,$startRowColRef) = explode('!',$startRowColRef);

						}

						if ($rangeWS1 != '') $rangeWS1 .= '!';

						$rangeWS2 = $rangeWS1;

						if (strpos('!',$val) !== FALSE) {

							list($rangeWS2,$val) = explode('!',$val);

						}

						if ($rangeWS2 != '') $rangeWS2 .= '!';

						if ((is_integer($startRowColRef)) && (ctype_digit($val)) &&

							($startRowColRef <= 1048576) && ($val <= 1048576)) {

							//	Row range

							$endRowColRef = ($pCellParent !== NULL) ? $pCellParent->getHighestColumn() : 'XFD';	//	Max 16,384 columns for Excel2007

							$output[count($output)-1]['value'] = $rangeWS1.'A'.$startRowColRef;

							$val = $rangeWS2.$endRowColRef.$val;

						} elseif ((ctype_alpha($startRowColRef)) && (ctype_alpha($val)) &&

							(strlen($startRowColRef) <= 3) && (strlen($val) <= 3)) {

							//	Column range

							$endRowColRef = ($pCellParent !== NULL) ? $pCellParent->getHighestRow() : 1048576;		//	Max 1,048,576 rows for Excel2007

							$output[count($output)-1]['value'] = $rangeWS1.strtoupper($startRowColRef).'1';

							$val = $rangeWS2.$val.$endRowColRef;

						}

					}



					$localeConstant = FALSE;

					if ($opCharacter == '"') {

//						echo 'Element is a String<br />';

						//	UnEscape any quotes within the string

						$val = self::_wrapResult(str_replace('""','"',self::_unwrapResult($val)));

					} elseif (is_numeric($val)) {

//						echo 'Element is a Number<br />';

						if ((strpos($val,'.') !== FALSE) || (stripos($val,'e') !== FALSE) || ($val > PHP_INT_MAX) || ($val < -PHP_INT_MAX)) {

//							echo 'Casting '.$val.' to float<br />';

							$val = (float) $val;

						} else {

//							echo 'Casting '.$val.' to integer<br />';

							$val = (integer) $val;

						}

					} elseif (isset(self::$_ExcelConstants[trim(strtoupper($val))])) {

						$excelConstant = trim(strtoupper($val));

//						echo 'Element '.$excelConstant.' is an Excel Constant<br />';

						$val = self::$_ExcelConstants[$excelConstant];

					} elseif (($localeConstant = array_search(trim(strtoupper($val)), self::$_localeBoolean)) !== FALSE) {

//						echo 'Element '.$localeConstant.' is an Excel Constant<br />';

						$val = self::$_ExcelConstants[$localeConstant];

					}

					$details = array('type' => 'Value', 'value' => $val, 'reference' => NULL);

					if ($localeConstant) { $details['localeValue'] = $localeConstant; }

					$output[] = $details;

				}

				$index += $length;



			} elseif ($opCharacter == '$') {	// absolute row or column range

				++$index;

			} elseif ($opCharacter == ')') {	// miscellaneous error checking

				if ($expectingOperand) {

					$output[] = array('type' => 'NULL Value', 'value' => self::$_ExcelConstants['NULL'], 'reference' => NULL);

					$expectingOperand = FALSE;

					$expectingOperator = TRUE;

				} else {

					return $this->_raiseFormulaError("Formula Error: Unexpected ')'");

				}

			} elseif (isset(self::$_operators[$opCharacter]) && !$expectingOperator) {

				return $this->_raiseFormulaError("Formula Error: Unexpected operator '$opCharacter'");

			} else {	// I don't even want to know what you did to get here

				return $this->_raiseFormulaError("Formula Error: An unexpected error occured");

			}

			//	Test for end of formula string

			if ($index == strlen($formula)) {

				//	Did we end with an operator?.

				//	Only valid for the % unary operator

				if ((isset(self::$_operators[$opCharacter])) && ($opCharacter != '%')) {

					return $this->_raiseFormulaError("Formula Error: Operator '$opCharacter' has no operands");

				} else {

					break;

				}

			}

			//	Ignore white space

			while (($formula{$index} == "\n") || ($formula{$index} == "\r")) {

				++$index;

			}

			if ($formula{$index} == ' ') {

				while ($formula{$index} == ' ') {

					++$index;

				}

				//	If we're expecting an operator, but only have a space between the previous and next operands (and both are

				//		Cell References) then we have an INTERSECTION operator

//				echo 'Possible Intersect Operator<br />';

				if (($expectingOperator) && (preg_match('/^'.self::CALCULATION_REGEXP_CELLREF.'.*/Ui', substr($formula, $index), $match)) &&

					($output[count($output)-1]['type'] == 'Cell Reference')) {

//					echo 'Element is an Intersect Operator<br />';

					while($stack->count() > 0 &&

						($o2 = $stack->last()) &&

						isset(self::$_operators[$o2['value']]) &&

						@(self::$_operatorAssociativity[$opCharacter] ? self::$_operatorPrecedence[$opCharacter] < self::$_operatorPrecedence[$o2['value']] : self::$_operatorPrecedence[$opCharacter] <= self::$_operatorPrecedence[$o2['value']])) {

						$output[] = $stack->pop();								//	Swap operands and higher precedence operators from the stack to the output

					}

					$stack->push('Binary Operator','|');	//	Put an Intersect Operator on the stack

					$expectingOperator = FALSE;

				}

			}

		}



		while (($op = $stack->pop()) !== NULL) {	// pop everything off the stack and push onto output

			if ((is_array($op) && $op['value'] == '(') || ($op === '('))

				return $this->_raiseFormulaError("Formula Error: Expecting ')'");	// if there are any opening braces on the stack, then braces were unbalanced

			$output[] = $op;

		}

		return $output;

	}	//	function _parseFormula()





	private static function _dataTestReference(&$operandData)

	{

		$operand = $operandData['value'];

		if (($operandData['reference'] === NULL) && (is_array($operand))) {

			$rKeys = array_keys($operand);

			$rowKey = array_shift($rKeys);

			$cKeys = array_keys(array_keys($operand[$rowKey]));

			$colKey = array_shift($cKeys);

			if (ctype_upper($colKey)) {

				$operandData['reference'] = $colKey.$rowKey;

			}

		}

		return $operand;

	}



	// evaluate postfix notation

	private function _processTokenStack($tokens, $cellID = NULL, PHPExcel_Cell $pCell = NULL) {

		if ($tokens == FALSE) return FALSE;



		//	If we're using cell caching, then $pCell may well be flushed back to the cache (which detaches the parent cell collection),

		//		so we store the parent cell collection so that we can re-attach it when necessary

		$pCellWorksheet = ($pCell !== NULL) ? $pCell->getWorksheet() : NULL;

		$pCellParent = ($pCell !== NULL) ? $pCell->getParent() : null;

		$stack = new PHPExcel_Calculation_Token_Stack;



		//	Loop through each token in turn

		foreach ($tokens as $tokenData) {

//			print_r($tokenData);

//			echo '<br />';

			$token = $tokenData['value'];

//			echo '<b>Token is '.$token.'</b><br />';

			// if the token is a binary operator, pop the top two values off the stack, do the operation, and push the result back on the stack

			if (isset(self::$_binaryOperators[$token])) {

//				echo 'Token is a binary operator<br />';

				//	We must have two operands, error if we don't

				if (($operand2Data = $stack->pop()) === NULL) return $this->_raiseFormulaError('Internal error - Operand value missing from stack');

				if (($operand1Data = $stack->pop()) === NULL) return $this->_raiseFormulaError('Internal error - Operand value missing from stack');



				$operand1 = self::_dataTestReference($operand1Data);

				$operand2 = self::_dataTestReference($operand2Data);



				//	Log what we're doing

				if ($token == ':') {

					$this->_debugLog->writeDebugLog('Evaluating Range ', $this->_showValue($operand1Data['reference']), ' ', $token, ' ', $this->_showValue($operand2Data['reference']));

				} else {

					$this->_debugLog->writeDebugLog('Evaluating ', $this->_showValue($operand1), ' ', $token, ' ', $this->_showValue($operand2));

				}



				//	Process the operation in the appropriate manner

				switch ($token) {

					//	Comparison (Boolean) Operators

					case '>'	:			//	Greater than

					case '<'	:			//	Less than

					case '>='	:			//	Greater than or Equal to

					case '<='	:			//	Less than or Equal to

					case '='	:			//	Equality

					case '<>'	:			//	Inequality

						$this->_executeBinaryComparisonOperation($cellID,$operand1,$operand2,$token,$stack);

						break;

					//	Binary Operators

					case ':'	:			//	Range

						$sheet1 = $sheet2 = '';

						if (strpos($operand1Data['reference'],'!') !== FALSE) {

							list($sheet1,$operand1Data['reference']) = explode('!',$operand1Data['reference']);

						} else {

							$sheet1 = ($pCellParent !== NULL) ? $pCellWorksheet->getTitle() : '';

						}

						if (strpos($operand2Data['reference'],'!') !== FALSE) {

							list($sheet2,$operand2Data['reference']) = explode('!',$operand2Data['reference']);

						} else {

							$sheet2 = $sheet1;

						}

						if ($sheet1 == $sheet2) {

							if ($operand1Data['reference'] === NULL) {

								if ((trim($operand1Data['value']) != '') && (is_numeric($operand1Data['value']))) {

									$operand1Data['reference'] = $pCell->getColumn().$operand1Data['value'];

								} elseif (trim($operand1Data['reference']) == '') {

									$operand1Data['reference'] = $pCell->getCoordinate();

								} else {

									$operand1Data['reference'] = $operand1Data['value'].$pCell->getRow();

								}

							}

							if ($operand2Data['reference'] === NULL) {

								if ((trim($operand2Data['value']) != '') && (is_numeric($operand2Data['value']))) {

									$operand2Data['reference'] = $pCell->getColumn().$operand2Data['value'];

								} elseif (trim($operand2Data['reference']) == '') {

									$operand2Data['reference'] = $pCell->getCoordinate();

								} else {

									$operand2Data['reference'] = $operand2Data['value'].$pCell->getRow();

								}

							}



							$oData = array_merge(explode(':',$operand1Data['reference']),explode(':',$operand2Data['reference']));

							$oCol = $oRow = array();

							foreach($oData as $oDatum) {

								$oCR = PHPExcel_Cell::coordinateFromString($oDatum);

								$oCol[] = PHPExcel_Cell::columnIndexFromString($oCR[0]) - 1;

								$oRow[] = $oCR[1];

							}

							$cellRef = PHPExcel_Cell::stringFromColumnIndex(min($oCol)).min($oRow).':'.PHPExcel_Cell::stringFromColumnIndex(max($oCol)).max($oRow);

							if ($pCellParent !== NULL) {

								$cellValue = $this->extractCellRange($cellRef, $this->_workbook->getSheetByName($sheet1), FALSE);

							} else {

								return $this->_raiseFormulaError('Unable to access Cell Reference');

							}

							$stack->push('Cell Reference',$cellValue,$cellRef);

						} else {

							$stack->push('Error',PHPExcel_Calculation_Functions::REF(),NULL);

						}



						break;

					case '+'	:			//	Addition

						$this->_executeNumericBinaryOperation($cellID,$operand1,$operand2,$token,'plusEquals',$stack);

						break;

					case '-'	:			//	Subtraction

						$this->_executeNumericBinaryOperation($cellID,$operand1,$operand2,$token,'minusEquals',$stack);

						break;

					case '*'	:			//	Multiplication

						$this->_executeNumericBinaryOperation($cellID,$operand1,$operand2,$token,'arrayTimesEquals',$stack);

						break;

					case '/'	:			//	Division

						$this->_executeNumericBinaryOperation($cellID,$operand1,$operand2,$token,'arrayRightDivide',$stack);

						break;

					case '^'	:			//	Exponential

						$this->_executeNumericBinaryOperation($cellID,$operand1,$operand2,$token,'power',$stack);

						break;

					case '&'	:			//	Concatenation

						//	If either of the operands is a matrix, we need to treat them both as matrices

						//		(converting the other operand to a matrix if need be); then perform the required

						//		matrix operation

						if (is_bool($operand1)) {

							$operand1 = ($operand1) ? self::$_localeBoolean['TRUE'] : self::$_localeBoolean['FALSE'];

						}

						if (is_bool($operand2)) {

							$operand2 = ($operand2) ? self::$_localeBoolean['TRUE'] : self::$_localeBoolean['FALSE'];

						}

						if ((is_array($operand1)) || (is_array($operand2))) {

							//	Ensure that both operands are arrays/matrices

							self::_checkMatrixOperands($operand1,$operand2,2);

							try {

								//	Convert operand 1 from a PHP array to a matrix

								$matrix = new PHPExcel_Shared_JAMA_Matrix($operand1);

								//	Perform the required operation against the operand 1 matrix, passing in operand 2

								$matrixResult = $matrix->concat($operand2);

								$result = $matrixResult->getArray();

							} catch (PHPExcel_Exception $ex) {

								$this->_debugLog->writeDebugLog('JAMA Matrix Exception: ', $ex->getMessage());

								$result = '#VALUE!';

							}

						} else {

							$result = '"'.str_replace('""','"',self::_unwrapResult($operand1,'"').self::_unwrapResult($operand2,'"')).'"';

						}

						$this->_debugLog->writeDebugLog('Evaluation Result is ', $this->_showTypeDetails($result));

						$stack->push('Value',$result);

						break;

					case '|'	:			//	Intersect

						$rowIntersect = array_intersect_key($operand1,$operand2);

						$cellIntersect = $oCol = $oRow = array();

						foreach(array_keys($rowIntersect) as $row) {

							$oRow[] = $row;

							foreach($rowIntersect[$row] as $col => $data) {

								$oCol[] = PHPExcel_Cell::columnIndexFromString($col) - 1;

								$cellIntersect[$row] = array_intersect_key($operand1[$row],$operand2[$row]);

							}

						}

						$cellRef = PHPExcel_Cell::stringFromColumnIndex(min($oCol)).min($oRow).':'.PHPExcel_Cell::stringFromColumnIndex(max($oCol)).max($oRow);

						$this->_debugLog->writeDebugLog('Evaluation Result is ', $this->_showTypeDetails($cellIntersect));

						$stack->push('Value',$cellIntersect,$cellRef);

						break;

				}



			// if the token is a unary operator, pop one value off the stack, do the operation, and push it back on

			} elseif (($token === '~') || ($token === '%')) {

//				echo 'Token is a unary operator<br />';

				if (($arg = $stack->pop()) === NULL) return $this->_raiseFormulaError('Internal error - Operand value missing from stack');

				$arg = $arg['value'];

				if ($token === '~') {

//					echo 'Token is a negation operator<br />';

					$this->_debugLog->writeDebugLog('Evaluating Negation of ', $this->_showValue($arg));

					$multiplier = -1;

				} else {

//					echo 'Token is a percentile operator<br />';

					$this->_debugLog->writeDebugLog('Evaluating Percentile of ', $this->_showValue($arg));

					$multiplier = 0.01;

				}

				if (is_array($arg)) {

					self::_checkMatrixOperands($arg,$multiplier,2);

					try {

						$matrix1 = new PHPExcel_Shared_JAMA_Matrix($arg);

						$matrixResult = $matrix1->arrayTimesEquals($multiplier);

						$result = $matrixResult->getArray();

					} catch (PHPExcel_Exception $ex) {

						$this->_debugLog->writeDebugLog('JAMA Matrix Exception: ', $ex->getMessage());

						$result = '#VALUE!';

					}

					$this->_debugLog->writeDebugLog('Evaluation Result is ', $this->_showTypeDetails($result));

					$stack->push('Value',$result);

				} else {

					$this->_executeNumericBinaryOperation($cellID,$multiplier,$arg,'*','arrayTimesEquals',$stack);

				}



			} elseif (preg_match('/^'.self::CALCULATION_REGEXP_CELLREF.'$/i', $token, $matches)) {

				$cellRef = NULL;

//				echo 'Element '.$token.' is a Cell reference<br />';

				if (isset($matches[8])) {

//					echo 'Reference is a Range of cells<br />';

					if ($pCell === NULL) {

//						We can't access the range, so return a REF error

						$cellValue = PHPExcel_Calculation_Functions::REF();

					} else {

						$cellRef = $matches[6].$matches[7].':'.$matches[9].$matches[10];

						if ($matches[2] > '') {

							$matches[2] = trim($matches[2],"\"'");

							if ((strpos($matches[2],'[') !== FALSE) || (strpos($matches[2],']') !== FALSE)) {

								//	It's a Reference to an external workbook (not currently supported)

								return $this->_raiseFormulaError('Unable to access External Workbook');

							}

							$matches[2] = trim($matches[2],"\"'");

//							echo '$cellRef='.$cellRef.' in worksheet '.$matches[2].'<br />';

							$this->_debugLog->writeDebugLog('Evaluating Cell Range ', $cellRef, ' in worksheet ', $matches[2]);

							if ($pCellParent !== NULL) {

								$cellValue = $this->extractCellRange($cellRef, $this->_workbook->getSheetByName($matches[2]), FALSE);

							} else {

								return $this->_raiseFormulaError('Unable to access Cell Reference');

							}

							$this->_debugLog->writeDebugLog('Evaluation Result for cells ', $cellRef, ' in worksheet ', $matches[2], ' is ', $this->_showTypeDetails($cellValue));

//							$cellRef = $matches[2].'!'.$cellRef;

						} else {

//							echo '$cellRef='.$cellRef.' in current worksheet<br />';

							$this->_debugLog->writeDebugLog('Evaluating Cell Range ', $cellRef, ' in current worksheet');

							if ($pCellParent !== NULL) {

								$cellValue = $this->extractCellRange($cellRef, $pCellWorksheet, FALSE);

							} else {

								return $this->_raiseFormulaError('Unable to access Cell Reference');

							}

							$this->_debugLog->writeDebugLog('Evaluation Result for cells ', $cellRef, ' is ', $this->_showTypeDetails($cellValue));

						}

					}

				} else {

//					echo 'Reference is a single Cell<br />';

					if ($pCell === NULL) {

//						We can't access the cell, so return a REF error

						$cellValue = PHPExcel_Calculation_Functions::REF();

					} else {

						$cellRef = $matches[6].$matches[7];

						if ($matches[2] > '') {

							$matches[2] = trim($matches[2],"\"'");

							if ((strpos($matches[2],'[') !== FALSE) || (strpos($matches[2],']') !== FALSE)) {

								//	It's a Reference to an external workbook (not currently supported)

								return $this->_raiseFormulaError('Unable to access External Workbook');

							}

//							echo '$cellRef='.$cellRef.' in worksheet '.$matches[2].'<br />';

							$this->_debugLog->writeDebugLog('Evaluating Cell ', $cellRef, ' in worksheet ', $matches[2]);

							if ($pCellParent !== NULL) {

								$cellSheet = $this->_workbook->getSheetByName($matches[2]);

								if ($cellSheet && $cellSheet->cellExists($cellRef)) {

									$cellValue = $this->extractCellRange($cellRef, $this->_workbook->getSheetByName($matches[2]), FALSE);

									$pCell->attach($pCellParent);

								} else {

									$cellValue = NULL;

								}

							} else {

								return $this->_raiseFormulaError('Unable to access Cell Reference');

							}

							$this->_debugLog->writeDebugLog('Evaluation Result for cell ', $cellRef, ' in worksheet ', $matches[2], ' is ', $this->_showTypeDetails($cellValue));

//							$cellRef = $matches[2].'!'.$cellRef;

						} else {

//							echo '$cellRef='.$cellRef.' in current worksheet<br />';

							$this->_debugLog->writeDebugLog('Evaluating Cell ', $cellRef, ' in current worksheet');

							if ($pCellParent->isDataSet($cellRef)) {

								$cellValue = $this->extractCellRange($cellRef, $pCellWorksheet, FALSE);

								$pCell->attach($pCellParent);

							} else {

								$cellValue = NULL;

							}

							$this->_debugLog->writeDebugLog('Evaluation Result for cell ', $cellRef, ' is ', $this->_showTypeDetails($cellValue));

						}

					}

				}

				$stack->push('Value',$cellValue,$cellRef);



			// if the token is a function, pop arguments off the stack, hand them to the function, and push the result back on

			} elseif (preg_match('/^'.self::CALCULATION_REGEXP_FUNCTION.'$/i', $token, $matches)) {

//				echo 'Token is a function<br />';

				$functionName = $matches[1];

				$argCount = $stack->pop();

				$argCount = $argCount['value'];

				if ($functionName != 'MKMATRIX') {

					$this->_debugLog->writeDebugLog('Evaluating Function ', self::_localeFunc($functionName), '() with ', (($argCount == 0) ? 'no' : $argCount), ' argument', (($argCount == 1) ? '' : 's'));

				}

				if ((isset(self::$_PHPExcelFunctions[$functionName])) || (isset(self::$_controlFunctions[$functionName]))) {	// function

					if (isset(self::$_PHPExcelFunctions[$functionName])) {

						$functionCall = self::$_PHPExcelFunctions[$functionName]['functionCall'];

						$passByReference = isset(self::$_PHPExcelFunctions[$functionName]['passByReference']);

						$passCellReference = isset(self::$_PHPExcelFunctions[$functionName]['passCellReference']);

					} elseif (isset(self::$_controlFunctions[$functionName])) {

						$functionCall = self::$_controlFunctions[$functionName]['functionCall'];

						$passByReference = isset(self::$_controlFunctions[$functionName]['passByReference']);

						$passCellReference = isset(self::$_controlFunctions[$functionName]['passCellReference']);

					}

					// get the arguments for this function

//					echo 'Function '.$functionName.' expects '.$argCount.' arguments<br />';

					$args = $argArrayVals = array();

					for ($i = 0; $i < $argCount; ++$i) {

						$arg = $stack->pop();

						$a = $argCount - $i - 1;

						if (($passByReference) &&

							(isset(self::$_PHPExcelFunctions[$functionName]['passByReference'][$a])) &&

							(self::$_PHPExcelFunctions[$functionName]['passByReference'][$a])) {

							if ($arg['reference'] === NULL) {

								$args[] = $cellID;

								if ($functionName != 'MKMATRIX') { $argArrayVals[] = $this->_showValue($cellID); }

							} else {

								$args[] = $arg['reference'];

								if ($functionName != 'MKMATRIX') { $argArrayVals[] = $this->_showValue($arg['reference']); }

							}

						} else {

							$args[] = self::_unwrapResult($arg['value']);

							if ($functionName != 'MKMATRIX') { $argArrayVals[] = $this->_showValue($arg['value']); }

						}

					}

					//	Reverse the order of the arguments

					krsort($args);

					if (($passByReference) && ($argCount == 0)) {

						$args[] = $cellID;

						$argArrayVals[] = $this->_showValue($cellID);

					}

//					echo 'Arguments are: ';

//					print_r($args);

//					echo '<br />';

					if ($functionName != 'MKMATRIX') {

						if ($this->_debugLog->getWriteDebugLog()) {

							krsort($argArrayVals);

							$this->_debugLog->writeDebugLog('Evaluating ', self::_localeFunc($functionName), '( ', implode(self::$_localeArgumentSeparator.' ',PHPExcel_Calculation_Functions::flattenArray($argArrayVals)), ' )');

						}

					}

					//	Process each argument in turn, building the return value as an array

//					if (($argCount == 1) && (is_array($args[1])) && ($functionName != 'MKMATRIX')) {

//						$operand1 = $args[1];

//						$this->_debugLog->writeDebugLog('Argument is a matrix: ', $this->_showValue($operand1));

//						$result = array();

//						$row = 0;

//						foreach($operand1 as $args) {

//							if (is_array($args)) {

//								foreach($args as $arg) {

//									$this->_debugLog->writeDebugLog('Evaluating ', self::_localeFunc($functionName), '( ', $this->_showValue($arg), ' )');

//									$r = call_user_func_array($functionCall,$arg);

//									$this->_debugLog->writeDebugLog('Evaluation Result for ', self::_localeFunc($functionName), '() function call is ', $this->_showTypeDetails($r));

//									$result[$row][] = $r;

//								}

//								++$row;

//							} else {

//								$this->_debugLog->writeDebugLog('Evaluating ', self::_localeFunc($functionName), '( ', $this->_showValue($args), ' )');

//								$r = call_user_func_array($functionCall,$args);

//								$this->_debugLog->writeDebugLog('Evaluation Result for ', self::_localeFunc($functionName), '() function call is ', $this->_showTypeDetails($r));

//								$result[] = $r;

//							}

//						}

//					} else {

					//	Process the argument with the appropriate function call

						if ($passCellReference) {

							$args[] = $pCell;

						}

						if (strpos($functionCall,'::') !== FALSE) {

							$result = call_user_func_array(explode('::',$functionCall),$args);

						} else {

							foreach($args as &$arg) {

								$arg = PHPExcel_Calculation_Functions::flattenSingleValue($arg);

							}

							unset($arg);

							$result = call_user_func_array($functionCall,$args);

						}

//					}

					if ($functionName != 'MKMATRIX') {

						$this->_debugLog->writeDebugLog('Evaluation Result for ', self::_localeFunc($functionName), '() function call is ', $this->_showTypeDetails($result));

					}

					$stack->push('Value',self::_wrapResult($result));

				}



			} else {

				// if the token is a number, boolean, string or an Excel error, push it onto the stack

				if (isset(self::$_ExcelConstants[strtoupper($token)])) {

					$excelConstant = strtoupper($token);

//					echo 'Token is a PHPExcel constant: '.$excelConstant.'<br />';

					$stack->push('Constant Value',self::$_ExcelConstants[$excelConstant]);

					$this->_debugLog->writeDebugLog('Evaluating Constant ', $excelConstant, ' as ', $this->_showTypeDetails(self::$_ExcelConstants[$excelConstant]));

				} elseif ((is_numeric($token)) || ($token === NULL) || (is_bool($token)) || ($token == '') || ($token{0} == '"') || ($token{0} == '#')) {

//					echo 'Token is a number, boolean, string, null or an Excel error<br />';

					$stack->push('Value',$token);

				// if the token is a named range, push the named range name onto the stack

				} elseif (preg_match('/^'.self::CALCULATION_REGEXP_NAMEDRANGE.'$/i', $token, $matches)) {

//					echo 'Token is a named range<br />';

					$namedRange = $matches[6];

//					echo 'Named Range is '.$namedRange.'<br />';

					$this->_debugLog->writeDebugLog('Evaluating Named Range ', $namedRange);

					$cellValue = $this->extractNamedRange($namedRange, ((NULL !== $pCell) ? $pCellWorksheet : NULL), FALSE);

					$pCell->attach($pCellParent);

					$this->_debugLog->writeDebugLog('Evaluation Result for named range ', $namedRange, ' is ', $this->_showTypeDetails($cellValue));

					$stack->push('Named Range',$cellValue,$namedRange);

				} else {

					return $this->_raiseFormulaError("undefined variable '$token'");

				}

			}

		}

		// when we're out of tokens, the stack should have a single element, the final result

		if ($stack->count() != 1) return $this->_raiseFormulaError("internal error");

		$output = $stack->pop();

		$output = $output['value'];



//		if ((is_array($output)) && (self::$returnArrayAsType != self::RETURN_ARRAY_AS_ARRAY)) {

//			return array_shift(PHPExcel_Calculation_Functions::flattenArray($output));

//		}

		return $output;

	}	//	function _processTokenStack()





	private function _validateBinaryOperand($cellID, &$operand, &$stack) {

		if (is_array($operand)) {

			if ((count($operand, COUNT_RECURSIVE) - count($operand)) == 1) {

				do {

					$operand = array_pop($operand);

				} while (is_array($operand));

			}

		}

		//	Numbers, matrices and booleans can pass straight through, as they're already valid

		if (is_string($operand)) {

			//	We only need special validations for the operand if it is a string

			//	Start by stripping off the quotation marks we use to identify true excel string values internally

			if ($operand > '' && $operand{0} == '"') { $operand = self::_unwrapResult($operand); }

			//	If the string is a numeric value, we treat it as a numeric, so no further testing

			if (!is_numeric($operand)) {

				//	If not a numeric, test to see if the value is an Excel error, and so can't be used in normal binary operations

				if ($operand > '' && $operand{0} == '#') {

					$stack->push('Value', $operand);

					$this->_debugLog->writeDebugLog('Evaluation Result is ', $this->_showTypeDetails($operand));

					return FALSE;

				} elseif (!PHPExcel_Shared_String::convertToNumberIfFraction($operand)) {

					//	If not a numeric or a fraction, then it's a text string, and so can't be used in mathematical binary operations

					$stack->push('Value', '#VALUE!');

					$this->_debugLog->writeDebugLog('Evaluation Result is a ', $this->_showTypeDetails('#VALUE!'));

					return FALSE;

				}

			}

		}



		//	return a true if the value of the operand is one that we can use in normal binary operations

		return TRUE;

	}	//	function _validateBinaryOperand()





	private function _executeBinaryComparisonOperation($cellID, $operand1, $operand2, $operation, &$stack, $recursingArrays=FALSE) {

		//	If we're dealing with matrix operations, we want a matrix result

		if ((is_array($operand1)) || (is_array($operand2))) {

			$result = array();

			if ((is_array($operand1)) && (!is_array($operand2))) {

				foreach($operand1 as $x => $operandData) {

					$this->_debugLog->writeDebugLog('Evaluating Comparison ', $this->_showValue($operandData), ' ', $operation, ' ', $this->_showValue($operand2));

					$this->_executeBinaryComparisonOperation($cellID,$operandData,$operand2,$operation,$stack);

					$r = $stack->pop();

					$result[$x] = $r['value'];

				}

			} elseif ((!is_array($operand1)) && (is_array($operand2))) {

				foreach($operand2 as $x => $operandData) {

					$this->_debugLog->writeDebugLog('Evaluating Comparison ', $this->_showValue($operand1), ' ', $operation, ' ', $this->_showValue($operandData));

					$this->_executeBinaryComparisonOperation($cellID,$operand1,$operandData,$operation,$stack);

					$r = $stack->pop();

					$result[$x] = $r['value'];

				}

			} else {

				if (!$recursingArrays) { self::_checkMatrixOperands($operand1,$operand2,2); }

				foreach($operand1 as $x => $operandData) {

					$this->_debugLog->writeDebugLog('Evaluating Comparison ', $this->_showValue($operandData), ' ', $operation, ' ', $this->_showValue($operand2[$x]));

					$this->_executeBinaryComparisonOperation($cellID,$operandData,$operand2[$x],$operation,$stack,TRUE);

					$r = $stack->pop();

					$result[$x] = $r['value'];

				}

			}

			//	Log the result details

			$this->_debugLog->writeDebugLog('Comparison Evaluation Result is ', $this->_showTypeDetails($result));

			//	And push the result onto the stack

			$stack->push('Array',$result);

			return TRUE;

		}



		//	Simple validate the two operands if they are string values

		if (is_string($operand1) && $operand1 > '' && $operand1{0} == '"') { $operand1 = self::_unwrapResult($operand1); }

		if (is_string($operand2) && $operand2 > '' && $operand2{0} == '"') { $operand2 = self::_unwrapResult($operand2); }



		// Use case insensitive comparaison if not OpenOffice mode

		if (PHPExcel_Calculation_Functions::getCompatibilityMode() != PHPExcel_Calculation_Functions::COMPATIBILITY_OPENOFFICE)

		{

			if (is_string($operand1)) {

				$operand1 = strtoupper($operand1);

			}



			if (is_string($operand2)) {

				$operand2 = strtoupper($operand2);

			}

		}



		$useLowercaseFirstComparison = is_string($operand1) && is_string($operand2) && PHPExcel_Calculation_Functions::getCompatibilityMode() == PHPExcel_Calculation_Functions::COMPATIBILITY_OPENOFFICE;



		//	execute the necessary operation

		switch ($operation) {

			//	Greater than

			case '>':

				if ($useLowercaseFirstComparison) {

					$result = $this->strcmpLowercaseFirst($operand1, $operand2) > 0;

				} else {

					$result = ($operand1 > $operand2);

				}

				break;

			//	Less than

			case '<':

				if ($useLowercaseFirstComparison) {

					$result = $this->strcmpLowercaseFirst($operand1, $operand2) < 0;

				} else {

					$result = ($operand1 < $operand2);

				}

				break;

			//	Equality

			case '=':

				$result = ($operand1 == $operand2);

				break;

			//	Greater than or equal

			case '>=':

				if ($useLowercaseFirstComparison) {

					$result = $this->strcmpLowercaseFirst($operand1, $operand2) >= 0;

				} else {

					$result = ($operand1 >= $operand2);

				}

				break;

			//	Less than or equal

			case '<=':

				if ($useLowercaseFirstComparison) {

					$result = $this->strcmpLowercaseFirst($operand1, $operand2) <= 0;

				} else {

					$result = ($operand1 <= $operand2);

				}

				break;

			//	Inequality

			case '<>':

				$result = ($operand1 != $operand2);

				break;

		}



		//	Log the result details

		$this->_debugLog->writeDebugLog('Evaluation Result is ', $this->_showTypeDetails($result));

		//	And push the result onto the stack

		$stack->push('Value',$result);

		return TRUE;

	}	//	function _executeBinaryComparisonOperation()



	/**

	 * Compare two strings in the same way as strcmp() except that lowercase come before uppercase letters

	 * @param string $str1

	 * @param string $str2

	 * @return integer

	 */

	private function strcmpLowercaseFirst($str1, $str2)

	{

		$from = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz';

		$to = 'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ';

		$inversedStr1 = strtr($str1, $from, $to);

		$inversedStr2 = strtr($str2, $from, $to);



		return strcmp($inversedStr1, $inversedStr2);

	}



	private function _executeNumericBinaryOperation($cellID,$operand1,$operand2,$operation,$matrixFunction,&$stack) {

		//	Validate the two operands

		if (!$this->_validateBinaryOperand($cellID,$operand1,$stack)) return FALSE;

		if (!$this->_validateBinaryOperand($cellID,$operand2,$stack)) return FALSE;



		//	If either of the operands is a matrix, we need to treat them both as matrices

		//		(converting the other operand to a matrix if need be); then perform the required

		//		matrix operation

		if ((is_array($operand1)) || (is_array($operand2))) {

			//	Ensure that both operands are arrays/matrices of the same size

			self::_checkMatrixOperands($operand1, $operand2, 2);



			try {

				//	Convert operand 1 from a PHP array to a matrix

				$matrix = new PHPExcel_Shared_JAMA_Matrix($operand1);

				//	Perform the required operation against the operand 1 matrix, passing in operand 2

				$matrixResult = $matrix->$matrixFunction($operand2);

				$result = $matrixResult->getArray();

			} catch (PHPExcel_Exception $ex) {

				$this->_debugLog->writeDebugLog('JAMA Matrix Exception: ', $ex->getMessage());

				$result = '#VALUE!';

			}

		} else {

			if ((PHPExcel_Calculation_Functions::getCompatibilityMode() != PHPExcel_Calculation_Functions::COMPATIBILITY_OPENOFFICE) &&

				((is_string($operand1) && !is_numeric($operand1) && strlen($operand1)>0) || 

                 (is_string($operand2) && !is_numeric($operand2) && strlen($operand2)>0))) {

				$result = PHPExcel_Calculation_Functions::VALUE();

			} else {

				//	If we're dealing with non-matrix operations, execute the necessary operation

				switch ($operation) {

					//	Addition

					case '+':

						$result = $operand1 + $operand2;

						break;

					//	Subtraction

					case '-':

						$result = $operand1 - $operand2;

						break;

					//	Multiplication

					case '*':

						$result = $operand1 * $operand2;

						break;

					//	Division

					case '/':

						if ($operand2 == 0) {

							//	Trap for Divide by Zero error

							$stack->push('Value','#DIV/0!');

							$this->_debugLog->writeDebugLog('Evaluation Result is ', $this->_showTypeDetails('#DIV/0!'));

							return FALSE;

						} else {

							$result = $operand1 / $operand2;

						}

						break;

					//	Power

					case '^':

						$result = pow($operand1, $operand2);

						break;

				}

			}

		}



		//	Log the result details

		$this->_debugLog->writeDebugLog('Evaluation Result is ', $this->_showTypeDetails($result));

		//	And push the result onto the stack

		$stack->push('Value',$result);

		return TRUE;

	}	//	function _executeNumericBinaryOperation()





	// trigger an error, but nicely, if need be

	protected function _raiseFormulaError($errorMessage) {

		$this->formulaError = $errorMessage;

		$this->_cyclicReferenceStack->clear();

		if (!$this->suppressFormulaErrors) throw new PHPExcel_Calculation_Exception($errorMessage);

		trigger_error($errorMessage, E_USER_ERROR);

	}	//	function _raiseFormulaError()





	/**

	 * Extract range values

	 *

	 * @param	string				&$pRange	String based range representation

	 * @param	PHPExcel_Worksheet	$pSheet		Worksheet

	 * @param	boolean				$resetLog	Flag indicating whether calculation log should be reset or not

	 * @return  mixed				Array of values in range if range contains more than one element. Otherwise, a single value is returned.

	 * @throws	PHPExcel_Calculation_Exception

	 */

	public function extractCellRange(&$pRange = 'A1', PHPExcel_Worksheet $pSheet = NULL, $resetLog = TRUE) {

		// Return value

		$returnValue = array ();



//		echo 'extractCellRange('.$pRange.')',PHP_EOL;

		if ($pSheet !== NULL) {

			$pSheetName = $pSheet->getTitle();

//			echo 'Passed sheet name is '.$pSheetName.PHP_EOL;

//			echo 'Range reference is '.$pRange.PHP_EOL;

			if (strpos ($pRange, '!') !== false) {

//				echo '$pRange reference includes sheet reference',PHP_EOL;

				list($pSheetName,$pRange) = PHPExcel_Worksheet::extractSheetTitle($pRange, true);

//				echo 'New sheet name is '.$pSheetName,PHP_EOL;

//				echo 'Adjusted Range reference is '.$pRange,PHP_EOL;

				$pSheet = $this->_workbook->getSheetByName($pSheetName);

			}



			// Extract range

			$aReferences = PHPExcel_Cell::extractAllCellReferencesInRange($pRange);

			$pRange = $pSheetName.'!'.$pRange;

			if (!isset($aReferences[1])) {

				//	Single cell in range

				sscanf($aReferences[0],'%[A-Z]%d', $currentCol, $currentRow);

				$cellValue = NULL;

				if ($pSheet->cellExists($aReferences[0])) {

					$returnValue[$currentRow][$currentCol] = $pSheet->getCell($aReferences[0])->getCalculatedValue($resetLog);

				} else {

					$returnValue[$currentRow][$currentCol] = NULL;

				}

			} else {

				// Extract cell data for all cells in the range

				foreach ($aReferences as $reference) {

					// Extract range

					sscanf($reference,'%[A-Z]%d', $currentCol, $currentRow);

					$cellValue = NULL;

					if ($pSheet->cellExists($reference)) {

						$returnValue[$currentRow][$currentCol] = $pSheet->getCell($reference)->getCalculatedValue($resetLog);

					} else {

						$returnValue[$currentRow][$currentCol] = NULL;

					}

				}

			}

		}



		// Return

		return $returnValue;

	}	//	function extractCellRange()





	/**

	 * Extract range values

	 *

	 * @param	string				&$pRange	String based range representation

	 * @param	PHPExcel_Worksheet	$pSheet		Worksheet

	 * @return  mixed				Array of values in range if range contains more than one element. Otherwise, a single value is returned.

	 * @param	boolean				$resetLog	Flag indicating whether calculation log should be reset or not

	 * @throws	PHPExcel_Calculation_Exception

	 */

	public function extractNamedRange(&$pRange = 'A1', PHPExcel_Worksheet $pSheet = NULL, $resetLog = TRUE) {

		// Return value

		$returnValue = array ();



//		echo 'extractNamedRange('.$pRange.')<br />';

		if ($pSheet !== NULL) {

			$pSheetName = $pSheet->getTitle();

//			echo 'Current sheet name is '.$pSheetName.'<br />';

//			echo 'Range reference is '.$pRange.'<br />';

			if (strpos ($pRange, '!') !== false) {

//				echo '$pRange reference includes sheet reference',PHP_EOL;

				list($pSheetName,$pRange) = PHPExcel_Worksheet::extractSheetTitle($pRange, true);

//				echo 'New sheet name is '.$pSheetName,PHP_EOL;

//				echo 'Adjusted Range reference is '.$pRange,PHP_EOL;

				$pSheet = $this->_workbook->getSheetByName($pSheetName);

			}



			// Named range?

			$namedRange = PHPExcel_NamedRange::resolveRange($pRange, $pSheet);

			if ($namedRange !== NULL) {

				$pSheet = $namedRange->getWorksheet();

//				echo 'Named Range '.$pRange.' (';

				$pRange = $namedRange->getRange();

				$splitRange = PHPExcel_Cell::splitRange($pRange);

				//	Convert row and column references

				if (ctype_alpha($splitRange[0][0])) {

					$pRange = $splitRange[0][0] . '1:' . $splitRange[0][1] . $namedRange->getWorksheet()->getHighestRow();

				} elseif(ctype_digit($splitRange[0][0])) {

					$pRange = 'A' . $splitRange[0][0] . ':' . $namedRange->getWorksheet()->getHighestColumn() . $splitRange[0][1];

				}

//				echo $pRange.') is in sheet '.$namedRange->getWorksheet()->getTitle().'<br />';



//				if ($pSheet->getTitle() != $namedRange->getWorksheet()->getTitle()) {

//					if (!$namedRange->getLocalOnly()) {

//						$pSheet = $namedRange->getWorksheet();

//					} else {

//						return $returnValue;

//					}

//				}

			} else {

				return PHPExcel_Calculation_Functions::REF();

			}



			// Extract range

			$aReferences = PHPExcel_Cell::extractAllCellReferencesInRange($pRange);

//			var_dump($aReferences);

			if (!isset($aReferences[1])) {

				//	Single cell (or single column or row) in range

				list($currentCol,$currentRow) = PHPExcel_Cell::coordinateFromString($aReferences[0]);

				$cellValue = NULL;

				if ($pSheet->cellExists($aReferences[0])) {

					$returnValue[$currentRow][$currentCol] = $pSheet->getCell($aReferences[0])->getCalculatedValue($resetLog);

				} else {

					$returnValue[$currentRow][$currentCol] = NULL;

				}

			} else {

				// Extract cell data for all cells in the range

				foreach ($aReferences as $reference) {

					// Extract range

					list($currentCol,$currentRow) = PHPExcel_Cell::coordinateFromString($reference);

//					echo 'NAMED RANGE: $currentCol='.$currentCol.' $currentRow='.$currentRow.'<br />';

					$cellValue = NULL;

					if ($pSheet->cellExists($reference)) {

						$returnValue[$currentRow][$currentCol] = $pSheet->getCell($reference)->getCalculatedValue($resetLog);

					} else {

						$returnValue[$currentRow][$currentCol] = NULL;

					}

				}

			}

//				print_r($returnValue);

//			echo '<br />';

		}



		// Return

		return $returnValue;

	}	//	function extractNamedRange()





	/**

	 * Is a specific function implemented?

	 *

	 * @param	string	$pFunction	Function Name

	 * @return	boolean

	 */

	public function isImplemented($pFunction = '') {

		$pFunction = strtoupper ($pFunction);

		if (isset(self::$_PHPExcelFunctions[$pFunction])) {

			return (self::$_PHPExcelFunctions[$pFunction]['functionCall'] != 'PHPExcel_Calculation_Functions::DUMMY');

		} else {

			return FALSE;

		}

	}	//	function isImplemented()





	/**

	 * Get a list of all implemented functions as an array of function objects

	 *

	 * @return	array of PHPExcel_Calculation_Function

	 */

	public function listFunctions() {

		// Return value

		$returnValue = array();

		// Loop functions

		foreach(self::$_PHPExcelFunctions as $functionName => $function) {

			if ($function['functionCall'] != 'PHPExcel_Calculation_Functions::DUMMY') {

				$returnValue[$functionName] = new PHPExcel_Calculation_Function($function['category'],

																				$functionName,

																				$function['functionCall']

																			   );

			}

		}



		// Return

		return $returnValue;

	}	//	function listFunctions()





	/**

	 * Get a list of all Excel function names

	 *

	 * @return	array

	 */

	public function listAllFunctionNames() {

		return array_keys(self::$_PHPExcelFunctions);

	}	//	function listAllFunctionNames()



	/**

	 * Get a list of implemented Excel function names

	 *

	 * @return	array

	 */

	public function listFunctionNames() {

		// Return value

		$returnValue = array();

		// Loop functions

		foreach(self::$_PHPExcelFunctions as $functionName => $function) {

			if ($function['functionCall'] != 'PHPExcel_Calculation_Functions::DUMMY') {

				$returnValue[] = $functionName;

			}

		}



		// Return

		return $returnValue;

	}	//	function listFunctionNames()



}	//	class PHPExcel_Calculation



