Context Navigation

← Previous Revision
Latest Revision
Next Revision →
Blame
Revision Log

Calculation.php @ 1

Last change on this file since 1 was 1, checked in by dungnv, 11 years ago

File size: 171.1 KB

Line
1	<?php
2	/**
3	* PHPExcel
4	*
5	* Copyright (c) 2006 - 2014 PHPExcel
6	*
7	* This library is free software; you can redistribute it and/or
8	* modify it under the terms of the GNU Lesser General Public
9	* License as published by the Free Software Foundation; either
10	* version 2.1 of the License, or (at your option) any later version.
11	*
12	* This library is distributed in the hope that it will be useful,
13	* but WITHOUT ANY WARRANTY; without even the implied warranty of
14	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15	* Lesser General Public License for more details.
16	*
17	* You should have received a copy of the GNU Lesser General Public
18	* License along with this library; if not, write to the Free Software
19	* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
20	*
21	* @category PHPExcel
22	* @package PHPExcel_Calculation
23	* @copyright Copyright (c) 2006 - 2014 PHPExcel (http://www.codeplex.com/PHPExcel)
24	* @license http://www.gnu.org/licenses/old-licenses/lgpl-2.1.txt LGPL
25	* @version 1.8.0, 2014-03-02
26	*/
27
28
29	/** PHPExcel root directory */
30	if (!defined('PHPEXCEL_ROOT')) {
31	/**
32	* @ignore
33	*/
34	define('PHPEXCEL_ROOT', dirname(__FILE__) . '/../');
35	require(PHPEXCEL_ROOT . 'PHPExcel/Autoloader.php');
36	}
37
38
39	if (!defined('CALCULATION_REGEXP_CELLREF')) {
40	// Test for support of \P (multibyte options) in PCRE
41	if(defined('PREG_BAD_UTF8_ERROR')) {
42	// Cell reference (cell or range of cells, with or without a sheet reference)
43	define('CALCULATION_REGEXP_CELLREF','((([^\s,!&%^\/\\+<>=-])\|(\'[^\']\')\|(\"[^\"]\"))!)?\$?([a-z]{1,3})\$?(\d{1,7})');
44	// Named Range of cells
45	define('CALCULATION_REGEXP_NAMEDRANGE','((([^\s,!&%^\/\\+<>=-])\|(\'[^\']\')\|(\"[^\"]\"))!)?([_A-Z][_A-Z0-9\.]*)');
46	} else {
47	// Cell reference (cell or range of cells, with or without a sheet reference)
48	define('CALCULATION_REGEXP_CELLREF','(((\w)\|(\'[^\']\')\|(\"[^\"]*\"))!)?\$?([a-z]{1,3})\$?(\d+)');
49	// Named Range of cells
50	define('CALCULATION_REGEXP_NAMEDRANGE','(((\w)\|(\'.\')\|(\".\"))!)?([_A-Z][_A-Z0-9\.])');
51	}
52	}
53
54
55	/**
56	* PHPExcel_Calculation (Multiton)
57	*
58	* @category PHPExcel
59	* @package PHPExcel_Calculation
60	* @copyright Copyright (c) 2006 - 2014 PHPExcel (http://www.codeplex.com/PHPExcel)
61	*/
62	class PHPExcel_Calculation {
63
64	/** Constants */
65	/** Regular Expressions */
66	// Numeric operand
67	const CALCULATION_REGEXP_NUMBER = '[-+]?\d*\.?\d+(e[-+]?\d+)?';
68	// String operand
69	const CALCULATION_REGEXP_STRING = '"(?:[^"]\|"")*"';
70	// Opening bracket
71	const CALCULATION_REGEXP_OPENBRACE = '\(';
72	// Function (allow for the old @ symbol that could be used to prefix a function, but we'll ignore it)
73	const CALCULATION_REGEXP_FUNCTION = '@?([A-Z][A-Z0-9\.])[\s]\(';
74	// Cell reference (cell or range of cells, with or without a sheet reference)
75	const CALCULATION_REGEXP_CELLREF = CALCULATION_REGEXP_CELLREF;
76	// Named Range of cells
77	const CALCULATION_REGEXP_NAMEDRANGE = CALCULATION_REGEXP_NAMEDRANGE;
78	// Error
79	const CALCULATION_REGEXP_ERROR = '\#[A-Z][A-Z0_\/]*[!\?]?';
80
81
82	/** constants */
83	const RETURN_ARRAY_AS_ERROR = 'error';
84	const RETURN_ARRAY_AS_VALUE = 'value';
85	const RETURN_ARRAY_AS_ARRAY = 'array';
86
87	private static $returnArrayAsType = self::RETURN_ARRAY_AS_VALUE;
88
89
90	/**
91	* Instance of this class
92	*
93	* @access private
94	* @var PHPExcel_Calculation
95	*/
96	private static $_instance;
97
98
99	/**
100	* Instance of the workbook this Calculation Engine is using
101	*
102	* @access private
103	* @var PHPExcel
104	*/
105	private $_workbook;
106
107	/**
108	* List of instances of the calculation engine that we've instantiated for individual workbooks
109	*
110	* @access private
111	* @var PHPExcel_Calculation[]
112	*/
113	private static $_workbookSets;
114
115	/**
116	* Calculation cache
117	*
118	* @access private
119	* @var array
120	*/
121	private $_calculationCache = array ();
122
123
124	/**
125	* Calculation cache enabled
126	*
127	* @access private
128	* @var boolean
129	*/
130	private $_calculationCacheEnabled = TRUE;
131
132
133	/**
134	* List of operators that can be used within formulae
135	* The true/false value indicates whether it is a binary operator or a unary operator
136	*
137	* @access private
138	* @var array
139	*/
140	private static $_operators = array('+' => TRUE, '-' => TRUE, '*' => TRUE, '/' => TRUE,
141	'^' => TRUE, '&' => TRUE, '%' => FALSE, '~' => FALSE,
142	'>' => TRUE, '<' => TRUE, '=' => TRUE, '>=' => TRUE,
143	'<=' => TRUE, '<>' => TRUE, '\|' => TRUE, ':' => TRUE
144	);
145
146
147	/**
148	* List of binary operators (those that expect two operands)
149	*
150	* @access private
151	* @var array
152	*/
153	private static $_binaryOperators = array('+' => TRUE, '-' => TRUE, '*' => TRUE, '/' => TRUE,
154	'^' => TRUE, '&' => TRUE, '>' => TRUE, '<' => TRUE,
155	'=' => TRUE, '>=' => TRUE, '<=' => TRUE, '<>' => TRUE,
156	'\|' => TRUE, ':' => TRUE
157	);
158
159	/**
160	* The debug log generated by the calculation engine
161	*
162	* @access private
163	* @var PHPExcel_CalcEngine_Logger
164	*
165	*/
166	private $debugLog;
167
168	/**
169	* Flag to determine how formula errors should be handled
170	* If true, then a user error will be triggered
171	* If false, then an exception will be thrown
172	*
173	* @access public
174	* @var boolean
175	*
176	*/
177	public $suppressFormulaErrors = FALSE;
178
179	/**
180	* Error message for any error that was raised/thrown by the calculation engine
181	*
182	* @access public
183	* @var string
184	*
185	*/
186	public $formulaError = NULL;
187
188	/**
189	* An array of the nested cell references accessed by the calculation engine, used for the debug log
190	*
191	* @access private
192	* @var array of string
193	*
194	*/
195	private $_cyclicReferenceStack;
196
197	/**
198	* Current iteration counter for cyclic formulae
199	* If the value is 0 (or less) then cyclic formulae will throw an exception,
200	* otherwise they will iterate to the limit defined here before returning a result
201	*
202	* @var integer
203	*
204	*/
205	private $_cyclicFormulaCount = 0;
206
207	private $_cyclicFormulaCell = '';
208
209	/**
210	* Number of iterations for cyclic formulae
211	*
212	* @var integer
213	*
214	*/
215	public $cyclicFormulaCount = 0;
216
217	/**
218	* Precision used for calculations
219	*
220	* @var integer
221	*
222	*/
223	private $_savedPrecision = 14;
224
225
226	/**
227	* The current locale setting
228	*
229	* @var string
230	*
231	*/
232	private static $_localeLanguage = 'en_us'; // US English (default locale)
233
234	/**
235	* List of available locale settings
236	* Note that this is read for the locale subdirectory only when requested
237	*
238	* @var string[]
239	*
240	*/
241	private static $_validLocaleLanguages = array( 'en' // English (default language)
242	);
243	/**
244	* Locale-specific argument separator for function arguments
245	*
246	* @var string
247	*
248	*/
249	private static $_localeArgumentSeparator = ',';
250	private static $_localeFunctions = array();
251
252	/**
253	* Locale-specific translations for Excel constants (True, False and Null)
254	*
255	* @var string[]
256	*
257	*/
258	public static $_localeBoolean = array( 'TRUE' => 'TRUE',
259	'FALSE' => 'FALSE',
260	'NULL' => 'NULL'
261	);
262
263
264	/**
265	* Excel constant string translations to their PHP equivalents
266	* Constant conversion from text name/value to actual (datatyped) value
267	*
268	* @var string[]
269	*
270	*/
271	private static $_ExcelConstants = array('TRUE' => TRUE,
272	'FALSE' => FALSE,
273	'NULL' => NULL
274	);
275
276	// PHPExcel functions
277	private static $_PHPExcelFunctions = array( // PHPExcel functions
278	'ABS' => array('category' => PHPExcel_Calculation_Function::CATEGORY_MATH_AND_TRIG,
279	'functionCall' => 'abs',
280	'argumentCount' => '1'
281	),
282	'ACCRINT' => array('category' => PHPExcel_Calculation_Function::CATEGORY_FINANCIAL,
283	'functionCall' => 'PHPExcel_Calculation_Financial::ACCRINT',
284	'argumentCount' => '4-7'
285	),
286	'ACCRINTM' => array('category' => PHPExcel_Calculation_Function::CATEGORY_FINANCIAL,
287	'functionCall' => 'PHPExcel_Calculation_Financial::ACCRINTM',
288	'argumentCount' => '3-5'
289	),
290	'ACOS' => array('category' => PHPExcel_Calculation_Function::CATEGORY_MATH_AND_TRIG,
291	'functionCall' => 'acos',
292	'argumentCount' => '1'
293	),
294	'ACOSH' => array('category' => PHPExcel_Calculation_Function::CATEGORY_MATH_AND_TRIG,
295	'functionCall' => 'acosh',
296	'argumentCount' => '1'
297	),
298	'ADDRESS' => array('category' => PHPExcel_Calculation_Function::CATEGORY_LOOKUP_AND_REFERENCE,
299	'functionCall' => 'PHPExcel_Calculation_LookupRef::CELL_ADDRESS',
300	'argumentCount' => '2-5'
301	),
302	'AMORDEGRC' => array('category' => PHPExcel_Calculation_Function::CATEGORY_FINANCIAL,
303	'functionCall' => 'PHPExcel_Calculation_Financial::AMORDEGRC',
304	'argumentCount' => '6,7'
305	),
306	'AMORLINC' => array('category' => PHPExcel_Calculation_Function::CATEGORY_FINANCIAL,
307	'functionCall' => 'PHPExcel_Calculation_Financial::AMORLINC',
308	'argumentCount' => '6,7'
309	),
310	'AND' => array('category' => PHPExcel_Calculation_Function::CATEGORY_LOGICAL,
311	'functionCall' => 'PHPExcel_Calculation_Logical::LOGICAL_AND',
312	'argumentCount' => '1+'
313	),
314	'AREAS' => array('category' => PHPExcel_Calculation_Function::CATEGORY_LOOKUP_AND_REFERENCE,
315	'functionCall' => 'PHPExcel_Calculation_Functions::DUMMY',
316	'argumentCount' => '1'
317	),
318	'ASC' => array('category' => PHPExcel_Calculation_Function::CATEGORY_TEXT_AND_DATA,
319	'functionCall' => 'PHPExcel_Calculation_Functions::DUMMY',
320	'argumentCount' => '1'
321	),
322	'ASIN' => array('category' => PHPExcel_Calculation_Function::CATEGORY_MATH_AND_TRIG,
323	'functionCall' => 'asin',
324	'argumentCount' => '1'
325	),
326	'ASINH' => array('category' => PHPExcel_Calculation_Function::CATEGORY_MATH_AND_TRIG,
327	'functionCall' => 'asinh',
328	'argumentCount' => '1'
329	),
330	'ATAN' => array('category' => PHPExcel_Calculation_Function::CATEGORY_MATH_AND_TRIG,
331	'functionCall' => 'atan',
332	'argumentCount' => '1'
333	),
334	'ATAN2' => array('category' => PHPExcel_Calculation_Function::CATEGORY_MATH_AND_TRIG,
335	'functionCall' => 'PHPExcel_Calculation_MathTrig::ATAN2',
336	'argumentCount' => '2'
337	),
338	'ATANH' => array('category' => PHPExcel_Calculation_Function::CATEGORY_MATH_AND_TRIG,
339	'functionCall' => 'atanh',
340	'argumentCount' => '1'
341	),
342	'AVEDEV' => array('category' => PHPExcel_Calculation_Function::CATEGORY_STATISTICAL,
343	'functionCall' => 'PHPExcel_Calculation_Statistical::AVEDEV',
344	'argumentCount' => '1+'
345	),
346	'AVERAGE' => array('category' => PHPExcel_Calculation_Function::CATEGORY_STATISTICAL,
347	'functionCall' => 'PHPExcel_Calculation_Statistical::AVERAGE',
348	'argumentCount' => '1+'
349	),
350	'AVERAGEA' => array('category' => PHPExcel_Calculation_Function::CATEGORY_STATISTICAL,
351	'functionCall' => 'PHPExcel_Calculation_Statistical::AVERAGEA',
352	'argumentCount' => '1+'
353	),
354	'AVERAGEIF' => array('category' => PHPExcel_Calculation_Function::CATEGORY_STATISTICAL,
355	'functionCall' => 'PHPExcel_Calculation_Statistical::AVERAGEIF',
356	'argumentCount' => '2,3'
357	),
358	'AVERAGEIFS' => array('category' => PHPExcel_Calculation_Function::CATEGORY_STATISTICAL,
359	'functionCall' => 'PHPExcel_Calculation_Functions::DUMMY',
360	'argumentCount' => '3+'
361	),
362	'BAHTTEXT' => array('category' => PHPExcel_Calculation_Function::CATEGORY_TEXT_AND_DATA,
363	'functionCall' => 'PHPExcel_Calculation_Functions::DUMMY',
364	'argumentCount' => '1'
365	),
366	'BESSELI' => array('category' => PHPExcel_Calculation_Function::CATEGORY_ENGINEERING,
367	'functionCall' => 'PHPExcel_Calculation_Engineering::BESSELI',
368	'argumentCount' => '2'
369	),
370	'BESSELJ' => array('category' => PHPExcel_Calculation_Function::CATEGORY_ENGINEERING,
371	'functionCall' => 'PHPExcel_Calculation_Engineering::BESSELJ',
372	'argumentCount' => '2'
373	),
374	'BESSELK' => array('category' => PHPExcel_Calculation_Function::CATEGORY_ENGINEERING,
375	'functionCall' => 'PHPExcel_Calculation_Engineering::BESSELK',
376	'argumentCount' => '2'
377	),
378	'BESSELY' => array('category' => PHPExcel_Calculation_Function::CATEGORY_ENGINEERING,
379	'functionCall' => 'PHPExcel_Calculation_Engineering::BESSELY',
380	'argumentCount' => '2'
381	),
382	'BETADIST' => array('category' => PHPExcel_Calculation_Function::CATEGORY_STATISTICAL,
383	'functionCall' => 'PHPExcel_Calculation_Statistical::BETADIST',
384	'argumentCount' => '3-5'
385	),
386	'BETAINV' => array('category' => PHPExcel_Calculation_Function::CATEGORY_STATISTICAL,
387	'functionCall' => 'PHPExcel_Calculation_Statistical::BETAINV',
388	'argumentCount' => '3-5'
389	),
390	'BIN2DEC' => array('category' => PHPExcel_Calculation_Function::CATEGORY_ENGINEERING,
391	'functionCall' => 'PHPExcel_Calculation_Engineering::BINTODEC',
392	'argumentCount' => '1'
393	),
394	'BIN2HEX' => array('category' => PHPExcel_Calculation_Function::CATEGORY_ENGINEERING,
395	'functionCall' => 'PHPExcel_Calculation_Engineering::BINTOHEX',
396	'argumentCount' => '1,2'
397	),
398	'BIN2OCT' => array('category' => PHPExcel_Calculation_Function::CATEGORY_ENGINEERING,
399	'functionCall' => 'PHPExcel_Calculation_Engineering::BINTOOCT',
400	'argumentCount' => '1,2'
401	),
402	'BINOMDIST' => array('category' => PHPExcel_Calculation_Function::CATEGORY_STATISTICAL,
403	'functionCall' => 'PHPExcel_Calculation_Statistical::BINOMDIST',
404	'argumentCount' => '4'
405	),
406	'CEILING' => array('category' => PHPExcel_Calculation_Function::CATEGORY_MATH_AND_TRIG,
407	'functionCall' => 'PHPExcel_Calculation_MathTrig::CEILING',
408	'argumentCount' => '2'
409	),
410	'CELL' => array('category' => PHPExcel_Calculation_Function::CATEGORY_INFORMATION,
411	'functionCall' => 'PHPExcel_Calculation_Functions::DUMMY',
412	'argumentCount' => '1,2'
413	),
414	'CHAR' => array('category' => PHPExcel_Calculation_Function::CATEGORY_TEXT_AND_DATA,
415	'functionCall' => 'PHPExcel_Calculation_TextData::CHARACTER',
416	'argumentCount' => '1'
417	),
418	'CHIDIST' => array('category' => PHPExcel_Calculation_Function::CATEGORY_STATISTICAL,
419	'functionCall' => 'PHPExcel_Calculation_Statistical::CHIDIST',
420	'argumentCount' => '2'
421	),
422	'CHIINV' => array('category' => PHPExcel_Calculation_Function::CATEGORY_STATISTICAL,
423	'functionCall' => 'PHPExcel_Calculation_Statistical::CHIINV',
424	'argumentCount' => '2'
425	),
426	'CHITEST' => array('category' => PHPExcel_Calculation_Function::CATEGORY_STATISTICAL,
427	'functionCall' => 'PHPExcel_Calculation_Functions::DUMMY',
428	'argumentCount' => '2'
429	),
430	'CHOOSE' => array('category' => PHPExcel_Calculation_Function::CATEGORY_LOOKUP_AND_REFERENCE,
431	'functionCall' => 'PHPExcel_Calculation_LookupRef::CHOOSE',
432	'argumentCount' => '2+'
433	),
434	'CLEAN' => array('category' => PHPExcel_Calculation_Function::CATEGORY_TEXT_AND_DATA,
435	'functionCall' => 'PHPExcel_Calculation_TextData::TRIMNONPRINTABLE',
436	'argumentCount' => '1'
437	),
438	'CODE' => array('category' => PHPExcel_Calculation_Function::CATEGORY_TEXT_AND_DATA,
439	'functionCall' => 'PHPExcel_Calculation_TextData::ASCIICODE',
440	'argumentCount' => '1'
441	),
442	'COLUMN' => array('category' => PHPExcel_Calculation_Function::CATEGORY_LOOKUP_AND_REFERENCE,
443	'functionCall' => 'PHPExcel_Calculation_LookupRef::COLUMN',
444	'argumentCount' => '-1',
445	'passByReference' => array(TRUE)
446	),
447	'COLUMNS' => array('category' => PHPExcel_Calculation_Function::CATEGORY_LOOKUP_AND_REFERENCE,
448	'functionCall' => 'PHPExcel_Calculation_LookupRef::COLUMNS',
449	'argumentCount' => '1'
450	),
451	'COMBIN' => array('category' => PHPExcel_Calculation_Function::CATEGORY_MATH_AND_TRIG,
452	'functionCall' => 'PHPExcel_Calculation_MathTrig::COMBIN',
453	'argumentCount' => '2'
454	),
455	'COMPLEX' => array('category' => PHPExcel_Calculation_Function::CATEGORY_ENGINEERING,
456	'functionCall' => 'PHPExcel_Calculation_Engineering::COMPLEX',
457	'argumentCount' => '2,3'
458	),
459	'CONCATENATE' => array('category' => PHPExcel_Calculation_Function::CATEGORY_TEXT_AND_DATA,
460	'functionCall' => 'PHPExcel_Calculation_TextData::CONCATENATE',
461	'argumentCount' => '1+'
462	),
463	'CONFIDENCE' => array('category' => PHPExcel_Calculation_Function::CATEGORY_STATISTICAL,
464	'functionCall' => 'PHPExcel_Calculation_Statistical::CONFIDENCE',
465	'argumentCount' => '3'
466	),
467	'CONVERT' => array('category' => PHPExcel_Calculation_Function::CATEGORY_ENGINEERING,
468	'functionCall' => 'PHPExcel_Calculation_Engineering::CONVERTUOM',
469	'argumentCount' => '3'
470	),
471	'CORREL' => array('category' => PHPExcel_Calculation_Function::CATEGORY_STATISTICAL,
472	'functionCall' => 'PHPExcel_Calculation_Statistical::CORREL',
473	'argumentCount' => '2'
474	),
475	'COS' => array('category' => PHPExcel_Calculation_Function::CATEGORY_MATH_AND_TRIG,
476	'functionCall' => 'cos',
477	'argumentCount' => '1'
478	),
479	'COSH' => array('category' => PHPExcel_Calculation_Function::CATEGORY_MATH_AND_TRIG,
480	'functionCall' => 'cosh',
481	'argumentCount' => '1'
482	),
483	'COUNT' => array('category' => PHPExcel_Calculation_Function::CATEGORY_STATISTICAL,
484	'functionCall' => 'PHPExcel_Calculation_Statistical::COUNT',
485	'argumentCount' => '1+'
486	),
487	'COUNTA' => array('category' => PHPExcel_Calculation_Function::CATEGORY_STATISTICAL,
488	'functionCall' => 'PHPExcel_Calculation_Statistical::COUNTA',
489	'argumentCount' => '1+'
490	),
491	'COUNTBLANK' => array('category' => PHPExcel_Calculation_Function::CATEGORY_STATISTICAL,
492	'functionCall' => 'PHPExcel_Calculation_Statistical::COUNTBLANK',
493	'argumentCount' => '1'
494	),
495	'COUNTIF' => array('category' => PHPExcel_Calculation_Function::CATEGORY_STATISTICAL,
496	'functionCall' => 'PHPExcel_Calculation_Statistical::COUNTIF',
497	'argumentCount' => '2'
498	),
499	'COUNTIFS' => array('category' => PHPExcel_Calculation_Function::CATEGORY_STATISTICAL,
500	'functionCall' => 'PHPExcel_Calculation_Functions::DUMMY',
501	'argumentCount' => '2'
502	),
503	'COUPDAYBS' => array('category' => PHPExcel_Calculation_Function::CATEGORY_FINANCIAL,
504	'functionCall' => 'PHPExcel_Calculation_Financial::COUPDAYBS',
505	'argumentCount' => '3,4'
506	),
507	'COUPDAYS' => array('category' => PHPExcel_Calculation_Function::CATEGORY_FINANCIAL,
508	'functionCall' => 'PHPExcel_Calculation_Financial::COUPDAYS',
509	'argumentCount' => '3,4'
510	),
511	'COUPDAYSNC' => array('category' => PHPExcel_Calculation_Function::CATEGORY_FINANCIAL,
512	'functionCall' => 'PHPExcel_Calculation_Financial::COUPDAYSNC',
513	'argumentCount' => '3,4'
514	),
515	'COUPNCD' => array('category' => PHPExcel_Calculation_Function::CATEGORY_FINANCIAL,
516	'functionCall' => 'PHPExcel_Calculation_Financial::COUPNCD',
517	'argumentCount' => '3,4'
518	),
519	'COUPNUM' => array('category' => PHPExcel_Calculation_Function::CATEGORY_FINANCIAL,
520	'functionCall' => 'PHPExcel_Calculation_Financial::COUPNUM',
521	'argumentCount' => '3,4'
522	),
523	'COUPPCD' => array('category' => PHPExcel_Calculation_Function::CATEGORY_FINANCIAL,
524	'functionCall' => 'PHPExcel_Calculation_Financial::COUPPCD',
525	'argumentCount' => '3,4'
526	),
527	'COVAR' => array('category' => PHPExcel_Calculation_Function::CATEGORY_STATISTICAL,
528	'functionCall' => 'PHPExcel_Calculation_Statistical::COVAR',
529	'argumentCount' => '2'
530	),
531	'CRITBINOM' => array('category' => PHPExcel_Calculation_Function::CATEGORY_STATISTICAL,
532	'functionCall' => 'PHPExcel_Calculation_Statistical::CRITBINOM',
533	'argumentCount' => '3'
534	),
535	'CUBEKPIMEMBER' => array('category' => PHPExcel_Calculation_Function::CATEGORY_CUBE,
536	'functionCall' => 'PHPExcel_Calculation_Functions::DUMMY',
537	'argumentCount' => '?'
538	),
539	'CUBEMEMBER' => array('category' => PHPExcel_Calculation_Function::CATEGORY_CUBE,
540	'functionCall' => 'PHPExcel_Calculation_Functions::DUMMY',
541	'argumentCount' => '?'
542	),
543	'CUBEMEMBERPROPERTY' => array('category' => PHPExcel_Calculation_Function::CATEGORY_CUBE,
544	'functionCall' => 'PHPExcel_Calculation_Functions::DUMMY',
545	'argumentCount' => '?'
546	),
547	'CUBERANKEDMEMBER' => array('category' => PHPExcel_Calculation_Function::CATEGORY_CUBE,
548	'functionCall' => 'PHPExcel_Calculation_Functions::DUMMY',
549	'argumentCount' => '?'
550	),
551	'CUBESET' => array('category' => PHPExcel_Calculation_Function::CATEGORY_CUBE,
552	'functionCall' => 'PHPExcel_Calculation_Functions::DUMMY',
553	'argumentCount' => '?'
554	),
555	'CUBESETCOUNT' => array('category' => PHPExcel_Calculation_Function::CATEGORY_CUBE,
556	'functionCall' => 'PHPExcel_Calculation_Functions::DUMMY',
557	'argumentCount' => '?'
558	),
559	'CUBEVALUE' => array('category' => PHPExcel_Calculation_Function::CATEGORY_CUBE,
560	'functionCall' => 'PHPExcel_Calculation_Functions::DUMMY',
561	'argumentCount' => '?'
562	),
563	'CUMIPMT' => array('category' => PHPExcel_Calculation_Function::CATEGORY_FINANCIAL,
564	'functionCall' => 'PHPExcel_Calculation_Financial::CUMIPMT',
565	'argumentCount' => '6'
566	),
567	'CUMPRINC' => array('category' => PHPExcel_Calculation_Function::CATEGORY_FINANCIAL,
568	'functionCall' => 'PHPExcel_Calculation_Financial::CUMPRINC',
569	'argumentCount' => '6'
570	),
571	'DATE' => array('category' => PHPExcel_Calculation_Function::CATEGORY_DATE_AND_TIME,
572	'functionCall' => 'PHPExcel_Calculation_DateTime::DATE',
573	'argumentCount' => '3'
574	),
575	'DATEDIF' => array('category' => PHPExcel_Calculation_Function::CATEGORY_DATE_AND_TIME,
576	'functionCall' => 'PHPExcel_Calculation_DateTime::DATEDIF',
577	'argumentCount' => '2,3'
578	),
579	'DATEVALUE' => array('category' => PHPExcel_Calculation_Function::CATEGORY_DATE_AND_TIME,
580	'functionCall' => 'PHPExcel_Calculation_DateTime::DATEVALUE',
581	'argumentCount' => '1'
582	),
583	'DAVERAGE' => array('category' => PHPExcel_Calculation_Function::CATEGORY_DATABASE,
584	'functionCall' => 'PHPExcel_Calculation_Database::DAVERAGE',
585	'argumentCount' => '3'
586	),
587	'DAY' => array('category' => PHPExcel_Calculation_Function::CATEGORY_DATE_AND_TIME,
588	'functionCall' => 'PHPExcel_Calculation_DateTime::DAYOFMONTH',
589	'argumentCount' => '1'
590	),
591	'DAYS360' => array('category' => PHPExcel_Calculation_Function::CATEGORY_DATE_AND_TIME,
592	'functionCall' => 'PHPExcel_Calculation_DateTime::DAYS360',
593	'argumentCount' => '2,3'
594	),
595	'DB' => array('category' => PHPExcel_Calculation_Function::CATEGORY_FINANCIAL,
596	'functionCall' => 'PHPExcel_Calculation_Financial::DB',
597	'argumentCount' => '4,5'
598	),
599	'DCOUNT' => array('category' => PHPExcel_Calculation_Function::CATEGORY_DATABASE,
600	'functionCall' => 'PHPExcel_Calculation_Database::DCOUNT',
601	'argumentCount' => '3'
602	),
603	'DCOUNTA' => array('category' => PHPExcel_Calculation_Function::CATEGORY_DATABASE,
604	'functionCall' => 'PHPExcel_Calculation_Database::DCOUNTA',
605	'argumentCount' => '3'
606	),
607	'DDB' => array('category' => PHPExcel_Calculation_Function::CATEGORY_FINANCIAL,
608	'functionCall' => 'PHPExcel_Calculation_Financial::DDB',
609	'argumentCount' => '4,5'
610	),
611	'DEC2BIN' => array('category' => PHPExcel_Calculation_Function::CATEGORY_ENGINEERING,
612	'functionCall' => 'PHPExcel_Calculation_Engineering::DECTOBIN',
613	'argumentCount' => '1,2'
614	),
615	'DEC2HEX' => array('category' => PHPExcel_Calculation_Function::CATEGORY_ENGINEERING,
616	'functionCall' => 'PHPExcel_Calculation_Engineering::DECTOHEX',
617	'argumentCount' => '1,2'
618	),
619	'DEC2OCT' => array('category' => PHPExcel_Calculation_Function::CATEGORY_ENGINEERING,
620	'functionCall' => 'PHPExcel_Calculation_Engineering::DECTOOCT',
621	'argumentCount' => '1,2'
622	),
623	'DEGREES' => array('category' => PHPExcel_Calculation_Function::CATEGORY_MATH_AND_TRIG,
624	'functionCall' => 'rad2deg',
625	'argumentCount' => '1'
626	),
627	'DELTA' => array('category' => PHPExcel_Calculation_Function::CATEGORY_ENGINEERING,
628	'functionCall' => 'PHPExcel_Calculation_Engineering::DELTA',
629	'argumentCount' => '1,2'
630	),
631	'DEVSQ' => array('category' => PHPExcel_Calculation_Function::CATEGORY_STATISTICAL,
632	'functionCall' => 'PHPExcel_Calculation_Statistical::DEVSQ',
633	'argumentCount' => '1+'
634	),
635	'DGET' => array('category' => PHPExcel_Calculation_Function::CATEGORY_DATABASE,
636	'functionCall' => 'PHPExcel_Calculation_Database::DGET',
637	'argumentCount' => '3'
638	),
639	'DISC' => array('category' => PHPExcel_Calculation_Function::CATEGORY_FINANCIAL,
640	'functionCall' => 'PHPExcel_Calculation_Financial::DISC',
641	'argumentCount' => '4,5'
642	),
643	'DMAX' => array('category' => PHPExcel_Calculation_Function::CATEGORY_DATABASE,
644	'functionCall' => 'PHPExcel_Calculation_Database::DMAX',
645	'argumentCount' => '3'
646	),
647	'DMIN' => array('category' => PHPExcel_Calculation_Function::CATEGORY_DATABASE,
648	'functionCall' => 'PHPExcel_Calculation_Database::DMIN',
649	'argumentCount' => '3'
650	),
651	'DOLLAR' => array('category' => PHPExcel_Calculation_Function::CATEGORY_TEXT_AND_DATA,
652	'functionCall' => 'PHPExcel_Calculation_TextData::DOLLAR',
653	'argumentCount' => '1,2'
654	),
655	'DOLLARDE' => array('category' => PHPExcel_Calculation_Function::CATEGORY_FINANCIAL,
656	'functionCall' => 'PHPExcel_Calculation_Financial::DOLLARDE',
657	'argumentCount' => '2'
658	),
659	'DOLLARFR' => array('category' => PHPExcel_Calculation_Function::CATEGORY_FINANCIAL,
660	'functionCall' => 'PHPExcel_Calculation_Financial::DOLLARFR',
661	'argumentCount' => '2'
662	),
663	'DPRODUCT' => array('category' => PHPExcel_Calculation_Function::CATEGORY_DATABASE,
664	'functionCall' => 'PHPExcel_Calculation_Database::DPRODUCT',
665	'argumentCount' => '3'
666	),
667	'DSTDEV' => array('category' => PHPExcel_Calculation_Function::CATEGORY_DATABASE,
668	'functionCall' => 'PHPExcel_Calculation_Database::DSTDEV',
669	'argumentCount' => '3'
670	),
671	'DSTDEVP' => array('category' => PHPExcel_Calculation_Function::CATEGORY_DATABASE,
672	'functionCall' => 'PHPExcel_Calculation_Database::DSTDEVP',
673	'argumentCount' => '3'
674	),
675	'DSUM' => array('category' => PHPExcel_Calculation_Function::CATEGORY_DATABASE,
676	'functionCall' => 'PHPExcel_Calculation_Database::DSUM',
677	'argumentCount' => '3'
678	),
679	'DURATION' => array('category' => PHPExcel_Calculation_Function::CATEGORY_FINANCIAL,
680	'functionCall' => 'PHPExcel_Calculation_Functions::DUMMY',
681	'argumentCount' => '5,6'
682	),
683	'DVAR' => array('category' => PHPExcel_Calculation_Function::CATEGORY_DATABASE,
684	'functionCall' => 'PHPExcel_Calculation_Database::DVAR',
685	'argumentCount' => '3'
686	),
687	'DVARP' => array('category' => PHPExcel_Calculation_Function::CATEGORY_DATABASE,
688	'functionCall' => 'PHPExcel_Calculation_Database::DVARP',
689	'argumentCount' => '3'
690	),
691	'EDATE' => array('category' => PHPExcel_Calculation_Function::CATEGORY_DATE_AND_TIME,
692	'functionCall' => 'PHPExcel_Calculation_DateTime::EDATE',
693	'argumentCount' => '2'
694	),
695	'EFFECT' => array('category' => PHPExcel_Calculation_Function::CATEGORY_FINANCIAL,
696	'functionCall' => 'PHPExcel_Calculation_Financial::EFFECT',
697	'argumentCount' => '2'
698	),
699	'EOMONTH' => array('category' => PHPExcel_Calculation_Function::CATEGORY_DATE_AND_TIME,
700	'functionCall' => 'PHPExcel_Calculation_DateTime::EOMONTH',
701	'argumentCount' => '2'
702	),
703	'ERF' => array('category' => PHPExcel_Calculation_Function::CATEGORY_ENGINEERING,
704	'functionCall' => 'PHPExcel_Calculation_Engineering::ERF',
705	'argumentCount' => '1,2'
706	),
707	'ERFC' => array('category' => PHPExcel_Calculation_Function::CATEGORY_ENGINEERING,
708	'functionCall' => 'PHPExcel_Calculation_Engineering::ERFC',
709	'argumentCount' => '1'
710	),
711	'ERROR.TYPE' => array('category' => PHPExcel_Calculation_Function::CATEGORY_INFORMATION,
712	'functionCall' => 'PHPExcel_Calculation_Functions::ERROR_TYPE',
713	'argumentCount' => '1'
714	),
715	'EVEN' => array('category' => PHPExcel_Calculation_Function::CATEGORY_MATH_AND_TRIG,
716	'functionCall' => 'PHPExcel_Calculation_MathTrig::EVEN',
717	'argumentCount' => '1'
718	),
719	'EXACT' => array('category' => PHPExcel_Calculation_Function::CATEGORY_TEXT_AND_DATA,
720	'functionCall' => 'PHPExcel_Calculation_Functions::DUMMY',
721	'argumentCount' => '2'
722	),
723	'EXP' => array('category' => PHPExcel_Calculation_Function::CATEGORY_MATH_AND_TRIG,
724	'functionCall' => 'exp',
725	'argumentCount' => '1'
726	),
727	'EXPONDIST' => array('category' => PHPExcel_Calculation_Function::CATEGORY_STATISTICAL,
728	'functionCall' => 'PHPExcel_Calculation_Statistical::EXPONDIST',
729	'argumentCount' => '3'
730	),
731	'FACT' => array('category' => PHPExcel_Calculation_Function::CATEGORY_MATH_AND_TRIG,
732	'functionCall' => 'PHPExcel_Calculation_MathTrig::FACT',
733	'argumentCount' => '1'
734	),
735	'FACTDOUBLE' => array('category' => PHPExcel_Calculation_Function::CATEGORY_MATH_AND_TRIG,
736	'functionCall' => 'PHPExcel_Calculation_MathTrig::FACTDOUBLE',
737	'argumentCount' => '1'
738	),
739	'FALSE' => array('category' => PHPExcel_Calculation_Function::CATEGORY_LOGICAL,
740	'functionCall' => 'PHPExcel_Calculation_Logical::FALSE',
741	'argumentCount' => '0'
742	),
743	'FDIST' => array('category' => PHPExcel_Calculation_Function::CATEGORY_STATISTICAL,
744	'functionCall' => 'PHPExcel_Calculation_Functions::DUMMY',
745	'argumentCount' => '3'
746	),
747	'FIND' => array('category' => PHPExcel_Calculation_Function::CATEGORY_TEXT_AND_DATA,
748	'functionCall' => 'PHPExcel_Calculation_TextData::SEARCHSENSITIVE',
749	'argumentCount' => '2,3'
750	),
751	'FINDB' => array('category' => PHPExcel_Calculation_Function::CATEGORY_TEXT_AND_DATA,
752	'functionCall' => 'PHPExcel_Calculation_TextData::SEARCHSENSITIVE',
753	'argumentCount' => '2,3'
754	),
755	'FINV' => array('category' => PHPExcel_Calculation_Function::CATEGORY_STATISTICAL,
756	'functionCall' => 'PHPExcel_Calculation_Functions::DUMMY',
757	'argumentCount' => '3'
758	),
759	'FISHER' => array('category' => PHPExcel_Calculation_Function::CATEGORY_STATISTICAL,
760	'functionCall' => 'PHPExcel_Calculation_Statistical::FISHER',
761	'argumentCount' => '1'
762	),
763	'FISHERINV' => array('category' => PHPExcel_Calculation_Function::CATEGORY_STATISTICAL,
764	'functionCall' => 'PHPExcel_Calculation_Statistical::FISHERINV',
765	'argumentCount' => '1'
766	),
767	'FIXED' => array('category' => PHPExcel_Calculation_Function::CATEGORY_TEXT_AND_DATA,
768	'functionCall' => 'PHPExcel_Calculation_TextData::FIXEDFORMAT',
769	'argumentCount' => '1-3'
770	),
771	'FLOOR' => array('category' => PHPExcel_Calculation_Function::CATEGORY_MATH_AND_TRIG,
772	'functionCall' => 'PHPExcel_Calculation_MathTrig::FLOOR',
773	'argumentCount' => '2'
774	),
775	'FORECAST' => array('category' => PHPExcel_Calculation_Function::CATEGORY_STATISTICAL,
776	'functionCall' => 'PHPExcel_Calculation_Statistical::FORECAST',
777	'argumentCount' => '3'
778	),
779	'FREQUENCY' => array('category' => PHPExcel_Calculation_Function::CATEGORY_STATISTICAL,
780	'functionCall' => 'PHPExcel_Calculation_Functions::DUMMY',
781	'argumentCount' => '2'
782	),
783	'FTEST' => array('category' => PHPExcel_Calculation_Function::CATEGORY_STATISTICAL,
784	'functionCall' => 'PHPExcel_Calculation_Functions::DUMMY',
785	'argumentCount' => '2'
786	),
787	'FV' => array('category' => PHPExcel_Calculation_Function::CATEGORY_FINANCIAL,
788	'functionCall' => 'PHPExcel_Calculation_Financial::FV',
789	'argumentCount' => '3-5'
790	),
791	'FVSCHEDULE' => array('category' => PHPExcel_Calculation_Function::CATEGORY_FINANCIAL,
792	'functionCall' => 'PHPExcel_Calculation_Financial::FVSCHEDULE',
793	'argumentCount' => '2'
794	),
795	'GAMMADIST' => array('category' => PHPExcel_Calculation_Function::CATEGORY_STATISTICAL,
796	'functionCall' => 'PHPExcel_Calculation_Statistical::GAMMADIST',
797	'argumentCount' => '4'
798	),
799	'GAMMAINV' => array('category' => PHPExcel_Calculation_Function::CATEGORY_STATISTICAL,
800	'functionCall' => 'PHPExcel_Calculation_Statistical::GAMMAINV',
801	'argumentCount' => '3'
802	),
803	'GAMMALN' => array('category' => PHPExcel_Calculation_Function::CATEGORY_STATISTICAL,
804	'functionCall' => 'PHPExcel_Calculation_Statistical::GAMMALN',
805	'argumentCount' => '1'
806	),
807	'GCD' => array('category' => PHPExcel_Calculation_Function::CATEGORY_MATH_AND_TRIG,
808	'functionCall' => 'PHPExcel_Calculation_MathTrig::GCD',
809	'argumentCount' => '1+'
810	),
811	'GEOMEAN' => array('category' => PHPExcel_Calculation_Function::CATEGORY_STATISTICAL,
812	'functionCall' => 'PHPExcel_Calculation_Statistical::GEOMEAN',
813	'argumentCount' => '1+'
814	),
815	'GESTEP' => array('category' => PHPExcel_Calculation_Function::CATEGORY_ENGINEERING,
816	'functionCall' => 'PHPExcel_Calculation_Engineering::GESTEP',
817	'argumentCount' => '1,2'
818	),
819	'GETPIVOTDATA' => array('category' => PHPExcel_Calculation_Function::CATEGORY_LOOKUP_AND_REFERENCE,
820	'functionCall' => 'PHPExcel_Calculation_Functions::DUMMY',
821	'argumentCount' => '2+'
822	),
823	'GROWTH' => array('category' => PHPExcel_Calculation_Function::CATEGORY_STATISTICAL,
824	'functionCall' => 'PHPExcel_Calculation_Statistical::GROWTH',
825	'argumentCount' => '1-4'
826	),
827	'HARMEAN' => array('category' => PHPExcel_Calculation_Function::CATEGORY_STATISTICAL,
828	'functionCall' => 'PHPExcel_Calculation_Statistical::HARMEAN',
829	'argumentCount' => '1+'
830	),
831	'HEX2BIN' => array('category' => PHPExcel_Calculation_Function::CATEGORY_ENGINEERING,
832	'functionCall' => 'PHPExcel_Calculation_Engineering::HEXTOBIN',
833	'argumentCount' => '1,2'
834	),
835	'HEX2DEC' => array('category' => PHPExcel_Calculation_Function::CATEGORY_ENGINEERING,
836	'functionCall' => 'PHPExcel_Calculation_Engineering::HEXTODEC',
837	'argumentCount' => '1'
838	),
839	'HEX2OCT' => array('category' => PHPExcel_Calculation_Function::CATEGORY_ENGINEERING,
840	'functionCall' => 'PHPExcel_Calculation_Engineering::HEXTOOCT',
841	'argumentCount' => '1,2'
842	),
843	'HLOOKUP' => array('category' => PHPExcel_Calculation_Function::CATEGORY_LOOKUP_AND_REFERENCE,
844	'functionCall' => 'PHPExcel_Calculation_LookupRef::HLOOKUP',
845	'argumentCount' => '3,4'
846	),
847	'HOUR' => array('category' => PHPExcel_Calculation_Function::CATEGORY_DATE_AND_TIME,
848	'functionCall' => 'PHPExcel_Calculation_DateTime::HOUROFDAY',
849	'argumentCount' => '1'
850	),
851	'HYPERLINK' => array('category' => PHPExcel_Calculation_Function::CATEGORY_LOOKUP_AND_REFERENCE,
852	'functionCall' => 'PHPExcel_Calculation_LookupRef::HYPERLINK',
853	'argumentCount' => '1,2',
854	'passCellReference'=> TRUE
855	),
856	'HYPGEOMDIST' => array('category' => PHPExcel_Calculation_Function::CATEGORY_STATISTICAL,
857	'functionCall' => 'PHPExcel_Calculation_Statistical::HYPGEOMDIST',
858	'argumentCount' => '4'
859	),
860	'IF' => array('category' => PHPExcel_Calculation_Function::CATEGORY_LOGICAL,
861	'functionCall' => 'PHPExcel_Calculation_Logical::STATEMENT_IF',
862	'argumentCount' => '1-3'
863	),
864	'IFERROR' => array('category' => PHPExcel_Calculation_Function::CATEGORY_LOGICAL,
865	'functionCall' => 'PHPExcel_Calculation_Logical::IFERROR',
866	'argumentCount' => '2'
867	),
868	'IMABS' => array('category' => PHPExcel_Calculation_Function::CATEGORY_ENGINEERING,
869	'functionCall' => 'PHPExcel_Calculation_Engineering::IMABS',
870	'argumentCount' => '1'
871	),
872	'IMAGINARY' => array('category' => PHPExcel_Calculation_Function::CATEGORY_ENGINEERING,
873	'functionCall' => 'PHPExcel_Calculation_Engineering::IMAGINARY',
874	'argumentCount' => '1'
875	),
876	'IMARGUMENT' => array('category' => PHPExcel_Calculation_Function::CATEGORY_ENGINEERING,
877	'functionCall' => 'PHPExcel_Calculation_Engineering::IMARGUMENT',
878	'argumentCount' => '1'
879	),
880	'IMCONJUGATE' => array('category' => PHPExcel_Calculation_Function::CATEGORY_ENGINEERING,
881	'functionCall' => 'PHPExcel_Calculation_Engineering::IMCONJUGATE',
882	'argumentCount' => '1'
883	),
884	'IMCOS' => array('category' => PHPExcel_Calculation_Function::CATEGORY_ENGINEERING,
885	'functionCall' => 'PHPExcel_Calculation_Engineering::IMCOS',
886	'argumentCount' => '1'
887	),
888	'IMDIV' => array('category' => PHPExcel_Calculation_Function::CATEGORY_ENGINEERING,
889	'functionCall' => 'PHPExcel_Calculation_Engineering::IMDIV',
890	'argumentCount' => '2'
891	),
892	'IMEXP' => array('category' => PHPExcel_Calculation_Function::CATEGORY_ENGINEERING,
893	'functionCall' => 'PHPExcel_Calculation_Engineering::IMEXP',
894	'argumentCount' => '1'
895	),
896	'IMLN' => array('category' => PHPExcel_Calculation_Function::CATEGORY_ENGINEERING,
897	'functionCall' => 'PHPExcel_Calculation_Engineering::IMLN',
898	'argumentCount' => '1'
899	),
900	'IMLOG10' => array('category' => PHPExcel_Calculation_Function::CATEGORY_ENGINEERING,
901	'functionCall' => 'PHPExcel_Calculation_Engineering::IMLOG10',
902	'argumentCount' => '1'
903	),
904	'IMLOG2' => array('category' => PHPExcel_Calculation_Function::CATEGORY_ENGINEERING,
905	'functionCall' => 'PHPExcel_Calculation_Engineering::IMLOG2',
906	'argumentCount' => '1'
907	),
908	'IMPOWER' => array('category' => PHPExcel_Calculation_Function::CATEGORY_ENGINEERING,
909	'functionCall' => 'PHPExcel_Calculation_Engineering::IMPOWER',
910	'argumentCount' => '2'
911	),
912	'IMPRODUCT' => array('category' => PHPExcel_Calculation_Function::CATEGORY_ENGINEERING,
913	'functionCall' => 'PHPExcel_Calculation_Engineering::IMPRODUCT',
914	'argumentCount' => '1+'
915	),
916	'IMREAL' => array('category' => PHPExcel_Calculation_Function::CATEGORY_ENGINEERING,
917	'functionCall' => 'PHPExcel_Calculation_Engineering::IMREAL',
918	'argumentCount' => '1'
919	),
920	'IMSIN' => array('category' => PHPExcel_Calculation_Function::CATEGORY_ENGINEERING,
921	'functionCall' => 'PHPExcel_Calculation_Engineering::IMSIN',
922	'argumentCount' => '1'
923	),
924	'IMSQRT' => array('category' => PHPExcel_Calculation_Function::CATEGORY_ENGINEERING,
925	'functionCall' => 'PHPExcel_Calculation_Engineering::IMSQRT',
926	'argumentCount' => '1'
927	),
928	'IMSUB' => array('category' => PHPExcel_Calculation_Function::CATEGORY_ENGINEERING,
929	'functionCall' => 'PHPExcel_Calculation_Engineering::IMSUB',
930	'argumentCount' => '2'
931	),
932	'IMSUM' => array('category' => PHPExcel_Calculation_Function::CATEGORY_ENGINEERING,
933	'functionCall' => 'PHPExcel_Calculation_Engineering::IMSUM',
934	'argumentCount' => '1+'
935	),
936	'INDEX' => array('category' => PHPExcel_Calculation_Function::CATEGORY_LOOKUP_AND_REFERENCE,
937	'functionCall' => 'PHPExcel_Calculation_LookupRef::INDEX',
938	'argumentCount' => '1-4'
939	),
940	'INDIRECT' => array('category' => PHPExcel_Calculation_Function::CATEGORY_LOOKUP_AND_REFERENCE,
941	'functionCall' => 'PHPExcel_Calculation_LookupRef::INDIRECT',
942	'argumentCount' => '1,2',
943	'passCellReference'=> TRUE
944	),
945	'INFO' => array('category' => PHPExcel_Calculation_Function::CATEGORY_INFORMATION,
946	'functionCall' => 'PHPExcel_Calculation_Functions::DUMMY',
947	'argumentCount' => '1'
948	),
949	'INT' => array('category' => PHPExcel_Calculation_Function::CATEGORY_MATH_AND_TRIG,
950	'functionCall' => 'PHPExcel_Calculation_MathTrig::INT',
951	'argumentCount' => '1'
952	),
953	'INTERCEPT' => array('category' => PHPExcel_Calculation_Function::CATEGORY_STATISTICAL,
954	'functionCall' => 'PHPExcel_Calculation_Statistical::INTERCEPT',
955	'argumentCount' => '2'
956	),
957	'INTRATE' => array('category' => PHPExcel_Calculation_Function::CATEGORY_FINANCIAL,
958	'functionCall' => 'PHPExcel_Calculation_Financial::INTRATE',
959	'argumentCount' => '4,5'
960	),
961	'IPMT' => array('category' => PHPExcel_Calculation_Function::CATEGORY_FINANCIAL,
962	'functionCall' => 'PHPExcel_Calculation_Financial::IPMT',
963	'argumentCount' => '4-6'
964	),
965	'IRR' => array('category' => PHPExcel_Calculation_Function::CATEGORY_FINANCIAL,
966	'functionCall' => 'PHPExcel_Calculation_Financial::IRR',
967	'argumentCount' => '1,2'
968	),
969	'ISBLANK' => array('category' => PHPExcel_Calculation_Function::CATEGORY_INFORMATION,
970	'functionCall' => 'PHPExcel_Calculation_Functions::IS_BLANK',
971	'argumentCount' => '1'
972	),
973	'ISERR' => array('category' => PHPExcel_Calculation_Function::CATEGORY_INFORMATION,
974	'functionCall' => 'PHPExcel_Calculation_Functions::IS_ERR',
975	'argumentCount' => '1'
976	),
977	'ISERROR' => array('category' => PHPExcel_Calculation_Function::CATEGORY_INFORMATION,
978	'functionCall' => 'PHPExcel_Calculation_Functions::IS_ERROR',
979	'argumentCount' => '1'
980	),
981	'ISEVEN' => array('category' => PHPExcel_Calculation_Function::CATEGORY_INFORMATION,
982	'functionCall' => 'PHPExcel_Calculation_Functions::IS_EVEN',
983	'argumentCount' => '1'
984	),
985	'ISLOGICAL' => array('category' => PHPExcel_Calculation_Function::CATEGORY_INFORMATION,
986	'functionCall' => 'PHPExcel_Calculation_Functions::IS_LOGICAL',
987	'argumentCount' => '1'
988	),
989	'ISNA' => array('category' => PHPExcel_Calculation_Function::CATEGORY_INFORMATION,
990	'functionCall' => 'PHPExcel_Calculation_Functions::IS_NA',
991	'argumentCount' => '1'
992	),
993	'ISNONTEXT' => array('category' => PHPExcel_Calculation_Function::CATEGORY_INFORMATION,
994	'functionCall' => 'PHPExcel_Calculation_Functions::IS_NONTEXT',
995	'argumentCount' => '1'
996	),
997	'ISNUMBER' => array('category' => PHPExcel_Calculation_Function::CATEGORY_INFORMATION,
998	'functionCall' => 'PHPExcel_Calculation_Functions::IS_NUMBER',
999	'argumentCount' => '1'
1000	),
1001	'ISODD' => array('category' => PHPExcel_Calculation_Function::CATEGORY_INFORMATION,
1002	'functionCall' => 'PHPExcel_Calculation_Functions::IS_ODD',
1003	'argumentCount' => '1'
1004	),
1005	'ISPMT' => array('category' => PHPExcel_Calculation_Function::CATEGORY_FINANCIAL,
1006	'functionCall' => 'PHPExcel_Calculation_Financial::ISPMT',
1007	'argumentCount' => '4'
1008	),
1009	'ISREF' => array('category' => PHPExcel_Calculation_Function::CATEGORY_INFORMATION,
1010	'functionCall' => 'PHPExcel_Calculation_Functions::DUMMY',
1011	'argumentCount' => '1'
1012	),
1013	'ISTEXT' => array('category' => PHPExcel_Calculation_Function::CATEGORY_INFORMATION,
1014	'functionCall' => 'PHPExcel_Calculation_Functions::IS_TEXT',
1015	'argumentCount' => '1'
1016	),
1017	'JIS' => array('category' => PHPExcel_Calculation_Function::CATEGORY_TEXT_AND_DATA,
1018	'functionCall' => 'PHPExcel_Calculation_Functions::DUMMY',
1019	'argumentCount' => '1'
1020	),
1021	'KURT' => array('category' => PHPExcel_Calculation_Function::CATEGORY_STATISTICAL,
1022	'functionCall' => 'PHPExcel_Calculation_Statistical::KURT',
1023	'argumentCount' => '1+'
1024	),
1025	'LARGE' => array('category' => PHPExcel_Calculation_Function::CATEGORY_STATISTICAL,
1026	'functionCall' => 'PHPExcel_Calculation_Statistical::LARGE',
1027	'argumentCount' => '2'
1028	),
1029	'LCM' => array('category' => PHPExcel_Calculation_Function::CATEGORY_MATH_AND_TRIG,
1030	'functionCall' => 'PHPExcel_Calculation_MathTrig::LCM',
1031	'argumentCount' => '1+'
1032	),
1033	'LEFT' => array('category' => PHPExcel_Calculation_Function::CATEGORY_TEXT_AND_DATA,
1034	'functionCall' => 'PHPExcel_Calculation_TextData::LEFT',
1035	'argumentCount' => '1,2'
1036	),
1037	'LEFTB' => array('category' => PHPExcel_Calculation_Function::CATEGORY_TEXT_AND_DATA,
1038	'functionCall' => 'PHPExcel_Calculation_TextData::LEFT',
1039	'argumentCount' => '1,2'
1040	),
1041	'LEN' => array('category' => PHPExcel_Calculation_Function::CATEGORY_TEXT_AND_DATA,
1042	'functionCall' => 'PHPExcel_Calculation_TextData::STRINGLENGTH',
1043	'argumentCount' => '1'
1044	),
1045	'LENB' => array('category' => PHPExcel_Calculation_Function::CATEGORY_TEXT_AND_DATA,
1046	'functionCall' => 'PHPExcel_Calculation_TextData::STRINGLENGTH',
1047	'argumentCount' => '1'
1048	),
1049	'LINEST' => array('category' => PHPExcel_Calculation_Function::CATEGORY_STATISTICAL,
1050	'functionCall' => 'PHPExcel_Calculation_Statistical::LINEST',
1051	'argumentCount' => '1-4'
1052	),
1053	'LN' => array('category' => PHPExcel_Calculation_Function::CATEGORY_MATH_AND_TRIG,
1054	'functionCall' => 'log',
1055	'argumentCount' => '1'
1056	),
1057	'LOG' => array('category' => PHPExcel_Calculation_Function::CATEGORY_MATH_AND_TRIG,
1058	'functionCall' => 'PHPExcel_Calculation_MathTrig::LOG_BASE',
1059	'argumentCount' => '1,2'
1060	),
1061	'LOG10' => array('category' => PHPExcel_Calculation_Function::CATEGORY_MATH_AND_TRIG,
1062	'functionCall' => 'log10',
1063	'argumentCount' => '1'
1064	),
1065	'LOGEST' => array('category' => PHPExcel_Calculation_Function::CATEGORY_STATISTICAL,
1066	'functionCall' => 'PHPExcel_Calculation_Statistical::LOGEST',
1067	'argumentCount' => '1-4'
1068	),
1069	'LOGINV' => array('category' => PHPExcel_Calculation_Function::CATEGORY_STATISTICAL,
1070	'functionCall' => 'PHPExcel_Calculation_Statistical::LOGINV',
1071	'argumentCount' => '3'
1072	),
1073	'LOGNORMDIST' => array('category' => PHPExcel_Calculation_Function::CATEGORY_STATISTICAL,
1074	'functionCall' => 'PHPExcel_Calculation_Statistical::LOGNORMDIST',
1075	'argumentCount' => '3'
1076	),
1077	'LOOKUP' => array('category' => PHPExcel_Calculation_Function::CATEGORY_LOOKUP_AND_REFERENCE,
1078	'functionCall' => 'PHPExcel_Calculation_LookupRef::LOOKUP',
1079	'argumentCount' => '2,3'
1080	),
1081	'LOWER' => array('category' => PHPExcel_Calculation_Function::CATEGORY_TEXT_AND_DATA,
1082	'functionCall' => 'PHPExcel_Calculation_TextData::LOWERCASE',
1083	'argumentCount' => '1'
1084	),
1085	'MATCH' => array('category' => PHPExcel_Calculation_Function::CATEGORY_LOOKUP_AND_REFERENCE,
1086	'functionCall' => 'PHPExcel_Calculation_LookupRef::MATCH',
1087	'argumentCount' => '2,3'
1088	),
1089	'MAX' => array('category' => PHPExcel_Calculation_Function::CATEGORY_STATISTICAL,
1090	'functionCall' => 'PHPExcel_Calculation_Statistical::MAX',
1091	'argumentCount' => '1+'
1092	),
1093	'MAXA' => array('category' => PHPExcel_Calculation_Function::CATEGORY_STATISTICAL,
1094	'functionCall' => 'PHPExcel_Calculation_Statistical::MAXA',
1095	'argumentCount' => '1+'
1096	),
1097	'MAXIF' => array('category' => PHPExcel_Calculation_Function::CATEGORY_STATISTICAL,
1098	'functionCall' => 'PHPExcel_Calculation_Statistical::MAXIF',
1099	'argumentCount' => '2+'
1100	),
1101	'MDETERM' => array('category' => PHPExcel_Calculation_Function::CATEGORY_MATH_AND_TRIG,
1102	'functionCall' => 'PHPExcel_Calculation_MathTrig::MDETERM',
1103	'argumentCount' => '1'
1104	),
1105	'MDURATION' => array('category' => PHPExcel_Calculation_Function::CATEGORY_FINANCIAL,
1106	'functionCall' => 'PHPExcel_Calculation_Functions::DUMMY',
1107	'argumentCount' => '5,6'
1108	),
1109	'MEDIAN' => array('category' => PHPExcel_Calculation_Function::CATEGORY_STATISTICAL,
1110	'functionCall' => 'PHPExcel_Calculation_Statistical::MEDIAN',
1111	'argumentCount' => '1+'
1112	),
1113	'MEDIANIF' => array('category' => PHPExcel_Calculation_Function::CATEGORY_STATISTICAL,
1114	'functionCall' => 'PHPExcel_Calculation_Functions::DUMMY',
1115	'argumentCount' => '2+'
1116	),
1117	'MID' => array('category' => PHPExcel_Calculation_Function::CATEGORY_TEXT_AND_DATA,
1118	'functionCall' => 'PHPExcel_Calculation_TextData::MID',
1119	'argumentCount' => '3'
1120	),
1121	'MIDB' => array('category' => PHPExcel_Calculation_Function::CATEGORY_TEXT_AND_DATA,
1122	'functionCall' => 'PHPExcel_Calculation_TextData::MID',
1123	'argumentCount' => '3'
1124	),
1125	'MIN' => array('category' => PHPExcel_Calculation_Function::CATEGORY_STATISTICAL,
1126	'functionCall' => 'PHPExcel_Calculation_Statistical::MIN',
1127	'argumentCount' => '1+'
1128	),
1129	'MINA' => array('category' => PHPExcel_Calculation_Function::CATEGORY_STATISTICAL,
1130	'functionCall' => 'PHPExcel_Calculation_Statistical::MINA',
1131	'argumentCount' => '1+'
1132	),
1133	'MINIF' => array('category' => PHPExcel_Calculation_Function::CATEGORY_STATISTICAL,
1134	'functionCall' => 'PHPExcel_Calculation_Statistical::MINIF',
1135	'argumentCount' => '2+'
1136	),
1137	'MINUTE' => array('category' => PHPExcel_Calculation_Function::CATEGORY_DATE_AND_TIME,
1138	'functionCall' => 'PHPExcel_Calculation_DateTime::MINUTEOFHOUR',
1139	'argumentCount' => '1'
1140	),
1141	'MINVERSE' => array('category' => PHPExcel_Calculation_Function::CATEGORY_MATH_AND_TRIG,
1142	'functionCall' => 'PHPExcel_Calculation_MathTrig::MINVERSE',
1143	'argumentCount' => '1'
1144	),
1145	'MIRR' => array('category' => PHPExcel_Calculation_Function::CATEGORY_FINANCIAL,
1146	'functionCall' => 'PHPExcel_Calculation_Financial::MIRR',
1147	'argumentCount' => '3'
1148	),
1149	'MMULT' => array('category' => PHPExcel_Calculation_Function::CATEGORY_MATH_AND_TRIG,
1150	'functionCall' => 'PHPExcel_Calculation_MathTrig::MMULT',
1151	'argumentCount' => '2'
1152	),
1153	'MOD' => array('category' => PHPExcel_Calculation_Function::CATEGORY_MATH_AND_TRIG,
1154	'functionCall' => 'PHPExcel_Calculation_MathTrig::MOD',
1155	'argumentCount' => '2'
1156	),
1157	'MODE' => array('category' => PHPExcel_Calculation_Function::CATEGORY_STATISTICAL,
1158	'functionCall' => 'PHPExcel_Calculation_Statistical::MODE',
1159	'argumentCount' => '1+'
1160	),
1161	'MONTH' => array('category' => PHPExcel_Calculation_Function::CATEGORY_DATE_AND_TIME,
1162	'functionCall' => 'PHPExcel_Calculation_DateTime::MONTHOFYEAR',
1163	'argumentCount' => '1'
1164	),
1165	'MROUND' => array('category' => PHPExcel_Calculation_Function::CATEGORY_MATH_AND_TRIG,
1166	'functionCall' => 'PHPExcel_Calculation_MathTrig::MROUND',
1167	'argumentCount' => '2'
1168	),
1169	'MULTINOMIAL' => array('category' => PHPExcel_Calculation_Function::CATEGORY_MATH_AND_TRIG,
1170	'functionCall' => 'PHPExcel_Calculation_MathTrig::MULTINOMIAL',
1171	'argumentCount' => '1+'
1172	),
1173	'N' => array('category' => PHPExcel_Calculation_Function::CATEGORY_INFORMATION,
1174	'functionCall' => 'PHPExcel_Calculation_Functions::N',
1175	'argumentCount' => '1'
1176	),
1177	'NA' => array('category' => PHPExcel_Calculation_Function::CATEGORY_INFORMATION,
1178	'functionCall' => 'PHPExcel_Calculation_Functions::NA',
1179	'argumentCount' => '0'
1180	),
1181	'NEGBINOMDIST' => array('category' => PHPExcel_Calculation_Function::CATEGORY_STATISTICAL,
1182	'functionCall' => 'PHPExcel_Calculation_Statistical::NEGBINOMDIST',
1183	'argumentCount' => '3'
1184	),
1185	'NETWORKDAYS' => array('category' => PHPExcel_Calculation_Function::CATEGORY_DATE_AND_TIME,
1186	'functionCall' => 'PHPExcel_Calculation_DateTime::NETWORKDAYS',
1187	'argumentCount' => '2+'
1188	),
1189	'NOMINAL' => array('category' => PHPExcel_Calculation_Function::CATEGORY_FINANCIAL,
1190	'functionCall' => 'PHPExcel_Calculation_Financial::NOMINAL',
1191	'argumentCount' => '2'
1192	),
1193	'NORMDIST' => array('category' => PHPExcel_Calculation_Function::CATEGORY_STATISTICAL,
1194	'functionCall' => 'PHPExcel_Calculation_Statistical::NORMDIST',
1195	'argumentCount' => '4'
1196	),
1197	'NORMINV' => array('category' => PHPExcel_Calculation_Function::CATEGORY_STATISTICAL,
1198	'functionCall' => 'PHPExcel_Calculation_Statistical::NORMINV',
1199	'argumentCount' => '3'
1200	),
1201	'NORMSDIST' => array('category' => PHPExcel_Calculation_Function::CATEGORY_STATISTICAL,
1202	'functionCall' => 'PHPExcel_Calculation_Statistical::NORMSDIST',
1203	'argumentCount' => '1'
1204	),
1205	'NORMSINV' => array('category' => PHPExcel_Calculation_Function::CATEGORY_STATISTICAL,
1206	'functionCall' => 'PHPExcel_Calculation_Statistical::NORMSINV',
1207	'argumentCount' => '1'
1208	),
1209	'NOT' => array('category' => PHPExcel_Calculation_Function::CATEGORY_LOGICAL,
1210	'functionCall' => 'PHPExcel_Calculation_Logical::NOT',
1211	'argumentCount' => '1'
1212	),
1213	'NOW' => array('category' => PHPExcel_Calculation_Function::CATEGORY_DATE_AND_TIME,
1214	'functionCall' => 'PHPExcel_Calculation_DateTime::DATETIMENOW',
1215	'argumentCount' => '0'
1216	),
1217	'NPER' => array('category' => PHPExcel_Calculation_Function::CATEGORY_FINANCIAL,
1218	'functionCall' => 'PHPExcel_Calculation_Financial::NPER',
1219	'argumentCount' => '3-5'
1220	),
1221	'NPV' => array('category' => PHPExcel_Calculation_Function::CATEGORY_FINANCIAL,
1222	'functionCall' => 'PHPExcel_Calculation_Financial::NPV',
1223	'argumentCount' => '2+'
1224	),
1225	'OCT2BIN' => array('category' => PHPExcel_Calculation_Function::CATEGORY_ENGINEERING,
1226	'functionCall' => 'PHPExcel_Calculation_Engineering::OCTTOBIN',
1227	'argumentCount' => '1,2'
1228	),
1229	'OCT2DEC' => array('category' => PHPExcel_Calculation_Function::CATEGORY_ENGINEERING,
1230	'functionCall' => 'PHPExcel_Calculation_Engineering::OCTTODEC',
1231	'argumentCount' => '1'
1232	),
1233	'OCT2HEX' => array('category' => PHPExcel_Calculation_Function::CATEGORY_ENGINEERING,
1234	'functionCall' => 'PHPExcel_Calculation_Engineering::OCTTOHEX',
1235	'argumentCount' => '1,2'
1236	),
1237	'ODD' => array('category' => PHPExcel_Calculation_Function::CATEGORY_MATH_AND_TRIG,
1238	'functionCall' => 'PHPExcel_Calculation_MathTrig::ODD',
1239	'argumentCount' => '1'
1240	),
1241	'ODDFPRICE' => array('category' => PHPExcel_Calculation_Function::CATEGORY_FINANCIAL,
1242	'functionCall' => 'PHPExcel_Calculation_Functions::DUMMY',
1243	'argumentCount' => '8,9'
1244	),
1245	'ODDFYIELD' => array('category' => PHPExcel_Calculation_Function::CATEGORY_FINANCIAL,
1246	'functionCall' => 'PHPExcel_Calculation_Functions::DUMMY',
1247	'argumentCount' => '8,9'
1248	),
1249	'ODDLPRICE' => array('category' => PHPExcel_Calculation_Function::CATEGORY_FINANCIAL,
1250	'functionCall' => 'PHPExcel_Calculation_Functions::DUMMY',
1251	'argumentCount' => '7,8'
1252	),
1253	'ODDLYIELD' => array('category' => PHPExcel_Calculation_Function::CATEGORY_FINANCIAL,
1254	'functionCall' => 'PHPExcel_Calculation_Functions::DUMMY',
1255	'argumentCount' => '7,8'
1256	),
1257	'OFFSET' => array('category' => PHPExcel_Calculation_Function::CATEGORY_LOOKUP_AND_REFERENCE,
1258	'functionCall' => 'PHPExcel_Calculation_LookupRef::OFFSET',
1259	'argumentCount' => '3,5',
1260	'passCellReference'=> TRUE,
1261	'passByReference' => array(TRUE)
1262	),
1263	'OR' => array('category' => PHPExcel_Calculation_Function::CATEGORY_LOGICAL,
1264	'functionCall' => 'PHPExcel_Calculation_Logical::LOGICAL_OR',
1265	'argumentCount' => '1+'
1266	),
1267	'PEARSON' => array('category' => PHPExcel_Calculation_Function::CATEGORY_STATISTICAL,
1268	'functionCall' => 'PHPExcel_Calculation_Statistical::CORREL',
1269	'argumentCount' => '2'
1270	),
1271	'PERCENTILE' => array('category' => PHPExcel_Calculation_Function::CATEGORY_STATISTICAL,
1272	'functionCall' => 'PHPExcel_Calculation_Statistical::PERCENTILE',
1273	'argumentCount' => '2'
1274	),
1275	'PERCENTRANK' => array('category' => PHPExcel_Calculation_Function::CATEGORY_STATISTICAL,
1276	'functionCall' => 'PHPExcel_Calculation_Statistical::PERCENTRANK',
1277	'argumentCount' => '2,3'
1278	),
1279	'PERMUT' => array('category' => PHPExcel_Calculation_Function::CATEGORY_STATISTICAL,
1280	'functionCall' => 'PHPExcel_Calculation_Statistical::PERMUT',
1281	'argumentCount' => '2'
1282	),
1283	'PHONETIC' => array('category' => PHPExcel_Calculation_Function::CATEGORY_TEXT_AND_DATA,
1284	'functionCall' => 'PHPExcel_Calculation_Functions::DUMMY',
1285	'argumentCount' => '1'
1286	),
1287	'PI' => array('category' => PHPExcel_Calculation_Function::CATEGORY_MATH_AND_TRIG,
1288	'functionCall' => 'pi',
1289	'argumentCount' => '0'
1290	),
1291	'PMT' => array('category' => PHPExcel_Calculation_Function::CATEGORY_FINANCIAL,
1292	'functionCall' => 'PHPExcel_Calculation_Financial::PMT',
1293	'argumentCount' => '3-5'
1294	),
1295	'POISSON' => array('category' => PHPExcel_Calculation_Function::CATEGORY_STATISTICAL,
1296	'functionCall' => 'PHPExcel_Calculation_Statistical::POISSON',
1297	'argumentCount' => '3'
1298	),
1299	'POWER' => array('category' => PHPExcel_Calculation_Function::CATEGORY_MATH_AND_TRIG,
1300	'functionCall' => 'PHPExcel_Calculation_MathTrig::POWER',
1301	'argumentCount' => '2'
1302	),
1303	'PPMT' => array('category' => PHPExcel_Calculation_Function::CATEGORY_FINANCIAL,
1304	'functionCall' => 'PHPExcel_Calculation_Financial::PPMT',
1305	'argumentCount' => '4-6'
1306	),
1307	'PRICE' => array('category' => PHPExcel_Calculation_Function::CATEGORY_FINANCIAL,
1308	'functionCall' => 'PHPExcel_Calculation_Financial::PRICE',
1309	'argumentCount' => '6,7'
1310	),
1311	'PRICEDISC' => array('category' => PHPExcel_Calculation_Function::CATEGORY_FINANCIAL,
1312	'functionCall' => 'PHPExcel_Calculation_Financial::PRICEDISC',
1313	'argumentCount' => '4,5'
1314	),
1315	'PRICEMAT' => array('category' => PHPExcel_Calculation_Function::CATEGORY_FINANCIAL,
1316	'functionCall' => 'PHPExcel_Calculation_Financial::PRICEMAT',
1317	'argumentCount' => '5,6'
1318	),
1319	'PROB' => array('category' => PHPExcel_Calculation_Function::CATEGORY_STATISTICAL,
1320	'functionCall' => 'PHPExcel_Calculation_Functions::DUMMY',
1321	'argumentCount' => '3,4'
1322	),
1323	'PRODUCT' => array('category' => PHPExcel_Calculation_Function::CATEGORY_MATH_AND_TRIG,
1324	'functionCall' => 'PHPExcel_Calculation_MathTrig::PRODUCT',
1325	'argumentCount' => '1+'
1326	),
1327	'PROPER' => array('category' => PHPExcel_Calculation_Function::CATEGORY_TEXT_AND_DATA,
1328	'functionCall' => 'PHPExcel_Calculation_TextData::PROPERCASE',
1329	'argumentCount' => '1'
1330	),
1331	'PV' => array('category' => PHPExcel_Calculation_Function::CATEGORY_FINANCIAL,
1332	'functionCall' => 'PHPExcel_Calculation_Financial::PV',
1333	'argumentCount' => '3-5'
1334	),
1335	'QUARTILE' => array('category' => PHPExcel_Calculation_Function::CATEGORY_STATISTICAL,
1336	'functionCall' => 'PHPExcel_Calculation_Statistical::QUARTILE',
1337	'argumentCount' => '2'
1338	),
1339	'QUOTIENT' => array('category' => PHPExcel_Calculation_Function::CATEGORY_MATH_AND_TRIG,
1340	'functionCall' => 'PHPExcel_Calculation_MathTrig::QUOTIENT',
1341	'argumentCount' => '2'
1342	),
1343	'RADIANS' => array('category' => PHPExcel_Calculation_Function::CATEGORY_MATH_AND_TRIG,
1344	'functionCall' => 'deg2rad',
1345	'argumentCount' => '1'
1346	),
1347	'RAND' => array('category' => PHPExcel_Calculation_Function::CATEGORY_MATH_AND_TRIG,
1348	'functionCall' => 'PHPExcel_Calculation_MathTrig::RAND',
1349	'argumentCount' => '0'
1350	),
1351	'RANDBETWEEN' => array('category' => PHPExcel_Calculation_Function::CATEGORY_MATH_AND_TRIG,
1352	'functionCall' => 'PHPExcel_Calculation_MathTrig::RAND',
1353	'argumentCount' => '2'
1354	),
1355	'RANK' => array('category' => PHPExcel_Calculation_Function::CATEGORY_STATISTICAL,
1356	'functionCall' => 'PHPExcel_Calculation_Statistical::RANK',
1357	'argumentCount' => '2,3'
1358	),
1359	'RATE' => array('category' => PHPExcel_Calculation_Function::CATEGORY_FINANCIAL,
1360	'functionCall' => 'PHPExcel_Calculation_Financial::RATE',
1361	'argumentCount' => '3-6'
1362	),
1363	'RECEIVED' => array('category' => PHPExcel_Calculation_Function::CATEGORY_FINANCIAL,
1364	'functionCall' => 'PHPExcel_Calculation_Financial::RECEIVED',
1365	'argumentCount' => '4-5'
1366	),
1367	'REPLACE' => array('category' => PHPExcel_Calculation_Function::CATEGORY_TEXT_AND_DATA,
1368	'functionCall' => 'PHPExcel_Calculation_TextData::REPLACE',
1369	'argumentCount' => '4'
1370	),
1371	'REPLACEB' => array('category' => PHPExcel_Calculation_Function::CATEGORY_TEXT_AND_DATA,
1372	'functionCall' => 'PHPExcel_Calculation_TextData::REPLACE',
1373	'argumentCount' => '4'
1374	),
1375	'REPT' => array('category' => PHPExcel_Calculation_Function::CATEGORY_TEXT_AND_DATA,
1376	'functionCall' => 'str_repeat',
1377	'argumentCount' => '2'
1378	),
1379	'RIGHT' => array('category' => PHPExcel_Calculation_Function::CATEGORY_TEXT_AND_DATA,
1380	'functionCall' => 'PHPExcel_Calculation_TextData::RIGHT',
1381	'argumentCount' => '1,2'
1382	),
1383	'RIGHTB' => array('category' => PHPExcel_Calculation_Function::CATEGORY_TEXT_AND_DATA,
1384	'functionCall' => 'PHPExcel_Calculation_TextData::RIGHT',
1385	'argumentCount' => '1,2'
1386	),
1387	'ROMAN' => array('category' => PHPExcel_Calculation_Function::CATEGORY_MATH_AND_TRIG,
1388	'functionCall' => 'PHPExcel_Calculation_MathTrig::ROMAN',
1389	'argumentCount' => '1,2'
1390	),
1391	'ROUND' => array('category' => PHPExcel_Calculation_Function::CATEGORY_MATH_AND_TRIG,
1392	'functionCall' => 'round',
1393	'argumentCount' => '2'
1394	),
1395	'ROUNDDOWN' => array('category' => PHPExcel_Calculation_Function::CATEGORY_MATH_AND_TRIG,
1396	'functionCall' => 'PHPExcel_Calculation_MathTrig::ROUNDDOWN',
1397	'argumentCount' => '2'
1398	),
1399	'ROUNDUP' => array('category' => PHPExcel_Calculation_Function::CATEGORY_MATH_AND_TRIG,
1400	'functionCall' => 'PHPExcel_Calculation_MathTrig::ROUNDUP',
1401	'argumentCount' => '2'
1402	),
1403	'ROW' => array('category' => PHPExcel_Calculation_Function::CATEGORY_LOOKUP_AND_REFERENCE,
1404	'functionCall' => 'PHPExcel_Calculation_LookupRef::ROW',
1405	'argumentCount' => '-1',
1406	'passByReference' => array(TRUE)
1407	),
1408	'ROWS' => array('category' => PHPExcel_Calculation_Function::CATEGORY_LOOKUP_AND_REFERENCE,
1409	'functionCall' => 'PHPExcel_Calculation_LookupRef::ROWS',
1410	'argumentCount' => '1'
1411	),
1412	'RSQ' => array('category' => PHPExcel_Calculation_Function::CATEGORY_STATISTICAL,
1413	'functionCall' => 'PHPExcel_Calculation_Statistical::RSQ',
1414	'argumentCount' => '2'
1415	),
1416	'RTD' => array('category' => PHPExcel_Calculation_Function::CATEGORY_LOOKUP_AND_REFERENCE,
1417	'functionCall' => 'PHPExcel_Calculation_Functions::DUMMY',
1418	'argumentCount' => '1+'
1419	),
1420	'SEARCH' => array('category' => PHPExcel_Calculation_Function::CATEGORY_TEXT_AND_DATA,
1421	'functionCall' => 'PHPExcel_Calculation_TextData::SEARCHINSENSITIVE',
1422	'argumentCount' => '2,3'
1423	),
1424	'SEARCHB' => array('category' => PHPExcel_Calculation_Function::CATEGORY_TEXT_AND_DATA,
1425	'functionCall' => 'PHPExcel_Calculation_TextData::SEARCHINSENSITIVE',
1426	'argumentCount' => '2,3'
1427	),
1428	'SECOND' => array('category' => PHPExcel_Calculation_Function::CATEGORY_DATE_AND_TIME,
1429	'functionCall' => 'PHPExcel_Calculation_DateTime::SECONDOFMINUTE',
1430	'argumentCount' => '1'
1431	),
1432	'SERIESSUM' => array('category' => PHPExcel_Calculation_Function::CATEGORY_MATH_AND_TRIG,
1433	'functionCall' => 'PHPExcel_Calculation_MathTrig::SERIESSUM',
1434	'argumentCount' => '4'
1435	),
1436	'SIGN' => array('category' => PHPExcel_Calculation_Function::CATEGORY_MATH_AND_TRIG,
1437	'functionCall' => 'PHPExcel_Calculation_MathTrig::SIGN',
1438	'argumentCount' => '1'
1439	),
1440	'SIN' => array('category' => PHPExcel_Calculation_Function::CATEGORY_MATH_AND_TRIG,
1441	'functionCall' => 'sin',
1442	'argumentCount' => '1'
1443	),
1444	'SINH' => array('category' => PHPExcel_Calculation_Function::CATEGORY_MATH_AND_TRIG,
1445	'functionCall' => 'sinh',
1446	'argumentCount' => '1'
1447	),
1448	'SKEW' => array('category' => PHPExcel_Calculation_Function::CATEGORY_STATISTICAL,
1449	'functionCall' => 'PHPExcel_Calculation_Statistical::SKEW',
1450	'argumentCount' => '1+'
1451	),
1452	'SLN' => array('category' => PHPExcel_Calculation_Function::CATEGORY_FINANCIAL,
1453	'functionCall' => 'PHPExcel_Calculation_Financial::SLN',
1454	'argumentCount' => '3'
1455	),
1456	'SLOPE' => array('category' => PHPExcel_Calculation_Function::CATEGORY_STATISTICAL,
1457	'functionCall' => 'PHPExcel_Calculation_Statistical::SLOPE',
1458	'argumentCount' => '2'
1459	),
1460	'SMALL' => array('category' => PHPExcel_Calculation_Function::CATEGORY_STATISTICAL,
1461	'functionCall' => 'PHPExcel_Calculation_Statistical::SMALL',
1462	'argumentCount' => '2'
1463	),
1464	'SQRT' => array('category' => PHPExcel_Calculation_Function::CATEGORY_MATH_AND_TRIG,
1465	'functionCall' => 'sqrt',
1466	'argumentCount' => '1'
1467	),
1468	'SQRTPI' => array('category' => PHPExcel_Calculation_Function::CATEGORY_MATH_AND_TRIG,
1469	'functionCall' => 'PHPExcel_Calculation_MathTrig::SQRTPI',
1470	'argumentCount' => '1'
1471	),
1472	'STANDARDIZE' => array('category' => PHPExcel_Calculation_Function::CATEGORY_STATISTICAL,
1473	'functionCall' => 'PHPExcel_Calculation_Statistical::STANDARDIZE',
1474	'argumentCount' => '3'
1475	),
1476	'STDEV' => array('category' => PHPExcel_Calculation_Function::CATEGORY_STATISTICAL,
1477	'functionCall' => 'PHPExcel_Calculation_Statistical::STDEV',
1478	'argumentCount' => '1+'
1479	),
1480	'STDEVA' => array('category' => PHPExcel_Calculation_Function::CATEGORY_STATISTICAL,
1481	'functionCall' => 'PHPExcel_Calculation_Statistical::STDEVA',
1482	'argumentCount' => '1+'
1483	),
1484	'STDEVP' => array('category' => PHPExcel_Calculation_Function::CATEGORY_STATISTICAL,
1485	'functionCall' => 'PHPExcel_Calculation_Statistical::STDEVP',
1486	'argumentCount' => '1+'
1487	),
1488	'STDEVPA' => array('category' => PHPExcel_Calculation_Function::CATEGORY_STATISTICAL,
1489	'functionCall' => 'PHPExcel_Calculation_Statistical::STDEVPA',
1490	'argumentCount' => '1+'
1491	),
1492	'STEYX' => array('category' => PHPExcel_Calculation_Function::CATEGORY_STATISTICAL,
1493	'functionCall' => 'PHPExcel_Calculation_Statistical::STEYX',
1494	'argumentCount' => '2'
1495	),
1496	'SUBSTITUTE' => array('category' => PHPExcel_Calculation_Function::CATEGORY_TEXT_AND_DATA,
1497	'functionCall' => 'PHPExcel_Calculation_TextData::SUBSTITUTE',
1498	'argumentCount' => '3,4'
1499	),
1500	'SUBTOTAL' => array('category' => PHPExcel_Calculation_Function::CATEGORY_MATH_AND_TRIG,
1501	'functionCall' => 'PHPExcel_Calculation_MathTrig::SUBTOTAL',
1502	'argumentCount' => '2+'
1503	),
1504	'SUM' => array('category' => PHPExcel_Calculation_Function::CATEGORY_MATH_AND_TRIG,
1505	'functionCall' => 'PHPExcel_Calculation_MathTrig::SUM',
1506	'argumentCount' => '1+'
1507	),
1508	'SUMIF' => array('category' => PHPExcel_Calculation_Function::CATEGORY_MATH_AND_TRIG,
1509	'functionCall' => 'PHPExcel_Calculation_MathTrig::SUMIF',
1510	'argumentCount' => '2,3'
1511	),
1512	'SUMIFS' => array('category' => PHPExcel_Calculation_Function::CATEGORY_MATH_AND_TRIG,
1513	'functionCall' => 'PHPExcel_Calculation_Functions::DUMMY',
1514	'argumentCount' => '?'
1515	),
1516	'SUMPRODUCT' => array('category' => PHPExcel_Calculation_Function::CATEGORY_MATH_AND_TRIG,
1517	'functionCall' => 'PHPExcel_Calculation_MathTrig::SUMPRODUCT',
1518	'argumentCount' => '1+'
1519	),
1520	'SUMSQ' => array('category' => PHPExcel_Calculation_Function::CATEGORY_MATH_AND_TRIG,
1521	'functionCall' => 'PHPExcel_Calculation_MathTrig::SUMSQ',
1522	'argumentCount' => '1+'
1523	),
1524	'SUMX2MY2' => array('category' => PHPExcel_Calculation_Function::CATEGORY_MATH_AND_TRIG,
1525	'functionCall' => 'PHPExcel_Calculation_MathTrig::SUMX2MY2',
1526	'argumentCount' => '2'
1527	),
1528	'SUMX2PY2' => array('category' => PHPExcel_Calculation_Function::CATEGORY_MATH_AND_TRIG,
1529	'functionCall' => 'PHPExcel_Calculation_MathTrig::SUMX2PY2',
1530	'argumentCount' => '2'
1531	),
1532	'SUMXMY2' => array('category' => PHPExcel_Calculation_Function::CATEGORY_MATH_AND_TRIG,
1533	'functionCall' => 'PHPExcel_Calculation_MathTrig::SUMXMY2',
1534	'argumentCount' => '2'
1535	),
1536	'SYD' => array('category' => PHPExcel_Calculation_Function::CATEGORY_FINANCIAL,
1537	'functionCall' => 'PHPExcel_Calculation_Financial::SYD',
1538	'argumentCount' => '4'
1539	),
1540	'T' => array('category' => PHPExcel_Calculation_Function::CATEGORY_TEXT_AND_DATA,
1541	'functionCall' => 'PHPExcel_Calculation_TextData::RETURNSTRING',
1542	'argumentCount' => '1'
1543	),
1544	'TAN' => array('category' => PHPExcel_Calculation_Function::CATEGORY_MATH_AND_TRIG,
1545	'functionCall' => 'tan',
1546	'argumentCount' => '1'
1547	),
1548	'TANH' => array('category' => PHPExcel_Calculation_Function::CATEGORY_MATH_AND_TRIG,
1549	'functionCall' => 'tanh',
1550	'argumentCount' => '1'
1551	),
1552	'TBILLEQ' => array('category' => PHPExcel_Calculation_Function::CATEGORY_FINANCIAL,
1553	'functionCall' => 'PHPExcel_Calculation_Financial::TBILLEQ',
1554	'argumentCount' => '3'
1555	),
1556	'TBILLPRICE' => array('category' => PHPExcel_Calculation_Function::CATEGORY_FINANCIAL,
1557	'functionCall' => 'PHPExcel_Calculation_Financial::TBILLPRICE',
1558	'argumentCount' => '3'
1559	),
1560	'TBILLYIELD' => array('category' => PHPExcel_Calculation_Function::CATEGORY_FINANCIAL,
1561	'functionCall' => 'PHPExcel_Calculation_Financial::TBILLYIELD',
1562	'argumentCount' => '3'
1563	),
1564	'TDIST' => array('category' => PHPExcel_Calculation_Function::CATEGORY_STATISTICAL,
1565	'functionCall' => 'PHPExcel_Calculation_Statistical::TDIST',
1566	'argumentCount' => '3'
1567	),
1568	'TEXT' => array('category' => PHPExcel_Calculation_Function::CATEGORY_TEXT_AND_DATA,
1569	'functionCall' => 'PHPExcel_Calculation_TextData::TEXTFORMAT',
1570	'argumentCount' => '2'
1571	),
1572	'TIME' => array('category' => PHPExcel_Calculation_Function::CATEGORY_DATE_AND_TIME,
1573	'functionCall' => 'PHPExcel_Calculation_DateTime::TIME',
1574	'argumentCount' => '3'
1575	),
1576	'TIMEVALUE' => array('category' => PHPExcel_Calculation_Function::CATEGORY_DATE_AND_TIME,
1577	'functionCall' => 'PHPExcel_Calculation_DateTime::TIMEVALUE',
1578	'argumentCount' => '1'
1579	),
1580	'TINV' => array('category' => PHPExcel_Calculation_Function::CATEGORY_STATISTICAL,
1581	'functionCall' => 'PHPExcel_Calculation_Statistical::TINV',
1582	'argumentCount' => '2'
1583	),
1584	'TODAY' => array('category' => PHPExcel_Calculation_Function::CATEGORY_DATE_AND_TIME,
1585	'functionCall' => 'PHPExcel_Calculation_DateTime::DATENOW',
1586	'argumentCount' => '0'
1587	),
1588	'TRANSPOSE' => array('category' => PHPExcel_Calculation_Function::CATEGORY_LOOKUP_AND_REFERENCE,
1589	'functionCall' => 'PHPExcel_Calculation_LookupRef::TRANSPOSE',
1590	'argumentCount' => '1'
1591	),
1592	'TREND' => array('category' => PHPExcel_Calculation_Function::CATEGORY_STATISTICAL,
1593	'functionCall' => 'PHPExcel_Calculation_Statistical::TREND',
1594	'argumentCount' => '1-4'
1595	),
1596	'TRIM' => array('category' => PHPExcel_Calculation_Function::CATEGORY_TEXT_AND_DATA,
1597	'functionCall' => 'PHPExcel_Calculation_TextData::TRIMSPACES',
1598	'argumentCount' => '1'
1599	),
1600	'TRIMMEAN' => array('category' => PHPExcel_Calculation_Function::CATEGORY_STATISTICAL,
1601	'functionCall' => 'PHPExcel_Calculation_Statistical::TRIMMEAN',
1602	'argumentCount' => '2'
1603	),
1604	'TRUE' => array('category' => PHPExcel_Calculation_Function::CATEGORY_LOGICAL,
1605	'functionCall' => 'PHPExcel_Calculation_Logical::TRUE',
1606	'argumentCount' => '0'
1607	),
1608	'TRUNC' => array('category' => PHPExcel_Calculation_Function::CATEGORY_MATH_AND_TRIG,
1609	'functionCall' => 'PHPExcel_Calculation_MathTrig::TRUNC',
1610	'argumentCount' => '1,2'
1611	),
1612	'TTEST' => array('category' => PHPExcel_Calculation_Function::CATEGORY_STATISTICAL,
1613	'functionCall' => 'PHPExcel_Calculation_Functions::DUMMY',
1614	'argumentCount' => '4'
1615	),
1616	'TYPE' => array('category' => PHPExcel_Calculation_Function::CATEGORY_INFORMATION,
1617	'functionCall' => 'PHPExcel_Calculation_Functions::TYPE',
1618	'argumentCount' => '1'
1619	),
1620	'UPPER' => array('category' => PHPExcel_Calculation_Function::CATEGORY_TEXT_AND_DATA,
1621	'functionCall' => 'PHPExcel_Calculation_TextData::UPPERCASE',
1622	'argumentCount' => '1'
1623	),
1624	'USDOLLAR' => array('category' => PHPExcel_Calculation_Function::CATEGORY_FINANCIAL,
1625	'functionCall' => 'PHPExcel_Calculation_Functions::DUMMY',
1626	'argumentCount' => '2'
1627	),
1628	'VALUE' => array('category' => PHPExcel_Calculation_Function::CATEGORY_TEXT_AND_DATA,
1629	'functionCall' => 'PHPExcel_Calculation_Functions::DUMMY',
1630	'argumentCount' => '1'
1631	),
1632	'VAR' => array('category' => PHPExcel_Calculation_Function::CATEGORY_STATISTICAL,
1633	'functionCall' => 'PHPExcel_Calculation_Statistical::VARFunc',
1634	'argumentCount' => '1+'
1635	),
1636	'VARA' => array('category' => PHPExcel_Calculation_Function::CATEGORY_STATISTICAL,
1637	'functionCall' => 'PHPExcel_Calculation_Statistical::VARA',
1638	'argumentCount' => '1+'
1639	),
1640	'VARP' => array('category' => PHPExcel_Calculation_Function::CATEGORY_STATISTICAL,
1641	'functionCall' => 'PHPExcel_Calculation_Statistical::VARP',
1642	'argumentCount' => '1+'
1643	),
1644	'VARPA' => array('category' => PHPExcel_Calculation_Function::CATEGORY_STATISTICAL,
1645	'functionCall' => 'PHPExcel_Calculation_Statistical::VARPA',
1646	'argumentCount' => '1+'
1647	),
1648	'VDB' => array('category' => PHPExcel_Calculation_Function::CATEGORY_FINANCIAL,
1649	'functionCall' => 'PHPExcel_Calculation_Functions::DUMMY',
1650	'argumentCount' => '5-7'
1651	),
1652	'VERSION' => array('category' => PHPExcel_Calculation_Function::CATEGORY_INFORMATION,
1653	'functionCall' => 'PHPExcel_Calculation_Functions::VERSION',
1654	'argumentCount' => '0'
1655	),
1656	'VLOOKUP' => array('category' => PHPExcel_Calculation_Function::CATEGORY_LOOKUP_AND_REFERENCE,
1657	'functionCall' => 'PHPExcel_Calculation_LookupRef::VLOOKUP',
1658	'argumentCount' => '3,4'
1659	),
1660	'WEEKDAY' => array('category' => PHPExcel_Calculation_Function::CATEGORY_DATE_AND_TIME,
1661	'functionCall' => 'PHPExcel_Calculation_DateTime::DAYOFWEEK',
1662	'argumentCount' => '1,2'
1663	),
1664	'WEEKNUM' => array('category' => PHPExcel_Calculation_Function::CATEGORY_DATE_AND_TIME,
1665	'functionCall' => 'PHPExcel_Calculation_DateTime::WEEKOFYEAR',
1666	'argumentCount' => '1,2'
1667	),
1668	'WEIBULL' => array('category' => PHPExcel_Calculation_Function::CATEGORY_STATISTICAL,
1669	'functionCall' => 'PHPExcel_Calculation_Statistical::WEIBULL',
1670	'argumentCount' => '4'
1671	),
1672	'WORKDAY' => array('category' => PHPExcel_Calculation_Function::CATEGORY_DATE_AND_TIME,
1673	'functionCall' => 'PHPExcel_Calculation_DateTime::WORKDAY',
1674	'argumentCount' => '2+'
1675	),
1676	'XIRR' => array('category' => PHPExcel_Calculation_Function::CATEGORY_FINANCIAL,
1677	'functionCall' => 'PHPExcel_Calculation_Financial::XIRR',
1678	'argumentCount' => '2,3'
1679	),
1680	'XNPV' => array('category' => PHPExcel_Calculation_Function::CATEGORY_FINANCIAL,
1681	'functionCall' => 'PHPExcel_Calculation_Financial::XNPV',
1682	'argumentCount' => '3'
1683	),
1684	'YEAR' => array('category' => PHPExcel_Calculation_Function::CATEGORY_DATE_AND_TIME,
1685	'functionCall' => 'PHPExcel_Calculation_DateTime::YEAR',
1686	'argumentCount' => '1'
1687	),
1688	'YEARFRAC' => array('category' => PHPExcel_Calculation_Function::CATEGORY_DATE_AND_TIME,
1689	'functionCall' => 'PHPExcel_Calculation_DateTime::YEARFRAC',
1690	'argumentCount' => '2,3'
1691	),
1692	'YIELD' => array('category' => PHPExcel_Calculation_Function::CATEGORY_FINANCIAL,
1693	'functionCall' => 'PHPExcel_Calculation_Functions::DUMMY',
1694	'argumentCount' => '6,7'
1695	),
1696	'YIELDDISC' => array('category' => PHPExcel_Calculation_Function::CATEGORY_FINANCIAL,
1697	'functionCall' => 'PHPExcel_Calculation_Financial::YIELDDISC',
1698	'argumentCount' => '4,5'
1699	),
1700	'YIELDMAT' => array('category' => PHPExcel_Calculation_Function::CATEGORY_FINANCIAL,
1701	'functionCall' => 'PHPExcel_Calculation_Financial::YIELDMAT',
1702	'argumentCount' => '5,6'
1703	),
1704	'ZTEST' => array('category' => PHPExcel_Calculation_Function::CATEGORY_STATISTICAL,
1705	'functionCall' => 'PHPExcel_Calculation_Statistical::ZTEST',
1706	'argumentCount' => '2-3'
1707	)
1708	);
1709
1710
1711	// Internal functions used for special control purposes
1712	private static $_controlFunctions = array(
1713	'MKMATRIX' => array('argumentCount' => '*',
1714	'functionCall' => 'self::_mkMatrix'
1715	)
1716	);
1717
1718
1719
1720
1721	private function __construct(PHPExcel $workbook = NULL) {
1722	$setPrecision = (PHP_INT_SIZE == 4) ? 14 : 16;
1723	$this->_savedPrecision = ini_get('precision');
1724	if ($this->_savedPrecision < $setPrecision) {
1725	ini_set('precision',$setPrecision);
1726	}
1727
1728	if ($workbook !== NULL) {
1729	self::$_workbookSets[$workbook->getID()] = $this;
1730	}
1731
1732	$this->_workbook = $workbook;
1733	$this->_cyclicReferenceStack = new PHPExcel_CalcEngine_CyclicReferenceStack();
1734	$this->_debugLog = new PHPExcel_CalcEngine_Logger($this->_cyclicReferenceStack);
1735	} // function __construct()
1736
1737
1738	public function __destruct() {
1739	if ($this->_savedPrecision != ini_get('precision')) {
1740	ini_set('precision',$this->_savedPrecision);
1741	}
1742	}
1743
1744	private static function _loadLocales() {
1745	$localeFileDirectory = PHPEXCEL_ROOT.'PHPExcel/locale/';
1746	foreach (glob($localeFileDirectory.'/*',GLOB_ONLYDIR) as $filename) {
1747	$filename = substr($filename,strlen($localeFileDirectory)+1);
1748	if ($filename != 'en') {
1749	self::$_validLocaleLanguages[] = $filename;
1750	}
1751	}
1752	}
1753
1754	/**
1755	* Get an instance of this class
1756	*
1757	* @access public
1758	* @param PHPExcel $workbook Injected workbook for working with a PHPExcel object,
1759	* or NULL to create a standalone claculation engine
1760	* @return PHPExcel_Calculation
1761	*/
1762	public static function getInstance(PHPExcel $workbook = NULL) {
1763	if ($workbook !== NULL) {
1764	if (isset(self::$_workbookSets[$workbook->getID()])) {
1765	return self::$_workbookSets[$workbook->getID()];
1766	}
1767	return new PHPExcel_Calculation($workbook);
1768	}
1769
1770	if (!isset(self::$_instance) \|\| (self::$_instance === NULL)) {
1771	self::$_instance = new PHPExcel_Calculation();
1772	}
1773
1774	return self::$_instance;
1775	} // function getInstance()
1776
1777	/**
1778	* Unset an instance of this class
1779	*
1780	* @access public
1781	* @param PHPExcel $workbook Injected workbook identifying the instance to unset
1782	*/
1783	public static function unsetInstance(PHPExcel $workbook = NULL) {
1784	if ($workbook !== NULL) {
1785	if (isset(self::$_workbookSets[$workbook->getID()])) {
1786	unset(self::$_workbookSets[$workbook->getID()]);
1787	}
1788	}
1789	}
1790
1791	/**
1792	* Flush the calculation cache for any existing instance of this class
1793	* but only if a PHPExcel_Calculation instance exists
1794	*
1795	* @access public
1796	* @return null
1797	*/
1798	public function flushInstance() {
1799	$this->clearCalculationCache();
1800	} // function flushInstance()
1801
1802
1803	/**
1804	* Get the debuglog for this claculation engine instance
1805	*
1806	* @access public
1807	* @return PHPExcel_CalcEngine_Logger
1808	*/
1809	public function getDebugLog() {
1810	return $this->_debugLog;
1811	}
1812
1813	/**
1814	* __clone implementation. Cloning should not be allowed in a Singleton!
1815	*
1816	* @access public
1817	* @throws PHPExcel_Calculation_Exception
1818	*/
1819	public final function __clone() {
1820	throw new PHPExcel_Calculation_Exception ('Cloning the calculation engine is not allowed!');
1821	} // function __clone()
1822
1823
1824	/**
1825	* Return the locale-specific translation of TRUE
1826	*
1827	* @access public
1828	* @return string locale-specific translation of TRUE
1829	*/
1830	public static function getTRUE() {
1831	return self::$_localeBoolean['TRUE'];
1832	}
1833
1834	/**
1835	* Return the locale-specific translation of FALSE
1836	*
1837	* @access public
1838	* @return string locale-specific translation of FALSE
1839	*/
1840	public static function getFALSE() {
1841	return self::$_localeBoolean['FALSE'];
1842	}
1843
1844	/**
1845	* Set the Array Return Type (Array or Value of first element in the array)
1846	*
1847	* @access public
1848	* @param string $returnType Array return type
1849	* @return boolean Success or failure
1850	*/
1851	public static function setArrayReturnType($returnType) {
1852	if (($returnType == self::RETURN_ARRAY_AS_VALUE) \|\|
1853	($returnType == self::RETURN_ARRAY_AS_ERROR) \|\|
1854	($returnType == self::RETURN_ARRAY_AS_ARRAY)) {
1855	self::$returnArrayAsType = $returnType;
1856	return TRUE;
1857	}
1858	return FALSE;
1859	} // function setArrayReturnType()
1860
1861
1862	/**
1863	* Return the Array Return Type (Array or Value of first element in the array)
1864	*
1865	* @access public
1866	* @return string $returnType Array return type
1867	*/
1868	public static function getArrayReturnType() {
1869	return self::$returnArrayAsType;
1870	} // function getArrayReturnType()
1871
1872
1873	/**
1874	* Is calculation caching enabled?
1875	*
1876	* @access public
1877	* @return boolean
1878	*/
1879	public function getCalculationCacheEnabled() {
1880	return $this->_calculationCacheEnabled;
1881	} // function getCalculationCacheEnabled()
1882
1883	/**
1884	* Enable/disable calculation cache
1885	*
1886	* @access public
1887	* @param boolean $pValue
1888	*/
1889	public function setCalculationCacheEnabled($pValue = TRUE) {
1890	$this->_calculationCacheEnabled = $pValue;
1891	$this->clearCalculationCache();
1892	} // function setCalculationCacheEnabled()
1893
1894
1895	/**
1896	* Enable calculation cache
1897	*/
1898	public function enableCalculationCache() {
1899	$this->setCalculationCacheEnabled(TRUE);
1900	} // function enableCalculationCache()
1901
1902
1903	/**
1904	* Disable calculation cache
1905	*/
1906	public function disableCalculationCache() {
1907	$this->setCalculationCacheEnabled(FALSE);
1908	} // function disableCalculationCache()
1909
1910
1911	/**
1912	* Clear calculation cache
1913	*/
1914	public function clearCalculationCache() {
1915	$this->_calculationCache = array();
1916	} // function clearCalculationCache()
1917
1918	/**
1919	* Clear calculation cache for a specified worksheet
1920	*
1921	* @param string $worksheetName
1922	*/
1923	public function clearCalculationCacheForWorksheet($worksheetName) {
1924	if (isset($this->_calculationCache[$worksheetName])) {
1925	unset($this->_calculationCache[$worksheetName]);
1926	}
1927	} // function clearCalculationCacheForWorksheet()
1928
1929	/**
1930	* Rename calculation cache for a specified worksheet
1931	*
1932	* @param string $fromWorksheetName
1933	* @param string $toWorksheetName
1934	*/
1935	public function renameCalculationCacheForWorksheet($fromWorksheetName, $toWorksheetName) {
1936	if (isset($this->_calculationCache[$fromWorksheetName])) {
1937	$this->_calculationCache[$toWorksheetName] = &$this->_calculationCache[$fromWorksheetName];
1938	unset($this->_calculationCache[$fromWorksheetName]);
1939	}
1940	} // function renameCalculationCacheForWorksheet()
1941
1942
1943	/**
1944	* Get the currently defined locale code
1945	*
1946	* @return string
1947	*/
1948	public function getLocale() {
1949	return self::$_localeLanguage;
1950	} // function getLocale()
1951
1952
1953	/**
1954	* Set the locale code
1955	*
1956	* @param string $locale The locale to use for formula translation
1957	* @return boolean
1958	*/
1959	public function setLocale($locale = 'en_us') {
1960	// Identify our locale and language
1961	$language = $locale = strtolower($locale);
1962	if (strpos($locale,'_') !== FALSE) {
1963	list($language) = explode('_',$locale);
1964	}
1965
1966	if (count(self::$_validLocaleLanguages) == 1)
1967	self::_loadLocales();
1968
1969	// Test whether we have any language data for this language (any locale)
1970	if (in_array($language,self::$_validLocaleLanguages)) {
1971	// initialise language/locale settings
1972	self::$_localeFunctions = array();
1973	self::$_localeArgumentSeparator = ',';
1974	self::$_localeBoolean = array('TRUE' => 'TRUE', 'FALSE' => 'FALSE', 'NULL' => 'NULL');
1975	// Default is English, if user isn't requesting english, then read the necessary data from the locale files
1976	if ($locale != 'en_us') {
1977	// Search for a file with a list of function names for locale
1978	$functionNamesFile = PHPEXCEL_ROOT . 'PHPExcel'.DIRECTORY_SEPARATOR.'locale'.DIRECTORY_SEPARATOR.str_replace('_',DIRECTORY_SEPARATOR,$locale).DIRECTORY_SEPARATOR.'functions';
1979	if (!file_exists($functionNamesFile)) {
1980	// If there isn't a locale specific function file, look for a language specific function file
1981	$functionNamesFile = PHPEXCEL_ROOT . 'PHPExcel'.DIRECTORY_SEPARATOR.'locale'.DIRECTORY_SEPARATOR.$language.DIRECTORY_SEPARATOR.'functions';
1982	if (!file_exists($functionNamesFile)) {
1983	return FALSE;
1984	}
1985	}
1986	// Retrieve the list of locale or language specific function names
1987	$localeFunctions = file($functionNamesFile,FILE_IGNORE_NEW_LINES \| FILE_SKIP_EMPTY_LINES);
1988	foreach ($localeFunctions as $localeFunction) {
1989	list($localeFunction) = explode('##',$localeFunction); // Strip out comments
1990	if (strpos($localeFunction,'=') !== FALSE) {
1991	list($fName,$lfName) = explode('=',$localeFunction);
1992	$fName = trim($fName);
1993	$lfName = trim($lfName);
1994	if ((isset(self::$_PHPExcelFunctions[$fName])) && ($lfName != '') && ($fName != $lfName)) {
1995	self::$_localeFunctions[$fName] = $lfName;
1996	}
1997	}
1998	}
1999	// Default the TRUE and FALSE constants to the locale names of the TRUE() and FALSE() functions
2000	if (isset(self::$_localeFunctions['TRUE'])) { self::$_localeBoolean['TRUE'] = self::$_localeFunctions['TRUE']; }
2001	if (isset(self::$_localeFunctions['FALSE'])) { self::$_localeBoolean['FALSE'] = self::$_localeFunctions['FALSE']; }
2002
2003	$configFile = PHPEXCEL_ROOT . 'PHPExcel'.DIRECTORY_SEPARATOR.'locale'.DIRECTORY_SEPARATOR.str_replace('_',DIRECTORY_SEPARATOR,$locale).DIRECTORY_SEPARATOR.'config';
2004	if (!file_exists($configFile)) {
2005	$configFile = PHPEXCEL_ROOT . 'PHPExcel'.DIRECTORY_SEPARATOR.'locale'.DIRECTORY_SEPARATOR.$language.DIRECTORY_SEPARATOR.'config';
2006	}
2007	if (file_exists($configFile)) {
2008	$localeSettings = file($configFile,FILE_IGNORE_NEW_LINES \| FILE_SKIP_EMPTY_LINES);
2009	foreach ($localeSettings as $localeSetting) {
2010	list($localeSetting) = explode('##',$localeSetting); // Strip out comments
2011	if (strpos($localeSetting,'=') !== FALSE) {
2012	list($settingName,$settingValue) = explode('=',$localeSetting);
2013	$settingName = strtoupper(trim($settingName));
2014	switch ($settingName) {
2015	case 'ARGUMENTSEPARATOR' :
2016	self::$_localeArgumentSeparator = trim($settingValue);
2017	break;
2018	}
2019	}
2020	}
2021	}
2022	}
2023
2024	self::$functionReplaceFromExcel = self::$functionReplaceToExcel =
2025	self::$functionReplaceFromLocale = self::$functionReplaceToLocale = NULL;
2026	self::$_localeLanguage = $locale;
2027	return TRUE;
2028	}
2029	return FALSE;
2030	} // function setLocale()
2031
2032
2033
2034	public static function _translateSeparator($fromSeparator,$toSeparator,$formula,&$inBraces) {
2035	$strlen = mb_strlen($formula);
2036	for ($i = 0; $i < $strlen; ++$i) {
2037	$chr = mb_substr($formula,$i,1);
2038	switch ($chr) {
2039	case '{' : $inBraces = TRUE;
2040	break;
2041	case '}' : $inBraces = FALSE;
2042	break;
2043	case $fromSeparator :
2044	if (!$inBraces) {
2045	$formula = mb_substr($formula,0,$i).$toSeparator.mb_substr($formula,$i+1);
2046	}
2047	}
2048	}
2049	return $formula;
2050	}
2051
2052	private static function _translateFormula($from,$to,$formula,$fromSeparator,$toSeparator) {
2053	// Convert any Excel function names to the required language
2054	if (self::$_localeLanguage !== 'en_us') {
2055	$inBraces = FALSE;
2056	// If there is the possibility of braces within a quoted string, then we don't treat those as matrix indicators
2057	if (strpos($formula,'"') !== FALSE) {
2058	// So instead we skip replacing in any quoted strings by only replacing in every other array element after we've exploded
2059	// the formula
2060	$temp = explode('"',$formula);
2061	$i = FALSE;
2062	foreach($temp as &$value) {
2063	// Only count/replace in alternating array entries
2064	if ($i = !$i) {
2065	$value = preg_replace($from,$to,$value);
2066	$value = self::_translateSeparator($fromSeparator,$toSeparator,$value,$inBraces);
2067	}
2068	}
2069	unset($value);
2070	// Then rebuild the formula string
2071	$formula = implode('"',$temp);
2072	} else {
2073	// If there's no quoted strings, then we do a simple count/replace
2074	$formula = preg_replace($from,$to,$formula);
2075	$formula = self::_translateSeparator($fromSeparator,$toSeparator,$formula,$inBraces);
2076	}
2077	}
2078
2079	return $formula;
2080	}
2081
2082	private static $functionReplaceFromExcel = NULL;
2083	private static $functionReplaceToLocale = NULL;
2084
2085	public function _translateFormulaToLocale($formula) {
2086	if (self::$functionReplaceFromExcel === NULL) {
2087	self::$functionReplaceFromExcel = array();
2088	foreach(array_keys(self::$_localeFunctions) as $excelFunctionName) {
2089	self::$functionReplaceFromExcel[] = '/(@?[^\w\.])'.preg_quote($excelFunctionName).'([\s]*\()/Ui';
2090	}
2091	foreach(array_keys(self::$_localeBoolean) as $excelBoolean) {
2092	self::$functionReplaceFromExcel[] = '/(@?[^\w\.])'.preg_quote($excelBoolean).'([^\w\.])/Ui';
2093	}
2094
2095	}
2096
2097	if (self::$functionReplaceToLocale === NULL) {
2098	self::$functionReplaceToLocale = array();
2099	foreach(array_values(self::$_localeFunctions) as $localeFunctionName) {
2100	self::$functionReplaceToLocale[] = '$1'.trim($localeFunctionName).'$2';
2101	}
2102	foreach(array_values(self::$_localeBoolean) as $localeBoolean) {
2103	self::$functionReplaceToLocale[] = '$1'.trim($localeBoolean).'$2';
2104	}
2105	}
2106
2107	return self::_translateFormula(self::$functionReplaceFromExcel,self::$functionReplaceToLocale,$formula,',',self::$_localeArgumentSeparator);
2108	} // function _translateFormulaToLocale()
2109
2110
2111	private static $functionReplaceFromLocale = NULL;
2112	private static $functionReplaceToExcel = NULL;
2113
2114	public function _translateFormulaToEnglish($formula) {
2115	if (self::$functionReplaceFromLocale === NULL) {
2116	self::$functionReplaceFromLocale = array();
2117	foreach(array_values(self::$_localeFunctions) as $localeFunctionName) {
2118	self::$functionReplaceFromLocale[] = '/(@?[^\w\.])'.preg_quote($localeFunctionName).'([\s]*\()/Ui';
2119	}
2120	foreach(array_values(self::$_localeBoolean) as $excelBoolean) {
2121	self::$functionReplaceFromLocale[] = '/(@?[^\w\.])'.preg_quote($excelBoolean).'([^\w\.])/Ui';
2122	}
2123	}
2124
2125	if (self::$functionReplaceToExcel === NULL) {
2126	self::$functionReplaceToExcel = array();
2127	foreach(array_keys(self::$_localeFunctions) as $excelFunctionName) {
2128	self::$functionReplaceToExcel[] = '$1'.trim($excelFunctionName).'$2';
2129	}
2130	foreach(array_keys(self::$_localeBoolean) as $excelBoolean) {
2131	self::$functionReplaceToExcel[] = '$1'.trim($excelBoolean).'$2';
2132	}
2133	}
2134
2135	return self::_translateFormula(self::$functionReplaceFromLocale,self::$functionReplaceToExcel,$formula,self::$_localeArgumentSeparator,',');
2136	} // function _translateFormulaToEnglish()
2137
2138
2139	public static function _localeFunc($function) {
2140	if (self::$_localeLanguage !== 'en_us') {
2141	$functionName = trim($function,'(');
2142	if (isset(self::$_localeFunctions[$functionName])) {
2143	$brace = ($functionName != $function);
2144	$function = self::$_localeFunctions[$functionName];
2145	if ($brace) { $function .= '('; }
2146	}
2147	}
2148	return $function;
2149	}
2150
2151
2152
2153
2154	/**
2155	* Wrap string values in quotes
2156	*
2157	* @param mixed $value
2158	* @return mixed
2159	*/
2160	public static function _wrapResult($value) {
2161	if (is_string($value)) {
2162	// Error values cannot be "wrapped"
2163	if (preg_match('/^'.self::CALCULATION_REGEXP_ERROR.'$/i', $value, $match)) {
2164	// Return Excel errors "as is"
2165	return $value;
2166	}
2167	// Return strings wrapped in quotes
2168	return '"'.$value.'"';
2169	// Convert numeric errors to NaN error
2170	} else if((is_float($value)) && ((is_nan($value)) \|\| (is_infinite($value)))) {
2171	return PHPExcel_Calculation_Functions::NaN();
2172	}
2173
2174	return $value;
2175	} // function _wrapResult()
2176
2177
2178	/**
2179	* Remove quotes used as a wrapper to identify string values
2180	*
2181	* @param mixed $value
2182	* @return mixed
2183	*/
2184	public static function _unwrapResult($value) {
2185	if (is_string($value)) {
2186	if ((isset($value{0})) && ($value{0} == '"') && (substr($value,-1) == '"')) {
2187	return substr($value,1,-1);
2188	}
2189	// Convert numeric errors to NaN error
2190	} else if((is_float($value)) && ((is_nan($value)) \|\| (is_infinite($value)))) {
2191	return PHPExcel_Calculation_Functions::NaN();
2192	}
2193	return $value;
2194	} // function _unwrapResult()
2195
2196
2197
2198
2199	/**
2200	* Calculate cell value (using formula from a cell ID)
2201	* Retained for backward compatibility
2202	*
2203	* @access public
2204	* @param PHPExcel_Cell $pCell Cell to calculate
2205	* @return mixed
2206	* @throws PHPExcel_Calculation_Exception
2207	*/
2208	public function calculate(PHPExcel_Cell $pCell = NULL) {
2209	try {
2210	return $this->calculateCellValue($pCell);
2211	} catch (PHPExcel_Exception $e) {
2212	throw new PHPExcel_Calculation_Exception($e->getMessage());
2213	}
2214	} // function calculate()
2215
2216
2217	/**
2218	* Calculate the value of a cell formula
2219	*
2220	* @access public
2221	* @param PHPExcel_Cell $pCell Cell to calculate
2222	* @param Boolean $resetLog Flag indicating whether the debug log should be reset or not
2223	* @return mixed
2224	* @throws PHPExcel_Calculation_Exception
2225	*/
2226	public function calculateCellValue(PHPExcel_Cell $pCell = NULL, $resetLog = TRUE) {
2227	if ($pCell === NULL) {
2228	return NULL;
2229	}
2230
2231	$returnArrayAsType = self::$returnArrayAsType;
2232	if ($resetLog) {
2233	// Initialise the logging settings if requested
2234	$this->formulaError = null;
2235	$this->_debugLog->clearLog();
2236	$this->_cyclicReferenceStack->clear();
2237	$this->_cyclicFormulaCount = 1;
2238
2239	self::$returnArrayAsType = self::RETURN_ARRAY_AS_ARRAY;
2240	}
2241
2242	// Execute the calculation for the cell formula
2243	try {
2244	$result = self::_unwrapResult($this->_calculateFormulaValue($pCell->getValue(), $pCell->getCoordinate(), $pCell));
2245	} catch (PHPExcel_Exception $e) {
2246	throw new PHPExcel_Calculation_Exception($e->getMessage());
2247	}
2248
2249	if ((is_array($result)) && (self::$returnArrayAsType != self::RETURN_ARRAY_AS_ARRAY)) {
2250	self::$returnArrayAsType = $returnArrayAsType;
2251	$testResult = PHPExcel_Calculation_Functions::flattenArray($result);
2252	if (self::$returnArrayAsType == self::RETURN_ARRAY_AS_ERROR) {
2253	return PHPExcel_Calculation_Functions::VALUE();
2254	}
2255	// If there's only a single cell in the array, then we allow it
2256	if (count($testResult) != 1) {
2257	// If keys are numeric, then it's a matrix result rather than a cell range result, so we permit it
2258	$r = array_keys($result);
2259	$r = array_shift($r);
2260	if (!is_numeric($r)) { return PHPExcel_Calculation_Functions::VALUE(); }
2261	if (is_array($result[$r])) {
2262	$c = array_keys($result[$r]);
2263	$c = array_shift($c);
2264	if (!is_numeric($c)) {
2265	return PHPExcel_Calculation_Functions::VALUE();
2266	}
2267	}
2268	}
2269	$result = array_shift($testResult);
2270	}
2271	self::$returnArrayAsType = $returnArrayAsType;
2272
2273
2274	if ($result === NULL) {
2275	return 0;
2276	} elseif((is_float($result)) && ((is_nan($result)) \|\| (is_infinite($result)))) {
2277	return PHPExcel_Calculation_Functions::NaN();
2278	}
2279	return $result;
2280	} // function calculateCellValue(
2281
2282
2283	/**
2284	* Validate and parse a formula string
2285	*
2286	* @param string $formula Formula to parse
2287	* @return array
2288	* @throws PHPExcel_Calculation_Exception
2289	*/
2290	public function parseFormula($formula) {
2291	// Basic validation that this is indeed a formula
2292	// We return an empty array if not
2293	$formula = trim($formula);
2294	if ((!isset($formula{0})) \|\| ($formula{0} != '=')) return array();
2295	$formula = ltrim(substr($formula,1));
2296	if (!isset($formula{0})) return array();
2297
2298	// Parse the formula and return the token stack
2299	return $this->_parseFormula($formula);
2300	} // function parseFormula()
2301
2302
2303	/**
2304	* Calculate the value of a formula
2305	*
2306	* @param string $formula Formula to parse
2307	* @param string $cellID Address of the cell to calculate
2308	* @param PHPExcel_Cell $pCell Cell to calculate
2309	* @return mixed
2310	* @throws PHPExcel_Calculation_Exception
2311	*/
2312	public function calculateFormula($formula, $cellID=NULL, PHPExcel_Cell $pCell = NULL) {
2313	// Initialise the logging settings
2314	$this->formulaError = null;
2315	$this->_debugLog->clearLog();
2316	$this->_cyclicReferenceStack->clear();
2317
2318	// Disable calculation cacheing because it only applies to cell calculations, not straight formulae
2319	// But don't actually flush any cache
2320	$resetCache = $this->getCalculationCacheEnabled();
2321	$this->_calculationCacheEnabled = FALSE;
2322	// Execute the calculation
2323	try {
2324	$result = self::_unwrapResult($this->_calculateFormulaValue($formula, $cellID, $pCell));
2325	} catch (PHPExcel_Exception $e) {
2326	throw new PHPExcel_Calculation_Exception($e->getMessage());
2327	}
2328
2329	// Reset calculation cacheing to its previous state
2330	$this->_calculationCacheEnabled = $resetCache;
2331
2332	return $result;
2333	} // function calculateFormula()
2334
2335
2336	public function getValueFromCache($worksheetName, $cellID, &$cellValue) {
2337	// Is calculation cacheing enabled?
2338	// Is the value present in calculation cache?
2339	//echo 'Test cache for ',$worksheetName,'!',$cellID,PHP_EOL;
2340	$this->_debugLog->writeDebugLog('Testing cache value for cell ', $worksheetName, '!', $cellID);
2341	if (($this->_calculationCacheEnabled) && (isset($this->_calculationCache[$worksheetName][$cellID]))) {
2342	//echo 'Retrieve from cache',PHP_EOL;
2343	$this->_debugLog->writeDebugLog('Retrieving value for cell ', $worksheetName, '!', $cellID, ' from cache');
2344	// Return the cached result
2345	$cellValue = $this->_calculationCache[$worksheetName][$cellID];
2346	return TRUE;
2347	}
2348	return FALSE;
2349	}
2350
2351	public function saveValueToCache($worksheetName, $cellID, $cellValue) {
2352	if ($this->_calculationCacheEnabled) {
2353	$this->_calculationCache[$worksheetName][$cellID] = $cellValue;
2354	}
2355	}
2356
2357	/**
2358	* Parse a cell formula and calculate its value
2359	*
2360	* @param string $formula The formula to parse and calculate
2361	* @param string $cellID The ID (e.g. A3) of the cell that we are calculating
2362	* @param PHPExcel_Cell $pCell Cell to calculate
2363	* @return mixed
2364	* @throws PHPExcel_Calculation_Exception
2365	*/
2366	public function _calculateFormulaValue($formula, $cellID=null, PHPExcel_Cell $pCell = null) {
2367	$cellValue = '';
2368
2369	// Basic validation that this is indeed a formula
2370	// We simply return the cell value if not
2371	$formula = trim($formula);
2372	if ($formula{0} != '=') return self::_wrapResult($formula);
2373	$formula = ltrim(substr($formula,1));
2374	if (!isset($formula{0})) return self::_wrapResult($formula);
2375
2376	$pCellParent = ($pCell !== NULL) ? $pCell->getWorksheet() : NULL;
2377	$wsTitle = ($pCellParent !== NULL) ? $pCellParent->getTitle() : "\x00Wrk";
2378
2379	if (($cellID !== NULL) && ($this->getValueFromCache($wsTitle, $cellID, $cellValue))) {
2380	return $cellValue;
2381	}
2382
2383	if (($wsTitle{0} !== "\x00") && ($this->_cyclicReferenceStack->onStack($wsTitle.'!'.$cellID))) {
2384	if ($this->cyclicFormulaCount <= 0) {
2385	return $this->_raiseFormulaError('Cyclic Reference in Formula');
2386	} elseif (($this->_cyclicFormulaCount >= $this->cyclicFormulaCount) &&
2387	($this->_cyclicFormulaCell == $wsTitle.'!'.$cellID)) {
2388	return $cellValue;
2389	} elseif ($this->_cyclicFormulaCell == $wsTitle.'!'.$cellID) {
2390	++$this->_cyclicFormulaCount;
2391	if ($this->_cyclicFormulaCount >= $this->cyclicFormulaCount) {
2392	return $cellValue;
2393	}
2394	} elseif ($this->_cyclicFormulaCell == '') {
2395	$this->_cyclicFormulaCell = $wsTitle.'!'.$cellID;
2396	if ($this->_cyclicFormulaCount >= $this->cyclicFormulaCount) {
2397	return $cellValue;
2398	}
2399	}
2400	}
2401
2402	// Parse the formula onto the token stack and calculate the value
2403	$this->_cyclicReferenceStack->push($wsTitle.'!'.$cellID);
2404	$cellValue = $this->_processTokenStack($this->_parseFormula($formula, $pCell), $cellID, $pCell);
2405	$this->_cyclicReferenceStack->pop();
2406
2407	// Save to calculation cache
2408	if ($cellID !== NULL) {
2409	$this->saveValueToCache($wsTitle, $cellID, $cellValue);
2410	}
2411
2412	// Return the calculated value
2413	return $cellValue;
2414	} // function _calculateFormulaValue()
2415
2416
2417	/**
2418	* Ensure that paired matrix operands are both matrices and of the same size
2419	*
2420	* @param mixed &$operand1 First matrix operand
2421	* @param mixed &$operand2 Second matrix operand
2422	* @param integer $resize Flag indicating whether the matrices should be resized to match
2423	* and (if so), whether the smaller dimension should grow or the
2424	* larger should shrink.
2425	* 0 = no resize
2426	* 1 = shrink to fit
2427	* 2 = extend to fit
2428	*/
2429	private static function _checkMatrixOperands(&$operand1,&$operand2,$resize = 1) {
2430	// Examine each of the two operands, and turn them into an array if they aren't one already
2431	// Note that this function should only be called if one or both of the operand is already an array
2432	if (!is_array($operand1)) {
2433	list($matrixRows,$matrixColumns) = self::_getMatrixDimensions($operand2);
2434	$operand1 = array_fill(0,$matrixRows,array_fill(0,$matrixColumns,$operand1));
2435	$resize = 0;
2436	} elseif (!is_array($operand2)) {
2437	list($matrixRows,$matrixColumns) = self::_getMatrixDimensions($operand1);
2438	$operand2 = array_fill(0,$matrixRows,array_fill(0,$matrixColumns,$operand2));
2439	$resize = 0;
2440	}
2441
2442	list($matrix1Rows,$matrix1Columns) = self::_getMatrixDimensions($operand1);
2443	list($matrix2Rows,$matrix2Columns) = self::_getMatrixDimensions($operand2);
2444	if (($matrix1Rows == $matrix2Columns) && ($matrix2Rows == $matrix1Columns)) {
2445	$resize = 1;
2446	}
2447
2448	if ($resize == 2) {
2449	// Given two matrices of (potentially) unequal size, convert the smaller in each dimension to match the larger
2450	self::_resizeMatricesExtend($operand1,$operand2,$matrix1Rows,$matrix1Columns,$matrix2Rows,$matrix2Columns);
2451	} elseif ($resize == 1) {
2452	// Given two matrices of (potentially) unequal size, convert the larger in each dimension to match the smaller
2453	self::_resizeMatricesShrink($operand1,$operand2,$matrix1Rows,$matrix1Columns,$matrix2Rows,$matrix2Columns);
2454	}
2455	return array( $matrix1Rows,$matrix1Columns,$matrix2Rows,$matrix2Columns);
2456	} // function _checkMatrixOperands()
2457
2458
2459	/**
2460	* Read the dimensions of a matrix, and re-index it with straight numeric keys starting from row 0, column 0
2461	*
2462	* @param mixed &$matrix matrix operand
2463	* @return array An array comprising the number of rows, and number of columns
2464	*/
2465	public static function _getMatrixDimensions(&$matrix) {
2466	$matrixRows = count($matrix);
2467	$matrixColumns = 0;
2468	foreach($matrix as $rowKey => $rowValue) {
2469	$matrixColumns = max(count($rowValue),$matrixColumns);
2470	if (!is_array($rowValue)) {
2471	$matrix[$rowKey] = array($rowValue);
2472	} else {
2473	$matrix[$rowKey] = array_values($rowValue);
2474	}
2475	}
2476	$matrix = array_values($matrix);
2477	return array($matrixRows,$matrixColumns);
2478	} // function _getMatrixDimensions()
2479
2480
2481	/**
2482	* Ensure that paired matrix operands are both matrices of the same size
2483	*
2484	* @param mixed &$matrix1 First matrix operand
2485	* @param mixed &$matrix2 Second matrix operand
2486	* @param integer $matrix1Rows Row size of first matrix operand
2487	* @param integer $matrix1Columns Column size of first matrix operand
2488	* @param integer $matrix2Rows Row size of second matrix operand
2489	* @param integer $matrix2Columns Column size of second matrix operand
2490	*/
2491	private static function _resizeMatricesShrink(&$matrix1,&$matrix2,$matrix1Rows,$matrix1Columns,$matrix2Rows,$matrix2Columns) {
2492	if (($matrix2Columns < $matrix1Columns) \|\| ($matrix2Rows < $matrix1Rows)) {
2493	if ($matrix2Rows < $matrix1Rows) {
2494	for ($i = $matrix2Rows; $i < $matrix1Rows; ++$i) {
2495	unset($matrix1[$i]);
2496	}
2497	}
2498	if ($matrix2Columns < $matrix1Columns) {
2499	for ($i = 0; $i < $matrix1Rows; ++$i) {
2500	for ($j = $matrix2Columns; $j < $matrix1Columns; ++$j) {
2501	unset($matrix1[$i][$j]);
2502	}
2503	}
2504	}
2505	}
2506
2507	if (($matrix1Columns < $matrix2Columns) \|\| ($matrix1Rows < $matrix2Rows)) {
2508	if ($matrix1Rows < $matrix2Rows) {
2509	for ($i = $matrix1Rows; $i < $matrix2Rows; ++$i) {
2510	unset($matrix2[$i]);
2511	}
2512	}
2513	if ($matrix1Columns < $matrix2Columns) {
2514	for ($i = 0; $i < $matrix2Rows; ++$i) {
2515	for ($j = $matrix1Columns; $j < $matrix2Columns; ++$j) {
2516	unset($matrix2[$i][$j]);
2517	}
2518	}
2519	}
2520	}
2521	} // function _resizeMatricesShrink()
2522
2523
2524	/**
2525	* Ensure that paired matrix operands are both matrices of the same size
2526	*
2527	* @param mixed &$matrix1 First matrix operand
2528	* @param mixed &$matrix2 Second matrix operand
2529	* @param integer $matrix1Rows Row size of first matrix operand
2530	* @param integer $matrix1Columns Column size of first matrix operand
2531	* @param integer $matrix2Rows Row size of second matrix operand
2532	* @param integer $matrix2Columns Column size of second matrix operand
2533	*/
2534	private static function _resizeMatricesExtend(&$matrix1,&$matrix2,$matrix1Rows,$matrix1Columns,$matrix2Rows,$matrix2Columns) {
2535	if (($matrix2Columns < $matrix1Columns) \|\| ($matrix2Rows < $matrix1Rows)) {
2536	if ($matrix2Columns < $matrix1Columns) {
2537	for ($i = 0; $i < $matrix2Rows; ++$i) {
2538	$x = $matrix2[$i][$matrix2Columns-1];
2539	for ($j = $matrix2Columns; $j < $matrix1Columns; ++$j) {
2540	$matrix2[$i][$j] = $x;
2541	}
2542	}
2543	}
2544	if ($matrix2Rows < $matrix1Rows) {
2545	$x = $matrix2[$matrix2Rows-1];
2546	for ($i = 0; $i < $matrix1Rows; ++$i) {
2547	$matrix2[$i] = $x;
2548	}
2549	}
2550	}
2551
2552	if (($matrix1Columns < $matrix2Columns) \|\| ($matrix1Rows < $matrix2Rows)) {
2553	if ($matrix1Columns < $matrix2Columns) {
2554	for ($i = 0; $i < $matrix1Rows; ++$i) {
2555	$x = $matrix1[$i][$matrix1Columns-1];
2556	for ($j = $matrix1Columns; $j < $matrix2Columns; ++$j) {
2557	$matrix1[$i][$j] = $x;
2558	}
2559	}
2560	}
2561	if ($matrix1Rows < $matrix2Rows) {
2562	$x = $matrix1[$matrix1Rows-1];
2563	for ($i = 0; $i < $matrix2Rows; ++$i) {
2564	$matrix1[$i] = $x;
2565	}
2566	}
2567	}
2568	} // function _resizeMatricesExtend()
2569
2570
2571	/**
2572	* Format details of an operand for display in the log (based on operand type)
2573	*
2574	* @param mixed $value First matrix operand
2575	* @return mixed
2576	*/
2577	private function _showValue($value) {
2578	if ($this->_debugLog->getWriteDebugLog()) {
2579	$testArray = PHPExcel_Calculation_Functions::flattenArray($value);
2580	if (count($testArray) == 1) {
2581	$value = array_pop($testArray);
2582	}
2583
2584	if (is_array($value)) {
2585	$returnMatrix = array();
2586	$pad = $rpad = ', ';
2587	foreach($value as $row) {
2588	if (is_array($row)) {
2589	$returnMatrix[] = implode($pad,array_map(array($this,'_showValue'),$row));
2590	$rpad = '; ';
2591	} else {
2592	$returnMatrix[] = $this->_showValue($row);
2593	}
2594	}
2595	return '{ '.implode($rpad,$returnMatrix).' }';
2596	} elseif(is_string($value) && (trim($value,'"') == $value)) {
2597	return '"'.$value.'"';
2598	} elseif(is_bool($value)) {
2599	return ($value) ? self::$_localeBoolean['TRUE'] : self::$_localeBoolean['FALSE'];
2600	}
2601	}
2602	return PHPExcel_Calculation_Functions::flattenSingleValue($value);
2603	} // function _showValue()
2604
2605
2606	/**
2607	* Format type and details of an operand for display in the log (based on operand type)
2608	*
2609	* @param mixed $value First matrix operand
2610	* @return mixed
2611	*/
2612	private function _showTypeDetails($value) {
2613	if ($this->_debugLog->getWriteDebugLog()) {
2614	$testArray = PHPExcel_Calculation_Functions::flattenArray($value);
2615	if (count($testArray) == 1) {
2616	$value = array_pop($testArray);
2617	}
2618
2619	if ($value === NULL) {
2620	return 'a NULL value';
2621	} elseif (is_float($value)) {
2622	$typeString = 'a floating point number';
2623	} elseif(is_int($value)) {
2624	$typeString = 'an integer number';
2625	} elseif(is_bool($value)) {
2626	$typeString = 'a boolean';
2627	} elseif(is_array($value)) {
2628	$typeString = 'a matrix';
2629	} else {
2630	if ($value == '') {
2631	return 'an empty string';
2632	} elseif ($value{0} == '#') {
2633	return 'a '.$value.' error';
2634	} else {
2635	$typeString = 'a string';
2636	}
2637	}
2638	return $typeString.' with a value of '.$this->_showValue($value);
2639	}
2640	} // function _showTypeDetails()
2641
2642
2643	private static function _convertMatrixReferences($formula) {
2644	static $matrixReplaceFrom = array('{',';','}');
2645	static $matrixReplaceTo = array('MKMATRIX(MKMATRIX(','),MKMATRIX(','))');
2646
2647	// Convert any Excel matrix references to the MKMATRIX() function
2648	if (strpos($formula,'{') !== FALSE) {
2649	// If there is the possibility of braces within a quoted string, then we don't treat those as matrix indicators
2650	if (strpos($formula,'"') !== FALSE) {
2651	// So instead we skip replacing in any quoted strings by only replacing in every other array element after we've exploded
2652	// the formula
2653	$temp = explode('"',$formula);
2654	// Open and Closed counts used for trapping mismatched braces in the formula
2655	$openCount = $closeCount = 0;
2656	$i = FALSE;
2657	foreach($temp as &$value) {
2658	// Only count/replace in alternating array entries
2659	if ($i = !$i) {
2660	$openCount += substr_count($value,'{');
2661	$closeCount += substr_count($value,'}');
2662	$value = str_replace($matrixReplaceFrom,$matrixReplaceTo,$value);
2663	}
2664	}
2665	unset($value);
2666	// Then rebuild the formula string
2667	$formula = implode('"',$temp);
2668	} else {
2669	// If there's no quoted strings, then we do a simple count/replace
2670	$openCount = substr_count($formula,'{');
2671	$closeCount = substr_count($formula,'}');
2672	$formula = str_replace($matrixReplaceFrom,$matrixReplaceTo,$formula);
2673	}
2674	// Trap for mismatched braces and trigger an appropriate error
2675	if ($openCount < $closeCount) {
2676	if ($openCount > 0) {
2677	return $this->_raiseFormulaError("Formula Error: Mismatched matrix braces '}'");
2678	} else {
2679	return $this->_raiseFormulaError("Formula Error: Unexpected '}' encountered");
2680	}
2681	} elseif ($openCount > $closeCount) {
2682	if ($closeCount > 0) {
2683	return $this->_raiseFormulaError("Formula Error: Mismatched matrix braces '{'");
2684	} else {
2685	return $this->_raiseFormulaError("Formula Error: Unexpected '{' encountered");
2686	}
2687	}
2688	}
2689
2690	return $formula;
2691	} // function _convertMatrixReferences()
2692
2693
2694	private static function _mkMatrix() {
2695	return func_get_args();
2696	} // function _mkMatrix()
2697
2698
2699	// Binary Operators
2700	// These operators always work on two values
2701	// Array key is the operator, the value indicates whether this is a left or right associative operator
2702	private static $_operatorAssociativity = array(
2703	'^' => 0, // Exponentiation
2704	'*' => 0, '/' => 0, // Multiplication and Division
2705	'+' => 0, '-' => 0, // Addition and Subtraction
2706	'&' => 0, // Concatenation
2707	'\|' => 0, ':' => 0, // Intersect and Range
2708	'>' => 0, '<' => 0, '=' => 0, '>=' => 0, '<=' => 0, '<>' => 0 // Comparison
2709	);
2710
2711	// Comparison (Boolean) Operators
2712	// These operators work on two values, but always return a boolean result
2713	private static $_comparisonOperators = array('>' => TRUE, '<' => TRUE, '=' => TRUE, '>=' => TRUE, '<=' => TRUE, '<>' => TRUE);
2714
2715	// Operator Precedence
2716	// This list includes all valid operators, whether binary (including boolean) or unary (such as %)
2717	// Array key is the operator, the value is its precedence
2718	private static $_operatorPrecedence = array(
2719	':' => 8, // Range
2720	'\|' => 7, // Intersect
2721	'~' => 6, // Negation
2722	'%' => 5, // Percentage
2723	'^' => 4, // Exponentiation
2724	'*' => 3, '/' => 3, // Multiplication and Division
2725	'+' => 2, '-' => 2, // Addition and Subtraction
2726	'&' => 1, // Concatenation
2727	'>' => 0, '<' => 0, '=' => 0, '>=' => 0, '<=' => 0, '<>' => 0 // Comparison
2728	);
2729
2730	// Convert infix to postfix notation
2731	private function _parseFormula($formula, PHPExcel_Cell $pCell = NULL) {
2732	if (($formula = self::_convertMatrixReferences(trim($formula))) === FALSE) {
2733	return FALSE;
2734	}
2735
2736	// If we're using cell caching, then $pCell may well be flushed back to the cache (which detaches the parent worksheet),
2737	// so we store the parent worksheet so that we can re-attach it when necessary
2738	$pCellParent = ($pCell !== NULL) ? $pCell->getWorksheet() : NULL;
2739
2740	$regexpMatchString = '/^('.self::CALCULATION_REGEXP_FUNCTION.
2741	'\|'.self::CALCULATION_REGEXP_CELLREF.
2742	'\|'.self::CALCULATION_REGEXP_NUMBER.
2743	'\|'.self::CALCULATION_REGEXP_STRING.
2744	'\|'.self::CALCULATION_REGEXP_OPENBRACE.
2745	'\|'.self::CALCULATION_REGEXP_NAMEDRANGE.
2746	'\|'.self::CALCULATION_REGEXP_ERROR.
2747	')/si';
2748
2749	// Start with initialisation
2750	$index = 0;
2751	$stack = new PHPExcel_Calculation_Token_Stack;
2752	$output = array();
2753	$expectingOperator = FALSE; // We use this test in syntax-checking the expression to determine when a
2754	// - is a negation or + is a positive operator rather than an operation
2755	$expectingOperand = FALSE; // We use this test in syntax-checking the expression to determine whether an operand
2756	// should be null in a function call
2757	// The guts of the lexical parser
2758	// Loop through the formula extracting each operator and operand in turn
2759	while(TRUE) {
2760	//echo 'Assessing Expression '.substr($formula, $index),PHP_EOL;
2761	$opCharacter = $formula{$index}; // Get the first character of the value at the current index position
2762	//echo 'Initial character of expression block is '.$opCharacter,PHP_EOL;
2763	if ((isset(self::$_comparisonOperators[$opCharacter])) && (strlen($formula) > $index) && (isset(self::$_comparisonOperators[$formula{$index+1}]))) {
2764	$opCharacter .= $formula{++$index};
2765	//echo 'Initial character of expression block is comparison operator '.$opCharacter.PHP_EOL;
2766	}
2767
2768	// Find out if we're currently at the beginning of a number, variable, cell reference, function, parenthesis or operand
2769	$isOperandOrFunction = preg_match($regexpMatchString, substr($formula, $index), $match);
2770	//echo '$isOperandOrFunction is '.(($isOperandOrFunction) ? 'True' : 'False').PHP_EOL;
2771	//var_dump($match);
2772
2773	if ($opCharacter == '-' && !$expectingOperator) { // Is it a negation instead of a minus?
2774	//echo 'Element is a Negation operator',PHP_EOL;
2775	$stack->push('Unary Operator','~'); // Put a negation on the stack
2776	++$index; // and drop the negation symbol
2777	} elseif ($opCharacter == '%' && $expectingOperator) {
2778	//echo 'Element is a Percentage operator',PHP_EOL;
2779	$stack->push('Unary Operator','%'); // Put a percentage on the stack
2780	++$index;
2781	} elseif ($opCharacter == '+' && !$expectingOperator) { // Positive (unary plus rather than binary operator plus) can be discarded?
2782	//echo 'Element is a Positive number, not Plus operator',PHP_EOL;
2783	++$index; // Drop the redundant plus symbol
2784	} elseif ((($opCharacter == '~') \|\| ($opCharacter == '\|')) && (!$isOperandOrFunction)) { // We have to explicitly deny a tilde or pipe, because they are legal
2785	return $this->_raiseFormulaError("Formula Error: Illegal character '~'"); // on the stack but not in the input expression
2786
2787	} elseif ((isset(self::$_operators[$opCharacter]) or $isOperandOrFunction) && $expectingOperator) { // Are we putting an operator on the stack?
2788	//echo 'Element with value '.$opCharacter.' is an Operator',PHP_EOL;
2789	while($stack->count() > 0 &&
2790	($o2 = $stack->last()) &&
2791	isset(self::$_operators[$o2['value']]) &&
2792	@(self::$_operatorAssociativity[$opCharacter] ? self::$_operatorPrecedence[$opCharacter] < self::$_operatorPrecedence[$o2['value']] : self::$_operatorPrecedence[$opCharacter] <= self::$_operatorPrecedence[$o2['value']])) {
2793	$output[] = $stack->pop(); // Swap operands and higher precedence operators from the stack to the output
2794	}
2795	$stack->push('Binary Operator',$opCharacter); // Finally put our current operator onto the stack
2796	++$index;
2797	$expectingOperator = FALSE;
2798
2799	} elseif ($opCharacter == ')' && $expectingOperator) { // Are we expecting to close a parenthesis?
2800	//echo 'Element is a Closing bracket',PHP_EOL;
2801	$expectingOperand = FALSE;
2802	while (($o2 = $stack->pop()) && $o2['value'] != '(') { // Pop off the stack back to the last (
2803	if ($o2 === NULL) return $this->_raiseFormulaError('Formula Error: Unexpected closing brace ")"');
2804	else $output[] = $o2;
2805	}
2806	$d = $stack->last(2);
2807	if (preg_match('/^'.self::CALCULATION_REGEXP_FUNCTION.'$/i', $d['value'], $matches)) { // Did this parenthesis just close a function?
2808	$functionName = $matches[1]; // Get the function name
2809	//echo 'Closed Function is '.$functionName,PHP_EOL;
2810	$d = $stack->pop();
2811	$argumentCount = $d['value']; // See how many arguments there were (argument count is the next value stored on the stack)
2812	//if ($argumentCount == 0) {
2813	// echo 'With no arguments',PHP_EOL;
2814	//} elseif ($argumentCount == 1) {
2815	// echo 'With 1 argument',PHP_EOL;
2816	//} else {
2817	// echo 'With '.$argumentCount.' arguments',PHP_EOL;
2818	//}
2819	$output[] = $d; // Dump the argument count on the output
2820	$output[] = $stack->pop(); // Pop the function and push onto the output
2821	if (isset(self::$_controlFunctions[$functionName])) {
2822	//echo 'Built-in function '.$functionName,PHP_EOL;
2823	$expectedArgumentCount = self::$_controlFunctions[$functionName]['argumentCount'];
2824	$functionCall = self::$_controlFunctions[$functionName]['functionCall'];
2825	} elseif (isset(self::$_PHPExcelFunctions[$functionName])) {
2826	//echo 'PHPExcel function '.$functionName,PHP_EOL;
2827	$expectedArgumentCount = self::$_PHPExcelFunctions[$functionName]['argumentCount'];
2828	$functionCall = self::$_PHPExcelFunctions[$functionName]['functionCall'];
2829	} else { // did we somehow push a non-function on the stack? this should never happen
2830	return $this->_raiseFormulaError("Formula Error: Internal error, non-function on stack");
2831	}
2832	// Check the argument count
2833	$argumentCountError = FALSE;
2834	if (is_numeric($expectedArgumentCount)) {
2835	if ($expectedArgumentCount < 0) {
2836	//echo '$expectedArgumentCount is between 0 and '.abs($expectedArgumentCount),PHP_EOL;
2837	if ($argumentCount > abs($expectedArgumentCount)) {
2838	$argumentCountError = TRUE;
2839	$expectedArgumentCountString = 'no more than '.abs($expectedArgumentCount);
2840	}
2841	} else {
2842	//echo '$expectedArgumentCount is numeric '.$expectedArgumentCount,PHP_EOL;
2843	if ($argumentCount != $expectedArgumentCount) {
2844	$argumentCountError = TRUE;
2845	$expectedArgumentCountString = $expectedArgumentCount;
2846	}
2847	}
2848	} elseif ($expectedArgumentCount != '*') {
2849	$isOperandOrFunction = preg_match('/(\d)([-+,])(\d)/',$expectedArgumentCount,$argMatch);
2850	//print_r($argMatch);
2851	//echo PHP_EOL;
2852	switch ($argMatch[2]) {
2853	case '+' :
2854	if ($argumentCount < $argMatch[1]) {
2855	$argumentCountError = TRUE;
2856	$expectedArgumentCountString = $argMatch[1].' or more ';
2857	}
2858	break;
2859	case '-' :
2860	if (($argumentCount < $argMatch[1]) \|\| ($argumentCount > $argMatch[3])) {
2861	$argumentCountError = TRUE;
2862	$expectedArgumentCountString = 'between '.$argMatch[1].' and '.$argMatch[3];
2863	}
2864	break;
2865	case ',' :
2866	if (($argumentCount != $argMatch[1]) && ($argumentCount != $argMatch[3])) {
2867	$argumentCountError = TRUE;
2868	$expectedArgumentCountString = 'either '.$argMatch[1].' or '.$argMatch[3];
2869	}
2870	break;
2871	}
2872	}
2873	if ($argumentCountError) {
2874	return $this->_raiseFormulaError("Formula Error: Wrong number of arguments for $functionName() function: $argumentCount given, ".$expectedArgumentCountString." expected");
2875	}
2876	}
2877	++$index;
2878
2879	} elseif ($opCharacter == ',') { // Is this the separator for function arguments?
2880	//echo 'Element is a Function argument separator',PHP_EOL;
2881	while (($o2 = $stack->pop()) && $o2['value'] != '(') { // Pop off the stack back to the last (
2882	if ($o2 === NULL) return $this->_raiseFormulaError("Formula Error: Unexpected ,");
2883	else $output[] = $o2; // pop the argument expression stuff and push onto the output
2884	}
2885	// If we've a comma when we're expecting an operand, then what we actually have is a null operand;
2886	// so push a null onto the stack
2887	if (($expectingOperand) \|\| (!$expectingOperator)) {
2888	$output[] = array('type' => 'NULL Value', 'value' => self::$_ExcelConstants['NULL'], 'reference' => NULL);
2889	}
2890	// make sure there was a function
2891	$d = $stack->last(2);
2892	if (!preg_match('/^'.self::CALCULATION_REGEXP_FUNCTION.'$/i', $d['value'], $matches))
2893	return $this->_raiseFormulaError("Formula Error: Unexpected ,");
2894	$d = $stack->pop();
2895	$stack->push($d['type'],++$d['value'],$d['reference']); // increment the argument count
2896	$stack->push('Brace', '('); // put the ( back on, we'll need to pop back to it again
2897	$expectingOperator = FALSE;
2898	$expectingOperand = TRUE;
2899	++$index;
2900
2901	} elseif ($opCharacter == '(' && !$expectingOperator) {
2902	// echo 'Element is an Opening Bracket<br />';
2903	$stack->push('Brace', '(');
2904	++$index;
2905
2906	} elseif ($isOperandOrFunction && !$expectingOperator) { // do we now have a function/variable/number?
2907	$expectingOperator = TRUE;
2908	$expectingOperand = FALSE;
2909	$val = $match[1];
2910	$length = strlen($val);
2911	// echo 'Element with value '.$val.' is an Operand, Variable, Constant, String, Number, Cell Reference or Function<br />';
2912
2913	if (preg_match('/^'.self::CALCULATION_REGEXP_FUNCTION.'$/i', $val, $matches)) {
2914	$val = preg_replace('/\s/','',$val);
2915	// echo 'Element '.$val.' is a Function<br />';
2916	if (isset(self::$_PHPExcelFunctions[strtoupper($matches[1])]) \|\| isset(self::$_controlFunctions[strtoupper($matches[1])])) { // it's a function
2917	$stack->push('Function', strtoupper($val));
2918	$ax = preg_match('/^\s(\s\))/i', substr($formula, $index+$length), $amatch);
2919	if ($ax) {
2920	$stack->push('Operand Count for Function '.strtoupper($val).')', 0);
2921	$expectingOperator = TRUE;
2922	} else {
2923	$stack->push('Operand Count for Function '.strtoupper($val).')', 1);
2924	$expectingOperator = FALSE;
2925	}
2926	$stack->push('Brace', '(');
2927	} else { // it's a var w/ implicit multiplication
2928	$output[] = array('type' => 'Value', 'value' => $matches[1], 'reference' => NULL);
2929	}
2930	} elseif (preg_match('/^'.self::CALCULATION_REGEXP_CELLREF.'$/i', $val, $matches)) {
2931	// echo 'Element '.$val.' is a Cell reference<br />';
2932	// Watch for this case-change when modifying to allow cell references in different worksheets...
2933	// Should only be applied to the actual cell column, not the worksheet name
2934
2935	// If the last entry on the stack was a : operator, then we have a cell range reference
2936	$testPrevOp = $stack->last(1);
2937	if ($testPrevOp['value'] == ':') {
2938	// If we have a worksheet reference, then we're playing with a 3D reference
2939	if ($matches[2] == '') {
2940	// Otherwise, we 'inherit' the worksheet reference from the start cell reference
2941	// The start of the cell range reference should be the last entry in $output
2942	$startCellRef = $output[count($output)-1]['value'];
2943	preg_match('/^'.self::CALCULATION_REGEXP_CELLREF.'$/i', $startCellRef, $startMatches);
2944	if ($startMatches[2] > '') {
2945	$val = $startMatches[2].'!'.$val;
2946	}
2947	} else {
2948	return $this->_raiseFormulaError("3D Range references are not yet supported");
2949	}
2950	}
2951
2952	$output[] = array('type' => 'Cell Reference', 'value' => $val, 'reference' => $val);
2953	// $expectingOperator = FALSE;
2954	} else { // it's a variable, constant, string, number or boolean
2955	// echo 'Element is a Variable, Constant, String, Number or Boolean<br />';
2956	// If the last entry on the stack was a : operator, then we may have a row or column range reference
2957	$testPrevOp = $stack->last(1);
2958	if ($testPrevOp['value'] == ':') {
2959	$startRowColRef = $output[count($output)-1]['value'];
2960	$rangeWS1 = '';
2961	if (strpos('!',$startRowColRef) !== FALSE) {
2962	list($rangeWS1,$startRowColRef) = explode('!',$startRowColRef);
2963	}
2964	if ($rangeWS1 != '') $rangeWS1 .= '!';
2965	$rangeWS2 = $rangeWS1;
2966	if (strpos('!',$val) !== FALSE) {
2967	list($rangeWS2,$val) = explode('!',$val);
2968	}
2969	if ($rangeWS2 != '') $rangeWS2 .= '!';
2970	if ((is_integer($startRowColRef)) && (ctype_digit($val)) &&
2971	($startRowColRef <= 1048576) && ($val <= 1048576)) {
2972	// Row range
2973	$endRowColRef = ($pCellParent !== NULL) ? $pCellParent->getHighestColumn() : 'XFD'; // Max 16,384 columns for Excel2007
2974	$output[count($output)-1]['value'] = $rangeWS1.'A'.$startRowColRef;
2975	$val = $rangeWS2.$endRowColRef.$val;
2976	} elseif ((ctype_alpha($startRowColRef)) && (ctype_alpha($val)) &&
2977	(strlen($startRowColRef) <= 3) && (strlen($val) <= 3)) {
2978	// Column range
2979	$endRowColRef = ($pCellParent !== NULL) ? $pCellParent->getHighestRow() : 1048576; // Max 1,048,576 rows for Excel2007
2980	$output[count($output)-1]['value'] = $rangeWS1.strtoupper($startRowColRef).'1';
2981	$val = $rangeWS2.$val.$endRowColRef;
2982	}
2983	}
2984
2985	$localeConstant = FALSE;
2986	if ($opCharacter == '"') {
2987	// echo 'Element is a String<br />';
2988	// UnEscape any quotes within the string
2989	$val = self::_wrapResult(str_replace('""','"',self::_unwrapResult($val)));
2990	} elseif (is_numeric($val)) {
2991	// echo 'Element is a Number<br />';
2992	if ((strpos($val,'.') !== FALSE) \|\| (stripos($val,'e') !== FALSE) \|\| ($val > PHP_INT_MAX) \|\| ($val < -PHP_INT_MAX)) {
2993	// echo 'Casting '.$val.' to float<br />';
2994	$val = (float) $val;
2995	} else {
2996	// echo 'Casting '.$val.' to integer<br />';
2997	$val = (integer) $val;
2998	}
2999	} elseif (isset(self::$_ExcelConstants[trim(strtoupper($val))])) {
3000	$excelConstant = trim(strtoupper($val));
3001	// echo 'Element '.$excelConstant.' is an Excel Constant<br />';
3002	$val = self::$_ExcelConstants[$excelConstant];
3003	} elseif (($localeConstant = array_search(trim(strtoupper($val)), self::$_localeBoolean)) !== FALSE) {
3004	// echo 'Element '.$localeConstant.' is an Excel Constant<br />';
3005	$val = self::$_ExcelConstants[$localeConstant];
3006	}
3007	$details = array('type' => 'Value', 'value' => $val, 'reference' => NULL);
3008	if ($localeConstant) { $details['localeValue'] = $localeConstant; }
3009	$output[] = $details;
3010	}
3011	$index += $length;
3012
3013	} elseif ($opCharacter == '$') { // absolute row or column range
3014	++$index;
3015	} elseif ($opCharacter == ')') { // miscellaneous error checking
3016	if ($expectingOperand) {
3017	$output[] = array('type' => 'NULL Value', 'value' => self::$_ExcelConstants['NULL'], 'reference' => NULL);
3018	$expectingOperand = FALSE;
3019	$expectingOperator = TRUE;
3020	} else {
3021	return $this->_raiseFormulaError("Formula Error: Unexpected ')'");
3022	}
3023	} elseif (isset(self::$_operators[$opCharacter]) && !$expectingOperator) {
3024	return $this->_raiseFormulaError("Formula Error: Unexpected operator '$opCharacter'");
3025	} else { // I don't even want to know what you did to get here
3026	return $this->_raiseFormulaError("Formula Error: An unexpected error occured");
3027	}
3028	// Test for end of formula string
3029	if ($index == strlen($formula)) {
3030	// Did we end with an operator?.
3031	// Only valid for the % unary operator
3032	if ((isset(self::$_operators[$opCharacter])) && ($opCharacter != '%')) {
3033	return $this->_raiseFormulaError("Formula Error: Operator '$opCharacter' has no operands");
3034	} else {
3035	break;
3036	}
3037	}
3038	// Ignore white space
3039	while (($formula{$index} == "\n") \|\| ($formula{$index} == "\r")) {
3040	++$index;
3041	}
3042	if ($formula{$index} == ' ') {
3043	while ($formula{$index} == ' ') {
3044	++$index;
3045	}
3046	// If we're expecting an operator, but only have a space between the previous and next operands (and both are
3047	// Cell References) then we have an INTERSECTION operator
3048	// echo 'Possible Intersect Operator<br />';
3049	if (($expectingOperator) && (preg_match('/^'.self::CALCULATION_REGEXP_CELLREF.'.*/Ui', substr($formula, $index), $match)) &&
3050	($output[count($output)-1]['type'] == 'Cell Reference')) {
3051	// echo 'Element is an Intersect Operator<br />';
3052	while($stack->count() > 0 &&
3053	($o2 = $stack->last()) &&
3054	isset(self::$_operators[$o2['value']]) &&
3055	@(self::$_operatorAssociativity[$opCharacter] ? self::$_operatorPrecedence[$opCharacter] < self::$_operatorPrecedence[$o2['value']] : self::$_operatorPrecedence[$opCharacter] <= self::$_operatorPrecedence[$o2['value']])) {
3056	$output[] = $stack->pop(); // Swap operands and higher precedence operators from the stack to the output
3057	}
3058	$stack->push('Binary Operator','\|'); // Put an Intersect Operator on the stack
3059	$expectingOperator = FALSE;
3060	}
3061	}
3062	}
3063
3064	while (($op = $stack->pop()) !== NULL) { // pop everything off the stack and push onto output
3065	if ((is_array($op) && $op['value'] == '(') \|\| ($op === '('))
3066	return $this->_raiseFormulaError("Formula Error: Expecting ')'"); // if there are any opening braces on the stack, then braces were unbalanced
3067	$output[] = $op;
3068	}
3069	return $output;
3070	} // function _parseFormula()
3071
3072
3073	private static function _dataTestReference(&$operandData)
3074	{
3075	$operand = $operandData['value'];
3076	if (($operandData['reference'] === NULL) && (is_array($operand))) {
3077	$rKeys = array_keys($operand);
3078	$rowKey = array_shift($rKeys);
3079	$cKeys = array_keys(array_keys($operand[$rowKey]));
3080	$colKey = array_shift($cKeys);
3081	if (ctype_upper($colKey)) {
3082	$operandData['reference'] = $colKey.$rowKey;
3083	}
3084	}
3085	return $operand;
3086	}
3087
3088	// evaluate postfix notation
3089	private function _processTokenStack($tokens, $cellID = NULL, PHPExcel_Cell $pCell = NULL) {
3090	if ($tokens == FALSE) return FALSE;
3091
3092	// If we're using cell caching, then $pCell may well be flushed back to the cache (which detaches the parent cell collection),
3093	// so we store the parent cell collection so that we can re-attach it when necessary
3094	$pCellWorksheet = ($pCell !== NULL) ? $pCell->getWorksheet() : NULL;
3095	$pCellParent = ($pCell !== NULL) ? $pCell->getParent() : null;
3096	$stack = new PHPExcel_Calculation_Token_Stack;
3097
3098	// Loop through each token in turn
3099	foreach ($tokens as $tokenData) {
3100	// print_r($tokenData);
3101	// echo '<br />';
3102	$token = $tokenData['value'];
3103	// echo '<b>Token is '.$token.'</b><br />';
3104	// 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
3105	if (isset(self::$_binaryOperators[$token])) {
3106	// echo 'Token is a binary operator<br />';
3107	// We must have two operands, error if we don't
3108	if (($operand2Data = $stack->pop()) === NULL) return $this->_raiseFormulaError('Internal error - Operand value missing from stack');
3109	if (($operand1Data = $stack->pop()) === NULL) return $this->_raiseFormulaError('Internal error - Operand value missing from stack');
3110
3111	$operand1 = self::_dataTestReference($operand1Data);
3112	$operand2 = self::_dataTestReference($operand2Data);
3113
3114	// Log what we're doing
3115	if ($token == ':') {
3116	$this->_debugLog->writeDebugLog('Evaluating Range ', $this->_showValue($operand1Data['reference']), ' ', $token, ' ', $this->_showValue($operand2Data['reference']));
3117	} else {
3118	$this->_debugLog->writeDebugLog('Evaluating ', $this->_showValue($operand1), ' ', $token, ' ', $this->_showValue($operand2));
3119	}
3120
3121	// Process the operation in the appropriate manner
3122	switch ($token) {
3123	// Comparison (Boolean) Operators
3124	case '>' : // Greater than
3125	case '<' : // Less than
3126	case '>=' : // Greater than or Equal to
3127	case '<=' : // Less than or Equal to
3128	case '=' : // Equality
3129	case '<>' : // Inequality
3130	$this->_executeBinaryComparisonOperation($cellID,$operand1,$operand2,$token,$stack);
3131	break;
3132	// Binary Operators
3133	case ':' : // Range
3134	$sheet1 = $sheet2 = '';
3135	if (strpos($operand1Data['reference'],'!') !== FALSE) {
3136	list($sheet1,$operand1Data['reference']) = explode('!',$operand1Data['reference']);
3137	} else {
3138	$sheet1 = ($pCellParent !== NULL) ? $pCellWorksheet->getTitle() : '';
3139	}
3140	if (strpos($operand2Data['reference'],'!') !== FALSE) {
3141	list($sheet2,$operand2Data['reference']) = explode('!',$operand2Data['reference']);
3142	} else {
3143	$sheet2 = $sheet1;
3144	}
3145	if ($sheet1 == $sheet2) {
3146	if ($operand1Data['reference'] === NULL) {
3147	if ((trim($operand1Data['value']) != '') && (is_numeric($operand1Data['value']))) {
3148	$operand1Data['reference'] = $pCell->getColumn().$operand1Data['value'];
3149	} elseif (trim($operand1Data['reference']) == '') {
3150	$operand1Data['reference'] = $pCell->getCoordinate();
3151	} else {
3152	$operand1Data['reference'] = $operand1Data['value'].$pCell->getRow();
3153	}
3154	}
3155	if ($operand2Data['reference'] === NULL) {
3156	if ((trim($operand2Data['value']) != '') && (is_numeric($operand2Data['value']))) {
3157	$operand2Data['reference'] = $pCell->getColumn().$operand2Data['value'];
3158	} elseif (trim($operand2Data['reference']) == '') {
3159	$operand2Data['reference'] = $pCell->getCoordinate();
3160	} else {
3161	$operand2Data['reference'] = $operand2Data['value'].$pCell->getRow();
3162	}
3163	}
3164
3165	$oData = array_merge(explode(':',$operand1Data['reference']),explode(':',$operand2Data['reference']));
3166	$oCol = $oRow = array();
3167	foreach($oData as $oDatum) {
3168	$oCR = PHPExcel_Cell::coordinateFromString($oDatum);
3169	$oCol[] = PHPExcel_Cell::columnIndexFromString($oCR[0]) - 1;
3170	$oRow[] = $oCR[1];
3171	}
3172	$cellRef = PHPExcel_Cell::stringFromColumnIndex(min($oCol)).min($oRow).':'.PHPExcel_Cell::stringFromColumnIndex(max($oCol)).max($oRow);
3173	if ($pCellParent !== NULL) {
3174	$cellValue = $this->extractCellRange($cellRef, $this->_workbook->getSheetByName($sheet1), FALSE);
3175	} else {
3176	return $this->_raiseFormulaError('Unable to access Cell Reference');
3177	}
3178	$stack->push('Cell Reference',$cellValue,$cellRef);
3179	} else {
3180	$stack->push('Error',PHPExcel_Calculation_Functions::REF(),NULL);
3181	}
3182
3183	break;
3184	case '+' : // Addition
3185	$this->_executeNumericBinaryOperation($cellID,$operand1,$operand2,$token,'plusEquals',$stack);
3186	break;
3187	case '-' : // Subtraction
3188	$this->_executeNumericBinaryOperation($cellID,$operand1,$operand2,$token,'minusEquals',$stack);
3189	break;
3190	case '*' : // Multiplication
3191	$this->_executeNumericBinaryOperation($cellID,$operand1,$operand2,$token,'arrayTimesEquals',$stack);
3192	break;
3193	case '/' : // Division
3194	$this->_executeNumericBinaryOperation($cellID,$operand1,$operand2,$token,'arrayRightDivide',$stack);
3195	break;
3196	case '^' : // Exponential
3197	$this->_executeNumericBinaryOperation($cellID,$operand1,$operand2,$token,'power',$stack);
3198	break;
3199	case '&' : // Concatenation
3200	// If either of the operands is a matrix, we need to treat them both as matrices
3201	// (converting the other operand to a matrix if need be); then perform the required
3202	// matrix operation
3203	if (is_bool($operand1)) {
3204	$operand1 = ($operand1) ? self::$_localeBoolean['TRUE'] : self::$_localeBoolean['FALSE'];
3205	}
3206	if (is_bool($operand2)) {
3207	$operand2 = ($operand2) ? self::$_localeBoolean['TRUE'] : self::$_localeBoolean['FALSE'];
3208	}
3209	if ((is_array($operand1)) \|\| (is_array($operand2))) {
3210	// Ensure that both operands are arrays/matrices
3211	self::_checkMatrixOperands($operand1,$operand2,2);
3212	try {
3213	// Convert operand 1 from a PHP array to a matrix
3214	$matrix = new PHPExcel_Shared_JAMA_Matrix($operand1);
3215	// Perform the required operation against the operand 1 matrix, passing in operand 2
3216	$matrixResult = $matrix->concat($operand2);
3217	$result = $matrixResult->getArray();
3218	} catch (PHPExcel_Exception $ex) {
3219	$this->_debugLog->writeDebugLog('JAMA Matrix Exception: ', $ex->getMessage());
3220	$result = '#VALUE!';
3221	}
3222	} else {
3223	$result = '"'.str_replace('""','"',self::_unwrapResult($operand1,'"').self::_unwrapResult($operand2,'"')).'"';
3224	}
3225	$this->_debugLog->writeDebugLog('Evaluation Result is ', $this->_showTypeDetails($result));
3226	$stack->push('Value',$result);
3227	break;
3228	case '\|' : // Intersect
3229	$rowIntersect = array_intersect_key($operand1,$operand2);
3230	$cellIntersect = $oCol = $oRow = array();
3231	foreach(array_keys($rowIntersect) as $row) {
3232	$oRow[] = $row;
3233	foreach($rowIntersect[$row] as $col => $data) {
3234	$oCol[] = PHPExcel_Cell::columnIndexFromString($col) - 1;
3235	$cellIntersect[$row] = array_intersect_key($operand1[$row],$operand2[$row]);
3236	}
3237	}
3238	$cellRef = PHPExcel_Cell::stringFromColumnIndex(min($oCol)).min($oRow).':'.PHPExcel_Cell::stringFromColumnIndex(max($oCol)).max($oRow);
3239	$this->_debugLog->writeDebugLog('Evaluation Result is ', $this->_showTypeDetails($cellIntersect));
3240	$stack->push('Value',$cellIntersect,$cellRef);
3241	break;
3242	}
3243
3244	// if the token is a unary operator, pop one value off the stack, do the operation, and push it back on
3245	} elseif (($token === '~') \|\| ($token === '%')) {
3246	// echo 'Token is a unary operator<br />';
3247	if (($arg = $stack->pop()) === NULL) return $this->_raiseFormulaError('Internal error - Operand value missing from stack');
3248	$arg = $arg['value'];
3249	if ($token === '~') {
3250	// echo 'Token is a negation operator<br />';
3251	$this->_debugLog->writeDebugLog('Evaluating Negation of ', $this->_showValue($arg));
3252	$multiplier = -1;
3253	} else {
3254	// echo 'Token is a percentile operator<br />';
3255	$this->_debugLog->writeDebugLog('Evaluating Percentile of ', $this->_showValue($arg));
3256	$multiplier = 0.01;
3257	}
3258	if (is_array($arg)) {
3259	self::_checkMatrixOperands($arg,$multiplier,2);
3260	try {
3261	$matrix1 = new PHPExcel_Shared_JAMA_Matrix($arg);
3262	$matrixResult = $matrix1->arrayTimesEquals($multiplier);
3263	$result = $matrixResult->getArray();
3264	} catch (PHPExcel_Exception $ex) {
3265	$this->_debugLog->writeDebugLog('JAMA Matrix Exception: ', $ex->getMessage());
3266	$result = '#VALUE!';
3267	}
3268	$this->_debugLog->writeDebugLog('Evaluation Result is ', $this->_showTypeDetails($result));
3269	$stack->push('Value',$result);
3270	} else {
3271	$this->_executeNumericBinaryOperation($cellID,$multiplier,$arg,'*','arrayTimesEquals',$stack);
3272	}
3273
3274	} elseif (preg_match('/^'.self::CALCULATION_REGEXP_CELLREF.'$/i', $token, $matches)) {
3275	$cellRef = NULL;
3276	// echo 'Element '.$token.' is a Cell reference<br />';
3277	if (isset($matches[8])) {
3278	// echo 'Reference is a Range of cells<br />';
3279	if ($pCell === NULL) {
3280	// We can't access the range, so return a REF error
3281	$cellValue = PHPExcel_Calculation_Functions::REF();
3282	} else {
3283	$cellRef = $matches[6].$matches[7].':'.$matches[9].$matches[10];
3284	if ($matches[2] > '') {
3285	$matches[2] = trim($matches[2],"\"'");
3286	if ((strpos($matches[2],'[') !== FALSE) \|\| (strpos($matches[2],']') !== FALSE)) {
3287	// It's a Reference to an external workbook (not currently supported)
3288	return $this->_raiseFormulaError('Unable to access External Workbook');
3289	}
3290	$matches[2] = trim($matches[2],"\"'");
3291	// echo '$cellRef='.$cellRef.' in worksheet '.$matches[2].'<br />';
3292	$this->_debugLog->writeDebugLog('Evaluating Cell Range ', $cellRef, ' in worksheet ', $matches[2]);
3293	if ($pCellParent !== NULL) {
3294	$cellValue = $this->extractCellRange($cellRef, $this->_workbook->getSheetByName($matches[2]), FALSE);
3295	} else {
3296	return $this->_raiseFormulaError('Unable to access Cell Reference');
3297	}
3298	$this->_debugLog->writeDebugLog('Evaluation Result for cells ', $cellRef, ' in worksheet ', $matches[2], ' is ', $this->_showTypeDetails($cellValue));
3299	// $cellRef = $matches[2].'!'.$cellRef;
3300	} else {
3301	// echo '$cellRef='.$cellRef.' in current worksheet<br />';
3302	$this->_debugLog->writeDebugLog('Evaluating Cell Range ', $cellRef, ' in current worksheet');
3303	if ($pCellParent !== NULL) {
3304	$cellValue = $this->extractCellRange($cellRef, $pCellWorksheet, FALSE);
3305	} else {
3306	return $this->_raiseFormulaError('Unable to access Cell Reference');
3307	}
3308	$this->_debugLog->writeDebugLog('Evaluation Result for cells ', $cellRef, ' is ', $this->_showTypeDetails($cellValue));
3309	}
3310	}
3311	} else {
3312	// echo 'Reference is a single Cell<br />';
3313	if ($pCell === NULL) {
3314	// We can't access the cell, so return a REF error
3315	$cellValue = PHPExcel_Calculation_Functions::REF();
3316	} else {
3317	$cellRef = $matches[6].$matches[7];
3318	if ($matches[2] > '') {
3319	$matches[2] = trim($matches[2],"\"'");
3320	if ((strpos($matches[2],'[') !== FALSE) \|\| (strpos($matches[2],']') !== FALSE)) {
3321	// It's a Reference to an external workbook (not currently supported)
3322	return $this->_raiseFormulaError('Unable to access External Workbook');
3323	}
3324	// echo '$cellRef='.$cellRef.' in worksheet '.$matches[2].'<br />';
3325	$this->_debugLog->writeDebugLog('Evaluating Cell ', $cellRef, ' in worksheet ', $matches[2]);
3326	if ($pCellParent !== NULL) {
3327	$cellSheet = $this->_workbook->getSheetByName($matches[2]);
3328	if ($cellSheet && $cellSheet->cellExists($cellRef)) {
3329	$cellValue = $this->extractCellRange($cellRef, $this->_workbook->getSheetByName($matches[2]), FALSE);
3330	$pCell->attach($pCellParent);
3331	} else {
3332	$cellValue = NULL;
3333	}
3334	} else {
3335	return $this->_raiseFormulaError('Unable to access Cell Reference');
3336	}
3337	$this->_debugLog->writeDebugLog('Evaluation Result for cell ', $cellRef, ' in worksheet ', $matches[2], ' is ', $this->_showTypeDetails($cellValue));
3338	// $cellRef = $matches[2].'!'.$cellRef;
3339	} else {
3340	// echo '$cellRef='.$cellRef.' in current worksheet<br />';
3341	$this->_debugLog->writeDebugLog('Evaluating Cell ', $cellRef, ' in current worksheet');
3342	if ($pCellParent->isDataSet($cellRef)) {
3343	$cellValue = $this->extractCellRange($cellRef, $pCellWorksheet, FALSE);
3344	$pCell->attach($pCellParent);
3345	} else {
3346	$cellValue = NULL;
3347	}
3348	$this->_debugLog->writeDebugLog('Evaluation Result for cell ', $cellRef, ' is ', $this->_showTypeDetails($cellValue));
3349	}
3350	}
3351	}
3352	$stack->push('Value',$cellValue,$cellRef);
3353
3354	// if the token is a function, pop arguments off the stack, hand them to the function, and push the result back on
3355	} elseif (preg_match('/^'.self::CALCULATION_REGEXP_FUNCTION.'$/i', $token, $matches)) {
3356	// echo 'Token is a function<br />';
3357	$functionName = $matches[1];
3358	$argCount = $stack->pop();
3359	$argCount = $argCount['value'];
3360	if ($functionName != 'MKMATRIX') {
3361	$this->_debugLog->writeDebugLog('Evaluating Function ', self::_localeFunc($functionName), '() with ', (($argCount == 0) ? 'no' : $argCount), ' argument', (($argCount == 1) ? '' : 's'));
3362	}
3363	if ((isset(self::$_PHPExcelFunctions[$functionName])) \|\| (isset(self::$_controlFunctions[$functionName]))) { // function
3364	if (isset(self::$_PHPExcelFunctions[$functionName])) {
3365	$functionCall = self::$_PHPExcelFunctions[$functionName]['functionCall'];
3366	$passByReference = isset(self::$_PHPExcelFunctions[$functionName]['passByReference']);
3367	$passCellReference = isset(self::$_PHPExcelFunctions[$functionName]['passCellReference']);
3368	} elseif (isset(self::$_controlFunctions[$functionName])) {
3369	$functionCall = self::$_controlFunctions[$functionName]['functionCall'];
3370	$passByReference = isset(self::$_controlFunctions[$functionName]['passByReference']);
3371	$passCellReference = isset(self::$_controlFunctions[$functionName]['passCellReference']);
3372	}
3373	// get the arguments for this function
3374	// echo 'Function '.$functionName.' expects '.$argCount.' arguments<br />';
3375	$args = $argArrayVals = array();
3376	for ($i = 0; $i < $argCount; ++$i) {
3377	$arg = $stack->pop();
3378	$a = $argCount - $i - 1;
3379	if (($passByReference) &&
3380	(isset(self::$_PHPExcelFunctions[$functionName]['passByReference'][$a])) &&
3381	(self::$_PHPExcelFunctions[$functionName]['passByReference'][$a])) {
3382	if ($arg['reference'] === NULL) {
3383	$args[] = $cellID;
3384	if ($functionName != 'MKMATRIX') { $argArrayVals[] = $this->_showValue($cellID); }
3385	} else {
3386	$args[] = $arg['reference'];
3387	if ($functionName != 'MKMATRIX') { $argArrayVals[] = $this->_showValue($arg['reference']); }
3388	}
3389	} else {
3390	$args[] = self::_unwrapResult($arg['value']);
3391	if ($functionName != 'MKMATRIX') { $argArrayVals[] = $this->_showValue($arg['value']); }
3392	}
3393	}
3394	// Reverse the order of the arguments
3395	krsort($args);
3396	if (($passByReference) && ($argCount == 0)) {
3397	$args[] = $cellID;
3398	$argArrayVals[] = $this->_showValue($cellID);
3399	}
3400	// echo 'Arguments are: ';
3401	// print_r($args);
3402	// echo '<br />';
3403	if ($functionName != 'MKMATRIX') {
3404	if ($this->_debugLog->getWriteDebugLog()) {
3405	krsort($argArrayVals);
3406	$this->_debugLog->writeDebugLog('Evaluating ', self::_localeFunc($functionName), '( ', implode(self::$_localeArgumentSeparator.' ',PHPExcel_Calculation_Functions::flattenArray($argArrayVals)), ' )');
3407	}
3408	}
3409	// Process each argument in turn, building the return value as an array
3410	// if (($argCount == 1) && (is_array($args[1])) && ($functionName != 'MKMATRIX')) {
3411	// $operand1 = $args[1];
3412	// $this->_debugLog->writeDebugLog('Argument is a matrix: ', $this->_showValue($operand1));
3413	// $result = array();
3414	// $row = 0;
3415	// foreach($operand1 as $args) {
3416	// if (is_array($args)) {
3417	// foreach($args as $arg) {
3418	// $this->_debugLog->writeDebugLog('Evaluating ', self::_localeFunc($functionName), '( ', $this->_showValue($arg), ' )');
3419	// $r = call_user_func_array($functionCall,$arg);
3420	// $this->_debugLog->writeDebugLog('Evaluation Result for ', self::_localeFunc($functionName), '() function call is ', $this->_showTypeDetails($r));
3421	// $result[$row][] = $r;
3422	// }
3423	// ++$row;
3424	// } else {
3425	// $this->_debugLog->writeDebugLog('Evaluating ', self::_localeFunc($functionName), '( ', $this->_showValue($args), ' )');
3426	// $r = call_user_func_array($functionCall,$args);
3427	// $this->_debugLog->writeDebugLog('Evaluation Result for ', self::_localeFunc($functionName), '() function call is ', $this->_showTypeDetails($r));
3428	// $result[] = $r;
3429	// }
3430	// }
3431	// } else {
3432	// Process the argument with the appropriate function call
3433	if ($passCellReference) {
3434	$args[] = $pCell;
3435	}
3436	if (strpos($functionCall,'::') !== FALSE) {
3437	$result = call_user_func_array(explode('::',$functionCall),$args);
3438	} else {
3439	foreach($args as &$arg) {
3440	$arg = PHPExcel_Calculation_Functions::flattenSingleValue($arg);
3441	}
3442	unset($arg);
3443	$result = call_user_func_array($functionCall,$args);
3444	}
3445	// }
3446	if ($functionName != 'MKMATRIX') {
3447	$this->_debugLog->writeDebugLog('Evaluation Result for ', self::_localeFunc($functionName), '() function call is ', $this->_showTypeDetails($result));
3448	}
3449	$stack->push('Value',self::_wrapResult($result));
3450	}
3451
3452	} else {
3453	// if the token is a number, boolean, string or an Excel error, push it onto the stack
3454	if (isset(self::$_ExcelConstants[strtoupper($token)])) {
3455	$excelConstant = strtoupper($token);
3456	// echo 'Token is a PHPExcel constant: '.$excelConstant.'<br />';
3457	$stack->push('Constant Value',self::$_ExcelConstants[$excelConstant]);
3458	$this->_debugLog->writeDebugLog('Evaluating Constant ', $excelConstant, ' as ', $this->_showTypeDetails(self::$_ExcelConstants[$excelConstant]));
3459	} elseif ((is_numeric($token)) \|\| ($token === NULL) \|\| (is_bool($token)) \|\| ($token == '') \|\| ($token{0} == '"') \|\| ($token{0} == '#')) {
3460	// echo 'Token is a number, boolean, string, null or an Excel error<br />';
3461	$stack->push('Value',$token);
3462	// if the token is a named range, push the named range name onto the stack
3463	} elseif (preg_match('/^'.self::CALCULATION_REGEXP_NAMEDRANGE.'$/i', $token, $matches)) {
3464	// echo 'Token is a named range<br />';
3465	$namedRange = $matches[6];
3466	// echo 'Named Range is '.$namedRange.'<br />';
3467	$this->_debugLog->writeDebugLog('Evaluating Named Range ', $namedRange);
3468	$cellValue = $this->extractNamedRange($namedRange, ((NULL !== $pCell) ? $pCellWorksheet : NULL), FALSE);
3469	$pCell->attach($pCellParent);
3470	$this->_debugLog->writeDebugLog('Evaluation Result for named range ', $namedRange, ' is ', $this->_showTypeDetails($cellValue));
3471	$stack->push('Named Range',$cellValue,$namedRange);
3472	} else {
3473	return $this->_raiseFormulaError("undefined variable '$token'");
3474	}
3475	}
3476	}
3477	// when we're out of tokens, the stack should have a single element, the final result
3478	if ($stack->count() != 1) return $this->_raiseFormulaError("internal error");
3479	$output = $stack->pop();
3480	$output = $output['value'];
3481
3482	// if ((is_array($output)) && (self::$returnArrayAsType != self::RETURN_ARRAY_AS_ARRAY)) {
3483	// return array_shift(PHPExcel_Calculation_Functions::flattenArray($output));
3484	// }
3485	return $output;
3486	} // function _processTokenStack()
3487
3488
3489	private function _validateBinaryOperand($cellID, &$operand, &$stack) {
3490	if (is_array($operand)) {
3491	if ((count($operand, COUNT_RECURSIVE) - count($operand)) == 1) {
3492	do {
3493	$operand = array_pop($operand);
3494	} while (is_array($operand));
3495	}
3496	}
3497	// Numbers, matrices and booleans can pass straight through, as they're already valid
3498	if (is_string($operand)) {
3499	// We only need special validations for the operand if it is a string
3500	// Start by stripping off the quotation marks we use to identify true excel string values internally
3501	if ($operand > '' && $operand{0} == '"') { $operand = self::_unwrapResult($operand); }
3502	// If the string is a numeric value, we treat it as a numeric, so no further testing
3503	if (!is_numeric($operand)) {
3504	// If not a numeric, test to see if the value is an Excel error, and so can't be used in normal binary operations
3505	if ($operand > '' && $operand{0} == '#') {
3506	$stack->push('Value', $operand);
3507	$this->_debugLog->writeDebugLog('Evaluation Result is ', $this->_showTypeDetails($operand));
3508	return FALSE;
3509	} elseif (!PHPExcel_Shared_String::convertToNumberIfFraction($operand)) {
3510	// If not a numeric or a fraction, then it's a text string, and so can't be used in mathematical binary operations
3511	$stack->push('Value', '#VALUE!');
3512	$this->_debugLog->writeDebugLog('Evaluation Result is a ', $this->_showTypeDetails('#VALUE!'));
3513	return FALSE;
3514	}
3515	}
3516	}
3517
3518	// return a true if the value of the operand is one that we can use in normal binary operations
3519	return TRUE;
3520	} // function _validateBinaryOperand()
3521
3522
3523	private function _executeBinaryComparisonOperation($cellID, $operand1, $operand2, $operation, &$stack, $recursingArrays=FALSE) {
3524	// If we're dealing with matrix operations, we want a matrix result
3525	if ((is_array($operand1)) \|\| (is_array($operand2))) {
3526	$result = array();
3527	if ((is_array($operand1)) && (!is_array($operand2))) {
3528	foreach($operand1 as $x => $operandData) {
3529	$this->_debugLog->writeDebugLog('Evaluating Comparison ', $this->_showValue($operandData), ' ', $operation, ' ', $this->_showValue($operand2));
3530	$this->_executeBinaryComparisonOperation($cellID,$operandData,$operand2,$operation,$stack);
3531	$r = $stack->pop();
3532	$result[$x] = $r['value'];
3533	}
3534	} elseif ((!is_array($operand1)) && (is_array($operand2))) {
3535	foreach($operand2 as $x => $operandData) {
3536	$this->_debugLog->writeDebugLog('Evaluating Comparison ', $this->_showValue($operand1), ' ', $operation, ' ', $this->_showValue($operandData));
3537	$this->_executeBinaryComparisonOperation($cellID,$operand1,$operandData,$operation,$stack);
3538	$r = $stack->pop();
3539	$result[$x] = $r['value'];
3540	}
3541	} else {
3542	if (!$recursingArrays) { self::_checkMatrixOperands($operand1,$operand2,2); }
3543	foreach($operand1 as $x => $operandData) {
3544	$this->_debugLog->writeDebugLog('Evaluating Comparison ', $this->_showValue($operandData), ' ', $operation, ' ', $this->_showValue($operand2[$x]));
3545	$this->_executeBinaryComparisonOperation($cellID,$operandData,$operand2[$x],$operation,$stack,TRUE);
3546	$r = $stack->pop();
3547	$result[$x] = $r['value'];
3548	}
3549	}
3550	// Log the result details
3551	$this->_debugLog->writeDebugLog('Comparison Evaluation Result is ', $this->_showTypeDetails($result));
3552	// And push the result onto the stack
3553	$stack->push('Array',$result);
3554	return TRUE;
3555	}
3556
3557	// Simple validate the two operands if they are string values
3558	if (is_string($operand1) && $operand1 > '' && $operand1{0} == '"') { $operand1 = self::_unwrapResult($operand1); }
3559	if (is_string($operand2) && $operand2 > '' && $operand2{0} == '"') { $operand2 = self::_unwrapResult($operand2); }
3560
3561	// Use case insensitive comparaison if not OpenOffice mode
3562	if (PHPExcel_Calculation_Functions::getCompatibilityMode() != PHPExcel_Calculation_Functions::COMPATIBILITY_OPENOFFICE)
3563	{
3564	if (is_string($operand1)) {
3565	$operand1 = strtoupper($operand1);
3566	}
3567
3568	if (is_string($operand2)) {
3569	$operand2 = strtoupper($operand2);
3570	}
3571	}
3572
3573	$useLowercaseFirstComparison = is_string($operand1) && is_string($operand2) && PHPExcel_Calculation_Functions::getCompatibilityMode() == PHPExcel_Calculation_Functions::COMPATIBILITY_OPENOFFICE;
3574
3575	// execute the necessary operation
3576	switch ($operation) {
3577	// Greater than
3578	case '>':
3579	if ($useLowercaseFirstComparison) {
3580	$result = $this->strcmpLowercaseFirst($operand1, $operand2) > 0;
3581	} else {
3582	$result = ($operand1 > $operand2);
3583	}
3584	break;
3585	// Less than
3586	case '<':
3587	if ($useLowercaseFirstComparison) {
3588	$result = $this->strcmpLowercaseFirst($operand1, $operand2) < 0;
3589	} else {
3590	$result = ($operand1 < $operand2);
3591	}
3592	break;
3593	// Equality
3594	case '=':
3595	$result = ($operand1 == $operand2);
3596	break;
3597	// Greater than or equal
3598	case '>=':
3599	if ($useLowercaseFirstComparison) {
3600	$result = $this->strcmpLowercaseFirst($operand1, $operand2) >= 0;
3601	} else {
3602	$result = ($operand1 >= $operand2);
3603	}
3604	break;
3605	// Less than or equal
3606	case '<=':
3607	if ($useLowercaseFirstComparison) {
3608	$result = $this->strcmpLowercaseFirst($operand1, $operand2) <= 0;
3609	} else {
3610	$result = ($operand1 <= $operand2);
3611	}
3612	break;
3613	// Inequality
3614	case '<>':
3615	$result = ($operand1 != $operand2);
3616	break;
3617	}
3618
3619	// Log the result details
3620	$this->_debugLog->writeDebugLog('Evaluation Result is ', $this->_showTypeDetails($result));
3621	// And push the result onto the stack
3622	$stack->push('Value',$result);
3623	return TRUE;
3624	} // function _executeBinaryComparisonOperation()
3625
3626	/**
3627	* Compare two strings in the same way as strcmp() except that lowercase come before uppercase letters
3628	* @param string $str1
3629	* @param string $str2
3630	* @return integer
3631	*/
3632	private function strcmpLowercaseFirst($str1, $str2)
3633	{
3634	$from = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz';
3635	$to = 'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ';
3636	$inversedStr1 = strtr($str1, $from, $to);
3637	$inversedStr2 = strtr($str2, $from, $to);
3638
3639	return strcmp($inversedStr1, $inversedStr2);
3640	}
3641
3642	private function _executeNumericBinaryOperation($cellID,$operand1,$operand2,$operation,$matrixFunction,&$stack) {
3643	// Validate the two operands
3644	if (!$this->_validateBinaryOperand($cellID,$operand1,$stack)) return FALSE;
3645	if (!$this->_validateBinaryOperand($cellID,$operand2,$stack)) return FALSE;
3646
3647	// If either of the operands is a matrix, we need to treat them both as matrices
3648	// (converting the other operand to a matrix if need be); then perform the required
3649	// matrix operation
3650	if ((is_array($operand1)) \|\| (is_array($operand2))) {
3651	// Ensure that both operands are arrays/matrices of the same size
3652	self::_checkMatrixOperands($operand1, $operand2, 2);
3653
3654	try {
3655	// Convert operand 1 from a PHP array to a matrix
3656	$matrix = new PHPExcel_Shared_JAMA_Matrix($operand1);
3657	// Perform the required operation against the operand 1 matrix, passing in operand 2
3658	$matrixResult = $matrix->$matrixFunction($operand2);
3659	$result = $matrixResult->getArray();
3660	} catch (PHPExcel_Exception $ex) {
3661	$this->_debugLog->writeDebugLog('JAMA Matrix Exception: ', $ex->getMessage());
3662	$result = '#VALUE!';
3663	}
3664	} else {
3665	if ((PHPExcel_Calculation_Functions::getCompatibilityMode() != PHPExcel_Calculation_Functions::COMPATIBILITY_OPENOFFICE) &&
3666	((is_string($operand1) && !is_numeric($operand1) && strlen($operand1)>0) \|\|
3667	(is_string($operand2) && !is_numeric($operand2) && strlen($operand2)>0))) {
3668	$result = PHPExcel_Calculation_Functions::VALUE();
3669	} else {
3670	// If we're dealing with non-matrix operations, execute the necessary operation
3671	switch ($operation) {
3672	// Addition
3673	case '+':
3674	$result = $operand1 + $operand2;
3675	break;
3676	// Subtraction
3677	case '-':
3678	$result = $operand1 - $operand2;
3679	break;
3680	// Multiplication
3681	case '*':
3682	$result = $operand1 * $operand2;
3683	break;
3684	// Division
3685	case '/':
3686	if ($operand2 == 0) {
3687	// Trap for Divide by Zero error
3688	$stack->push('Value','#DIV/0!');
3689	$this->_debugLog->writeDebugLog('Evaluation Result is ', $this->_showTypeDetails('#DIV/0!'));
3690	return FALSE;
3691	} else {
3692	$result = $operand1 / $operand2;
3693	}
3694	break;
3695	// Power
3696	case '^':
3697	$result = pow($operand1, $operand2);
3698	break;
3699	}
3700	}
3701	}
3702
3703	// Log the result details
3704	$this->_debugLog->writeDebugLog('Evaluation Result is ', $this->_showTypeDetails($result));
3705	// And push the result onto the stack
3706	$stack->push('Value',$result);
3707	return TRUE;
3708	} // function _executeNumericBinaryOperation()
3709
3710
3711	// trigger an error, but nicely, if need be
3712	protected function _raiseFormulaError($errorMessage) {
3713	$this->formulaError = $errorMessage;
3714	$this->_cyclicReferenceStack->clear();
3715	if (!$this->suppressFormulaErrors) throw new PHPExcel_Calculation_Exception($errorMessage);
3716	trigger_error($errorMessage, E_USER_ERROR);
3717	} // function _raiseFormulaError()
3718
3719
3720	/**
3721	* Extract range values
3722	*
3723	* @param string &$pRange String based range representation
3724	* @param PHPExcel_Worksheet $pSheet Worksheet
3725	* @param boolean $resetLog Flag indicating whether calculation log should be reset or not
3726	* @return mixed Array of values in range if range contains more than one element. Otherwise, a single value is returned.
3727	* @throws PHPExcel_Calculation_Exception
3728	*/
3729	public function extractCellRange(&$pRange = 'A1', PHPExcel_Worksheet $pSheet = NULL, $resetLog = TRUE) {
3730	// Return value
3731	$returnValue = array ();
3732
3733	// echo 'extractCellRange('.$pRange.')',PHP_EOL;
3734	if ($pSheet !== NULL) {
3735	$pSheetName = $pSheet->getTitle();
3736	// echo 'Passed sheet name is '.$pSheetName.PHP_EOL;
3737	// echo 'Range reference is '.$pRange.PHP_EOL;
3738	if (strpos ($pRange, '!') !== false) {
3739	// echo '$pRange reference includes sheet reference',PHP_EOL;
3740	list($pSheetName,$pRange) = PHPExcel_Worksheet::extractSheetTitle($pRange, true);
3741	// echo 'New sheet name is '.$pSheetName,PHP_EOL;
3742	// echo 'Adjusted Range reference is '.$pRange,PHP_EOL;
3743	$pSheet = $this->_workbook->getSheetByName($pSheetName);
3744	}
3745
3746	// Extract range
3747	$aReferences = PHPExcel_Cell::extractAllCellReferencesInRange($pRange);
3748	$pRange = $pSheetName.'!'.$pRange;
3749	if (!isset($aReferences[1])) {
3750	// Single cell in range
3751	sscanf($aReferences[0],'%[A-Z]%d', $currentCol, $currentRow);
3752	$cellValue = NULL;
3753	if ($pSheet->cellExists($aReferences[0])) {
3754	$returnValue[$currentRow][$currentCol] = $pSheet->getCell($aReferences[0])->getCalculatedValue($resetLog);
3755	} else {
3756	$returnValue[$currentRow][$currentCol] = NULL;
3757	}
3758	} else {
3759	// Extract cell data for all cells in the range
3760	foreach ($aReferences as $reference) {
3761	// Extract range
3762	sscanf($reference,'%[A-Z]%d', $currentCol, $currentRow);
3763	$cellValue = NULL;
3764	if ($pSheet->cellExists($reference)) {
3765	$returnValue[$currentRow][$currentCol] = $pSheet->getCell($reference)->getCalculatedValue($resetLog);
3766	} else {
3767	$returnValue[$currentRow][$currentCol] = NULL;
3768	}
3769	}
3770	}
3771	}
3772
3773	// Return
3774	return $returnValue;
3775	} // function extractCellRange()
3776
3777
3778	/**
3779	* Extract range values
3780	*
3781	* @param string &$pRange String based range representation
3782	* @param PHPExcel_Worksheet $pSheet Worksheet
3783	* @return mixed Array of values in range if range contains more than one element. Otherwise, a single value is returned.
3784	* @param boolean $resetLog Flag indicating whether calculation log should be reset or not
3785	* @throws PHPExcel_Calculation_Exception
3786	*/
3787	public function extractNamedRange(&$pRange = 'A1', PHPExcel_Worksheet $pSheet = NULL, $resetLog = TRUE) {
3788	// Return value
3789	$returnValue = array ();
3790
3791	// echo 'extractNamedRange('.$pRange.')<br />';
3792	if ($pSheet !== NULL) {
3793	$pSheetName = $pSheet->getTitle();
3794	// echo 'Current sheet name is '.$pSheetName.'<br />';
3795	// echo 'Range reference is '.$pRange.'<br />';
3796	if (strpos ($pRange, '!') !== false) {
3797	// echo '$pRange reference includes sheet reference',PHP_EOL;
3798	list($pSheetName,$pRange) = PHPExcel_Worksheet::extractSheetTitle($pRange, true);
3799	// echo 'New sheet name is '.$pSheetName,PHP_EOL;
3800	// echo 'Adjusted Range reference is '.$pRange,PHP_EOL;
3801	$pSheet = $this->_workbook->getSheetByName($pSheetName);
3802	}
3803
3804	// Named range?
3805	$namedRange = PHPExcel_NamedRange::resolveRange($pRange, $pSheet);
3806	if ($namedRange !== NULL) {
3807	$pSheet = $namedRange->getWorksheet();
3808	// echo 'Named Range '.$pRange.' (';
3809	$pRange = $namedRange->getRange();
3810	$splitRange = PHPExcel_Cell::splitRange($pRange);
3811	// Convert row and column references
3812	if (ctype_alpha($splitRange[0][0])) {
3813	$pRange = $splitRange[0][0] . '1:' . $splitRange[0][1] . $namedRange->getWorksheet()->getHighestRow();
3814	} elseif(ctype_digit($splitRange[0][0])) {
3815	$pRange = 'A' . $splitRange[0][0] . ':' . $namedRange->getWorksheet()->getHighestColumn() . $splitRange[0][1];
3816	}
3817	// echo $pRange.') is in sheet '.$namedRange->getWorksheet()->getTitle().'<br />';
3818
3819	// if ($pSheet->getTitle() != $namedRange->getWorksheet()->getTitle()) {
3820	// if (!$namedRange->getLocalOnly()) {
3821	// $pSheet = $namedRange->getWorksheet();
3822	// } else {
3823	// return $returnValue;
3824	// }
3825	// }
3826	} else {
3827	return PHPExcel_Calculation_Functions::REF();
3828	}
3829
3830	// Extract range
3831	$aReferences = PHPExcel_Cell::extractAllCellReferencesInRange($pRange);
3832	// var_dump($aReferences);
3833	if (!isset($aReferences[1])) {
3834	// Single cell (or single column or row) in range
3835	list($currentCol,$currentRow) = PHPExcel_Cell::coordinateFromString($aReferences[0]);
3836	$cellValue = NULL;
3837	if ($pSheet->cellExists($aReferences[0])) {
3838	$returnValue[$currentRow][$currentCol] = $pSheet->getCell($aReferences[0])->getCalculatedValue($resetLog);
3839	} else {
3840	$returnValue[$currentRow][$currentCol] = NULL;
3841	}
3842	} else {
3843	// Extract cell data for all cells in the range
3844	foreach ($aReferences as $reference) {
3845	// Extract range
3846	list($currentCol,$currentRow) = PHPExcel_Cell::coordinateFromString($reference);
3847	// echo 'NAMED RANGE: $currentCol='.$currentCol.' $currentRow='.$currentRow.'<br />';
3848	$cellValue = NULL;
3849	if ($pSheet->cellExists($reference)) {
3850	$returnValue[$currentRow][$currentCol] = $pSheet->getCell($reference)->getCalculatedValue($resetLog);
3851	} else {
3852	$returnValue[$currentRow][$currentCol] = NULL;
3853	}
3854	}
3855	}
3856	// print_r($returnValue);
3857	// echo '<br />';
3858	}
3859
3860	// Return
3861	return $returnValue;
3862	} // function extractNamedRange()
3863
3864
3865	/**
3866	* Is a specific function implemented?
3867	*
3868	* @param string $pFunction Function Name
3869	* @return boolean
3870	*/
3871	public function isImplemented($pFunction = '') {
3872	$pFunction = strtoupper ($pFunction);
3873	if (isset(self::$_PHPExcelFunctions[$pFunction])) {
3874	return (self::$_PHPExcelFunctions[$pFunction]['functionCall'] != 'PHPExcel_Calculation_Functions::DUMMY');
3875	} else {
3876	return FALSE;
3877	}
3878	} // function isImplemented()
3879
3880
3881	/**
3882	* Get a list of all implemented functions as an array of function objects
3883	*
3884	* @return array of PHPExcel_Calculation_Function
3885	*/
3886	public function listFunctions() {
3887	// Return value
3888	$returnValue = array();
3889	// Loop functions
3890	foreach(self::$_PHPExcelFunctions as $functionName => $function) {
3891	if ($function['functionCall'] != 'PHPExcel_Calculation_Functions::DUMMY') {
3892	$returnValue[$functionName] = new PHPExcel_Calculation_Function($function['category'],
3893	$functionName,
3894	$function['functionCall']
3895	);
3896	}
3897	}
3898
3899	// Return
3900	return $returnValue;
3901	} // function listFunctions()
3902
3903
3904	/**
3905	* Get a list of all Excel function names
3906	*
3907	* @return array
3908	*/
3909	public function listAllFunctionNames() {
3910	return array_keys(self::$_PHPExcelFunctions);
3911	} // function listAllFunctionNames()
3912
3913	/**
3914	* Get a list of implemented Excel function names
3915	*
3916	* @return array
3917	*/
3918	public function listFunctionNames() {
3919	// Return value
3920	$returnValue = array();
3921	// Loop functions
3922	foreach(self::$_PHPExcelFunctions as $functionName => $function) {
3923	if ($function['functionCall'] != 'PHPExcel_Calculation_Functions::DUMMY') {
3924	$returnValue[] = $functionName;
3925	}
3926	}
3927
3928	// Return
3929	return $returnValue;
3930	} // function listFunctionNames()
3931
3932	} // class PHPExcel_Calculation
3933

Note: See TracBrowser for help on using the repository browser.

Context Navigation

source: sourcecode/application/libraries/PHPExcel/Calculation.php @ 1

Download in other formats: