visualizer / vendor / phpoffice / phpexcel / Classes / PHPExcel / Calculation / Statistical.php

Statistical.php in Visualizer – Tables & Charts Manager with Built-in AI Generator 3.0.3, at vendor/phpoffice/phpexcel/Classes/PHPExcel/Calculation/Statistical.php

3,652 lines 106.7 KB

Raw Download Zip

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 ##VERSION##, ##DATE##
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	require_once PHPEXCEL_ROOT . 'PHPExcel/Shared/trend/trendClass.php';
40
41
42	/** LOG_GAMMA_X_MAX_VALUE */
43	define('LOG_GAMMA_X_MAX_VALUE', 2.55e305);
44
45	/** XMININ */
46	define('XMININ', 2.23e-308);
47
48	/** EPS */
49	define('EPS', 2.22e-16);
50
51	/** SQRT2PI */
52	define('SQRT2PI', 2.5066282746310005024157652848110452530069867406099);
53
54
55	/**
56	* PHPExcel_Calculation_Statistical
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_Statistical {
63
64
65	private static function _checkTrendArrays(&$array1,&$array2) {
66	if (!is_array($array1)) { $array1 = array($array1); }
67	if (!is_array($array2)) { $array2 = array($array2); }
68
69	$array1 = PHPExcel_Calculation_Functions::flattenArray($array1);
70	$array2 = PHPExcel_Calculation_Functions::flattenArray($array2);
71	foreach($array1 as $key => $value) {
72	if ((is_bool($value)) \|\| (is_string($value)) \|\| (is_null($value))) {
73	unset($array1[$key]);
74	unset($array2[$key]);
75	}
76	}
77	foreach($array2 as $key => $value) {
78	if ((is_bool($value)) \|\| (is_string($value)) \|\| (is_null($value))) {
79	unset($array1[$key]);
80	unset($array2[$key]);
81	}
82	}
83	$array1 = array_merge($array1);
84	$array2 = array_merge($array2);
85
86	return True;
87	} // function _checkTrendArrays()
88
89
90	/**
91	* Beta function.
92	*
93	* @author Jaco van Kooten
94	*
95	* @param p require p>0
96	* @param q require q>0
97	* @return 0 if p<=0, q<=0 or p+q>2.55E305 to avoid errors and over/underflow
98	*/
99	private static function _beta($p, $q) {
100	if ($p <= 0.0 \|\| $q <= 0.0 \|\| ($p + $q) > LOG_GAMMA_X_MAX_VALUE) {
101	return 0.0;
102	} else {
103	return exp(self::_logBeta($p, $q));
104	}
105	} // function _beta()
106
107
108	/**
109	* Incomplete beta function
110	*
111	* @author Jaco van Kooten
112	* @author Paul Meagher
113	*
114	* The computation is based on formulas from Numerical Recipes, Chapter 6.4 (W.H. Press et al, 1992).
115	* @param x require 0<=x<=1
116	* @param p require p>0
117	* @param q require q>0
118	* @return 0 if x<0, p<=0, q<=0 or p+q>2.55E305 and 1 if x>1 to avoid errors and over/underflow
119	*/
120	private static function _incompleteBeta($x, $p, $q) {
121	if ($x <= 0.0) {
122	return 0.0;
123	} elseif ($x >= 1.0) {
124	return 1.0;
125	} elseif (($p <= 0.0) \|\| ($q <= 0.0) \|\| (($p + $q) > LOG_GAMMA_X_MAX_VALUE)) {
126	return 0.0;
127	}
128	$beta_gam = exp((0 - self::_logBeta($p, $q)) + $p * log($x) + $q * log(1.0 - $x));
129	if ($x < ($p + 1.0) / ($p + $q + 2.0)) {
130	return $beta_gam * self::_betaFraction($x, $p, $q) / $p;
131	} else {
132	return 1.0 - ($beta_gam * self::_betaFraction(1 - $x, $q, $p) / $q);
133	}
134	} // function _incompleteBeta()
135
136
137	// Function cache for _logBeta function
138	private static $_logBetaCache_p = 0.0;
139	private static $_logBetaCache_q = 0.0;
140	private static $_logBetaCache_result = 0.0;
141
142	/**
143	* The natural logarithm of the beta function.
144	*
145	* @param p require p>0
146	* @param q require q>0
147	* @return 0 if p<=0, q<=0 or p+q>2.55E305 to avoid errors and over/underflow
148	* @author Jaco van Kooten
149	*/
150	private static function _logBeta($p, $q) {
151	if ($p != self::$_logBetaCache_p \|\| $q != self::$_logBetaCache_q) {
152	self::$_logBetaCache_p = $p;
153	self::$_logBetaCache_q = $q;
154	if (($p <= 0.0) \|\| ($q <= 0.0) \|\| (($p + $q) > LOG_GAMMA_X_MAX_VALUE)) {
155	self::$_logBetaCache_result = 0.0;
156	} else {
157	self::$_logBetaCache_result = self::_logGamma($p) + self::_logGamma($q) - self::_logGamma($p + $q);
158	}
159	}
160	return self::$_logBetaCache_result;
161	} // function _logBeta()
162
163
164	/**
165	* Evaluates of continued fraction part of incomplete beta function.
166	* Based on an idea from Numerical Recipes (W.H. Press et al, 1992).
167	* @author Jaco van Kooten
168	*/
169	private static function _betaFraction($x, $p, $q) {
170	$c = 1.0;
171	$sum_pq = $p + $q;
172	$p_plus = $p + 1.0;
173	$p_minus = $p - 1.0;
174	$h = 1.0 - $sum_pq * $x / $p_plus;
175	if (abs($h) < XMININ) {
176	$h = XMININ;
177	}
178	$h = 1.0 / $h;
179	$frac = $h;
180	$m = 1;
181	$delta = 0.0;
182	while ($m <= MAX_ITERATIONS && abs($delta-1.0) > PRECISION ) {
183	$m2 = 2 * $m;
184	// even index for d
185	$d = $m * ($q - $m) * $x / ( ($p_minus + $m2) * ($p + $m2));
186	$h = 1.0 + $d * $h;
187	if (abs($h) < XMININ) {
188	$h = XMININ;
189	}
190	$h = 1.0 / $h;
191	$c = 1.0 + $d / $c;
192	if (abs($c) < XMININ) {
193	$c = XMININ;
194	}
195	$frac = $h $c;
196	// odd index for d
197	$d = -($p + $m) * ($sum_pq + $m) * $x / (($p + $m2) * ($p_plus + $m2));
198	$h = 1.0 + $d * $h;
199	if (abs($h) < XMININ) {
200	$h = XMININ;
201	}
202	$h = 1.0 / $h;
203	$c = 1.0 + $d / $c;
204	if (abs($c) < XMININ) {
205	$c = XMININ;
206	}
207	$delta = $h * $c;
208	$frac *= $delta;
209	++$m;
210	}
211	return $frac;
212	} // function _betaFraction()
213
214
215	/**
216	* logGamma function
217	*
218	* @version 1.1
219	* @author Jaco van Kooten
220	*
221	* Original author was Jaco van Kooten. Ported to PHP by Paul Meagher.
222	*
223	* The natural logarithm of the gamma function. <br />
224	* Based on public domain NETLIB (Fortran) code by W. J. Cody and L. Stoltz <br />
225	* Applied Mathematics Division <br />
226	* Argonne National Laboratory <br />
227	* Argonne, IL 60439 <br />
228	* <p>
229	* References:
230	* <ol>
231	* <li>W. J. Cody and K. E. Hillstrom, 'Chebyshev Approximations for the Natural
232	* Logarithm of the Gamma Function,' Math. Comp. 21, 1967, pp. 198-203.</li>
233	* <li>K. E. Hillstrom, ANL/AMD Program ANLC366S, DGAMMA/DLGAMA, May, 1969.</li>
234	* <li>Hart, Et. Al., Computer Approximations, Wiley and sons, New York, 1968.</li>
235	* </ol>
236	* </p>
237	* <p>
238	* From the original documentation:
239	* </p>
240	* <p>
241	* This routine calculates the LOG(GAMMA) function for a positive real argument X.
242	* Computation is based on an algorithm outlined in references 1 and 2.
243	* The program uses rational functions that theoretically approximate LOG(GAMMA)
244	* to at least 18 significant decimal digits. The approximation for X > 12 is from
245	* reference 3, while approximations for X < 12.0 are similar to those in reference
246	* 1, but are unpublished. The accuracy achieved depends on the arithmetic system,
247	* the compiler, the intrinsic functions, and proper selection of the
248	* machine-dependent constants.
249	* </p>
250	* <p>
251	* Error returns: <br />
252	* The program returns the value XINF for X .LE. 0.0 or when overflow would occur.
253	* The computation is believed to be free of underflow and overflow.
254	* </p>
255	* @return MAX_VALUE for x < 0.0 or when overflow would occur, i.e. x > 2.55E305
256	*/
257
258	// Function cache for logGamma
259	private static $_logGammaCache_result = 0.0;
260	private static $_logGammaCache_x = 0.0;
261
262	private static function _logGamma($x) {
263	// Log Gamma related constants
264	static $lg_d1 = -0.5772156649015328605195174;
265	static $lg_d2 = 0.4227843350984671393993777;
266	static $lg_d4 = 1.791759469228055000094023;
267
268	static $lg_p1 = array( 4.945235359296727046734888,
269	201.8112620856775083915565,
270	2290.838373831346393026739,
271	11319.67205903380828685045,
272	28557.24635671635335736389,
273	38484.96228443793359990269,
274	26377.48787624195437963534,
275	7225.813979700288197698961 );
276	static $lg_p2 = array( 4.974607845568932035012064,
277	542.4138599891070494101986,
278	15506.93864978364947665077,
279	184793.2904445632425417223,
280	1088204.76946882876749847,
281	3338152.967987029735917223,
282	5106661.678927352456275255,
283	3074109.054850539556250927 );
284	static $lg_p4 = array( 14745.02166059939948905062,
285	2426813.369486704502836312,
286	121475557.4045093227939592,
287	2663432449.630976949898078,
288	29403789566.34553899906876,
289	170266573776.5398868392998,
290	492612579337.743088758812,
291	560625185622.3951465078242 );
292
293	static $lg_q1 = array( 67.48212550303777196073036,
294	1113.332393857199323513008,
295	7738.757056935398733233834,
296	27639.87074403340708898585,
297	54993.10206226157329794414,
298	61611.22180066002127833352,
299	36351.27591501940507276287,
300	8785.536302431013170870835 );
301	static $lg_q2 = array( 183.0328399370592604055942,
302	7765.049321445005871323047,
303	133190.3827966074194402448,
304	1136705.821321969608938755,
305	5267964.117437946917577538,
306	13467014.54311101692290052,
307	17827365.30353274213975932,
308	9533095.591844353613395747 );
309	static $lg_q4 = array( 2690.530175870899333379843,
310	639388.5654300092398984238,
311	41355999.30241388052042842,
312	1120872109.61614794137657,
313	14886137286.78813811542398,
314	101680358627.2438228077304,
315	341747634550.7377132798597,
316	446315818741.9713286462081 );
317
318	static $lg_c = array( -0.001910444077728,
319	8.4171387781295e-4,
320	-5.952379913043012e-4,
321	7.93650793500350248e-4,
322	-0.002777777777777681622553,
323	0.08333333333333333331554247,
324	0.0057083835261 );
325
326	// Rough estimate of the fourth root of logGamma_xBig
327	static $lg_frtbig = 2.25e76;
328	static $pnt68 = 0.6796875;
329
330
331	if ($x == self::$_logGammaCache_x) {
332	return self::$_logGammaCache_result;
333	}
334	$y = $x;
335	if ($y > 0.0 && $y <= LOG_GAMMA_X_MAX_VALUE) {
336	if ($y <= EPS) {
337	$res = -log(y);
338	} elseif ($y <= 1.5) {
339	// ---------------------
340	// EPS .LT. X .LE. 1.5
341	// ---------------------
342	if ($y < $pnt68) {
343	$corr = -log($y);
344	$xm1 = $y;
345	} else {
346	$corr = 0.0;
347	$xm1 = $y - 1.0;
348	}
349	if ($y <= 0.5 \|\| $y >= $pnt68) {
350	$xden = 1.0;
351	$xnum = 0.0;
352	for ($i = 0; $i < 8; ++$i) {
353	$xnum = $xnum * $xm1 + $lg_p1[$i];
354	$xden = $xden * $xm1 + $lg_q1[$i];
355	}
356	$res = $corr + $xm1 * ($lg_d1 + $xm1 * ($xnum / $xden));
357	} else {
358	$xm2 = $y - 1.0;
359	$xden = 1.0;
360	$xnum = 0.0;
361	for ($i = 0; $i < 8; ++$i) {
362	$xnum = $xnum * $xm2 + $lg_p2[$i];
363	$xden = $xden * $xm2 + $lg_q2[$i];
364	}
365	$res = $corr + $xm2 * ($lg_d2 + $xm2 * ($xnum / $xden));
366	}
367	} elseif ($y <= 4.0) {
368	// ---------------------
369	// 1.5 .LT. X .LE. 4.0
370	// ---------------------
371	$xm2 = $y - 2.0;
372	$xden = 1.0;
373	$xnum = 0.0;
374	for ($i = 0; $i < 8; ++$i) {
375	$xnum = $xnum * $xm2 + $lg_p2[$i];
376	$xden = $xden * $xm2 + $lg_q2[$i];
377	}
378	$res = $xm2 * ($lg_d2 + $xm2 * ($xnum / $xden));
379	} elseif ($y <= 12.0) {
380	// ----------------------
381	// 4.0 .LT. X .LE. 12.0
382	// ----------------------
383	$xm4 = $y - 4.0;
384	$xden = -1.0;
385	$xnum = 0.0;
386	for ($i = 0; $i < 8; ++$i) {
387	$xnum = $xnum * $xm4 + $lg_p4[$i];
388	$xden = $xden * $xm4 + $lg_q4[$i];
389	}
390	$res = $lg_d4 + $xm4 * ($xnum / $xden);
391	} else {
392	// ---------------------------------
393	// Evaluate for argument .GE. 12.0
394	// ---------------------------------
395	$res = 0.0;
396	if ($y <= $lg_frtbig) {
397	$res = $lg_c[6];
398	$ysq = $y * $y;
399	for ($i = 0; $i < 6; ++$i)
400	$res = $res / $ysq + $lg_c[$i];
401	}
402	$res /= $y;
403	$corr = log($y);
404	$res = $res + log(SQRT2PI) - 0.5 * $corr;
405	$res += $y * ($corr - 1.0);
406	}
407	} else {
408	// --------------------------
409	// Return for bad arguments
410	// --------------------------
411	$res = MAX_VALUE;
412	}
413	// ------------------------------
414	// Final adjustments and return
415	// ------------------------------
416	self::$_logGammaCache_x = $x;
417	self::$_logGammaCache_result = $res;
418	return $res;
419	} // function _logGamma()
420
421
422	//
423	// Private implementation of the incomplete Gamma function
424	//
425	private static function _incompleteGamma($a,$x) {
426	static $max = 32;
427	$summer = 0;
428	for ($n=0; $n<=$max; ++$n) {
429	$divisor = $a;
430	for ($i=1; $i<=$n; ++$i) {
431	$divisor *= ($a + $i);
432	}
433	$summer += (pow($x,$n) / $divisor);
434	}
435	return pow($x,$a) * exp(0-$x) * $summer;
436	} // function _incompleteGamma()
437
438
439	//
440	// Private implementation of the Gamma function
441	//
442	private static function _gamma($data) {
443	if ($data == 0.0) return 0;
444
445	static $p0 = 1.000000000190015;
446	static $p = array ( 1 => 76.18009172947146,
447	2 => -86.50532032941677,
448	3 => 24.01409824083091,
449	4 => -1.231739572450155,
450	5 => 1.208650973866179e-3,
451	6 => -5.395239384953e-6
452	);
453
454	$y = $x = $data;
455	$tmp = $x + 5.5;
456	$tmp -= ($x + 0.5) * log($tmp);
457
458	$summer = $p0;
459	for ($j=1;$j<=6;++$j) {
460	$summer += ($p[$j] / ++$y);
461	}
462	return exp(0 - $tmp + log(SQRT2PI * $summer / $x));
463	} // function _gamma()
464
465
466	/***************************************************************************
467	* inverse_ncdf.php
468	* -------------------
469	* begin : Friday, January 16, 2004
470	* copyright : (C) 2004 Michael Nickerson
471	* email : nickersonm@yahoo.com
472	*
473	***************************************************************************/
474	private static function _inverse_ncdf($p) {
475	// Inverse ncdf approximation by Peter J. Acklam, implementation adapted to
476	// PHP by Michael Nickerson, using Dr. Thomas Ziegler's C implementation as
477	// a guide. http://home.online.no/~pjacklam/notes/invnorm/index.html
478	// I have not checked the accuracy of this implementation. Be aware that PHP
479	// will truncate the coeficcients to 14 digits.
480
481	// You have permission to use and distribute this function freely for
482	// whatever purpose you want, but please show common courtesy and give credit
483	// where credit is due.
484
485	// Input paramater is $p - probability - where 0 < p < 1.
486
487	// Coefficients in rational approximations
488	static $a = array( 1 => -3.969683028665376e+01,
489	2 => 2.209460984245205e+02,
490	3 => -2.759285104469687e+02,
491	4 => 1.383577518672690e+02,
492	5 => -3.066479806614716e+01,
493	6 => 2.506628277459239e+00
494	);
495
496	static $b = array( 1 => -5.447609879822406e+01,
497	2 => 1.615858368580409e+02,
498	3 => -1.556989798598866e+02,
499	4 => 6.680131188771972e+01,
500	5 => -1.328068155288572e+01
501	);
502
503	static $c = array( 1 => -7.784894002430293e-03,
504	2 => -3.223964580411365e-01,
505	3 => -2.400758277161838e+00,
506	4 => -2.549732539343734e+00,
507	5 => 4.374664141464968e+00,
508	6 => 2.938163982698783e+00
509	);
510
511	static $d = array( 1 => 7.784695709041462e-03,
512	2 => 3.224671290700398e-01,
513	3 => 2.445134137142996e+00,
514	4 => 3.754408661907416e+00
515	);
516
517	// Define lower and upper region break-points.
518	$p_low = 0.02425; //Use lower region approx. below this
519	$p_high = 1 - $p_low; //Use upper region approx. above this
520
521	if (0 < $p && $p < $p_low) {
522	// Rational approximation for lower region.
523	$q = sqrt(-2 * log($p));
524	return ((((($c[1] * $q + $c[2]) * $q + $c[3]) * $q + $c[4]) * $q + $c[5]) * $q + $c[6]) /
525	(((($d[1] * $q + $d[2]) * $q + $d[3]) * $q + $d[4]) * $q + 1);
526	} elseif ($p_low <= $p && $p <= $p_high) {
527	// Rational approximation for central region.
528	$q = $p - 0.5;
529	$r = $q * $q;
530	return ((((($a[1] * $r + $a[2]) * $r + $a[3]) * $r + $a[4]) * $r + $a[5]) * $r + $a[6]) * $q /
531	((((($b[1] * $r + $b[2]) * $r + $b[3]) * $r + $b[4]) * $r + $b[5]) * $r + 1);
532	} elseif ($p_high < $p && $p < 1) {
533	// Rational approximation for upper region.
534	$q = sqrt(-2 * log(1 - $p));
535	return -((((($c[1] * $q + $c[2]) * $q + $c[3]) * $q + $c[4]) * $q + $c[5]) * $q + $c[6]) /
536	(((($d[1] * $q + $d[2]) * $q + $d[3]) * $q + $d[4]) * $q + 1);
537	}
538	// If 0 < p < 1, return a null value
539	return PHPExcel_Calculation_Functions::NULL();
540	} // function _inverse_ncdf()
541
542
543	private static function _inverse_ncdf2($prob) {
544	// Approximation of inverse standard normal CDF developed by
545	// B. Moro, "The Full Monte," Risk 8(2), Feb 1995, 57-58.
546
547	$a1 = 2.50662823884;
548	$a2 = -18.61500062529;
549	$a3 = 41.39119773534;
550	$a4 = -25.44106049637;
551
552	$b1 = -8.4735109309;
553	$b2 = 23.08336743743;
554	$b3 = -21.06224101826;
555	$b4 = 3.13082909833;
556
557	$c1 = 0.337475482272615;
558	$c2 = 0.976169019091719;
559	$c3 = 0.160797971491821;
560	$c4 = 2.76438810333863E-02;
561	$c5 = 3.8405729373609E-03;
562	$c6 = 3.951896511919E-04;
563	$c7 = 3.21767881768E-05;
564	$c8 = 2.888167364E-07;
565	$c9 = 3.960315187E-07;
566
567	$y = $prob - 0.5;
568	if (abs($y) < 0.42) {
569	$z = ($y * $y);
570	$z = $y * ((($a4 * $z + $a3) * $z + $a2) * $z + $a1) / (((($b4 * $z + $b3) * $z + $b2) * $z + $b1) * $z + 1);
571	} else {
572	if ($y > 0) {
573	$z = log(-log(1 - $prob));
574	} else {
575	$z = log(-log($prob));
576	}
577	$z = $c1 + $z * ($c2 + $z * ($c3 + $z * ($c4 + $z * ($c5 + $z * ($c6 + $z * ($c7 + $z * ($c8 + $z * $c9)))))));
578	if ($y < 0) {
579	$z = -$z;
580	}
581	}
582	return $z;
583	} // function _inverse_ncdf2()
584
585
586	private static function _inverse_ncdf3($p) {
587	// ALGORITHM AS241 APPL. STATIST. (1988) VOL. 37, NO. 3.
588	// Produces the normal deviate Z corresponding to a given lower
589	// tail area of P; Z is accurate to about 1 part in 10**16.
590	//
591	// This is a PHP version of the original FORTRAN code that can
592	// be found at http://lib.stat.cmu.edu/apstat/
593	$split1 = 0.425;
594	$split2 = 5;
595	$const1 = 0.180625;
596	$const2 = 1.6;
597
598	// coefficients for p close to 0.5
599	$a0 = 3.3871328727963666080;
600	$a1 = 1.3314166789178437745E+2;
601	$a2 = 1.9715909503065514427E+3;
602	$a3 = 1.3731693765509461125E+4;
603	$a4 = 4.5921953931549871457E+4;
604	$a5 = 6.7265770927008700853E+4;
605	$a6 = 3.3430575583588128105E+4;
606	$a7 = 2.5090809287301226727E+3;
607
608	$b1 = 4.2313330701600911252E+1;
609	$b2 = 6.8718700749205790830E+2;
610	$b3 = 5.3941960214247511077E+3;
611	$b4 = 2.1213794301586595867E+4;
612	$b5 = 3.9307895800092710610E+4;
613	$b6 = 2.8729085735721942674E+4;
614	$b7 = 5.2264952788528545610E+3;
615
616	// coefficients for p not close to 0, 0.5 or 1.
617	$c0 = 1.42343711074968357734;
618	$c1 = 4.63033784615654529590;
619	$c2 = 5.76949722146069140550;
620	$c3 = 3.64784832476320460504;
621	$c4 = 1.27045825245236838258;
622	$c5 = 2.41780725177450611770E-1;
623	$c6 = 2.27238449892691845833E-2;
624	$c7 = 7.74545014278341407640E-4;
625
626	$d1 = 2.05319162663775882187;
627	$d2 = 1.67638483018380384940;
628	$d3 = 6.89767334985100004550E-1;
629	$d4 = 1.48103976427480074590E-1;
630	$d5 = 1.51986665636164571966E-2;
631	$d6 = 5.47593808499534494600E-4;
632	$d7 = 1.05075007164441684324E-9;
633
634	// coefficients for p near 0 or 1.
635	$e0 = 6.65790464350110377720;
636	$e1 = 5.46378491116411436990;
637	$e2 = 1.78482653991729133580;
638	$e3 = 2.96560571828504891230E-1;
639	$e4 = 2.65321895265761230930E-2;
640	$e5 = 1.24266094738807843860E-3;
641	$e6 = 2.71155556874348757815E-5;
642	$e7 = 2.01033439929228813265E-7;
643
644	$f1 = 5.99832206555887937690E-1;
645	$f2 = 1.36929880922735805310E-1;
646	$f3 = 1.48753612908506148525E-2;
647	$f4 = 7.86869131145613259100E-4;
648	$f5 = 1.84631831751005468180E-5;
649	$f6 = 1.42151175831644588870E-7;
650	$f7 = 2.04426310338993978564E-15;
651
652	$q = $p - 0.5;
653
654	// computation for p close to 0.5
655	if (abs($q) <= split1) {
656	$R = $const1 - $q * $q;
657	$z = $q * ((((((($a7 * $R + $a6) * $R + $a5) * $R + $a4) * $R + $a3) * $R + $a2) * $R + $a1) * $R + $a0) /
658	((((((($b7 * $R + $b6) * $R + $b5) * $R + $b4) * $R + $b3) * $R + $b2) * $R + $b1) * $R + 1);
659	} else {
660	if ($q < 0) {
661	$R = $p;
662	} else {
663	$R = 1 - $p;
664	}
665	$R = pow(-log($R),2);
666
667	// computation for p not close to 0, 0.5 or 1.
668	If ($R <= $split2) {
669	$R = $R - $const2;
670	$z = ((((((($c7 * $R + $c6) * $R + $c5) * $R + $c4) * $R + $c3) * $R + $c2) * $R + $c1) * $R + $c0) /
671	((((((($d7 * $R + $d6) * $R + $d5) * $R + $d4) * $R + $d3) * $R + $d2) * $R + $d1) * $R + 1);
672	} else {
673	// computation for p near 0 or 1.
674	$R = $R - $split2;
675	$z = ((((((($e7 * $R + $e6) * $R + $e5) * $R + $e4) * $R + $e3) * $R + $e2) * $R + $e1) * $R + $e0) /
676	((((((($f7 * $R + $f6) * $R + $f5) * $R + $f4) * $R + $f3) * $R + $f2) * $R + $f1) * $R + 1);
677	}
678	if ($q < 0) {
679	$z = -$z;
680	}
681	}
682	return $z;
683	} // function _inverse_ncdf3()
684
685
686	/**
687	* AVEDEV
688	*
689	* Returns the average of the absolute deviations of data points from their mean.
690	* AVEDEV is a measure of the variability in a data set.
691	*
692	* Excel Function:
693	* AVEDEV(value1[,value2[, ...]])
694	*
695	* @access public
696	* @category Statistical Functions
697	* @param mixed $arg,... Data values
698	* @return float
699	*/
700	public static function AVEDEV() {
701	$aArgs = PHPExcel_Calculation_Functions::flattenArrayIndexed(func_get_args());
702
703	// Return value
704	$returnValue = null;
705
706	$aMean = self::AVERAGE($aArgs);
707	if ($aMean != PHPExcel_Calculation_Functions::DIV0()) {
708	$aCount = 0;
709	foreach ($aArgs as $k => $arg) {
710	if ((is_bool($arg)) &&
711	((!PHPExcel_Calculation_Functions::isCellValue($k)) \|\| (PHPExcel_Calculation_Functions::getCompatibilityMode() == PHPExcel_Calculation_Functions::COMPATIBILITY_OPENOFFICE))) {
712	$arg = (integer) $arg;
713	}
714	// Is it a numeric value?
715	if ((is_numeric($arg)) && (!is_string($arg))) {
716	if (is_null($returnValue)) {
717	$returnValue = abs($arg - $aMean);
718	} else {
719	$returnValue += abs($arg - $aMean);
720	}
721	++$aCount;
722	}
723	}
724
725	// Return
726	if ($aCount == 0) {
727	return PHPExcel_Calculation_Functions::DIV0();
728	}
729	return $returnValue / $aCount;
730	}
731	return PHPExcel_Calculation_Functions::NaN();
732	} // function AVEDEV()
733
734
735	/**
736	* AVERAGE
737	*
738	* Returns the average (arithmetic mean) of the arguments
739	*
740	* Excel Function:
741	* AVERAGE(value1[,value2[, ...]])
742	*
743	* @access public
744	* @category Statistical Functions
745	* @param mixed $arg,... Data values
746	* @return float
747	*/
748	public static function AVERAGE() {
749	$returnValue = $aCount = 0;
750
751	// Loop through arguments
752	foreach (PHPExcel_Calculation_Functions::flattenArrayIndexed(func_get_args()) as $k => $arg) {
753	if ((is_bool($arg)) &&
754	((!PHPExcel_Calculation_Functions::isCellValue($k)) \|\| (PHPExcel_Calculation_Functions::getCompatibilityMode() == PHPExcel_Calculation_Functions::COMPATIBILITY_OPENOFFICE))) {
755	$arg = (integer) $arg;
756	}
757	// Is it a numeric value?
758	if ((is_numeric($arg)) && (!is_string($arg))) {
759	if (is_null($returnValue)) {
760	$returnValue = $arg;
761	} else {
762	$returnValue += $arg;
763	}
764	++$aCount;
765	}
766	}
767
768	// Return
769	if ($aCount > 0) {
770	return $returnValue / $aCount;
771	} else {
772	return PHPExcel_Calculation_Functions::DIV0();
773	}
774	} // function AVERAGE()
775
776
777	/**
778	* AVERAGEA
779	*
780	* Returns the average of its arguments, including numbers, text, and logical values
781	*
782	* Excel Function:
783	* AVERAGEA(value1[,value2[, ...]])
784	*
785	* @access public
786	* @category Statistical Functions
787	* @param mixed $arg,... Data values
788	* @return float
789	*/
790	public static function AVERAGEA() {
791	// Return value
792	$returnValue = null;
793
794	$aCount = 0;
795	// Loop through arguments
796	foreach (PHPExcel_Calculation_Functions::flattenArrayIndexed(func_get_args()) as $k => $arg) {
797	if ((is_bool($arg)) &&
798	(!PHPExcel_Calculation_Functions::isMatrixValue($k))) {
799	} else {
800	if ((is_numeric($arg)) \|\| (is_bool($arg)) \|\| ((is_string($arg) && ($arg != '')))) {
801	if (is_bool($arg)) {
802	$arg = (integer) $arg;
803	} elseif (is_string($arg)) {
804	$arg = 0;
805	}
806	if (is_null($returnValue)) {
807	$returnValue = $arg;
808	} else {
809	$returnValue += $arg;
810	}
811	++$aCount;
812	}
813	}
814	}
815
816	// Return
817	if ($aCount > 0) {
818	return $returnValue / $aCount;
819	} else {
820	return PHPExcel_Calculation_Functions::DIV0();
821	}
822	} // function AVERAGEA()
823
824
825	/**
826	* AVERAGEIF
827	*
828	* Returns the average value from a range of cells that contain numbers within the list of arguments
829	*
830	* Excel Function:
831	* AVERAGEIF(value1[,value2[, ...]],condition)
832	*
833	* @access public
834	* @category Mathematical and Trigonometric Functions
835	* @param mixed $arg,... Data values
836	* @param string $condition The criteria that defines which cells will be checked.
837	* @param mixed[] $averageArgs Data values
838	* @return float
839	*/
840	public static function AVERAGEIF($aArgs,$condition,$averageArgs = array()) {
841	// Return value
842	$returnValue = 0;
843
844	$aArgs = PHPExcel_Calculation_Functions::flattenArray($aArgs);
845	$averageArgs = PHPExcel_Calculation_Functions::flattenArray($averageArgs);
846	if (empty($averageArgs)) {
847	$averageArgs = $aArgs;
848	}
849	$condition = PHPExcel_Calculation_Functions::_ifCondition($condition);
850	// Loop through arguments
851	$aCount = 0;
852	foreach ($aArgs as $key => $arg) {
853	if (!is_numeric($arg)) { $arg = PHPExcel_Calculation::_wrapResult(strtoupper($arg)); }
854	$testCondition = '='.$arg.$condition;
855	if (PHPExcel_Calculation::getInstance()->_calculateFormulaValue($testCondition)) {
856	if ((is_null($returnValue)) \|\| ($arg > $returnValue)) {
857	$returnValue += $arg;
858	++$aCount;
859	}
860	}
861	}
862
863	// Return
864	if ($aCount > 0) {
865	return $returnValue / $aCount;
866	} else {
867	return PHPExcel_Calculation_Functions::DIV0();
868	}
869	} // function AVERAGEIF()
870
871
872	/**
873	* BETADIST
874	*
875	* Returns the beta distribution.
876	*
877	* @param float $value Value at which you want to evaluate the distribution
878	* @param float $alpha Parameter to the distribution
879	* @param float $beta Parameter to the distribution
880	* @param boolean $cumulative
881	* @return float
882	*
883	*/
884	public static function BETADIST($value,$alpha,$beta,$rMin=0,$rMax=1) {
885	$value = PHPExcel_Calculation_Functions::flattenSingleValue($value);
886	$alpha = PHPExcel_Calculation_Functions::flattenSingleValue($alpha);
887	$beta = PHPExcel_Calculation_Functions::flattenSingleValue($beta);
888	$rMin = PHPExcel_Calculation_Functions::flattenSingleValue($rMin);
889	$rMax = PHPExcel_Calculation_Functions::flattenSingleValue($rMax);
890
891	if ((is_numeric($value)) && (is_numeric($alpha)) && (is_numeric($beta)) && (is_numeric($rMin)) && (is_numeric($rMax))) {
892	if (($value < $rMin) \|\| ($value > $rMax) \|\| ($alpha <= 0) \|\| ($beta <= 0) \|\| ($rMin == $rMax)) {
893	return PHPExcel_Calculation_Functions::NaN();
894	}
895	if ($rMin > $rMax) {
896	$tmp = $rMin;
897	$rMin = $rMax;
898	$rMax = $tmp;
899	}
900	$value -= $rMin;
901	$value /= ($rMax - $rMin);
902	return self::_incompleteBeta($value,$alpha,$beta);
903	}
904	return PHPExcel_Calculation_Functions::VALUE();
905	} // function BETADIST()
906
907
908	/**
909	* BETAINV
910	*
911	* Returns the inverse of the beta distribution.
912	*
913	* @param float $probability Probability at which you want to evaluate the distribution
914	* @param float $alpha Parameter to the distribution
915	* @param float $beta Parameter to the distribution
916	* @param float $rMin Minimum value
917	* @param float $rMax Maximum value
918	* @param boolean $cumulative
919	* @return float
920	*
921	*/
922	public static function BETAINV($probability,$alpha,$beta,$rMin=0,$rMax=1) {
923	$probability = PHPExcel_Calculation_Functions::flattenSingleValue($probability);
924	$alpha = PHPExcel_Calculation_Functions::flattenSingleValue($alpha);
925	$beta = PHPExcel_Calculation_Functions::flattenSingleValue($beta);
926	$rMin = PHPExcel_Calculation_Functions::flattenSingleValue($rMin);
927	$rMax = PHPExcel_Calculation_Functions::flattenSingleValue($rMax);
928
929	if ((is_numeric($probability)) && (is_numeric($alpha)) && (is_numeric($beta)) && (is_numeric($rMin)) && (is_numeric($rMax))) {
930	if (($alpha <= 0) \|\| ($beta <= 0) \|\| ($rMin == $rMax) \|\| ($probability <= 0) \|\| ($probability > 1)) {
931	return PHPExcel_Calculation_Functions::NaN();
932	}
933	if ($rMin > $rMax) {
934	$tmp = $rMin;
935	$rMin = $rMax;
936	$rMax = $tmp;
937	}
938	$a = 0;
939	$b = 2;
940
941	$i = 0;
942	while ((($b - $a) > PRECISION) && ($i++ < MAX_ITERATIONS)) {
943	$guess = ($a + $b) / 2;
944	$result = self::BETADIST($guess, $alpha, $beta);
945	if (($result == $probability) \|\| ($result == 0)) {
946	$b = $a;
947	} elseif ($result > $probability) {
948	$b = $guess;
949	} else {
950	$a = $guess;
951	}
952	}
953	if ($i == MAX_ITERATIONS) {
954	return PHPExcel_Calculation_Functions::NA();
955	}
956	return round($rMin + $guess * ($rMax - $rMin),12);
957	}
958	return PHPExcel_Calculation_Functions::VALUE();
959	} // function BETAINV()
960
961
962	/**
963	* BINOMDIST
964	*
965	* Returns the individual term binomial distribution probability. Use BINOMDIST in problems with
966	* a fixed number of tests or trials, when the outcomes of any trial are only success or failure,
967	* when trials are independent, and when the probability of success is constant throughout the
968	* experiment. For example, BINOMDIST can calculate the probability that two of the next three
969	* babies born are male.
970	*
971	* @param float $value Number of successes in trials
972	* @param float $trials Number of trials
973	* @param float $probability Probability of success on each trial
974	* @param boolean $cumulative
975	* @return float
976	*
977	* @todo Cumulative distribution function
978	*
979	*/
980	public static function BINOMDIST($value, $trials, $probability, $cumulative) {
981	$value = floor(PHPExcel_Calculation_Functions::flattenSingleValue($value));
982	$trials = floor(PHPExcel_Calculation_Functions::flattenSingleValue($trials));
983	$probability = PHPExcel_Calculation_Functions::flattenSingleValue($probability);
984
985	if ((is_numeric($value)) && (is_numeric($trials)) && (is_numeric($probability))) {
986	if (($value < 0) \|\| ($value > $trials)) {
987	return PHPExcel_Calculation_Functions::NaN();
988	}
989	if (($probability < 0) \|\| ($probability > 1)) {
990	return PHPExcel_Calculation_Functions::NaN();
991	}
992	if ((is_numeric($cumulative)) \|\| (is_bool($cumulative))) {
993	if ($cumulative) {
994	$summer = 0;
995	for ($i = 0; $i <= $value; ++$i) {
996	$summer += PHPExcel_Calculation_MathTrig::COMBIN($trials,$i) * pow($probability,$i) * pow(1 - $probability,$trials - $i);
997	}
998	return $summer;
999	} else {
1000	return PHPExcel_Calculation_MathTrig::COMBIN($trials,$value) * pow($probability,$value) * pow(1 - $probability,$trials - $value) ;
1001	}
1002	}
1003	}
1004	return PHPExcel_Calculation_Functions::VALUE();
1005	} // function BINOMDIST()
1006
1007
1008	/**
1009	* CHIDIST
1010	*
1011	* Returns the one-tailed probability of the chi-squared distribution.
1012	*
1013	* @param float $value Value for the function
1014	* @param float $degrees degrees of freedom
1015	* @return float
1016	*/
1017	public static function CHIDIST($value, $degrees) {
1018	$value = PHPExcel_Calculation_Functions::flattenSingleValue($value);
1019	$degrees = floor(PHPExcel_Calculation_Functions::flattenSingleValue($degrees));
1020
1021	if ((is_numeric($value)) && (is_numeric($degrees))) {
1022	if ($degrees < 1) {
1023	return PHPExcel_Calculation_Functions::NaN();
1024	}
1025	if ($value < 0) {
1026	if (PHPExcel_Calculation_Functions::getCompatibilityMode() == PHPExcel_Calculation_Functions::COMPATIBILITY_GNUMERIC) {
1027	return 1;
1028	}
1029	return PHPExcel_Calculation_Functions::NaN();
1030	}
1031	return 1 - (self::_incompleteGamma($degrees/2,$value/2) / self::_gamma($degrees/2));
1032	}
1033	return PHPExcel_Calculation_Functions::VALUE();
1034	} // function CHIDIST()
1035
1036
1037	/**
1038	* CHIINV
1039	*
1040	* Returns the one-tailed probability of the chi-squared distribution.
1041	*
1042	* @param float $probability Probability for the function
1043	* @param float $degrees degrees of freedom
1044	* @return float
1045	*/
1046	public static function CHIINV($probability, $degrees) {
1047	$probability = PHPExcel_Calculation_Functions::flattenSingleValue($probability);
1048	$degrees = floor(PHPExcel_Calculation_Functions::flattenSingleValue($degrees));
1049
1050	if ((is_numeric($probability)) && (is_numeric($degrees))) {
1051
1052	$xLo = 100;
1053	$xHi = 0;
1054
1055	$x = $xNew = 1;
1056	$dx = 1;
1057	$i = 0;
1058
1059	while ((abs($dx) > PRECISION) && ($i++ < MAX_ITERATIONS)) {
1060	// Apply Newton-Raphson step
1061	$result = self::CHIDIST($x, $degrees);
1062	$error = $result - $probability;
1063	if ($error == 0.0) {
1064	$dx = 0;
1065	} elseif ($error < 0.0) {
1066	$xLo = $x;
1067	} else {
1068	$xHi = $x;
1069	}
1070	// Avoid division by zero
1071	if ($result != 0.0) {
1072	$dx = $error / $result;
1073	$xNew = $x - $dx;
1074	}
1075	// If the NR fails to converge (which for example may be the
1076	// case if the initial guess is too rough) we apply a bisection
1077	// step to determine a more narrow interval around the root.
1078	if (($xNew < $xLo) \|\| ($xNew > $xHi) \|\| ($result == 0.0)) {
1079	$xNew = ($xLo + $xHi) / 2;
1080	$dx = $xNew - $x;
1081	}
1082	$x = $xNew;
1083	}
1084	if ($i == MAX_ITERATIONS) {
1085	return PHPExcel_Calculation_Functions::NA();
1086	}
1087	return round($x,12);
1088	}
1089	return PHPExcel_Calculation_Functions::VALUE();
1090	} // function CHIINV()
1091
1092
1093	/**
1094	* CONFIDENCE
1095	*
1096	* Returns the confidence interval for a population mean
1097	*
1098	* @param float $alpha
1099	* @param float $stdDev Standard Deviation
1100	* @param float $size
1101	* @return float
1102	*
1103	*/
1104	public static function CONFIDENCE($alpha,$stdDev,$size) {
1105	$alpha = PHPExcel_Calculation_Functions::flattenSingleValue($alpha);
1106	$stdDev = PHPExcel_Calculation_Functions::flattenSingleValue($stdDev);
1107	$size = floor(PHPExcel_Calculation_Functions::flattenSingleValue($size));
1108
1109	if ((is_numeric($alpha)) && (is_numeric($stdDev)) && (is_numeric($size))) {
1110	if (($alpha <= 0) \|\| ($alpha >= 1)) {
1111	return PHPExcel_Calculation_Functions::NaN();
1112	}
1113	if (($stdDev <= 0) \|\| ($size < 1)) {
1114	return PHPExcel_Calculation_Functions::NaN();
1115	}
1116	return self::NORMSINV(1 - $alpha / 2) * $stdDev / sqrt($size);
1117	}
1118	return PHPExcel_Calculation_Functions::VALUE();
1119	} // function CONFIDENCE()
1120
1121
1122	/**
1123	* CORREL
1124	*
1125	* Returns covariance, the average of the products of deviations for each data point pair.
1126	*
1127	* @param array of mixed Data Series Y
1128	* @param array of mixed Data Series X
1129	* @return float
1130	*/
1131	public static function CORREL($yValues,$xValues=null) {
1132	if ((is_null($xValues)) \|\| (!is_array($yValues)) \|\| (!is_array($xValues))) {
1133	return PHPExcel_Calculation_Functions::VALUE();
1134	}
1135	if (!self::_checkTrendArrays($yValues,$xValues)) {
1136	return PHPExcel_Calculation_Functions::VALUE();
1137	}
1138	$yValueCount = count($yValues);
1139	$xValueCount = count($xValues);
1140
1141	if (($yValueCount == 0) \|\| ($yValueCount != $xValueCount)) {
1142	return PHPExcel_Calculation_Functions::NA();
1143	} elseif ($yValueCount == 1) {
1144	return PHPExcel_Calculation_Functions::DIV0();
1145	}
1146
1147	$bestFitLinear = trendClass::calculate(trendClass::TREND_LINEAR,$yValues,$xValues);
1148	return $bestFitLinear->getCorrelation();
1149	} // function CORREL()
1150
1151
1152	/**
1153	* COUNT
1154	*
1155	* Counts the number of cells that contain numbers within the list of arguments
1156	*
1157	* Excel Function:
1158	* COUNT(value1[,value2[, ...]])
1159	*
1160	* @access public
1161	* @category Statistical Functions
1162	* @param mixed $arg,... Data values
1163	* @return int
1164	*/
1165	public static function COUNT() {
1166	// Return value
1167	$returnValue = 0;
1168
1169	// Loop through arguments
1170	$aArgs = PHPExcel_Calculation_Functions::flattenArrayIndexed(func_get_args());
1171	foreach ($aArgs as $k => $arg) {
1172	if ((is_bool($arg)) &&
1173	((!PHPExcel_Calculation_Functions::isCellValue($k)) \|\| (PHPExcel_Calculation_Functions::getCompatibilityMode() == PHPExcel_Calculation_Functions::COMPATIBILITY_OPENOFFICE))) {
1174	$arg = (integer) $arg;
1175	}
1176	// Is it a numeric value?
1177	if ((is_numeric($arg)) && (!is_string($arg))) {
1178	++$returnValue;
1179	}
1180	}
1181
1182	// Return
1183	return $returnValue;
1184	} // function COUNT()
1185
1186
1187	/**
1188	* COUNTA
1189	*
1190	* Counts the number of cells that are not empty within the list of arguments
1191	*
1192	* Excel Function:
1193	* COUNTA(value1[,value2[, ...]])
1194	*
1195	* @access public
1196	* @category Statistical Functions
1197	* @param mixed $arg,... Data values
1198	* @return int
1199	*/
1200	public static function COUNTA() {
1201	// Return value
1202	$returnValue = 0;
1203
1204	// Loop through arguments
1205	$aArgs = PHPExcel_Calculation_Functions::flattenArray(func_get_args());
1206	foreach ($aArgs as $arg) {
1207	// Is it a numeric, boolean or string value?
1208	if ((is_numeric($arg)) \|\| (is_bool($arg)) \|\| ((is_string($arg) && ($arg != '')))) {
1209	++$returnValue;
1210	}
1211	}
1212
1213	// Return
1214	return $returnValue;
1215	} // function COUNTA()
1216
1217
1218	/**
1219	* COUNTBLANK
1220	*
1221	* Counts the number of empty cells within the list of arguments
1222	*
1223	* Excel Function:
1224	* COUNTBLANK(value1[,value2[, ...]])
1225	*
1226	* @access public
1227	* @category Statistical Functions
1228	* @param mixed $arg,... Data values
1229	* @return int
1230	*/
1231	public static function COUNTBLANK() {
1232	// Return value
1233	$returnValue = 0;
1234
1235	// Loop through arguments
1236	$aArgs = PHPExcel_Calculation_Functions::flattenArray(func_get_args());
1237	foreach ($aArgs as $arg) {
1238	// Is it a blank cell?
1239	if ((is_null($arg)) \|\| ((is_string($arg)) && ($arg == ''))) {
1240	++$returnValue;
1241	}
1242	}
1243
1244	// Return
1245	return $returnValue;
1246	} // function COUNTBLANK()
1247
1248
1249	/**
1250	* COUNTIF
1251	*
1252	* Counts the number of cells that contain numbers within the list of arguments
1253	*
1254	* Excel Function:
1255	* COUNTIF(value1[,value2[, ...]],condition)
1256	*
1257	* @access public
1258	* @category Statistical Functions
1259	* @param mixed $arg,... Data values
1260	* @param string $condition The criteria that defines which cells will be counted.
1261	* @return int
1262	*/
1263	public static function COUNTIF($aArgs,$condition) {
1264	// Return value
1265	$returnValue = 0;
1266
1267	$aArgs = PHPExcel_Calculation_Functions::flattenArray($aArgs);
1268	$condition = PHPExcel_Calculation_Functions::_ifCondition($condition);
1269	// Loop through arguments
1270	foreach ($aArgs as $arg) {
1271	if (!is_numeric($arg)) { $arg = PHPExcel_Calculation::_wrapResult(strtoupper($arg)); }
1272	$testCondition = '='.$arg.$condition;
1273	if (PHPExcel_Calculation::getInstance()->_calculateFormulaValue($testCondition)) {
1274	// Is it a value within our criteria
1275	++$returnValue;
1276	}
1277	}
1278
1279	// Return
1280	return $returnValue;
1281	} // function COUNTIF()
1282
1283
1284	/**
1285	* COVAR
1286	*
1287	* Returns covariance, the average of the products of deviations for each data point pair.
1288	*
1289	* @param array of mixed Data Series Y
1290	* @param array of mixed Data Series X
1291	* @return float
1292	*/
1293	public static function COVAR($yValues,$xValues) {
1294	if (!self::_checkTrendArrays($yValues,$xValues)) {
1295	return PHPExcel_Calculation_Functions::VALUE();
1296	}
1297	$yValueCount = count($yValues);
1298	$xValueCount = count($xValues);
1299
1300	if (($yValueCount == 0) \|\| ($yValueCount != $xValueCount)) {
1301	return PHPExcel_Calculation_Functions::NA();
1302	} elseif ($yValueCount == 1) {
1303	return PHPExcel_Calculation_Functions::DIV0();
1304	}
1305
1306	$bestFitLinear = trendClass::calculate(trendClass::TREND_LINEAR,$yValues,$xValues);
1307	return $bestFitLinear->getCovariance();
1308	} // function COVAR()
1309
1310
1311	/**
1312	* CRITBINOM
1313	*
1314	* Returns the smallest value for which the cumulative binomial distribution is greater
1315	* than or equal to a criterion value
1316	*
1317	* See http://support.microsoft.com/kb/828117/ for details of the algorithm used
1318	*
1319	* @param float $trials number of Bernoulli trials
1320	* @param float $probability probability of a success on each trial
1321	* @param float $alpha criterion value
1322	* @return int
1323	*
1324	* @todo Warning. This implementation differs from the algorithm detailed on the MS
1325	* web site in that $CumPGuessMinus1 = $CumPGuess - 1 rather than $CumPGuess - $PGuess
1326	* This eliminates a potential endless loop error, but may have an adverse affect on the
1327	* accuracy of the function (although all my tests have so far returned correct results).
1328	*
1329	*/
1330	public static function CRITBINOM($trials, $probability, $alpha) {
1331	$trials = floor(PHPExcel_Calculation_Functions::flattenSingleValue($trials));
1332	$probability = PHPExcel_Calculation_Functions::flattenSingleValue($probability);
1333	$alpha = PHPExcel_Calculation_Functions::flattenSingleValue($alpha);
1334
1335	if ((is_numeric($trials)) && (is_numeric($probability)) && (is_numeric($alpha))) {
1336	if ($trials < 0) {
1337	return PHPExcel_Calculation_Functions::NaN();
1338	}
1339	if (($probability < 0) \|\| ($probability > 1)) {
1340	return PHPExcel_Calculation_Functions::NaN();
1341	}
1342	if (($alpha < 0) \|\| ($alpha > 1)) {
1343	return PHPExcel_Calculation_Functions::NaN();
1344	}
1345	if ($alpha <= 0.5) {
1346	$t = sqrt(log(1 / ($alpha * $alpha)));
1347	$trialsApprox = 0 - ($t + (2.515517 + 0.802853 * $t + 0.010328 * $t * $t) / (1 + 1.432788 * $t + 0.189269 * $t * $t + 0.001308 * $t * $t * $t));
1348	} else {
1349	$t = sqrt(log(1 / pow(1 - $alpha,2)));
1350	$trialsApprox = $t - (2.515517 + 0.802853 * $t + 0.010328 * $t * $t) / (1 + 1.432788 * $t + 0.189269 * $t * $t + 0.001308 * $t * $t * $t);
1351	}
1352	$Guess = floor($trials * $probability + $trialsApprox * sqrt($trials * $probability * (1 - $probability)));
1353	if ($Guess < 0) {
1354	$Guess = 0;
1355	} elseif ($Guess > $trials) {
1356	$Guess = $trials;
1357	}
1358
1359	$TotalUnscaledProbability = $UnscaledPGuess = $UnscaledCumPGuess = 0.0;
1360	$EssentiallyZero = 10e-12;
1361
1362	$m = floor($trials * $probability);
1363	++$TotalUnscaledProbability;
1364	if ($m == $Guess) { ++$UnscaledPGuess; }
1365	if ($m <= $Guess) { ++$UnscaledCumPGuess; }
1366
1367	$PreviousValue = 1;
1368	$Done = False;
1369	$k = $m + 1;
1370	while ((!$Done) && ($k <= $trials)) {
1371	$CurrentValue = $PreviousValue * ($trials - $k + 1) * $probability / ($k * (1 - $probability));
1372	$TotalUnscaledProbability += $CurrentValue;
1373	if ($k == $Guess) { $UnscaledPGuess += $CurrentValue; }
1374	if ($k <= $Guess) { $UnscaledCumPGuess += $CurrentValue; }
1375	if ($CurrentValue <= $EssentiallyZero) { $Done = True; }
1376	$PreviousValue = $CurrentValue;
1377	++$k;
1378	}
1379
1380	$PreviousValue = 1;
1381	$Done = False;
1382	$k = $m - 1;
1383	while ((!$Done) && ($k >= 0)) {
1384	$CurrentValue = $PreviousValue * $k + 1 * (1 - $probability) / (($trials - $k) * $probability);
1385	$TotalUnscaledProbability += $CurrentValue;
1386	if ($k == $Guess) { $UnscaledPGuess += $CurrentValue; }
1387	if ($k <= $Guess) { $UnscaledCumPGuess += $CurrentValue; }
1388	if ($CurrentValue <= $EssentiallyZero) { $Done = True; }
1389	$PreviousValue = $CurrentValue;
1390	--$k;
1391	}
1392
1393	$PGuess = $UnscaledPGuess / $TotalUnscaledProbability;
1394	$CumPGuess = $UnscaledCumPGuess / $TotalUnscaledProbability;
1395
1396	// $CumPGuessMinus1 = $CumPGuess - $PGuess;
1397	$CumPGuessMinus1 = $CumPGuess - 1;
1398
1399	while (True) {
1400	if (($CumPGuessMinus1 < $alpha) && ($CumPGuess >= $alpha)) {
1401	return $Guess;
1402	} elseif (($CumPGuessMinus1 < $alpha) && ($CumPGuess < $alpha)) {
1403	$PGuessPlus1 = $PGuess * ($trials - $Guess) * $probability / $Guess / (1 - $probability);
1404	$CumPGuessMinus1 = $CumPGuess;
1405	$CumPGuess = $CumPGuess + $PGuessPlus1;
1406	$PGuess = $PGuessPlus1;
1407	++$Guess;
1408	} elseif (($CumPGuessMinus1 >= $alpha) && ($CumPGuess >= $alpha)) {
1409	$PGuessMinus1 = $PGuess * $Guess * (1 - $probability) / ($trials - $Guess + 1) / $probability;
1410	$CumPGuess = $CumPGuessMinus1;
1411	$CumPGuessMinus1 = $CumPGuessMinus1 - $PGuess;
1412	$PGuess = $PGuessMinus1;
1413	--$Guess;
1414	}
1415	}
1416	}
1417	return PHPExcel_Calculation_Functions::VALUE();
1418	} // function CRITBINOM()
1419
1420
1421	/**
1422	* DEVSQ
1423	*
1424	* Returns the sum of squares of deviations of data points from their sample mean.
1425	*
1426	* Excel Function:
1427	* DEVSQ(value1[,value2[, ...]])
1428	*
1429	* @access public
1430	* @category Statistical Functions
1431	* @param mixed $arg,... Data values
1432	* @return float
1433	*/
1434	public static function DEVSQ() {
1435	$aArgs = PHPExcel_Calculation_Functions::flattenArrayIndexed(func_get_args());
1436
1437	// Return value
1438	$returnValue = null;
1439
1440	$aMean = self::AVERAGE($aArgs);
1441	if ($aMean != PHPExcel_Calculation_Functions::DIV0()) {
1442	$aCount = -1;
1443	foreach ($aArgs as $k => $arg) {
1444	// Is it a numeric value?
1445	if ((is_bool($arg)) &&
1446	((!PHPExcel_Calculation_Functions::isCellValue($k)) \|\| (PHPExcel_Calculation_Functions::getCompatibilityMode() == PHPExcel_Calculation_Functions::COMPATIBILITY_OPENOFFICE))) {
1447	$arg = (integer) $arg;
1448	}
1449	if ((is_numeric($arg)) && (!is_string($arg))) {
1450	if (is_null($returnValue)) {
1451	$returnValue = pow(($arg - $aMean),2);
1452	} else {
1453	$returnValue += pow(($arg - $aMean),2);
1454	}
1455	++$aCount;
1456	}
1457	}
1458
1459	// Return
1460	if (is_null($returnValue)) {
1461	return PHPExcel_Calculation_Functions::NaN();
1462	} else {
1463	return $returnValue;
1464	}
1465	}
1466	return self::NA();
1467	} // function DEVSQ()
1468
1469
1470	/**
1471	* EXPONDIST
1472	*
1473	* Returns the exponential distribution. Use EXPONDIST to model the time between events,
1474	* such as how long an automated bank teller takes to deliver cash. For example, you can
1475	* use EXPONDIST to determine the probability that the process takes at most 1 minute.
1476	*
1477	* @param float $value Value of the function
1478	* @param float $lambda The parameter value
1479	* @param boolean $cumulative
1480	* @return float
1481	*/
1482	public static function EXPONDIST($value, $lambda, $cumulative) {
1483	$value = PHPExcel_Calculation_Functions::flattenSingleValue($value);
1484	$lambda = PHPExcel_Calculation_Functions::flattenSingleValue($lambda);
1485	$cumulative = PHPExcel_Calculation_Functions::flattenSingleValue($cumulative);
1486
1487	if ((is_numeric($value)) && (is_numeric($lambda))) {
1488	if (($value < 0) \|\| ($lambda < 0)) {
1489	return PHPExcel_Calculation_Functions::NaN();
1490	}
1491	if ((is_numeric($cumulative)) \|\| (is_bool($cumulative))) {
1492	if ($cumulative) {
1493	return 1 - exp(0-$value*$lambda);
1494	} else {
1495	return $lambda * exp(0-$value*$lambda);
1496	}
1497	}
1498	}
1499	return PHPExcel_Calculation_Functions::VALUE();
1500	} // function EXPONDIST()
1501
1502
1503	/**
1504	* FISHER
1505	*
1506	* Returns the Fisher transformation at x. This transformation produces a function that
1507	* is normally distributed rather than skewed. Use this function to perform hypothesis
1508	* testing on the correlation coefficient.
1509	*
1510	* @param float $value
1511	* @return float
1512	*/
1513	public static function FISHER($value) {
1514	$value = PHPExcel_Calculation_Functions::flattenSingleValue($value);
1515
1516	if (is_numeric($value)) {
1517	if (($value <= -1) \|\| ($value >= 1)) {
1518	return PHPExcel_Calculation_Functions::NaN();
1519	}
1520	return 0.5 * log((1+$value)/(1-$value));
1521	}
1522	return PHPExcel_Calculation_Functions::VALUE();
1523	} // function FISHER()
1524
1525
1526	/**
1527	* FISHERINV
1528	*
1529	* Returns the inverse of the Fisher transformation. Use this transformation when
1530	* analyzing correlations between ranges or arrays of data. If y = FISHER(x), then
1531	* FISHERINV(y) = x.
1532	*
1533	* @param float $value
1534	* @return float
1535	*/
1536	public static function FISHERINV($value) {
1537	$value = PHPExcel_Calculation_Functions::flattenSingleValue($value);
1538
1539	if (is_numeric($value)) {
1540	return (exp(2 * $value) - 1) / (exp(2 * $value) + 1);
1541	}
1542	return PHPExcel_Calculation_Functions::VALUE();
1543	} // function FISHERINV()
1544
1545
1546	/**
1547	* FORECAST
1548	*
1549	* Calculates, or predicts, a future value by using existing values. The predicted value is a y-value for a given x-value.
1550	*
1551	* @param float Value of X for which we want to find Y
1552	* @param array of mixed Data Series Y
1553	* @param array of mixed Data Series X
1554	* @return float
1555	*/
1556	public static function FORECAST($xValue,$yValues,$xValues) {
1557	$xValue = PHPExcel_Calculation_Functions::flattenSingleValue($xValue);
1558	if (!is_numeric($xValue)) {
1559	return PHPExcel_Calculation_Functions::VALUE();
1560	}
1561
1562	if (!self::_checkTrendArrays($yValues,$xValues)) {
1563	return PHPExcel_Calculation_Functions::VALUE();
1564	}
1565	$yValueCount = count($yValues);
1566	$xValueCount = count($xValues);
1567
1568	if (($yValueCount == 0) \|\| ($yValueCount != $xValueCount)) {
1569	return PHPExcel_Calculation_Functions::NA();
1570	} elseif ($yValueCount == 1) {
1571	return PHPExcel_Calculation_Functions::DIV0();
1572	}
1573
1574	$bestFitLinear = trendClass::calculate(trendClass::TREND_LINEAR,$yValues,$xValues);
1575	return $bestFitLinear->getValueOfYForX($xValue);
1576	} // function FORECAST()
1577
1578
1579	/**
1580	* GAMMADIST
1581	*
1582	* Returns the gamma distribution.
1583	*
1584	* @param float $value Value at which you want to evaluate the distribution
1585	* @param float $a Parameter to the distribution
1586	* @param float $b Parameter to the distribution
1587	* @param boolean $cumulative
1588	* @return float
1589	*
1590	*/
1591	public static function GAMMADIST($value,$a,$b,$cumulative) {
1592	$value = PHPExcel_Calculation_Functions::flattenSingleValue($value);
1593	$a = PHPExcel_Calculation_Functions::flattenSingleValue($a);
1594	$b = PHPExcel_Calculation_Functions::flattenSingleValue($b);
1595
1596	if ((is_numeric($value)) && (is_numeric($a)) && (is_numeric($b))) {
1597	if (($value < 0) \|\| ($a <= 0) \|\| ($b <= 0)) {
1598	return PHPExcel_Calculation_Functions::NaN();
1599	}
1600	if ((is_numeric($cumulative)) \|\| (is_bool($cumulative))) {
1601	if ($cumulative) {
1602	return self::_incompleteGamma($a,$value / $b) / self::_gamma($a);
1603	} else {
1604	return (1 / (pow($b,$a) * self::_gamma($a))) * pow($value,$a-1) * exp(0-($value / $b));
1605	}
1606	}
1607	}
1608	return PHPExcel_Calculation_Functions::VALUE();
1609	} // function GAMMADIST()
1610
1611
1612	/**
1613	* GAMMAINV
1614	*
1615	* Returns the inverse of the beta distribution.
1616	*
1617	* @param float $probability Probability at which you want to evaluate the distribution
1618	* @param float $alpha Parameter to the distribution
1619	* @param float $beta Parameter to the distribution
1620	* @return float
1621	*
1622	*/
1623	public static function GAMMAINV($probability,$alpha,$beta) {
1624	$probability = PHPExcel_Calculation_Functions::flattenSingleValue($probability);
1625	$alpha = PHPExcel_Calculation_Functions::flattenSingleValue($alpha);
1626	$beta = PHPExcel_Calculation_Functions::flattenSingleValue($beta);
1627
1628	if ((is_numeric($probability)) && (is_numeric($alpha)) && (is_numeric($beta))) {
1629	if (($alpha <= 0) \|\| ($beta <= 0) \|\| ($probability < 0) \|\| ($probability > 1)) {
1630	return PHPExcel_Calculation_Functions::NaN();
1631	}
1632
1633	$xLo = 0;
1634	$xHi = $alpha * $beta * 5;
1635
1636	$x = $xNew = 1;
1637	$error = $pdf = 0;
1638	$dx = 1024;
1639	$i = 0;
1640
1641	while ((abs($dx) > PRECISION) && ($i++ < MAX_ITERATIONS)) {
1642	// Apply Newton-Raphson step
1643	$error = self::GAMMADIST($x, $alpha, $beta, True) - $probability;
1644	if ($error < 0.0) {
1645	$xLo = $x;
1646	} else {
1647	$xHi = $x;
1648	}
1649	$pdf = self::GAMMADIST($x, $alpha, $beta, False);
1650	// Avoid division by zero
1651	if ($pdf != 0.0) {
1652	$dx = $error / $pdf;
1653	$xNew = $x - $dx;
1654	}
1655	// If the NR fails to converge (which for example may be the
1656	// case if the initial guess is too rough) we apply a bisection
1657	// step to determine a more narrow interval around the root.
1658	if (($xNew < $xLo) \|\| ($xNew > $xHi) \|\| ($pdf == 0.0)) {
1659	$xNew = ($xLo + $xHi) / 2;
1660	$dx = $xNew - $x;
1661	}
1662	$x = $xNew;
1663	}
1664	if ($i == MAX_ITERATIONS) {
1665	return PHPExcel_Calculation_Functions::NA();
1666	}
1667	return $x;
1668	}
1669	return PHPExcel_Calculation_Functions::VALUE();
1670	} // function GAMMAINV()
1671
1672
1673	/**
1674	* GAMMALN
1675	*
1676	* Returns the natural logarithm of the gamma function.
1677	*
1678	* @param float $value
1679	* @return float
1680	*/
1681	public static function GAMMALN($value) {
1682	$value = PHPExcel_Calculation_Functions::flattenSingleValue($value);
1683
1684	if (is_numeric($value)) {
1685	if ($value <= 0) {
1686	return PHPExcel_Calculation_Functions::NaN();
1687	}
1688	return log(self::_gamma($value));
1689	}
1690	return PHPExcel_Calculation_Functions::VALUE();
1691	} // function GAMMALN()
1692
1693
1694	/**
1695	* GEOMEAN
1696	*
1697	* Returns the geometric mean of an array or range of positive data. For example, you
1698	* can use GEOMEAN to calculate average growth rate given compound interest with
1699	* variable rates.
1700	*
1701	* Excel Function:
1702	* GEOMEAN(value1[,value2[, ...]])
1703	*
1704	* @access public
1705	* @category Statistical Functions
1706	* @param mixed $arg,... Data values
1707	* @return float
1708	*/
1709	public static function GEOMEAN() {
1710	$aArgs = PHPExcel_Calculation_Functions::flattenArray(func_get_args());
1711
1712	$aMean = PHPExcel_Calculation_MathTrig::PRODUCT($aArgs);
1713	if (is_numeric($aMean) && ($aMean > 0)) {
1714	$aCount = self::COUNT($aArgs) ;
1715	if (self::MIN($aArgs) > 0) {
1716	return pow($aMean, (1 / $aCount));
1717	}
1718	}
1719	return PHPExcel_Calculation_Functions::NaN();
1720	} // GEOMEAN()
1721
1722
1723	/**
1724	* GROWTH
1725	*
1726	* Returns values along a predicted emponential trend
1727	*
1728	* @param array of mixed Data Series Y
1729	* @param array of mixed Data Series X
1730	* @param array of mixed Values of X for which we want to find Y
1731	* @param boolean A logical value specifying whether to force the intersect to equal 0.
1732	* @return array of float
1733	*/
1734	public static function GROWTH($yValues,$xValues=array(),$newValues=array(),$const=True) {
1735	$yValues = PHPExcel_Calculation_Functions::flattenArray($yValues);
1736	$xValues = PHPExcel_Calculation_Functions::flattenArray($xValues);
1737	$newValues = PHPExcel_Calculation_Functions::flattenArray($newValues);
1738	$const = (is_null($const)) ? True : (boolean) PHPExcel_Calculation_Functions::flattenSingleValue($const);
1739
1740	$bestFitExponential = trendClass::calculate(trendClass::TREND_EXPONENTIAL,$yValues,$xValues,$const);
1741	if (empty($newValues)) {
1742	$newValues = $bestFitExponential->getXValues();
1743	}
1744
1745	$returnArray = array();
1746	foreach($newValues as $xValue) {
1747	$returnArray[0][] = $bestFitExponential->getValueOfYForX($xValue);
1748	}
1749
1750	return $returnArray;
1751	} // function GROWTH()
1752
1753
1754	/**
1755	* HARMEAN
1756	*
1757	* Returns the harmonic mean of a data set. The harmonic mean is the reciprocal of the
1758	* arithmetic mean of reciprocals.
1759	*
1760	* Excel Function:
1761	* HARMEAN(value1[,value2[, ...]])
1762	*
1763	* @access public
1764	* @category Statistical Functions
1765	* @param mixed $arg,... Data values
1766	* @return float
1767	*/
1768	public static function HARMEAN() {
1769	// Return value
1770	$returnValue = PHPExcel_Calculation_Functions::NA();
1771
1772	// Loop through arguments
1773	$aArgs = PHPExcel_Calculation_Functions::flattenArray(func_get_args());
1774	if (self::MIN($aArgs) < 0) {
1775	return PHPExcel_Calculation_Functions::NaN();
1776	}
1777	$aCount = 0;
1778	foreach ($aArgs as $arg) {
1779	// Is it a numeric value?
1780	if ((is_numeric($arg)) && (!is_string($arg))) {
1781	if ($arg <= 0) {
1782	return PHPExcel_Calculation_Functions::NaN();
1783	}
1784	if (is_null($returnValue)) {
1785	$returnValue = (1 / $arg);
1786	} else {
1787	$returnValue += (1 / $arg);
1788	}
1789	++$aCount;
1790	}
1791	}
1792
1793	// Return
1794	if ($aCount > 0) {
1795	return 1 / ($returnValue / $aCount);
1796	} else {
1797	return $returnValue;
1798	}
1799	} // function HARMEAN()
1800
1801
1802	/**
1803	* HYPGEOMDIST
1804	*
1805	* Returns the hypergeometric distribution. HYPGEOMDIST returns the probability of a given number of
1806	* sample successes, given the sample size, population successes, and population size.
1807	*
1808	* @param float $sampleSuccesses Number of successes in the sample
1809	* @param float $sampleNumber Size of the sample
1810	* @param float $populationSuccesses Number of successes in the population
1811	* @param float $populationNumber Population size
1812	* @return float
1813	*
1814	*/
1815	public static function HYPGEOMDIST($sampleSuccesses, $sampleNumber, $populationSuccesses, $populationNumber) {
1816	$sampleSuccesses = floor(PHPExcel_Calculation_Functions::flattenSingleValue($sampleSuccesses));
1817	$sampleNumber = floor(PHPExcel_Calculation_Functions::flattenSingleValue($sampleNumber));
1818	$populationSuccesses = floor(PHPExcel_Calculation_Functions::flattenSingleValue($populationSuccesses));
1819	$populationNumber = floor(PHPExcel_Calculation_Functions::flattenSingleValue($populationNumber));
1820
1821	if ((is_numeric($sampleSuccesses)) && (is_numeric($sampleNumber)) && (is_numeric($populationSuccesses)) && (is_numeric($populationNumber))) {
1822	if (($sampleSuccesses < 0) \|\| ($sampleSuccesses > $sampleNumber) \|\| ($sampleSuccesses > $populationSuccesses)) {
1823	return PHPExcel_Calculation_Functions::NaN();
1824	}
1825	if (($sampleNumber <= 0) \|\| ($sampleNumber > $populationNumber)) {
1826	return PHPExcel_Calculation_Functions::NaN();
1827	}
1828	if (($populationSuccesses <= 0) \|\| ($populationSuccesses > $populationNumber)) {
1829	return PHPExcel_Calculation_Functions::NaN();
1830	}
1831	return PHPExcel_Calculation_MathTrig::COMBIN($populationSuccesses,$sampleSuccesses) *
1832	PHPExcel_Calculation_MathTrig::COMBIN($populationNumber - $populationSuccesses,$sampleNumber - $sampleSuccesses) /
1833	PHPExcel_Calculation_MathTrig::COMBIN($populationNumber,$sampleNumber);
1834	}
1835	return PHPExcel_Calculation_Functions::VALUE();
1836	} // function HYPGEOMDIST()
1837
1838
1839	/**
1840	* INTERCEPT
1841	*
1842	* Calculates the point at which a line will intersect the y-axis by using existing x-values and y-values.
1843	*
1844	* @param array of mixed Data Series Y
1845	* @param array of mixed Data Series X
1846	* @return float
1847	*/
1848	public static function INTERCEPT($yValues,$xValues) {
1849	if (!self::_checkTrendArrays($yValues,$xValues)) {
1850	return PHPExcel_Calculation_Functions::VALUE();
1851	}
1852	$yValueCount = count($yValues);
1853	$xValueCount = count($xValues);
1854
1855	if (($yValueCount == 0) \|\| ($yValueCount != $xValueCount)) {
1856	return PHPExcel_Calculation_Functions::NA();
1857	} elseif ($yValueCount == 1) {
1858	return PHPExcel_Calculation_Functions::DIV0();
1859	}
1860
1861	$bestFitLinear = trendClass::calculate(trendClass::TREND_LINEAR,$yValues,$xValues);
1862	return $bestFitLinear->getIntersect();
1863	} // function INTERCEPT()
1864
1865
1866	/**
1867	* KURT
1868	*
1869	* Returns the kurtosis of a data set. Kurtosis characterizes the relative peakedness
1870	* or flatness of a distribution compared with the normal distribution. Positive
1871	* kurtosis indicates a relatively peaked distribution. Negative kurtosis indicates a
1872	* relatively flat distribution.
1873	*
1874	* @param array Data Series
1875	* @return float
1876	*/
1877	public static function KURT() {
1878	$aArgs = PHPExcel_Calculation_Functions::flattenArrayIndexed(func_get_args());
1879	$mean = self::AVERAGE($aArgs);
1880	$stdDev = self::STDEV($aArgs);
1881
1882	if ($stdDev > 0) {
1883	$count = $summer = 0;
1884	// Loop through arguments
1885	foreach ($aArgs as $k => $arg) {
1886	if ((is_bool($arg)) &&
1887	(!PHPExcel_Calculation_Functions::isMatrixValue($k))) {
1888	} else {
1889	// Is it a numeric value?
1890	if ((is_numeric($arg)) && (!is_string($arg))) {
1891	$summer += pow((($arg - $mean) / $stdDev),4) ;
1892	++$count;
1893	}
1894	}
1895	}
1896
1897	// Return
1898	if ($count > 3) {
1899	return $summer * ($count * ($count+1) / (($count-1) * ($count-2) * ($count-3))) - (3 * pow($count-1,2) / (($count-2) * ($count-3)));
1900	}
1901	}
1902	return PHPExcel_Calculation_Functions::DIV0();
1903	} // function KURT()
1904
1905
1906	/**
1907	* LARGE
1908	*
1909	* Returns the nth largest value in a data set. You can use this function to
1910	* select a value based on its relative standing.
1911	*
1912	* Excel Function:
1913	* LARGE(value1[,value2[, ...]],entry)
1914	*
1915	* @access public
1916	* @category Statistical Functions
1917	* @param mixed $arg,... Data values
1918	* @param int $entry Position (ordered from the largest) in the array or range of data to return
1919	* @return float
1920	*
1921	*/
1922	public static function LARGE() {
1923	$aArgs = PHPExcel_Calculation_Functions::flattenArray(func_get_args());
1924
1925	// Calculate
1926	$entry = floor(array_pop($aArgs));
1927
1928	if ((is_numeric($entry)) && (!is_string($entry))) {
1929	$mArgs = array();
1930	foreach ($aArgs as $arg) {
1931	// Is it a numeric value?
1932	if ((is_numeric($arg)) && (!is_string($arg))) {
1933	$mArgs[] = $arg;
1934	}
1935	}
1936	$count = self::COUNT($mArgs);
1937	$entry = floor(--$entry);
1938	if (($entry < 0) \|\| ($entry >= $count) \|\| ($count == 0)) {
1939	return PHPExcel_Calculation_Functions::NaN();
1940	}
1941	rsort($mArgs);
1942	return $mArgs[$entry];
1943	}
1944	return PHPExcel_Calculation_Functions::VALUE();
1945	} // function LARGE()
1946
1947
1948	/**
1949	* LINEST
1950	*
1951	* Calculates the statistics for a line by using the "least squares" method to calculate a straight line that best fits your data,
1952	* and then returns an array that describes the line.
1953	*
1954	* @param array of mixed Data Series Y
1955	* @param array of mixed Data Series X
1956	* @param boolean A logical value specifying whether to force the intersect to equal 0.
1957	* @param boolean A logical value specifying whether to return additional regression statistics.
1958	* @return array
1959	*/
1960	public static function LINEST($yValues, $xValues = NULL, $const = TRUE, $stats = FALSE) {
1961	$const = (is_null($const)) ? TRUE : (boolean) PHPExcel_Calculation_Functions::flattenSingleValue($const);
1962	$stats = (is_null($stats)) ? FALSE : (boolean) PHPExcel_Calculation_Functions::flattenSingleValue($stats);
1963	if (is_null($xValues)) $xValues = range(1,count(PHPExcel_Calculation_Functions::flattenArray($yValues)));
1964
1965	if (!self::_checkTrendArrays($yValues,$xValues)) {
1966	return PHPExcel_Calculation_Functions::VALUE();
1967	}
1968	$yValueCount = count($yValues);
1969	$xValueCount = count($xValues);
1970
1971
1972	if (($yValueCount == 0) \|\| ($yValueCount != $xValueCount)) {
1973	return PHPExcel_Calculation_Functions::NA();
1974	} elseif ($yValueCount == 1) {
1975	return 0;
1976	}
1977
1978	$bestFitLinear = trendClass::calculate(trendClass::TREND_LINEAR,$yValues,$xValues,$const);
1979	if ($stats) {
1980	return array( array( $bestFitLinear->getSlope(),
1981	$bestFitLinear->getSlopeSE(),
1982	$bestFitLinear->getGoodnessOfFit(),
1983	$bestFitLinear->getF(),
1984	$bestFitLinear->getSSRegression(),
1985	),
1986	array( $bestFitLinear->getIntersect(),
1987	$bestFitLinear->getIntersectSE(),
1988	$bestFitLinear->getStdevOfResiduals(),
1989	$bestFitLinear->getDFResiduals(),
1990	$bestFitLinear->getSSResiduals()
1991	)
1992	);
1993	} else {
1994	return array( $bestFitLinear->getSlope(),
1995	$bestFitLinear->getIntersect()
1996	);
1997	}
1998	} // function LINEST()
1999
2000
2001	/**
2002	* LOGEST
2003	*
2004	* Calculates an exponential curve that best fits the X and Y data series,
2005	* and then returns an array that describes the line.
2006	*
2007	* @param array of mixed Data Series Y
2008	* @param array of mixed Data Series X
2009	* @param boolean A logical value specifying whether to force the intersect to equal 0.
2010	* @param boolean A logical value specifying whether to return additional regression statistics.
2011	* @return array
2012	*/
2013	public static function LOGEST($yValues,$xValues=null,$const=True,$stats=False) {
2014	$const = (is_null($const)) ? True : (boolean) PHPExcel_Calculation_Functions::flattenSingleValue($const);
2015	$stats = (is_null($stats)) ? False : (boolean) PHPExcel_Calculation_Functions::flattenSingleValue($stats);
2016	if (is_null($xValues)) $xValues = range(1,count(PHPExcel_Calculation_Functions::flattenArray($yValues)));
2017
2018	if (!self::_checkTrendArrays($yValues,$xValues)) {
2019	return PHPExcel_Calculation_Functions::VALUE();
2020	}
2021	$yValueCount = count($yValues);
2022	$xValueCount = count($xValues);
2023
2024	foreach($yValues as $value) {
2025	if ($value <= 0.0) {
2026	return PHPExcel_Calculation_Functions::NaN();
2027	}
2028	}
2029
2030
2031	if (($yValueCount == 0) \|\| ($yValueCount != $xValueCount)) {
2032	return PHPExcel_Calculation_Functions::NA();
2033	} elseif ($yValueCount == 1) {
2034	return 1;
2035	}
2036
2037	$bestFitExponential = trendClass::calculate(trendClass::TREND_EXPONENTIAL,$yValues,$xValues,$const);
2038	if ($stats) {
2039	return array( array( $bestFitExponential->getSlope(),
2040	$bestFitExponential->getSlopeSE(),
2041	$bestFitExponential->getGoodnessOfFit(),
2042	$bestFitExponential->getF(),
2043	$bestFitExponential->getSSRegression(),
2044	),
2045	array( $bestFitExponential->getIntersect(),
2046	$bestFitExponential->getIntersectSE(),
2047	$bestFitExponential->getStdevOfResiduals(),
2048	$bestFitExponential->getDFResiduals(),
2049	$bestFitExponential->getSSResiduals()
2050	)
2051	);
2052	} else {
2053	return array( $bestFitExponential->getSlope(),
2054	$bestFitExponential->getIntersect()
2055	);
2056	}
2057	} // function LOGEST()
2058
2059
2060	/**
2061	* LOGINV
2062	*
2063	* Returns the inverse of the normal cumulative distribution
2064	*
2065	* @param float $probability
2066	* @param float $mean
2067	* @param float $stdDev
2068	* @return float
2069	*
2070	* @todo Try implementing P J Acklam's refinement algorithm for greater
2071	* accuracy if I can get my head round the mathematics
2072	* (as described at) http://home.online.no/~pjacklam/notes/invnorm/
2073	*/
2074	public static function LOGINV($probability, $mean, $stdDev) {
2075	$probability = PHPExcel_Calculation_Functions::flattenSingleValue($probability);
2076	$mean = PHPExcel_Calculation_Functions::flattenSingleValue($mean);
2077	$stdDev = PHPExcel_Calculation_Functions::flattenSingleValue($stdDev);
2078
2079	if ((is_numeric($probability)) && (is_numeric($mean)) && (is_numeric($stdDev))) {
2080	if (($probability < 0) \|\| ($probability > 1) \|\| ($stdDev <= 0)) {
2081	return PHPExcel_Calculation_Functions::NaN();
2082	}
2083	return exp($mean + $stdDev * self::NORMSINV($probability));
2084	}
2085	return PHPExcel_Calculation_Functions::VALUE();
2086	} // function LOGINV()
2087
2088
2089	/**
2090	* LOGNORMDIST
2091	*
2092	* Returns the cumulative lognormal distribution of x, where ln(x) is normally distributed
2093	* with parameters mean and standard_dev.
2094	*
2095	* @param float $value
2096	* @param float $mean
2097	* @param float $stdDev
2098	* @return float
2099	*/
2100	public static function LOGNORMDIST($value, $mean, $stdDev) {
2101	$value = PHPExcel_Calculation_Functions::flattenSingleValue($value);
2102	$mean = PHPExcel_Calculation_Functions::flattenSingleValue($mean);
2103	$stdDev = PHPExcel_Calculation_Functions::flattenSingleValue($stdDev);
2104
2105	if ((is_numeric($value)) && (is_numeric($mean)) && (is_numeric($stdDev))) {
2106	if (($value <= 0) \|\| ($stdDev <= 0)) {
2107	return PHPExcel_Calculation_Functions::NaN();
2108	}
2109	return self::NORMSDIST((log($value) - $mean) / $stdDev);
2110	}
2111	return PHPExcel_Calculation_Functions::VALUE();
2112	} // function LOGNORMDIST()
2113
2114
2115	/**
2116	* MAX
2117	*
2118	* MAX returns the value of the element of the values passed that has the highest value,
2119	* with negative numbers considered smaller than positive numbers.
2120	*
2121	* Excel Function:
2122	* MAX(value1[,value2[, ...]])
2123	*
2124	* @access public
2125	* @category Statistical Functions
2126	* @param mixed $arg,... Data values
2127	* @return float
2128	*/
2129	public static function MAX() {
2130	// Return value
2131	$returnValue = null;
2132
2133	// Loop through arguments
2134	$aArgs = PHPExcel_Calculation_Functions::flattenArray(func_get_args());
2135	foreach ($aArgs as $arg) {
2136	// Is it a numeric value?
2137	if ((is_numeric($arg)) && (!is_string($arg))) {
2138	if ((is_null($returnValue)) \|\| ($arg > $returnValue)) {
2139	$returnValue = $arg;
2140	}
2141	}
2142	}
2143
2144	// Return
2145	if(is_null($returnValue)) {
2146	return 0;
2147	}
2148	return $returnValue;
2149	} // function MAX()
2150
2151
2152	/**
2153	* MAXA
2154	*
2155	* Returns the greatest value in a list of arguments, including numbers, text, and logical values
2156	*
2157	* Excel Function:
2158	* MAXA(value1[,value2[, ...]])
2159	*
2160	* @access public
2161	* @category Statistical Functions
2162	* @param mixed $arg,... Data values
2163	* @return float
2164	*/
2165	public static function MAXA() {
2166	// Return value
2167	$returnValue = null;
2168
2169	// Loop through arguments
2170	$aArgs = PHPExcel_Calculation_Functions::flattenArray(func_get_args());
2171	foreach ($aArgs as $arg) {
2172	// Is it a numeric value?
2173	if ((is_numeric($arg)) \|\| (is_bool($arg)) \|\| ((is_string($arg) && ($arg != '')))) {
2174	if (is_bool($arg)) {
2175	$arg = (integer) $arg;
2176	} elseif (is_string($arg)) {
2177	$arg = 0;
2178	}
2179	if ((is_null($returnValue)) \|\| ($arg > $returnValue)) {
2180	$returnValue = $arg;
2181	}
2182	}
2183	}
2184
2185	// Return
2186	if(is_null($returnValue)) {
2187	return 0;
2188	}
2189	return $returnValue;
2190	} // function MAXA()
2191
2192
2193	/**
2194	* MAXIF
2195	*
2196	* Counts the maximum value within a range of cells that contain numbers within the list of arguments
2197	*
2198	* Excel Function:
2199	* MAXIF(value1[,value2[, ...]],condition)
2200	*
2201	* @access public
2202	* @category Mathematical and Trigonometric Functions
2203	* @param mixed $arg,... Data values
2204	* @param string $condition The criteria that defines which cells will be checked.
2205	* @return float
2206	*/
2207	public static function MAXIF($aArgs,$condition,$sumArgs = array()) {
2208	// Return value
2209	$returnValue = null;
2210
2211	$aArgs = PHPExcel_Calculation_Functions::flattenArray($aArgs);
2212	$sumArgs = PHPExcel_Calculation_Functions::flattenArray($sumArgs);
2213	if (empty($sumArgs)) {
2214	$sumArgs = $aArgs;
2215	}
2216	$condition = PHPExcel_Calculation_Functions::_ifCondition($condition);
2217	// Loop through arguments
2218	foreach ($aArgs as $key => $arg) {
2219	if (!is_numeric($arg)) { $arg = PHPExcel_Calculation::_wrapResult(strtoupper($arg)); }
2220	$testCondition = '='.$arg.$condition;
2221	if (PHPExcel_Calculation::getInstance()->_calculateFormulaValue($testCondition)) {
2222	if ((is_null($returnValue)) \|\| ($arg > $returnValue)) {
2223	$returnValue = $arg;
2224	}
2225	}
2226	}
2227
2228	// Return
2229	return $returnValue;
2230	} // function MAXIF()
2231
2232
2233	/**
2234	* MEDIAN
2235	*
2236	* Returns the median of the given numbers. The median is the number in the middle of a set of numbers.
2237	*
2238	* Excel Function:
2239	* MEDIAN(value1[,value2[, ...]])
2240	*
2241	* @access public
2242	* @category Statistical Functions
2243	* @param mixed $arg,... Data values
2244	* @return float
2245	*/
2246	public static function MEDIAN() {
2247	// Return value
2248	$returnValue = PHPExcel_Calculation_Functions::NaN();
2249
2250	$mArgs = array();
2251	// Loop through arguments
2252	$aArgs = PHPExcel_Calculation_Functions::flattenArray(func_get_args());
2253	foreach ($aArgs as $arg) {
2254	// Is it a numeric value?
2255	if ((is_numeric($arg)) && (!is_string($arg))) {
2256	$mArgs[] = $arg;
2257	}
2258	}
2259
2260	$mValueCount = count($mArgs);
2261	if ($mValueCount > 0) {
2262	sort($mArgs,SORT_NUMERIC);
2263	$mValueCount = $mValueCount / 2;
2264	if ($mValueCount == floor($mValueCount)) {
2265	$returnValue = ($mArgs[$mValueCount--] + $mArgs[$mValueCount]) / 2;
2266	} else {
2267	$mValueCount == floor($mValueCount);
2268	$returnValue = $mArgs[$mValueCount];
2269	}
2270	}
2271
2272	// Return
2273	return $returnValue;
2274	} // function MEDIAN()
2275
2276
2277	/**
2278	* MIN
2279	*
2280	* MIN returns the value of the element of the values passed that has the smallest value,
2281	* with negative numbers considered smaller than positive numbers.
2282	*
2283	* Excel Function:
2284	* MIN(value1[,value2[, ...]])
2285	*
2286	* @access public
2287	* @category Statistical Functions
2288	* @param mixed $arg,... Data values
2289	* @return float
2290	*/
2291	public static function MIN() {
2292	// Return value
2293	$returnValue = null;
2294
2295	// Loop through arguments
2296	$aArgs = PHPExcel_Calculation_Functions::flattenArray(func_get_args());
2297	foreach ($aArgs as $arg) {
2298	// Is it a numeric value?
2299	if ((is_numeric($arg)) && (!is_string($arg))) {
2300	if ((is_null($returnValue)) \|\| ($arg < $returnValue)) {
2301	$returnValue = $arg;
2302	}
2303	}
2304	}
2305
2306	// Return
2307	if(is_null($returnValue)) {
2308	return 0;
2309	}
2310	return $returnValue;
2311	} // function MIN()
2312
2313
2314	/**
2315	* MINA
2316	*
2317	* Returns the smallest value in a list of arguments, including numbers, text, and logical values
2318	*
2319	* Excel Function:
2320	* MINA(value1[,value2[, ...]])
2321	*
2322	* @access public
2323	* @category Statistical Functions
2324	* @param mixed $arg,... Data values
2325	* @return float
2326	*/
2327	public static function MINA() {
2328	// Return value
2329	$returnValue = null;
2330
2331	// Loop through arguments
2332	$aArgs = PHPExcel_Calculation_Functions::flattenArray(func_get_args());
2333	foreach ($aArgs as $arg) {
2334	// Is it a numeric value?
2335	if ((is_numeric($arg)) \|\| (is_bool($arg)) \|\| ((is_string($arg) && ($arg != '')))) {
2336	if (is_bool($arg)) {
2337	$arg = (integer) $arg;
2338	} elseif (is_string($arg)) {
2339	$arg = 0;
2340	}
2341	if ((is_null($returnValue)) \|\| ($arg < $returnValue)) {
2342	$returnValue = $arg;
2343	}
2344	}
2345	}
2346
2347	// Return
2348	if(is_null($returnValue)) {
2349	return 0;
2350	}
2351	return $returnValue;
2352	} // function MINA()
2353
2354
2355	/**
2356	* MINIF
2357	*
2358	* Returns the minimum value within a range of cells that contain numbers within the list of arguments
2359	*
2360	* Excel Function:
2361	* MINIF(value1[,value2[, ...]],condition)
2362	*
2363	* @access public
2364	* @category Mathematical and Trigonometric Functions
2365	* @param mixed $arg,... Data values
2366	* @param string $condition The criteria that defines which cells will be checked.
2367	* @return float
2368	*/
2369	public static function MINIF($aArgs,$condition,$sumArgs = array()) {
2370	// Return value
2371	$returnValue = null;
2372
2373	$aArgs = PHPExcel_Calculation_Functions::flattenArray($aArgs);
2374	$sumArgs = PHPExcel_Calculation_Functions::flattenArray($sumArgs);
2375	if (empty($sumArgs)) {
2376	$sumArgs = $aArgs;
2377	}
2378	$condition = PHPExcel_Calculation_Functions::_ifCondition($condition);
2379	// Loop through arguments
2380	foreach ($aArgs as $key => $arg) {
2381	if (!is_numeric($arg)) { $arg = PHPExcel_Calculation::_wrapResult(strtoupper($arg)); }
2382	$testCondition = '='.$arg.$condition;
2383	if (PHPExcel_Calculation::getInstance()->_calculateFormulaValue($testCondition)) {
2384	if ((is_null($returnValue)) \|\| ($arg < $returnValue)) {
2385	$returnValue = $arg;
2386	}
2387	}
2388	}
2389
2390	// Return
2391	return $returnValue;
2392	} // function MINIF()
2393
2394
2395	//
2396	// Special variant of array_count_values that isn't limited to strings and integers,
2397	// but can work with floating point numbers as values
2398	//
2399	private static function _modeCalc($data) {
2400	$frequencyArray = array();
2401	foreach($data as $datum) {
2402	$found = False;
2403	foreach($frequencyArray as $key => $value) {
2404	if ((string) $value['value'] == (string) $datum) {
2405	++$frequencyArray[$key]['frequency'];
2406	$found = True;
2407	break;
2408	}
2409	}
2410	if (!$found) {
2411	$frequencyArray[] = array('value' => $datum,
2412	'frequency' => 1 );
2413	}
2414	}
2415
2416	foreach($frequencyArray as $key => $value) {
2417	$frequencyList[$key] = $value['frequency'];
2418	$valueList[$key] = $value['value'];
2419	}
2420	array_multisort($frequencyList, SORT_DESC, $valueList, SORT_ASC, SORT_NUMERIC, $frequencyArray);
2421
2422	if ($frequencyArray[0]['frequency'] == 1) {
2423	return PHPExcel_Calculation_Functions::NA();
2424	}
2425	return $frequencyArray[0]['value'];
2426	} // function _modeCalc()
2427
2428
2429	/**
2430	* MODE
2431	*
2432	* Returns the most frequently occurring, or repetitive, value in an array or range of data
2433	*
2434	* Excel Function:
2435	* MODE(value1[,value2[, ...]])
2436	*
2437	* @access public
2438	* @category Statistical Functions
2439	* @param mixed $arg,... Data values
2440	* @return float
2441	*/
2442	public static function MODE() {
2443	// Return value
2444	$returnValue = PHPExcel_Calculation_Functions::NA();
2445
2446	// Loop through arguments
2447	$aArgs = PHPExcel_Calculation_Functions::flattenArray(func_get_args());
2448
2449	$mArgs = array();
2450	foreach ($aArgs as $arg) {
2451	// Is it a numeric value?
2452	if ((is_numeric($arg)) && (!is_string($arg))) {
2453	$mArgs[] = $arg;
2454	}
2455	}
2456
2457	if (!empty($mArgs)) {
2458	return self::_modeCalc($mArgs);
2459	}
2460
2461	// Return
2462	return $returnValue;
2463	} // function MODE()
2464
2465
2466	/**
2467	* NEGBINOMDIST
2468	*
2469	* Returns the negative binomial distribution. NEGBINOMDIST returns the probability that
2470	* there will be number_f failures before the number_s-th success, when the constant
2471	* probability of a success is probability_s. This function is similar to the binomial
2472	* distribution, except that the number of successes is fixed, and the number of trials is
2473	* variable. Like the binomial, trials are assumed to be independent.
2474	*
2475	* @param float $failures Number of Failures
2476	* @param float $successes Threshold number of Successes
2477	* @param float $probability Probability of success on each trial
2478	* @return float
2479	*
2480	*/
2481	public static function NEGBINOMDIST($failures, $successes, $probability) {
2482	$failures = floor(PHPExcel_Calculation_Functions::flattenSingleValue($failures));
2483	$successes = floor(PHPExcel_Calculation_Functions::flattenSingleValue($successes));
2484	$probability = PHPExcel_Calculation_Functions::flattenSingleValue($probability);
2485
2486	if ((is_numeric($failures)) && (is_numeric($successes)) && (is_numeric($probability))) {
2487	if (($failures < 0) \|\| ($successes < 1)) {
2488	return PHPExcel_Calculation_Functions::NaN();
2489	}
2490	if (($probability < 0) \|\| ($probability > 1)) {
2491	return PHPExcel_Calculation_Functions::NaN();
2492	}
2493	if (PHPExcel_Calculation_Functions::getCompatibilityMode() == PHPExcel_Calculation_Functions::COMPATIBILITY_GNUMERIC) {
2494	if (($failures + $successes - 1) <= 0) {
2495	return PHPExcel_Calculation_Functions::NaN();
2496	}
2497	}
2498	return (PHPExcel_Calculation_MathTrig::COMBIN($failures + $successes - 1,$successes - 1)) * (pow($probability,$successes)) * (pow(1 - $probability,$failures)) ;
2499	}
2500	return PHPExcel_Calculation_Functions::VALUE();
2501	} // function NEGBINOMDIST()
2502
2503
2504	/**
2505	* NORMDIST
2506	*
2507	* Returns the normal distribution for the specified mean and standard deviation. This
2508	* function has a very wide range of applications in statistics, including hypothesis
2509	* testing.
2510	*
2511	* @param float $value
2512	* @param float $mean Mean Value
2513	* @param float $stdDev Standard Deviation
2514	* @param boolean $cumulative
2515	* @return float
2516	*
2517	*/
2518	public static function NORMDIST($value, $mean, $stdDev, $cumulative) {
2519	$value = PHPExcel_Calculation_Functions::flattenSingleValue($value);
2520	$mean = PHPExcel_Calculation_Functions::flattenSingleValue($mean);
2521	$stdDev = PHPExcel_Calculation_Functions::flattenSingleValue($stdDev);
2522
2523	if ((is_numeric($value)) && (is_numeric($mean)) && (is_numeric($stdDev))) {
2524	if ($stdDev < 0) {
2525	return PHPExcel_Calculation_Functions::NaN();
2526	}
2527	if ((is_numeric($cumulative)) \|\| (is_bool($cumulative))) {
2528	if ($cumulative) {
2529	return 0.5 * (1 + PHPExcel_Calculation_Engineering::_erfVal(($value - $mean) / ($stdDev * sqrt(2))));
2530	} else {
2531	return (1 / (SQRT2PI * $stdDev)) * exp(0 - (pow($value - $mean,2) / (2 * ($stdDev * $stdDev))));
2532	}
2533	}
2534	}
2535	return PHPExcel_Calculation_Functions::VALUE();
2536	} // function NORMDIST()
2537
2538
2539	/**
2540	* NORMINV
2541	*
2542	* Returns the inverse of the normal cumulative distribution for the specified mean and standard deviation.
2543	*
2544	* @param float $value
2545	* @param float $mean Mean Value
2546	* @param float $stdDev Standard Deviation
2547	* @return float
2548	*
2549	*/
2550	public static function NORMINV($probability,$mean,$stdDev) {
2551	$probability = PHPExcel_Calculation_Functions::flattenSingleValue($probability);
2552	$mean = PHPExcel_Calculation_Functions::flattenSingleValue($mean);
2553	$stdDev = PHPExcel_Calculation_Functions::flattenSingleValue($stdDev);
2554
2555	if ((is_numeric($probability)) && (is_numeric($mean)) && (is_numeric($stdDev))) {
2556	if (($probability < 0) \|\| ($probability > 1)) {
2557	return PHPExcel_Calculation_Functions::NaN();
2558	}
2559	if ($stdDev < 0) {
2560	return PHPExcel_Calculation_Functions::NaN();
2561	}
2562	return (self::_inverse_ncdf($probability) * $stdDev) + $mean;
2563	}
2564	return PHPExcel_Calculation_Functions::VALUE();
2565	} // function NORMINV()
2566
2567
2568	/**
2569	* NORMSDIST
2570	*
2571	* Returns the standard normal cumulative distribution function. The distribution has
2572	* a mean of 0 (zero) and a standard deviation of one. Use this function in place of a
2573	* table of standard normal curve areas.
2574	*
2575	* @param float $value
2576	* @return float
2577	*/
2578	public static function NORMSDIST($value) {
2579	$value = PHPExcel_Calculation_Functions::flattenSingleValue($value);
2580
2581	return self::NORMDIST($value, 0, 1, True);
2582	} // function NORMSDIST()
2583
2584
2585	/**
2586	* NORMSINV
2587	*
2588	* Returns the inverse of the standard normal cumulative distribution
2589	*
2590	* @param float $value
2591	* @return float
2592	*/
2593	public static function NORMSINV($value) {
2594	return self::NORMINV($value, 0, 1);
2595	} // function NORMSINV()
2596
2597
2598	/**
2599	* PERCENTILE
2600	*
2601	* Returns the nth percentile of values in a range..
2602	*
2603	* Excel Function:
2604	* PERCENTILE(value1[,value2[, ...]],entry)
2605	*
2606	* @access public
2607	* @category Statistical Functions
2608	* @param mixed $arg,... Data values
2609	* @param float $entry Percentile value in the range 0..1, inclusive.
2610	* @return float
2611	*/
2612	public static function PERCENTILE() {
2613	$aArgs = PHPExcel_Calculation_Functions::flattenArray(func_get_args());
2614
2615	// Calculate
2616	$entry = array_pop($aArgs);
2617
2618	if ((is_numeric($entry)) && (!is_string($entry))) {
2619	if (($entry < 0) \|\| ($entry > 1)) {
2620	return PHPExcel_Calculation_Functions::NaN();
2621	}
2622	$mArgs = array();
2623	foreach ($aArgs as $arg) {
2624	// Is it a numeric value?
2625	if ((is_numeric($arg)) && (!is_string($arg))) {
2626	$mArgs[] = $arg;
2627	}
2628	}
2629	$mValueCount = count($mArgs);
2630	if ($mValueCount > 0) {
2631	sort($mArgs);
2632	$count = self::COUNT($mArgs);
2633	$index = $entry * ($count-1);
2634	$iBase = floor($index);
2635	if ($index == $iBase) {
2636	return $mArgs[$index];
2637	} else {
2638	$iNext = $iBase + 1;
2639	$iProportion = $index - $iBase;
2640	return $mArgs[$iBase] + (($mArgs[$iNext] - $mArgs[$iBase]) * $iProportion) ;
2641	}
2642	}
2643	}
2644	return PHPExcel_Calculation_Functions::VALUE();
2645	} // function PERCENTILE()
2646
2647
2648	/**
2649	* PERCENTRANK
2650	*
2651	* Returns the rank of a value in a data set as a percentage of the data set.
2652	*
2653	* @param array of number An array of, or a reference to, a list of numbers.
2654	* @param number The number whose rank you want to find.
2655	* @param number The number of significant digits for the returned percentage value.
2656	* @return float
2657	*/
2658	public static function PERCENTRANK($valueSet,$value,$significance=3) {
2659	$valueSet = PHPExcel_Calculation_Functions::flattenArray($valueSet);
2660	$value = PHPExcel_Calculation_Functions::flattenSingleValue($value);
2661	$significance = (is_null($significance)) ? 3 : (integer) PHPExcel_Calculation_Functions::flattenSingleValue($significance);
2662
2663	foreach($valueSet as $key => $valueEntry) {
2664	if (!is_numeric($valueEntry)) {
2665	unset($valueSet[$key]);
2666	}
2667	}
2668	sort($valueSet,SORT_NUMERIC);
2669	$valueCount = count($valueSet);
2670	if ($valueCount == 0) {
2671	return PHPExcel_Calculation_Functions::NaN();
2672	}
2673
2674	$valueAdjustor = $valueCount - 1;
2675	if (($value < $valueSet[0]) \|\| ($value > $valueSet[$valueAdjustor])) {
2676	return PHPExcel_Calculation_Functions::NA();
2677	}
2678
2679	$pos = array_search($value,$valueSet);
2680	if ($pos === False) {
2681	$pos = 0;
2682	$testValue = $valueSet[0];
2683	while ($testValue < $value) {
2684	$testValue = $valueSet[++$pos];
2685	}
2686	--$pos;
2687	$pos += (($value - $valueSet[$pos]) / ($testValue - $valueSet[$pos]));
2688	}
2689
2690	return round($pos / $valueAdjustor,$significance);
2691	} // function PERCENTRANK()
2692
2693
2694	/**
2695	* PERMUT
2696	*
2697	* Returns the number of permutations for a given number of objects that can be
2698	* selected from number objects. A permutation is any set or subset of objects or
2699	* events where internal order is significant. Permutations are different from
2700	* combinations, for which the internal order is not significant. Use this function
2701	* for lottery-style probability calculations.
2702	*
2703	* @param int $numObjs Number of different objects
2704	* @param int $numInSet Number of objects in each permutation
2705	* @return int Number of permutations
2706	*/
2707	public static function PERMUT($numObjs,$numInSet) {
2708	$numObjs = PHPExcel_Calculation_Functions::flattenSingleValue($numObjs);
2709	$numInSet = PHPExcel_Calculation_Functions::flattenSingleValue($numInSet);
2710
2711	if ((is_numeric($numObjs)) && (is_numeric($numInSet))) {
2712	$numInSet = floor($numInSet);
2713	if ($numObjs < $numInSet) {
2714	return PHPExcel_Calculation_Functions::NaN();
2715	}
2716	return round(PHPExcel_Calculation_MathTrig::FACT($numObjs) / PHPExcel_Calculation_MathTrig::FACT($numObjs - $numInSet));
2717	}
2718	return PHPExcel_Calculation_Functions::VALUE();
2719	} // function PERMUT()
2720
2721
2722	/**
2723	* POISSON
2724	*
2725	* Returns the Poisson distribution. A common application of the Poisson distribution
2726	* is predicting the number of events over a specific time, such as the number of
2727	* cars arriving at a toll plaza in 1 minute.
2728	*
2729	* @param float $value
2730	* @param float $mean Mean Value
2731	* @param boolean $cumulative
2732	* @return float
2733	*
2734	*/
2735	public static function POISSON($value, $mean, $cumulative) {
2736	$value = PHPExcel_Calculation_Functions::flattenSingleValue($value);
2737	$mean = PHPExcel_Calculation_Functions::flattenSingleValue($mean);
2738
2739	if ((is_numeric($value)) && (is_numeric($mean))) {
2740	if (($value < 0) \|\| ($mean <= 0)) {
2741	return PHPExcel_Calculation_Functions::NaN();
2742	}
2743	if ((is_numeric($cumulative)) \|\| (is_bool($cumulative))) {
2744	if ($cumulative) {
2745	$summer = 0;
2746	for ($i = 0; $i <= floor($value); ++$i) {
2747	$summer += pow($mean,$i) / PHPExcel_Calculation_MathTrig::FACT($i);
2748	}
2749	return exp(0-$mean) * $summer;
2750	} else {
2751	return (exp(0-$mean) * pow($mean,$value)) / PHPExcel_Calculation_MathTrig::FACT($value);
2752	}
2753	}
2754	}
2755	return PHPExcel_Calculation_Functions::VALUE();
2756	} // function POISSON()
2757
2758
2759	/**
2760	* QUARTILE
2761	*
2762	* Returns the quartile of a data set.
2763	*
2764	* Excel Function:
2765	* QUARTILE(value1[,value2[, ...]],entry)
2766	*
2767	* @access public
2768	* @category Statistical Functions
2769	* @param mixed $arg,... Data values
2770	* @param int $entry Quartile value in the range 1..3, inclusive.
2771	* @return float
2772	*/
2773	public static function QUARTILE() {
2774	$aArgs = PHPExcel_Calculation_Functions::flattenArray(func_get_args());
2775
2776	// Calculate
2777	$entry = floor(array_pop($aArgs));
2778
2779	if ((is_numeric($entry)) && (!is_string($entry))) {
2780	$entry /= 4;
2781	if (($entry < 0) \|\| ($entry > 1)) {
2782	return PHPExcel_Calculation_Functions::NaN();
2783	}
2784	return self::PERCENTILE($aArgs,$entry);
2785	}
2786	return PHPExcel_Calculation_Functions::VALUE();
2787	} // function QUARTILE()
2788
2789
2790	/**
2791	* RANK
2792	*
2793	* Returns the rank of a number in a list of numbers.
2794	*
2795	* @param number The number whose rank you want to find.
2796	* @param array of number An array of, or a reference to, a list of numbers.
2797	* @param mixed Order to sort the values in the value set
2798	* @return float
2799	*/
2800	public static function RANK($value,$valueSet,$order=0) {
2801	$value = PHPExcel_Calculation_Functions::flattenSingleValue($value);
2802	$valueSet = PHPExcel_Calculation_Functions::flattenArray($valueSet);
2803	$order = (is_null($order)) ? 0 : (integer) PHPExcel_Calculation_Functions::flattenSingleValue($order);
2804
2805	foreach($valueSet as $key => $valueEntry) {
2806	if (!is_numeric($valueEntry)) {
2807	unset($valueSet[$key]);
2808	}
2809	}
2810
2811	if ($order == 0) {
2812	rsort($valueSet,SORT_NUMERIC);
2813	} else {
2814	sort($valueSet,SORT_NUMERIC);
2815	}
2816	$pos = array_search($value,$valueSet);
2817	if ($pos === False) {
2818	return PHPExcel_Calculation_Functions::NA();
2819	}
2820
2821	return ++$pos;
2822	} // function RANK()
2823
2824
2825	/**
2826	* RSQ
2827	*
2828	* Returns the square of the Pearson product moment correlation coefficient through data points in known_y's and known_x's.
2829	*
2830	* @param array of mixed Data Series Y
2831	* @param array of mixed Data Series X
2832	* @return float
2833	*/
2834	public static function RSQ($yValues,$xValues) {
2835	if (!self::_checkTrendArrays($yValues,$xValues)) {
2836	return PHPExcel_Calculation_Functions::VALUE();
2837	}
2838	$yValueCount = count($yValues);
2839	$xValueCount = count($xValues);
2840
2841	if (($yValueCount == 0) \|\| ($yValueCount != $xValueCount)) {
2842	return PHPExcel_Calculation_Functions::NA();
2843	} elseif ($yValueCount == 1) {
2844	return PHPExcel_Calculation_Functions::DIV0();
2845	}
2846
2847	$bestFitLinear = trendClass::calculate(trendClass::TREND_LINEAR,$yValues,$xValues);
2848	return $bestFitLinear->getGoodnessOfFit();
2849	} // function RSQ()
2850
2851
2852	/**
2853	* SKEW
2854	*
2855	* Returns the skewness of a distribution. Skewness characterizes the degree of asymmetry
2856	* of a distribution around its mean. Positive skewness indicates a distribution with an
2857	* asymmetric tail extending toward more positive values. Negative skewness indicates a
2858	* distribution with an asymmetric tail extending toward more negative values.
2859	*
2860	* @param array Data Series
2861	* @return float
2862	*/
2863	public static function SKEW() {
2864	$aArgs = PHPExcel_Calculation_Functions::flattenArrayIndexed(func_get_args());
2865	$mean = self::AVERAGE($aArgs);
2866	$stdDev = self::STDEV($aArgs);
2867
2868	$count = $summer = 0;
2869	// Loop through arguments
2870	foreach ($aArgs as $k => $arg) {
2871	if ((is_bool($arg)) &&
2872	(!PHPExcel_Calculation_Functions::isMatrixValue($k))) {
2873	} else {
2874	// Is it a numeric value?
2875	if ((is_numeric($arg)) && (!is_string($arg))) {
2876	$summer += pow((($arg - $mean) / $stdDev),3) ;
2877	++$count;
2878	}
2879	}
2880	}
2881
2882	// Return
2883	if ($count > 2) {
2884	return $summer * ($count / (($count-1) * ($count-2)));
2885	}
2886	return PHPExcel_Calculation_Functions::DIV0();
2887	} // function SKEW()
2888
2889
2890	/**
2891	* SLOPE
2892	*
2893	* Returns the slope of the linear regression line through data points in known_y's and known_x's.
2894	*
2895	* @param array of mixed Data Series Y
2896	* @param array of mixed Data Series X
2897	* @return float
2898	*/
2899	public static function SLOPE($yValues,$xValues) {
2900	if (!self::_checkTrendArrays($yValues,$xValues)) {
2901	return PHPExcel_Calculation_Functions::VALUE();
2902	}
2903	$yValueCount = count($yValues);
2904	$xValueCount = count($xValues);
2905
2906	if (($yValueCount == 0) \|\| ($yValueCount != $xValueCount)) {
2907	return PHPExcel_Calculation_Functions::NA();
2908	} elseif ($yValueCount == 1) {
2909	return PHPExcel_Calculation_Functions::DIV0();
2910	}
2911
2912	$bestFitLinear = trendClass::calculate(trendClass::TREND_LINEAR,$yValues,$xValues);
2913	return $bestFitLinear->getSlope();
2914	} // function SLOPE()
2915
2916
2917	/**
2918	* SMALL
2919	*
2920	* Returns the nth smallest value in a data set. You can use this function to
2921	* select a value based on its relative standing.
2922	*
2923	* Excel Function:
2924	* SMALL(value1[,value2[, ...]],entry)
2925	*
2926	* @access public
2927	* @category Statistical Functions
2928	* @param mixed $arg,... Data values
2929	* @param int $entry Position (ordered from the smallest) in the array or range of data to return
2930	* @return float
2931	*/
2932	public static function SMALL() {
2933	$aArgs = PHPExcel_Calculation_Functions::flattenArray(func_get_args());
2934
2935	// Calculate
2936	$entry = array_pop($aArgs);
2937
2938	if ((is_numeric($entry)) && (!is_string($entry))) {
2939	$mArgs = array();
2940	foreach ($aArgs as $arg) {
2941	// Is it a numeric value?
2942	if ((is_numeric($arg)) && (!is_string($arg))) {
2943	$mArgs[] = $arg;
2944	}
2945	}
2946	$count = self::COUNT($mArgs);
2947	$entry = floor(--$entry);
2948	if (($entry < 0) \|\| ($entry >= $count) \|\| ($count == 0)) {
2949	return PHPExcel_Calculation_Functions::NaN();
2950	}
2951	sort($mArgs);
2952	return $mArgs[$entry];
2953	}
2954	return PHPExcel_Calculation_Functions::VALUE();
2955	} // function SMALL()
2956
2957
2958	/**
2959	* STANDARDIZE
2960	*
2961	* Returns a normalized value from a distribution characterized by mean and standard_dev.
2962	*
2963	* @param float $value Value to normalize
2964	* @param float $mean Mean Value
2965	* @param float $stdDev Standard Deviation
2966	* @return float Standardized value
2967	*/
2968	public static function STANDARDIZE($value,$mean,$stdDev) {
2969	$value = PHPExcel_Calculation_Functions::flattenSingleValue($value);
2970	$mean = PHPExcel_Calculation_Functions::flattenSingleValue($mean);
2971	$stdDev = PHPExcel_Calculation_Functions::flattenSingleValue($stdDev);
2972
2973	if ((is_numeric($value)) && (is_numeric($mean)) && (is_numeric($stdDev))) {
2974	if ($stdDev <= 0) {
2975	return PHPExcel_Calculation_Functions::NaN();
2976	}
2977	return ($value - $mean) / $stdDev ;
2978	}
2979	return PHPExcel_Calculation_Functions::VALUE();
2980	} // function STANDARDIZE()
2981
2982
2983	/**
2984	* STDEV
2985	*
2986	* Estimates standard deviation based on a sample. The standard deviation is a measure of how
2987	* widely values are dispersed from the average value (the mean).
2988	*
2989	* Excel Function:
2990	* STDEV(value1[,value2[, ...]])
2991	*
2992	* @access public
2993	* @category Statistical Functions
2994	* @param mixed $arg,... Data values
2995	* @return float
2996	*/
2997	public static function STDEV() {
2998	$aArgs = PHPExcel_Calculation_Functions::flattenArrayIndexed(func_get_args());
2999
3000	// Return value
3001	$returnValue = null;
3002
3003	$aMean = self::AVERAGE($aArgs);
3004	if (!is_null($aMean)) {
3005	$aCount = -1;
3006	foreach ($aArgs as $k => $arg) {
3007	if ((is_bool($arg)) &&
3008	((!PHPExcel_Calculation_Functions::isCellValue($k)) \|\| (PHPExcel_Calculation_Functions::getCompatibilityMode() == PHPExcel_Calculation_Functions::COMPATIBILITY_OPENOFFICE))) {
3009	$arg = (integer) $arg;
3010	}
3011	// Is it a numeric value?
3012	if ((is_numeric($arg)) && (!is_string($arg))) {
3013	if (is_null($returnValue)) {
3014	$returnValue = pow(($arg - $aMean),2);
3015	} else {
3016	$returnValue += pow(($arg - $aMean),2);
3017	}
3018	++$aCount;
3019	}
3020	}
3021
3022	// Return
3023	if (($aCount > 0) && ($returnValue >= 0)) {
3024	return sqrt($returnValue / $aCount);
3025	}
3026	}
3027	return PHPExcel_Calculation_Functions::DIV0();
3028	} // function STDEV()
3029
3030
3031	/**
3032	* STDEVA
3033	*
3034	* Estimates standard deviation based on a sample, including numbers, text, and logical values
3035	*
3036	* Excel Function:
3037	* STDEVA(value1[,value2[, ...]])
3038	*
3039	* @access public
3040	* @category Statistical Functions
3041	* @param mixed $arg,... Data values
3042	* @return float
3043	*/
3044	public static function STDEVA() {
3045	$aArgs = PHPExcel_Calculation_Functions::flattenArrayIndexed(func_get_args());
3046
3047	// Return value
3048	$returnValue = null;
3049
3050	$aMean = self::AVERAGEA($aArgs);
3051	if (!is_null($aMean)) {
3052	$aCount = -1;
3053	foreach ($aArgs as $k => $arg) {
3054	if ((is_bool($arg)) &&
3055	(!PHPExcel_Calculation_Functions::isMatrixValue($k))) {
3056	} else {
3057	// Is it a numeric value?
3058	if ((is_numeric($arg)) \|\| (is_bool($arg)) \|\| ((is_string($arg) & ($arg != '')))) {
3059	if (is_bool($arg)) {
3060	$arg = (integer) $arg;
3061	} elseif (is_string($arg)) {
3062	$arg = 0;
3063	}
3064	if (is_null($returnValue)) {
3065	$returnValue = pow(($arg - $aMean),2);
3066	} else {
3067	$returnValue += pow(($arg - $aMean),2);
3068	}
3069	++$aCount;
3070	}
3071	}
3072	}
3073
3074	// Return
3075	if (($aCount > 0) && ($returnValue >= 0)) {
3076	return sqrt($returnValue / $aCount);
3077	}
3078	}
3079	return PHPExcel_Calculation_Functions::DIV0();
3080	} // function STDEVA()
3081
3082
3083	/**
3084	* STDEVP
3085	*
3086	* Calculates standard deviation based on the entire population
3087	*
3088	* Excel Function:
3089	* STDEVP(value1[,value2[, ...]])
3090	*
3091	* @access public
3092	* @category Statistical Functions
3093	* @param mixed $arg,... Data values
3094	* @return float
3095	*/
3096	public static function STDEVP() {
3097	$aArgs = PHPExcel_Calculation_Functions::flattenArrayIndexed(func_get_args());
3098
3099	// Return value
3100	$returnValue = null;
3101
3102	$aMean = self::AVERAGE($aArgs);
3103	if (!is_null($aMean)) {
3104	$aCount = 0;
3105	foreach ($aArgs as $k => $arg) {
3106	if ((is_bool($arg)) &&
3107	((!PHPExcel_Calculation_Functions::isCellValue($k)) \|\| (PHPExcel_Calculation_Functions::getCompatibilityMode() == PHPExcel_Calculation_Functions::COMPATIBILITY_OPENOFFICE))) {
3108	$arg = (integer) $arg;
3109	}
3110	// Is it a numeric value?
3111	if ((is_numeric($arg)) && (!is_string($arg))) {
3112	if (is_null($returnValue)) {
3113	$returnValue = pow(($arg - $aMean),2);
3114	} else {
3115	$returnValue += pow(($arg - $aMean),2);
3116	}
3117	++$aCount;
3118	}
3119	}
3120
3121	// Return
3122	if (($aCount > 0) && ($returnValue >= 0)) {
3123	return sqrt($returnValue / $aCount);
3124	}
3125	}
3126	return PHPExcel_Calculation_Functions::DIV0();
3127	} // function STDEVP()
3128
3129
3130	/**
3131	* STDEVPA
3132	*
3133	* Calculates standard deviation based on the entire population, including numbers, text, and logical values
3134	*
3135	* Excel Function:
3136	* STDEVPA(value1[,value2[, ...]])
3137	*
3138	* @access public
3139	* @category Statistical Functions
3140	* @param mixed $arg,... Data values
3141	* @return float
3142	*/
3143	public static function STDEVPA() {
3144	$aArgs = PHPExcel_Calculation_Functions::flattenArrayIndexed(func_get_args());
3145
3146	// Return value
3147	$returnValue = null;
3148
3149	$aMean = self::AVERAGEA($aArgs);
3150	if (!is_null($aMean)) {
3151	$aCount = 0;
3152	foreach ($aArgs as $k => $arg) {
3153	if ((is_bool($arg)) &&
3154	(!PHPExcel_Calculation_Functions::isMatrixValue($k))) {
3155	} else {
3156	// Is it a numeric value?
3157	if ((is_numeric($arg)) \|\| (is_bool($arg)) \|\| ((is_string($arg) & ($arg != '')))) {
3158	if (is_bool($arg)) {
3159	$arg = (integer) $arg;
3160	} elseif (is_string($arg)) {
3161	$arg = 0;
3162	}
3163	if (is_null($returnValue)) {
3164	$returnValue = pow(($arg - $aMean),2);
3165	} else {
3166	$returnValue += pow(($arg - $aMean),2);
3167	}
3168	++$aCount;
3169	}
3170	}
3171	}
3172
3173	// Return
3174	if (($aCount > 0) && ($returnValue >= 0)) {
3175	return sqrt($returnValue / $aCount);
3176	}
3177	}
3178	return PHPExcel_Calculation_Functions::DIV0();
3179	} // function STDEVPA()
3180
3181
3182	/**
3183	* STEYX
3184	*
3185	* Returns the standard error of the predicted y-value for each x in the regression.
3186	*
3187	* @param array of mixed Data Series Y
3188	* @param array of mixed Data Series X
3189	* @return float
3190	*/
3191	public static function STEYX($yValues,$xValues) {
3192	if (!self::_checkTrendArrays($yValues,$xValues)) {
3193	return PHPExcel_Calculation_Functions::VALUE();
3194	}
3195	$yValueCount = count($yValues);
3196	$xValueCount = count($xValues);
3197
3198	if (($yValueCount == 0) \|\| ($yValueCount != $xValueCount)) {
3199	return PHPExcel_Calculation_Functions::NA();
3200	} elseif ($yValueCount == 1) {
3201	return PHPExcel_Calculation_Functions::DIV0();
3202	}
3203
3204	$bestFitLinear = trendClass::calculate(trendClass::TREND_LINEAR,$yValues,$xValues);
3205	return $bestFitLinear->getStdevOfResiduals();
3206	} // function STEYX()
3207
3208
3209	/**
3210	* TDIST
3211	*
3212	* Returns the probability of Student's T distribution.
3213	*
3214	* @param float $value Value for the function
3215	* @param float $degrees degrees of freedom
3216	* @param float $tails number of tails (1 or 2)
3217	* @return float
3218	*/
3219	public static function TDIST($value, $degrees, $tails) {
3220	$value = PHPExcel_Calculation_Functions::flattenSingleValue($value);
3221	$degrees = floor(PHPExcel_Calculation_Functions::flattenSingleValue($degrees));
3222	$tails = floor(PHPExcel_Calculation_Functions::flattenSingleValue($tails));
3223
3224	if ((is_numeric($value)) && (is_numeric($degrees)) && (is_numeric($tails))) {
3225	if (($value < 0) \|\| ($degrees < 1) \|\| ($tails < 1) \|\| ($tails > 2)) {
3226	return PHPExcel_Calculation_Functions::NaN();
3227	}
3228	// tdist, which finds the probability that corresponds to a given value
3229	// of t with k degrees of freedom. This algorithm is translated from a
3230	// pascal function on p81 of "Statistical Computing in Pascal" by D
3231	// Cooke, A H Craven & G M Clark (1985: Edward Arnold (Pubs.) Ltd:
3232	// London). The above Pascal algorithm is itself a translation of the
3233	// fortran algoritm "AS 3" by B E Cooper of the Atlas Computer
3234	// Laboratory as reported in (among other places) "Applied Statistics
3235	// Algorithms", editied by P Griffiths and I D Hill (1985; Ellis
3236	// Horwood Ltd.; W. Sussex, England).
3237	$tterm = $degrees;
3238	$ttheta = atan2($value,sqrt($tterm));
3239	$tc = cos($ttheta);
3240	$ts = sin($ttheta);
3241	$tsum = 0;
3242
3243	if (($degrees % 2) == 1) {
3244	$ti = 3;
3245	$tterm = $tc;
3246	} else {
3247	$ti = 2;
3248	$tterm = 1;
3249	}
3250
3251	$tsum = $tterm;
3252	while ($ti < $degrees) {
3253	$tterm = $tc $tc * ($ti - 1) / $ti;
3254	$tsum += $tterm;
3255	$ti += 2;
3256	}
3257	$tsum *= $ts;
3258	if (($degrees % 2) == 1) { $tsum = M_2DIVPI * ($tsum + $ttheta); }
3259	$tValue = 0.5 * (1 + $tsum);
3260	if ($tails == 1) {
3261	return 1 - abs($tValue);
3262	} else {
3263	return 1 - abs((1 - $tValue) - $tValue);
3264	}
3265	}
3266	return PHPExcel_Calculation_Functions::VALUE();
3267	} // function TDIST()
3268
3269
3270	/**
3271	* TINV
3272	*
3273	* Returns the one-tailed probability of the chi-squared distribution.
3274	*
3275	* @param float $probability Probability for the function
3276	* @param float $degrees degrees of freedom
3277	* @return float
3278	*/
3279	public static function TINV($probability, $degrees) {
3280	$probability = PHPExcel_Calculation_Functions::flattenSingleValue($probability);
3281	$degrees = floor(PHPExcel_Calculation_Functions::flattenSingleValue($degrees));
3282
3283	if ((is_numeric($probability)) && (is_numeric($degrees))) {
3284	$xLo = 100;
3285	$xHi = 0;
3286
3287	$x = $xNew = 1;
3288	$dx = 1;
3289	$i = 0;
3290
3291	while ((abs($dx) > PRECISION) && ($i++ < MAX_ITERATIONS)) {
3292	// Apply Newton-Raphson step
3293	$result = self::TDIST($x, $degrees, 2);
3294	$error = $result - $probability;
3295	if ($error == 0.0) {
3296	$dx = 0;
3297	} elseif ($error < 0.0) {
3298	$xLo = $x;
3299	} else {
3300	$xHi = $x;
3301	}
3302	// Avoid division by zero
3303	if ($result != 0.0) {
3304	$dx = $error / $result;
3305	$xNew = $x - $dx;
3306	}
3307	// If the NR fails to converge (which for example may be the
3308	// case if the initial guess is too rough) we apply a bisection
3309	// step to determine a more narrow interval around the root.
3310	if (($xNew < $xLo) \|\| ($xNew > $xHi) \|\| ($result == 0.0)) {
3311	$xNew = ($xLo + $xHi) / 2;
3312	$dx = $xNew - $x;
3313	}
3314	$x = $xNew;
3315	}
3316	if ($i == MAX_ITERATIONS) {
3317	return PHPExcel_Calculation_Functions::NA();
3318	}
3319	return round($x,12);
3320	}
3321	return PHPExcel_Calculation_Functions::VALUE();
3322	} // function TINV()
3323
3324
3325	/**
3326	* TREND
3327	*
3328	* Returns values along a linear trend
3329	*
3330	* @param array of mixed Data Series Y
3331	* @param array of mixed Data Series X
3332	* @param array of mixed Values of X for which we want to find Y
3333	* @param boolean A logical value specifying whether to force the intersect to equal 0.
3334	* @return array of float
3335	*/
3336	public static function TREND($yValues,$xValues=array(),$newValues=array(),$const=True) {
3337	$yValues = PHPExcel_Calculation_Functions::flattenArray($yValues);
3338	$xValues = PHPExcel_Calculation_Functions::flattenArray($xValues);
3339	$newValues = PHPExcel_Calculation_Functions::flattenArray($newValues);
3340	$const = (is_null($const)) ? True : (boolean) PHPExcel_Calculation_Functions::flattenSingleValue($const);
3341
3342	$bestFitLinear = trendClass::calculate(trendClass::TREND_LINEAR,$yValues,$xValues,$const);
3343	if (empty($newValues)) {
3344	$newValues = $bestFitLinear->getXValues();
3345	}
3346
3347	$returnArray = array();
3348	foreach($newValues as $xValue) {
3349	$returnArray[0][] = $bestFitLinear->getValueOfYForX($xValue);
3350	}
3351
3352	return $returnArray;
3353	} // function TREND()
3354
3355
3356	/**
3357	* TRIMMEAN
3358	*
3359	* Returns the mean of the interior of a data set. TRIMMEAN calculates the mean
3360	* taken by excluding a percentage of data points from the top and bottom tails
3361	* of a data set.
3362	*
3363	* Excel Function:
3364	* TRIMEAN(value1[,value2[, ...]],$discard)
3365	*
3366	* @access public
3367	* @category Statistical Functions
3368	* @param mixed $arg,... Data values
3369	* @param float $discard Percentage to discard
3370	* @return float
3371	*/
3372	public static function TRIMMEAN() {
3373	$aArgs = PHPExcel_Calculation_Functions::flattenArray(func_get_args());
3374
3375	// Calculate
3376	$percent = array_pop($aArgs);
3377
3378	if ((is_numeric($percent)) && (!is_string($percent))) {
3379	if (($percent < 0) \|\| ($percent > 1)) {
3380	return PHPExcel_Calculation_Functions::NaN();
3381	}
3382	$mArgs = array();
3383	foreach ($aArgs as $arg) {
3384	// Is it a numeric value?
3385	if ((is_numeric($arg)) && (!is_string($arg))) {
3386	$mArgs[] = $arg;
3387	}
3388	}
3389	$discard = floor(self::COUNT($mArgs) * $percent / 2);
3390	sort($mArgs);
3391	for ($i=0; $i < $discard; ++$i) {
3392	array_pop($mArgs);
3393	array_shift($mArgs);
3394	}
3395	return self::AVERAGE($mArgs);
3396	}
3397	return PHPExcel_Calculation_Functions::VALUE();
3398	} // function TRIMMEAN()
3399
3400
3401	/**
3402	* VARFunc
3403	*
3404	* Estimates variance based on a sample.
3405	*
3406	* Excel Function:
3407	* VAR(value1[,value2[, ...]])
3408	*
3409	* @access public
3410	* @category Statistical Functions
3411	* @param mixed $arg,... Data values
3412	* @return float
3413	*/
3414	public static function VARFunc() {
3415	// Return value
3416	$returnValue = PHPExcel_Calculation_Functions::DIV0();
3417
3418	$summerA = $summerB = 0;
3419
3420	// Loop through arguments
3421	$aArgs = PHPExcel_Calculation_Functions::flattenArray(func_get_args());
3422	$aCount = 0;
3423	foreach ($aArgs as $arg) {
3424	if (is_bool($arg)) { $arg = (integer) $arg; }
3425	// Is it a numeric value?
3426	if ((is_numeric($arg)) && (!is_string($arg))) {
3427	$summerA += ($arg * $arg);
3428	$summerB += $arg;
3429	++$aCount;
3430	}
3431	}
3432
3433	// Return
3434	if ($aCount > 1) {
3435	$summerA *= $aCount;
3436	$summerB *= $summerB;
3437	$returnValue = ($summerA - $summerB) / ($aCount * ($aCount - 1));
3438	}
3439	return $returnValue;
3440	} // function VARFunc()
3441
3442
3443	/**
3444	* VARA
3445	*
3446	* Estimates variance based on a sample, including numbers, text, and logical values
3447	*
3448	* Excel Function:
3449	* VARA(value1[,value2[, ...]])
3450	*
3451	* @access public
3452	* @category Statistical Functions
3453	* @param mixed $arg,... Data values
3454	* @return float
3455	*/
3456	public static function VARA() {
3457	// Return value
3458	$returnValue = PHPExcel_Calculation_Functions::DIV0();
3459
3460	$summerA = $summerB = 0;
3461
3462	// Loop through arguments
3463	$aArgs = PHPExcel_Calculation_Functions::flattenArrayIndexed(func_get_args());
3464	$aCount = 0;
3465	foreach ($aArgs as $k => $arg) {
3466	if ((is_string($arg)) &&
3467	(PHPExcel_Calculation_Functions::isValue($k))) {
3468	return PHPExcel_Calculation_Functions::VALUE();
3469	} elseif ((is_string($arg)) &&
3470	(!PHPExcel_Calculation_Functions::isMatrixValue($k))) {
3471	} else {
3472	// Is it a numeric value?
3473	if ((is_numeric($arg)) \|\| (is_bool($arg)) \|\| ((is_string($arg) & ($arg != '')))) {
3474	if (is_bool($arg)) {
3475	$arg = (integer) $arg;
3476	} elseif (is_string($arg)) {
3477	$arg = 0;
3478	}
3479	$summerA += ($arg * $arg);
3480	$summerB += $arg;
3481	++$aCount;
3482	}
3483	}
3484	}
3485
3486	// Return
3487	if ($aCount > 1) {
3488	$summerA *= $aCount;
3489	$summerB *= $summerB;
3490	$returnValue = ($summerA - $summerB) / ($aCount * ($aCount - 1));
3491	}
3492	return $returnValue;
3493	} // function VARA()
3494
3495
3496	/**
3497	* VARP
3498	*
3499	* Calculates variance based on the entire population
3500	*
3501	* Excel Function:
3502	* VARP(value1[,value2[, ...]])
3503	*
3504	* @access public
3505	* @category Statistical Functions
3506	* @param mixed $arg,... Data values
3507	* @return float
3508	*/
3509	public static function VARP() {
3510	// Return value
3511	$returnValue = PHPExcel_Calculation_Functions::DIV0();
3512
3513	$summerA = $summerB = 0;
3514
3515	// Loop through arguments
3516	$aArgs = PHPExcel_Calculation_Functions::flattenArray(func_get_args());
3517	$aCount = 0;
3518	foreach ($aArgs as $arg) {
3519	if (is_bool($arg)) { $arg = (integer) $arg; }
3520	// Is it a numeric value?
3521	if ((is_numeric($arg)) && (!is_string($arg))) {
3522	$summerA += ($arg * $arg);
3523	$summerB += $arg;
3524	++$aCount;
3525	}
3526	}
3527
3528	// Return
3529	if ($aCount > 0) {
3530	$summerA *= $aCount;
3531	$summerB *= $summerB;
3532	$returnValue = ($summerA - $summerB) / ($aCount * $aCount);
3533	}
3534	return $returnValue;
3535	} // function VARP()
3536
3537
3538	/**
3539	* VARPA
3540	*
3541	* Calculates variance based on the entire population, including numbers, text, and logical values
3542	*
3543	* Excel Function:
3544	* VARPA(value1[,value2[, ...]])
3545	*
3546	* @access public
3547	* @category Statistical Functions
3548	* @param mixed $arg,... Data values
3549	* @return float
3550	*/
3551	public static function VARPA() {
3552	// Return value
3553	$returnValue = PHPExcel_Calculation_Functions::DIV0();
3554
3555	$summerA = $summerB = 0;
3556
3557	// Loop through arguments
3558	$aArgs = PHPExcel_Calculation_Functions::flattenArrayIndexed(func_get_args());
3559	$aCount = 0;
3560	foreach ($aArgs as $k => $arg) {
3561	if ((is_string($arg)) &&
3562	(PHPExcel_Calculation_Functions::isValue($k))) {
3563	return PHPExcel_Calculation_Functions::VALUE();
3564	} elseif ((is_string($arg)) &&
3565	(!PHPExcel_Calculation_Functions::isMatrixValue($k))) {
3566	} else {
3567	// Is it a numeric value?
3568	if ((is_numeric($arg)) \|\| (is_bool($arg)) \|\| ((is_string($arg) & ($arg != '')))) {
3569	if (is_bool($arg)) {
3570	$arg = (integer) $arg;
3571	} elseif (is_string($arg)) {
3572	$arg = 0;
3573	}
3574	$summerA += ($arg * $arg);
3575	$summerB += $arg;
3576	++$aCount;
3577	}
3578	}
3579	}
3580
3581	// Return
3582	if ($aCount > 0) {
3583	$summerA *= $aCount;
3584	$summerB *= $summerB;
3585	$returnValue = ($summerA - $summerB) / ($aCount * $aCount);
3586	}
3587	return $returnValue;
3588	} // function VARPA()
3589
3590
3591	/**
3592	* WEIBULL
3593	*
3594	* Returns the Weibull distribution. Use this distribution in reliability
3595	* analysis, such as calculating a device's mean time to failure.
3596	*
3597	* @param float $value
3598	* @param float $alpha Alpha Parameter
3599	* @param float $beta Beta Parameter
3600	* @param boolean $cumulative
3601	* @return float
3602	*
3603	*/
3604	public static function WEIBULL($value, $alpha, $beta, $cumulative) {
3605	$value = PHPExcel_Calculation_Functions::flattenSingleValue($value);
3606	$alpha = PHPExcel_Calculation_Functions::flattenSingleValue($alpha);
3607	$beta = PHPExcel_Calculation_Functions::flattenSingleValue($beta);
3608
3609	if ((is_numeric($value)) && (is_numeric($alpha)) && (is_numeric($beta))) {
3610	if (($value < 0) \|\| ($alpha <= 0) \|\| ($beta <= 0)) {
3611	return PHPExcel_Calculation_Functions::NaN();
3612	}
3613	if ((is_numeric($cumulative)) \|\| (is_bool($cumulative))) {
3614	if ($cumulative) {
3615	return 1 - exp(0 - pow($value / $beta,$alpha));
3616	} else {
3617	return ($alpha / pow($beta,$alpha)) * pow($value,$alpha - 1) * exp(0 - pow($value / $beta,$alpha));
3618	}
3619	}
3620	}
3621	return PHPExcel_Calculation_Functions::VALUE();
3622	} // function WEIBULL()
3623
3624
3625	/**
3626	* ZTEST
3627	*
3628	* Returns the Weibull distribution. Use this distribution in reliability
3629	* analysis, such as calculating a device's mean time to failure.
3630	*
3631	* @param float $dataSet
3632	* @param float $m0 Alpha Parameter
3633	* @param float $sigma Beta Parameter
3634	* @param boolean $cumulative
3635	* @return float
3636	*
3637	*/
3638	public static function ZTEST($dataSet, $m0, $sigma = NULL) {
3639	$dataSet = PHPExcel_Calculation_Functions::flattenArrayIndexed($dataSet);
3640	$m0 = PHPExcel_Calculation_Functions::flattenSingleValue($m0);
3641	$sigma = PHPExcel_Calculation_Functions::flattenSingleValue($sigma);
3642
3643	if (is_null($sigma)) {
3644	$sigma = self::STDEV($dataSet);
3645	}
3646	$n = count($dataSet);
3647
3648	return 1 - self::NORMSDIST((self::AVERAGE($dataSet) - $m0)/($sigma/SQRT($n)));
3649	} // function ZTEST()
3650
3651	} // class PHPExcel_Calculation_Statistical
3652