wpdatatables / lib / phpoffice / phpspreadsheet / src / PhpSpreadsheet / Calculation / Statistical.php

Statistical.php in wpDataTables – WordPress Data Table, Dynamic Tables & Table Charts Plugin 6.5.1.7, at lib/phpoffice/phpspreadsheet/src/PhpSpreadsheet/Calculation/Statistical.php

1,740 lines 55.1 KB

Raw Download Zip

1	<?php
2
3	namespace PhpOffice\PhpSpreadsheet\Calculation;
4
5	use PhpOffice\PhpSpreadsheet\Calculation\Statistical\Averages;
6	use PhpOffice\PhpSpreadsheet\Calculation\Statistical\Conditional;
7	use PhpOffice\PhpSpreadsheet\Calculation\Statistical\Confidence;
8	use PhpOffice\PhpSpreadsheet\Calculation\Statistical\Counts;
9	use PhpOffice\PhpSpreadsheet\Calculation\Statistical\Maximum;
10	use PhpOffice\PhpSpreadsheet\Calculation\Statistical\Minimum;
11	use PhpOffice\PhpSpreadsheet\Calculation\Statistical\Permutations;
12	use PhpOffice\PhpSpreadsheet\Calculation\Statistical\StandardDeviations;
13	use PhpOffice\PhpSpreadsheet\Calculation\Statistical\Trends;
14	use PhpOffice\PhpSpreadsheet\Calculation\Statistical\Variances;
15
16	/**
17	* @deprecated 1.18.0
18	*/
19	class Statistical
20	{
21	const LOG_GAMMA_X_MAX_VALUE = 2.55e305;
22	const EPS = 2.22e-16;
23	const MAX_VALUE = 1.2e308;
24	const SQRT2PI = 2.5066282746310005024157652848110452530069867406099;
25
26	/**
27	* AVEDEV.
28	*
29	* Returns the average of the absolute deviations of data points from their mean.
30	* AVEDEV is a measure of the variability in a data set.
31	*
32	* Excel Function:
33	* AVEDEV(value1[,value2[, ...]])
34	*
35	* @deprecated 1.17.0
36	* Use the averageDeviations() method in the Statistical\Averages class instead
37	* @see Statistical\Averages::averageDeviations()
38	*
39	* @param mixed ...$args Data values
40	*
41	* @return float\|string
42	*/
43	public static function AVEDEV(...$args)
44	{
45	return Averages::averageDeviations(...$args);
46	}
47
48	/**
49	* AVERAGE.
50	*
51	* Returns the average (arithmetic mean) of the arguments
52	*
53	* Excel Function:
54	* AVERAGE(value1[,value2[, ...]])
55	*
56	* @deprecated 1.17.0
57	* Use the average() method in the Statistical\Averages class instead
58	* @see Statistical\Averages::average()
59	*
60	* @param mixed ...$args Data values
61	*
62	* @return float\|string
63	*/
64	public static function AVERAGE(...$args)
65	{
66	return Averages::average(...$args);
67	}
68
69	/**
70	* AVERAGEA.
71	*
72	* Returns the average of its arguments, including numbers, text, and logical values
73	*
74	* Excel Function:
75	* AVERAGEA(value1[,value2[, ...]])
76	*
77	* @deprecated 1.17.0
78	* Use the averageA() method in the Statistical\Averages class instead
79	* @see Statistical\Averages::averageA()
80	*
81	* @param mixed ...$args Data values
82	*
83	* @return float\|string
84	*/
85	public static function AVERAGEA(...$args)
86	{
87	return Averages::averageA(...$args);
88	}
89
90	/**
91	* AVERAGEIF.
92	*
93	* Returns the average value from a range of cells that contain numbers within the list of arguments
94	*
95	* Excel Function:
96	* AVERAGEIF(value1[,value2[, ...]],condition)
97	*
98	* @deprecated 1.17.0
99	* Use the AVERAGEIF() method in the Statistical\Conditional class instead
100	* @see Statistical\Conditional::AVERAGEIF()
101	*
102	* @param mixed $range Data values
103	* @param string $condition the criteria that defines which cells will be checked
104	* @param mixed[] $averageRange Data values
105	*
106	* @return null\|float\|string
107	*/
108	public static function AVERAGEIF($range, $condition, $averageRange = [])
109	{
110	return Conditional::AVERAGEIF($range, $condition, $averageRange);
111	}
112
113	/**
114	* BETADIST.
115	*
116	* Returns the beta distribution.
117	*
118	* @deprecated 1.18.0
119	* Use the distribution() method in the Statistical\Distributions\Beta class instead
120	* @see Statistical\Distributions\Beta::distribution()
121	*
122	* @param float $value Value at which you want to evaluate the distribution
123	* @param float $alpha Parameter to the distribution
124	* @param float $beta Parameter to the distribution
125	* @param mixed $rMin
126	* @param mixed $rMax
127	*
128	* @return array\|float\|string
129	*/
130	public static function BETADIST($value, $alpha, $beta, $rMin = 0, $rMax = 1)
131	{
132	return Statistical\Distributions\Beta::distribution($value, $alpha, $beta, $rMin, $rMax);
133	}
134
135	/**
136	* BETAINV.
137	*
138	* Returns the inverse of the Beta distribution.
139	*
140	* @deprecated 1.18.0
141	* Use the inverse() method in the Statistical\Distributions\Beta class instead
142	* @see Statistical\Distributions\Beta::inverse()
143	*
144	* @param float $probability Probability at which you want to evaluate the distribution
145	* @param float $alpha Parameter to the distribution
146	* @param float $beta Parameter to the distribution
147	* @param float $rMin Minimum value
148	* @param float $rMax Maximum value
149	*
150	* @return array\|float\|string
151	*/
152	public static function BETAINV($probability, $alpha, $beta, $rMin = 0, $rMax = 1)
153	{
154	return Statistical\Distributions\Beta::inverse($probability, $alpha, $beta, $rMin, $rMax);
155	}
156
157	/**
158	* BINOMDIST.
159	*
160	* Returns the individual term binomial distribution probability. Use BINOMDIST in problems with
161	* a fixed number of tests or trials, when the outcomes of any trial are only success or failure,
162	* when trials are independent, and when the probability of success is constant throughout the
163	* experiment. For example, BINOMDIST can calculate the probability that two of the next three
164	* babies born are male.
165	*
166	* @deprecated 1.18.0
167	* Use the distribution() method in the Statistical\Distributions\Binomial class instead
168	* @see Statistical\Distributions\Binomial::distribution()
169	*
170	* @param mixed $value Number of successes in trials
171	* @param mixed $trials Number of trials
172	* @param mixed $probability Probability of success on each trial
173	* @param mixed $cumulative
174	*
175	* @return array\|float\|string
176	*/
177	public static function BINOMDIST($value, $trials, $probability, $cumulative)
178	{
179	return Statistical\Distributions\Binomial::distribution($value, $trials, $probability, $cumulative);
180	}
181
182	/**
183	* CHIDIST.
184	*
185	* Returns the one-tailed probability of the chi-squared distribution.
186	*
187	* @deprecated 1.18.0
188	* Use the distributionRightTail() method in the Statistical\Distributions\ChiSquared class instead
189	* @see Statistical\Distributions\ChiSquared::distributionRightTail()
190	*
191	* @param float $value Value for the function
192	* @param float $degrees degrees of freedom
193	*
194	* @return array\|float\|string
195	*/
196	public static function CHIDIST($value, $degrees)
197	{
198	return Statistical\Distributions\ChiSquared::distributionRightTail($value, $degrees);
199	}
200
201	/**
202	* CHIINV.
203	*
204	* Returns the one-tailed probability of the chi-squared distribution.
205	*
206	* @deprecated 1.18.0
207	* Use the inverseRightTail() method in the Statistical\Distributions\ChiSquared class instead
208	* @see Statistical\Distributions\ChiSquared::inverseRightTail()
209	*
210	* @param float $probability Probability for the function
211	* @param float $degrees degrees of freedom
212	*
213	* @return array\|float\|string
214	*/
215	public static function CHIINV($probability, $degrees)
216	{
217	return Statistical\Distributions\ChiSquared::inverseRightTail($probability, $degrees);
218	}
219
220	/**
221	* CONFIDENCE.
222	*
223	* Returns the confidence interval for a population mean
224	*
225	* @deprecated 1.18.0
226	* Use the CONFIDENCE() method in the Statistical\Confidence class instead
227	* @see Statistical\Confidence::CONFIDENCE()
228	*
229	* @param float $alpha
230	* @param float $stdDev Standard Deviation
231	* @param float $size
232	*
233	* @return array\|float\|string
234	*/
235	public static function CONFIDENCE($alpha, $stdDev, $size)
236	{
237	return Confidence::CONFIDENCE($alpha, $stdDev, $size);
238	}
239
240	/**
241	* CORREL.
242	*
243	* Returns covariance, the average of the products of deviations for each data point pair.
244	*
245	* @deprecated 1.18.0
246	* Use the CORREL() method in the Statistical\Trends class instead
247	* @see Statistical\Trends::CORREL()
248	*
249	* @param mixed $yValues array of mixed Data Series Y
250	* @param null\|mixed $xValues array of mixed Data Series X
251	*
252	* @return float\|string
253	*/
254	public static function CORREL($yValues, $xValues = null)
255	{
256	return Trends::CORREL($xValues, $yValues);
257	}
258
259	/**
260	* COUNT.
261	*
262	* Counts the number of cells that contain numbers within the list of arguments
263	*
264	* Excel Function:
265	* COUNT(value1[,value2[, ...]])
266	*
267	* @deprecated 1.17.0
268	* Use the COUNT() method in the Statistical\Counts class instead
269	* @see Statistical\Counts::COUNT()
270	*
271	* @param mixed ...$args Data values
272	*
273	* @return int
274	*/
275	public static function COUNT(...$args)
276	{
277	return Counts::COUNT(...$args);
278	}
279
280	/**
281	* COUNTA.
282	*
283	* Counts the number of cells that are not empty within the list of arguments
284	*
285	* Excel Function:
286	* COUNTA(value1[,value2[, ...]])
287	*
288	* @deprecated 1.17.0
289	* Use the COUNTA() method in the Statistical\Counts class instead
290	* @see Statistical\Counts::COUNTA()
291	*
292	* @param mixed ...$args Data values
293	*
294	* @return int
295	*/
296	public static function COUNTA(...$args)
297	{
298	return Counts::COUNTA(...$args);
299	}
300
301	/**
302	* COUNTBLANK.
303	*
304	* Counts the number of empty cells within the list of arguments
305	*
306	* Excel Function:
307	* COUNTBLANK(value1[,value2[, ...]])
308	*
309	* @deprecated 1.17.0
310	* Use the COUNTBLANK() method in the Statistical\Counts class instead
311	* @see Statistical\Counts::COUNTBLANK()
312	*
313	* @param mixed $range Data values
314	*
315	* @return int
316	*/
317	public static function COUNTBLANK($range)
318	{
319	return Counts::COUNTBLANK($range);
320	}
321
322	/**
323	* COUNTIF.
324	*
325	* Counts the number of cells that contain numbers within the list of arguments
326	*
327	* Excel Function:
328	* COUNTIF(range,condition)
329	*
330	* @deprecated 1.17.0
331	* Use the COUNTIF() method in the Statistical\Conditional class instead
332	* @see Statistical\Conditional::COUNTIF()
333	*
334	* @param mixed $range Data values
335	* @param string $condition the criteria that defines which cells will be counted
336	*
337	* @return int\|string
338	*/
339	public static function COUNTIF($range, $condition)
340	{
341	return Conditional::COUNTIF($range, $condition);
342	}
343
344	/**
345	* COUNTIFS.
346	*
347	* Counts the number of cells that contain numbers within the list of arguments
348	*
349	* Excel Function:
350	* COUNTIFS(criteria_range1, criteria1, [criteria_range2, criteria2]…)
351	*
352	* @deprecated 1.17.0
353	* Use the COUNTIFS() method in the Statistical\Conditional class instead
354	* @see Statistical\Conditional::COUNTIFS()
355	*
356	* @param mixed $args Pairs of Ranges and Criteria
357	*
358	* @return int\|string
359	*/
360	public static function COUNTIFS(...$args)
361	{
362	return Conditional::COUNTIFS(...$args);
363	}
364
365	/**
366	* COVAR.
367	*
368	* Returns covariance, the average of the products of deviations for each data point pair.
369	*
370	* @deprecated 1.18.0
371	* Use the COVAR() method in the Statistical\Trends class instead
372	* @see Statistical\Trends::COVAR()
373	*
374	* @param mixed $yValues array of mixed Data Series Y
375	* @param mixed $xValues array of mixed Data Series X
376	*
377	* @return float\|string
378	*/
379	public static function COVAR($yValues, $xValues)
380	{
381	return Trends::COVAR($yValues, $xValues);
382	}
383
384	/**
385	* CRITBINOM.
386	*
387	* Returns the smallest value for which the cumulative binomial distribution is greater
388	* than or equal to a criterion value
389	*
390	* See https://support.microsoft.com/en-us/help/828117/ for details of the algorithm used
391	*
392	* @deprecated 1.18.0
393	* Use the inverse() method in the Statistical\Distributions\Binomial class instead
394	* @see Statistical\Distributions\Binomial::inverse()
395	*
396	* @param float $trials number of Bernoulli trials
397	* @param float $probability probability of a success on each trial
398	* @param float $alpha criterion value
399	*
400	* @return array\|int\|string
401	*/
402	public static function CRITBINOM($trials, $probability, $alpha)
403	{
404	return Statistical\Distributions\Binomial::inverse($trials, $probability, $alpha);
405	}
406
407	/**
408	* DEVSQ.
409	*
410	* Returns the sum of squares of deviations of data points from their sample mean.
411	*
412	* Excel Function:
413	* DEVSQ(value1[,value2[, ...]])
414	*
415	* @deprecated 1.18.0
416	* Use the sumSquares() method in the Statistical\Deviations class instead
417	* @see Statistical\Deviations::sumSquares()
418	*
419	* @param mixed ...$args Data values
420	*
421	* @return float\|string
422	*/
423	public static function DEVSQ(...$args)
424	{
425	return Statistical\Deviations::sumSquares(...$args);
426	}
427
428	/**
429	* EXPONDIST.
430	*
431	* Returns the exponential distribution. Use EXPONDIST to model the time between events,
432	* such as how long an automated bank teller takes to deliver cash. For example, you can
433	* use EXPONDIST to determine the probability that the process takes at most 1 minute.
434	*
435	* @deprecated 1.18.0
436	* Use the distribution() method in the Statistical\Distributions\Exponential class instead
437	* @see Statistical\Distributions\Exponential::distribution()
438	*
439	* @param float $value Value of the function
440	* @param float $lambda The parameter value
441	* @param bool $cumulative
442	*
443	* @return array\|float\|string
444	*/
445	public static function EXPONDIST($value, $lambda, $cumulative)
446	{
447	return Statistical\Distributions\Exponential::distribution($value, $lambda, $cumulative);
448	}
449
450	/**
451	* F.DIST.
452	*
453	* Returns the F probability distribution.
454	* You can use this function to determine whether two data sets have different degrees of diversity.
455	* For example, you can examine the test scores of men and women entering high school, and determine
456	* if the variability in the females is different from that found in the males.
457	*
458	* @deprecated 1.18.0
459	* Use the distribution() method in the Statistical\Distributions\F class instead
460	* @see Statistical\Distributions\F::distribution()
461	*
462	* @param float $value Value of the function
463	* @param int $u The numerator degrees of freedom
464	* @param int $v The denominator degrees of freedom
465	* @param bool $cumulative If cumulative is TRUE, F.DIST returns the cumulative distribution function;
466	* if FALSE, it returns the probability density function.
467	*
468	* @return array\|float\|string
469	*/
470	public static function FDIST2($value, $u, $v, $cumulative)
471	{
472	return Statistical\Distributions\F::distribution($value, $u, $v, $cumulative);
473	}
474
475	/**
476	* FISHER.
477	*
478	* Returns the Fisher transformation at x. This transformation produces a function that
479	* is normally distributed rather than skewed. Use this function to perform hypothesis
480	* testing on the correlation coefficient.
481	*
482	* @deprecated 1.18.0
483	* Use the distribution() method in the Statistical\Distributions\Fisher class instead
484	* @see Statistical\Distributions\Fisher::distribution()
485	*
486	* @param float $value
487	*
488	* @return array\|float\|string
489	*/
490	public static function FISHER($value)
491	{
492	return Statistical\Distributions\Fisher::distribution($value);
493	}
494
495	/**
496	* FISHERINV.
497	*
498	* Returns the inverse of the Fisher transformation. Use this transformation when
499	* analyzing correlations between ranges or arrays of data. If y = FISHER(x), then
500	* FISHERINV(y) = x.
501	*
502	* @deprecated 1.18.0
503	* Use the inverse() method in the Statistical\Distributions\Fisher class instead
504	* @see Statistical\Distributions\Fisher::inverse()
505	*
506	* @param float $value
507	*
508	* @return array\|float\|string
509	*/
510	public static function FISHERINV($value)
511	{
512	return Statistical\Distributions\Fisher::inverse($value);
513	}
514
515	/**
516	* FORECAST.
517	*
518	* Calculates, or predicts, a future value by using existing values. The predicted value is a y-value for a given x-value.
519	*
520	* @deprecated 1.18.0
521	* Use the FORECAST() method in the Statistical\Trends class instead
522	* @see Statistical\Trends::FORECAST()
523	*
524	* @param float $xValue Value of X for which we want to find Y
525	* @param mixed $yValues array of mixed Data Series Y
526	* @param mixed $xValues of mixed Data Series X
527	*
528	* @return array\|bool\|float\|string
529	*/
530	public static function FORECAST($xValue, $yValues, $xValues)
531	{
532	return Trends::FORECAST($xValue, $yValues, $xValues);
533	}
534
535	/**
536	* GAMMA.
537	*
538	* Returns the gamma function value.
539	*
540	* @deprecated 1.18.0
541	* Use the gamma() method in the Statistical\Distributions\Gamma class instead
542	* @see Statistical\Distributions\Gamma::gamma()
543	*
544	* @param float $value
545	*
546	* @return array\|float\|string The result, or a string containing an error
547	*/
548	public static function GAMMAFunction($value)
549	{
550	return Statistical\Distributions\Gamma::gamma($value);
551	}
552
553	/**
554	* GAMMADIST.
555	*
556	* Returns the gamma distribution.
557	*
558	* @deprecated 1.18.0
559	* Use the distribution() method in the Statistical\Distributions\Gamma class instead
560	* @see Statistical\Distributions\Gamma::distribution()
561	*
562	* @param float $value Value at which you want to evaluate the distribution
563	* @param float $a Parameter to the distribution
564	* @param float $b Parameter to the distribution
565	* @param bool $cumulative
566	*
567	* @return array\|float\|string
568	*/
569	public static function GAMMADIST($value, $a, $b, $cumulative)
570	{
571	return Statistical\Distributions\Gamma::distribution($value, $a, $b, $cumulative);
572	}
573
574	/**
575	* GAMMAINV.
576	*
577	* Returns the inverse of the Gamma distribution.
578	*
579	* @deprecated 1.18.0
580	* Use the inverse() method in the Statistical\Distributions\Gamma class instead
581	* @see Statistical\Distributions\Gamma::inverse()
582	*
583	* @param float $probability Probability at which you want to evaluate the distribution
584	* @param float $alpha Parameter to the distribution
585	* @param float $beta Parameter to the distribution
586	*
587	* @return array\|float\|string
588	*/
589	public static function GAMMAINV($probability, $alpha, $beta)
590	{
591	return Statistical\Distributions\Gamma::inverse($probability, $alpha, $beta);
592	}
593
594	/**
595	* GAMMALN.
596	*
597	* Returns the natural logarithm of the gamma function.
598	*
599	* @deprecated 1.18.0
600	* Use the ln() method in the Statistical\Distributions\Gamma class instead
601	* @see Statistical\Distributions\Gamma::ln()
602	*
603	* @param float $value
604	*
605	* @return array\|float\|string
606	*/
607	public static function GAMMALN($value)
608	{
609	return Statistical\Distributions\Gamma::ln($value);
610	}
611
612	/**
613	* GAUSS.
614	*
615	* Calculates the probability that a member of a standard normal population will fall between
616	* the mean and z standard deviations from the mean.
617	*
618	* @deprecated 1.18.0
619	* Use the gauss() method in the Statistical\Distributions\StandardNormal class instead
620	* @see Statistical\Distributions\StandardNormal::gauss()
621	*
622	* @param float $value
623	*
624	* @return array\|float\|string The result, or a string containing an error
625	*/
626	public static function GAUSS($value)
627	{
628	return Statistical\Distributions\StandardNormal::gauss($value);
629	}
630
631	/**
632	* GEOMEAN.
633	*
634	* Returns the geometric mean of an array or range of positive data. For example, you
635	* can use GEOMEAN to calculate average growth rate given compound interest with
636	* variable rates.
637	*
638	* Excel Function:
639	* GEOMEAN(value1[,value2[, ...]])
640	*
641	* @deprecated 1.18.0
642	* Use the geometric() method in the Statistical\Averages\Mean class instead
643	* @see Statistical\Averages\Mean::geometric()
644	*
645	* @param mixed ...$args Data values
646	*
647	* @return float\|string
648	*/
649	public static function GEOMEAN(...$args)
650	{
651	return Statistical\Averages\Mean::geometric(...$args);
652	}
653
654	/**
655	* GROWTH.
656	*
657	* Returns values along a predicted exponential Trend
658	*
659	* @deprecated 1.18.0
660	* Use the GROWTH() method in the Statistical\Trends class instead
661	* @see Statistical\Trends::GROWTH()
662	*
663	* @param mixed[] $yValues Data Series Y
664	* @param mixed[] $xValues Data Series X
665	* @param mixed[] $newValues Values of X for which we want to find Y
666	* @param bool $const a logical value specifying whether to force the intersect to equal 0
667	*
668	* @return float[]
669	*/
670	public static function GROWTH($yValues, $xValues = [], $newValues = [], $const = true)
671	{
672	return Trends::GROWTH($yValues, $xValues, $newValues, $const);
673	}
674
675	/**
676	* HARMEAN.
677	*
678	* Returns the harmonic mean of a data set. The harmonic mean is the reciprocal of the
679	* arithmetic mean of reciprocals.
680	*
681	* Excel Function:
682	* HARMEAN(value1[,value2[, ...]])
683	*
684	* @deprecated 1.18.0
685	* Use the harmonic() method in the Statistical\Averages\Mean class instead
686	* @see Statistical\Averages\Mean::harmonic()
687	*
688	* @param mixed ...$args Data values
689	*
690	* @return float\|string
691	*/
692	public static function HARMEAN(...$args)
693	{
694	return Statistical\Averages\Mean::harmonic(...$args);
695	}
696
697	/**
698	* HYPGEOMDIST.
699	*
700	* Returns the hypergeometric distribution. HYPGEOMDIST returns the probability of a given number of
701	* sample successes, given the sample size, population successes, and population size.
702	*
703	* @deprecated 1.18.0
704	* Use the distribution() method in the Statistical\Distributions\HyperGeometric class instead
705	* @see Statistical\Distributions\HyperGeometric::distribution()
706	*
707	* @param mixed $sampleSuccesses Number of successes in the sample
708	* @param mixed $sampleNumber Size of the sample
709	* @param mixed $populationSuccesses Number of successes in the population
710	* @param mixed $populationNumber Population size
711	*
712	* @return array\|float\|string
713	*/
714	public static function HYPGEOMDIST($sampleSuccesses, $sampleNumber, $populationSuccesses, $populationNumber)
715	{
716	return Statistical\Distributions\HyperGeometric::distribution(
717	$sampleSuccesses,
718	$sampleNumber,
719	$populationSuccesses,
720	$populationNumber
721	);
722	}
723
724	/**
725	* INTERCEPT.
726	*
727	* Calculates the point at which a line will intersect the y-axis by using existing x-values and y-values.
728	*
729	* @deprecated 1.18.0
730	* Use the INTERCEPT() method in the Statistical\Trends class instead
731	* @see Statistical\Trends::INTERCEPT()
732	*
733	* @param mixed[] $yValues Data Series Y
734	* @param mixed[] $xValues Data Series X
735	*
736	* @return float\|string
737	*/
738	public static function INTERCEPT($yValues, $xValues)
739	{
740	return Trends::INTERCEPT($yValues, $xValues);
741	}
742
743	/**
744	* KURT.
745	*
746	* Returns the kurtosis of a data set. Kurtosis characterizes the relative peakedness
747	* or flatness of a distribution compared with the normal distribution. Positive
748	* kurtosis indicates a relatively peaked distribution. Negative kurtosis indicates a
749	* relatively flat distribution.
750	*
751	* @deprecated 1.18.0
752	* Use the kurtosis() method in the Statistical\Deviations class instead
753	* @see Statistical\Deviations::kurtosis()
754	*
755	* @param array ...$args Data Series
756	*
757	* @return float\|string
758	*/
759	public static function KURT(...$args)
760	{
761	return Statistical\Deviations::kurtosis(...$args);
762	}
763
764	/**
765	* LARGE.
766	*
767	* Returns the nth largest value in a data set. You can use this function to
768	* select a value based on its relative standing.
769	*
770	* Excel Function:
771	* LARGE(value1[,value2[, ...]],entry)
772	*
773	* @deprecated 1.18.0
774	* Use the large() method in the Statistical\Size class instead
775	* @see Statistical\Size::large()
776	*
777	* @param mixed $args Data values
778	*
779	* @return float\|string The result, or a string containing an error
780	*/
781	public static function LARGE(...$args)
782	{
783	return Statistical\Size::large(...$args);
784	}
785
786	/**
787	* LINEST.
788	*
789	* Calculates the statistics for a line by using the "least squares" method to calculate a straight line that best fits your data,
790	* and then returns an array that describes the line.
791	*
792	* @deprecated 1.18.0
793	* Use the LINEST() method in the Statistical\Trends class instead
794	* @see Statistical\Trends::LINEST()
795	*
796	* @param mixed[] $yValues Data Series Y
797	* @param null\|mixed[] $xValues Data Series X
798	* @param bool $const a logical value specifying whether to force the intersect to equal 0
799	* @param bool $stats a logical value specifying whether to return additional regression statistics
800	*
801	* @return array\|int\|string The result, or a string containing an error
802	*/
803	public static function LINEST($yValues, $xValues = null, $const = true, $stats = false)
804	{
805	return Trends::LINEST($yValues, $xValues, $const, $stats);
806	}
807
808	/**
809	* LOGEST.
810	*
811	* Calculates an exponential curve that best fits the X and Y data series,
812	* and then returns an array that describes the line.
813	*
814	* @deprecated 1.18.0
815	* Use the LOGEST() method in the Statistical\Trends class instead
816	* @see Statistical\Trends::LOGEST()
817	*
818	* @param mixed[] $yValues Data Series Y
819	* @param null\|mixed[] $xValues Data Series X
820	* @param bool $const a logical value specifying whether to force the intersect to equal 0
821	* @param bool $stats a logical value specifying whether to return additional regression statistics
822	*
823	* @return array\|int\|string The result, or a string containing an error
824	*/
825	public static function LOGEST($yValues, $xValues = null, $const = true, $stats = false)
826	{
827	return Trends::LOGEST($yValues, $xValues, $const, $stats);
828	}
829
830	/**
831	* LOGINV.
832	*
833	* Returns the inverse of the normal cumulative distribution
834	*
835	* @deprecated 1.18.0
836	* Use the inverse() method in the Statistical\Distributions\LogNormal class instead
837	* @see Statistical\Distributions\LogNormal::inverse()
838	*
839	* @param float $probability
840	* @param float $mean
841	* @param float $stdDev
842	*
843	* @return array\|float\|string The result, or a string containing an error
844	*
845	* @TODO Try implementing P J Acklam's refinement algorithm for greater
846	* accuracy if I can get my head round the mathematics
847	* (as described at) http://home.online.no/~pjacklam/notes/invnorm/
848	*/
849	public static function LOGINV($probability, $mean, $stdDev)
850	{
851	return Statistical\Distributions\LogNormal::inverse($probability, $mean, $stdDev);
852	}
853
854	/**
855	* LOGNORMDIST.
856	*
857	* Returns the cumulative lognormal distribution of x, where ln(x) is normally distributed
858	* with parameters mean and standard_dev.
859	*
860	* @deprecated 1.18.0
861	* Use the cumulative() method in the Statistical\Distributions\LogNormal class instead
862	* @see Statistical\Distributions\LogNormal::cumulative()
863	*
864	* @param float $value
865	* @param float $mean
866	* @param float $stdDev
867	*
868	* @return array\|float\|string The result, or a string containing an error
869	*/
870	public static function LOGNORMDIST($value, $mean, $stdDev)
871	{
872	return Statistical\Distributions\LogNormal::cumulative($value, $mean, $stdDev);
873	}
874
875	/**
876	* LOGNORM.DIST.
877	*
878	* Returns the lognormal distribution of x, where ln(x) is normally distributed
879	* with parameters mean and standard_dev.
880	*
881	* @deprecated 1.18.0
882	* Use the distribution() method in the Statistical\Distributions\LogNormal class instead
883	* @see Statistical\Distributions\LogNormal::distribution()
884	*
885	* @param float $value
886	* @param float $mean
887	* @param float $stdDev
888	* @param bool $cumulative
889	*
890	* @return array\|float\|string The result, or a string containing an error
891	*/
892	public static function LOGNORMDIST2($value, $mean, $stdDev, $cumulative = false)
893	{
894	return Statistical\Distributions\LogNormal::distribution($value, $mean, $stdDev, $cumulative);
895	}
896
897	/**
898	* MAX.
899	*
900	* MAX returns the value of the element of the values passed that has the highest value,
901	* with negative numbers considered smaller than positive numbers.
902	*
903	* Excel Function:
904	* max(value1[,value2[, ...]])
905	*
906	* @deprecated 1.17.0
907	* Use the MAX() method in the Statistical\Maximum class instead
908	* @see Statistical\Maximum::max()
909	*
910	* @param mixed ...$args Data values
911	*
912	* @return float
913	*/
914	public static function MAX(...$args)
915	{
916	return Maximum::max(...$args);
917	}
918
919	/**
920	* MAXA.
921	*
922	* Returns the greatest value in a list of arguments, including numbers, text, and logical values
923	*
924	* Excel Function:
925	* maxA(value1[,value2[, ...]])
926	*
927	* @deprecated 1.17.0
928	* Use the MAXA() method in the Statistical\Maximum class instead
929	* @see Statistical\Maximum::maxA()
930	*
931	* @param mixed ...$args Data values
932	*
933	* @return float
934	*/
935	public static function MAXA(...$args)
936	{
937	return Maximum::maxA(...$args);
938	}
939
940	/**
941	* MAXIFS.
942	*
943	* Counts the maximum value within a range of cells that contain numbers within the list of arguments
944	*
945	* Excel Function:
946	* MAXIFS(max_range, criteria_range1, criteria1, [criteria_range2, criteria2], ...)
947	*
948	* @deprecated 1.17.0
949	* Use the MAXIFS() method in the Statistical\Conditional class instead
950	* @see Statistical\Conditional::MAXIFS()
951	*
952	* @param mixed $args Data range and criterias
953	*
954	* @return null\|float\|string
955	*/
956	public static function MAXIFS(...$args)
957	{
958	return Conditional::MAXIFS(...$args);
959	}
960
961	/**
962	* MEDIAN.
963	*
964	* Returns the median of the given numbers. The median is the number in the middle of a set of numbers.
965	*
966	* Excel Function:
967	* MEDIAN(value1[,value2[, ...]])
968	*
969	* @deprecated 1.18.0
970	* Use the median() method in the Statistical\Averages class instead
971	* @see Statistical\Averages::median()
972	*
973	* @param mixed ...$args Data values
974	*
975	* @return float\|string The result, or a string containing an error
976	*/
977	public static function MEDIAN(...$args)
978	{
979	return Statistical\Averages::median(...$args);
980	}
981
982	/**
983	* MIN.
984	*
985	* MIN returns the value of the element of the values passed that has the smallest value,
986	* with negative numbers considered smaller than positive numbers.
987	*
988	* Excel Function:
989	* MIN(value1[,value2[, ...]])
990	*
991	* @deprecated 1.17.0
992	* Use the min() method in the Statistical\Minimum class instead
993	* @see Statistical\Minimum::min()
994	*
995	* @param mixed ...$args Data values
996	*
997	* @return float
998	*/
999	public static function MIN(...$args)
1000	{
1001	return Minimum::min(...$args);
1002	}
1003
1004	/**
1005	* MINA.
1006	*
1007	* Returns the smallest value in a list of arguments, including numbers, text, and logical values
1008	*
1009	* Excel Function:
1010	* MINA(value1[,value2[, ...]])
1011	*
1012	* @deprecated 1.17.0
1013	* Use the minA() method in the Statistical\Minimum class instead
1014	* @see Statistical\Minimum::minA()
1015	*
1016	* @param mixed ...$args Data values
1017	*
1018	* @return float
1019	*/
1020	public static function MINA(...$args)
1021	{
1022	return Minimum::minA(...$args);
1023	}
1024
1025	/**
1026	* MINIFS.
1027	*
1028	* Returns the minimum value within a range of cells that contain numbers within the list of arguments
1029	*
1030	* Excel Function:
1031	* MINIFS(min_range, criteria_range1, criteria1, [criteria_range2, criteria2], ...)
1032	*
1033	* @deprecated 1.17.0
1034	* Use the MINIFS() method in the Statistical\Conditional class instead
1035	* @see Statistical\Conditional::MINIFS()
1036	*
1037	* @param mixed $args Data range and criterias
1038	*
1039	* @return null\|float\|string
1040	*/
1041	public static function MINIFS(...$args)
1042	{
1043	return Conditional::MINIFS(...$args);
1044	}
1045
1046	/**
1047	* MODE.
1048	*
1049	* Returns the most frequently occurring, or repetitive, value in an array or range of data
1050	*
1051	* Excel Function:
1052	* MODE(value1[,value2[, ...]])
1053	*
1054	* @deprecated 1.18.0
1055	* Use the mode() method in the Statistical\Averages class instead
1056	* @see Statistical\Averages::mode()
1057	*
1058	* @param mixed ...$args Data values
1059	*
1060	* @return float\|string The result, or a string containing an error
1061	*/
1062	public static function MODE(...$args)
1063	{
1064	return Statistical\Averages::mode(...$args);
1065	}
1066
1067	/**
1068	* NEGBINOMDIST.
1069	*
1070	* Returns the negative binomial distribution. NEGBINOMDIST returns the probability that
1071	* there will be number_f failures before the number_s-th success, when the constant
1072	* probability of a success is probability_s. This function is similar to the binomial
1073	* distribution, except that the number of successes is fixed, and the number of trials is
1074	* variable. Like the binomial, trials are assumed to be independent.
1075	*
1076	* @deprecated 1.18.0
1077	* Use the negative() method in the Statistical\Distributions\Binomial class instead
1078	* @see Statistical\Distributions\Binomial::negative()
1079	*
1080	* @param mixed $failures Number of Failures
1081	* @param mixed $successes Threshold number of Successes
1082	* @param mixed $probability Probability of success on each trial
1083	*
1084	* @return array\|float\|string The result, or a string containing an error
1085	*/
1086	public static function NEGBINOMDIST($failures, $successes, $probability)
1087	{
1088	return Statistical\Distributions\Binomial::negative($failures, $successes, $probability);
1089	}
1090
1091	/**
1092	* NORMDIST.
1093	*
1094	* Returns the normal distribution for the specified mean and standard deviation. This
1095	* function has a very wide range of applications in statistics, including hypothesis
1096	* testing.
1097	*
1098	* @deprecated 1.18.0
1099	* Use the distribution() method in the Statistical\Distributions\Normal class instead
1100	* @see Statistical\Distributions\Normal::distribution()
1101	*
1102	* @param mixed $value
1103	* @param mixed $mean Mean Value
1104	* @param mixed $stdDev Standard Deviation
1105	* @param mixed $cumulative
1106	*
1107	* @return array\|float\|string The result, or a string containing an error
1108	*/
1109	public static function NORMDIST($value, $mean, $stdDev, $cumulative)
1110	{
1111	return Statistical\Distributions\Normal::distribution($value, $mean, $stdDev, $cumulative);
1112	}
1113
1114	/**
1115	* NORMINV.
1116	*
1117	* Returns the inverse of the normal cumulative distribution for the specified mean and standard deviation.
1118	*
1119	* @deprecated 1.18.0
1120	* Use the inverse() method in the Statistical\Distributions\Normal class instead
1121	* @see Statistical\Distributions\Normal::inverse()
1122	*
1123	* @param mixed $probability
1124	* @param mixed $mean Mean Value
1125	* @param mixed $stdDev Standard Deviation
1126	*
1127	* @return array\|float\|string The result, or a string containing an error
1128	*/
1129	public static function NORMINV($probability, $mean, $stdDev)
1130	{
1131	return Statistical\Distributions\Normal::inverse($probability, $mean, $stdDev);
1132	}
1133
1134	/**
1135	* NORMSDIST.
1136	*
1137	* Returns the standard normal cumulative distribution function. The distribution has
1138	* a mean of 0 (zero) and a standard deviation of one. Use this function in place of a
1139	* table of standard normal curve areas.
1140	*
1141	* @deprecated 1.18.0
1142	* Use the cumulative() method in the Statistical\Distributions\StandardNormal class instead
1143	* @see Statistical\Distributions\StandardNormal::cumulative()
1144	*
1145	* @param mixed $value
1146	*
1147	* @return array\|float\|string The result, or a string containing an error
1148	*/
1149	public static function NORMSDIST($value)
1150	{
1151	return Statistical\Distributions\StandardNormal::cumulative($value);
1152	}
1153
1154	/**
1155	* NORM.S.DIST.
1156	*
1157	* Returns the standard normal cumulative distribution function. The distribution has
1158	* a mean of 0 (zero) and a standard deviation of one. Use this function in place of a
1159	* table of standard normal curve areas.
1160	*
1161	* @deprecated 1.18.0
1162	* Use the distribution() method in the Statistical\Distributions\StandardNormal class instead
1163	* @see Statistical\Distributions\StandardNormal::distribution()
1164	*
1165	* @param mixed $value
1166	* @param mixed $cumulative
1167	*
1168	* @return array\|float\|string The result, or a string containing an error
1169	*/
1170	public static function NORMSDIST2($value, $cumulative)
1171	{
1172	return Statistical\Distributions\StandardNormal::distribution($value, $cumulative);
1173	}
1174
1175	/**
1176	* NORMSINV.
1177	*
1178	* Returns the inverse of the standard normal cumulative distribution
1179	*
1180	* @deprecated 1.18.0
1181	* Use the inverse() method in the Statistical\Distributions\StandardNormal class instead
1182	* @see Statistical\Distributions\StandardNormal::inverse()
1183	*
1184	* @param mixed $value
1185	*
1186	* @return array\|float\|string The result, or a string containing an error
1187	*/
1188	public static function NORMSINV($value)
1189	{
1190	return Statistical\Distributions\StandardNormal::inverse($value);
1191	}
1192
1193	/**
1194	* PERCENTILE.
1195	*
1196	* Returns the nth percentile of values in a range..
1197	*
1198	* Excel Function:
1199	* PERCENTILE(value1[,value2[, ...]],entry)
1200	*
1201	* @deprecated 1.18.0
1202	* Use the PERCENTILE() method in the Statistical\Percentiles class instead
1203	* @see Statistical\Percentiles::PERCENTILE()
1204	*
1205	* @param mixed $args Data values
1206	*
1207	* @return float\|string The result, or a string containing an error
1208	*/
1209	public static function PERCENTILE(...$args)
1210	{
1211	return Statistical\Percentiles::PERCENTILE(...$args);
1212	}
1213
1214	/**
1215	* PERCENTRANK.
1216	*
1217	* Returns the rank of a value in a data set as a percentage of the data set.
1218	* Note that the returned rank is simply rounded to the appropriate significant digits,
1219	* rather than floored (as MS Excel), so value 3 for a value set of 1, 2, 3, 4 will return
1220	* 0.667 rather than 0.666
1221	*
1222	* @deprecated 1.18.0
1223	* Use the PERCENTRANK() method in the Statistical\Percentiles class instead
1224	* @see Statistical\Percentiles::PERCENTRANK()
1225	*
1226	* @param mixed $valueSet An array of, or a reference to, a list of numbers
1227	* @param mixed $value the number whose rank you want to find
1228	* @param mixed $significance the number of significant digits for the returned percentage value
1229	*
1230	* @return float\|string (string if result is an error)
1231	*/
1232	public static function PERCENTRANK($valueSet, $value, $significance = 3)
1233	{
1234	return Statistical\Percentiles::PERCENTRANK($valueSet, $value, $significance);
1235	}
1236
1237	/**
1238	* PERMUT.
1239	*
1240	* Returns the number of permutations for a given number of objects that can be
1241	* selected from number objects. A permutation is any set or subset of objects or
1242	* events where internal order is significant. Permutations are different from
1243	* combinations, for which the internal order is not significant. Use this function
1244	* for lottery-style probability calculations.
1245	*
1246	* @deprecated 1.17.0
1247	* Use the PERMUT() method in the Statistical\Permutations class instead
1248	* @see Statistical\Permutations::PERMUT()
1249	*
1250	* @param int $numObjs Number of different objects
1251	* @param int $numInSet Number of objects in each permutation
1252	*
1253	* @return array\|float\|int\|string Number of permutations, or a string containing an error
1254	*/
1255	public static function PERMUT($numObjs, $numInSet)
1256	{
1257	return Permutations::PERMUT($numObjs, $numInSet);
1258	}
1259
1260	/**
1261	* POISSON.
1262	*
1263	* Returns the Poisson distribution. A common application of the Poisson distribution
1264	* is predicting the number of events over a specific time, such as the number of
1265	* cars arriving at a toll plaza in 1 minute.
1266	*
1267	* @deprecated 1.18.0
1268	* Use the distribution() method in the Statistical\Distributions\Poisson class instead
1269	* @see Statistical\Distributions\Poisson::distribution()
1270	*
1271	* @param mixed $value
1272	* @param mixed $mean Mean Value
1273	* @param mixed $cumulative
1274	*
1275	* @return array\|float\|string The result, or a string containing an error
1276	*/
1277	public static function POISSON($value, $mean, $cumulative)
1278	{
1279	return Statistical\Distributions\Poisson::distribution($value, $mean, $cumulative);
1280	}
1281
1282	/**
1283	* QUARTILE.
1284	*
1285	* Returns the quartile of a data set.
1286	*
1287	* Excel Function:
1288	* QUARTILE(value1[,value2[, ...]],entry)
1289	*
1290	* @deprecated 1.18.0
1291	* Use the QUARTILE() method in the Statistical\Percentiles class instead
1292	* @see Statistical\Percentiles::QUARTILE()
1293	*
1294	* @param mixed $args Data values
1295	*
1296	* @return float\|string The result, or a string containing an error
1297	*/
1298	public static function QUARTILE(...$args)
1299	{
1300	return Statistical\Percentiles::QUARTILE(...$args);
1301	}
1302
1303	/**
1304	* RANK.
1305	*
1306	* Returns the rank of a number in a list of numbers.
1307	*
1308	* @deprecated 1.18.0
1309	* Use the RANK() method in the Statistical\Percentiles class instead
1310	* @see Statistical\Percentiles::RANK()
1311	*
1312	* @param mixed $value the number whose rank you want to find
1313	* @param mixed $valueSet An array of, or a reference to, a list of numbers
1314	* @param mixed $order Order to sort the values in the value set
1315	*
1316	* @return float\|string The result, or a string containing an error
1317	*/
1318	public static function RANK($value, $valueSet, $order = 0)
1319	{
1320	return Statistical\Percentiles::RANK($value, $valueSet, $order);
1321	}
1322
1323	/**
1324	* RSQ.
1325	*
1326	* Returns the square of the Pearson product moment correlation coefficient through data points in known_y's and known_x's.
1327	*
1328	* @deprecated 1.18.0
1329	* Use the RSQ() method in the Statistical\Trends class instead
1330	* @see Statistical\Trends::RSQ()
1331	*
1332	* @param mixed[] $yValues Data Series Y
1333	* @param mixed[] $xValues Data Series X
1334	*
1335	* @return float\|string The result, or a string containing an error
1336	*/
1337	public static function RSQ($yValues, $xValues)
1338	{
1339	return Trends::RSQ($yValues, $xValues);
1340	}
1341
1342	/**
1343	* SKEW.
1344	*
1345	* Returns the skewness of a distribution. Skewness characterizes the degree of asymmetry
1346	* of a distribution around its mean. Positive skewness indicates a distribution with an
1347	* asymmetric tail extending toward more positive values. Negative skewness indicates a
1348	* distribution with an asymmetric tail extending toward more negative values.
1349	*
1350	* @deprecated 1.18.0
1351	* Use the skew() method in the Statistical\Deviations class instead
1352	* @see Statistical\Deviations::skew()
1353	*
1354	* @param array ...$args Data Series
1355	*
1356	* @return float\|string The result, or a string containing an error
1357	*/
1358	public static function SKEW(...$args)
1359	{
1360	return Statistical\Deviations::skew(...$args);
1361	}
1362
1363	/**
1364	* SLOPE.
1365	*
1366	* Returns the slope of the linear regression line through data points in known_y's and known_x's.
1367	*
1368	* @deprecated 1.18.0
1369	* Use the SLOPE() method in the Statistical\Trends class instead
1370	* @see Statistical\Trends::SLOPE()
1371	*
1372	* @param mixed[] $yValues Data Series Y
1373	* @param mixed[] $xValues Data Series X
1374	*
1375	* @return float\|string The result, or a string containing an error
1376	*/
1377	public static function SLOPE($yValues, $xValues)
1378	{
1379	return Trends::SLOPE($yValues, $xValues);
1380	}
1381
1382	/**
1383	* SMALL.
1384	*
1385	* Returns the nth smallest value in a data set. You can use this function to
1386	* select a value based on its relative standing.
1387	*
1388	* Excel Function:
1389	* SMALL(value1[,value2[, ...]],entry)
1390	*
1391	* @deprecated 1.18.0
1392	* Use the small() method in the Statistical\Size class instead
1393	* @see Statistical\Size::small()
1394	*
1395	* @param mixed $args Data values
1396	*
1397	* @return float\|string The result, or a string containing an error
1398	*/
1399	public static function SMALL(...$args)
1400	{
1401	return Statistical\Size::small(...$args);
1402	}
1403
1404	/**
1405	* STANDARDIZE.
1406	*
1407	* Returns a normalized value from a distribution characterized by mean and standard_dev.
1408	*
1409	* @deprecated 1.18.0
1410	* Use the execute() method in the Statistical\Standardize class instead
1411	* @see Statistical\Standardize::execute()
1412	*
1413	* @param float $value Value to normalize
1414	* @param float $mean Mean Value
1415	* @param float $stdDev Standard Deviation
1416	*
1417	* @return array\|float\|string Standardized value, or a string containing an error
1418	*/
1419	public static function STANDARDIZE($value, $mean, $stdDev)
1420	{
1421	return Statistical\Standardize::execute($value, $mean, $stdDev);
1422	}
1423
1424	/**
1425	* STDEV.
1426	*
1427	* Estimates standard deviation based on a sample. The standard deviation is a measure of how
1428	* widely values are dispersed from the average value (the mean).
1429	*
1430	* Excel Function:
1431	* STDEV(value1[,value2[, ...]])
1432	*
1433	* @deprecated 1.17.0
1434	* Use the STDEV() method in the Statistical\StandardDeviations class instead
1435	* @see Statistical\StandardDeviations::STDEV()
1436	*
1437	* @param mixed ...$args Data values
1438	*
1439	* @return float\|string The result, or a string containing an error
1440	*/
1441	public static function STDEV(...$args)
1442	{
1443	return StandardDeviations::STDEV(...$args);
1444	}
1445
1446	/**
1447	* STDEVA.
1448	*
1449	* Estimates standard deviation based on a sample, including numbers, text, and logical values
1450	*
1451	* Excel Function:
1452	* STDEVA(value1[,value2[, ...]])
1453	*
1454	* @deprecated 1.17.0
1455	* Use the STDEVA() method in the Statistical\StandardDeviations class instead
1456	* @see Statistical\StandardDeviations::STDEVA()
1457	*
1458	* @param mixed ...$args Data values
1459	*
1460	* @return float\|string
1461	*/
1462	public static function STDEVA(...$args)
1463	{
1464	return StandardDeviations::STDEVA(...$args);
1465	}
1466
1467	/**
1468	* STDEVP.
1469	*
1470	* Calculates standard deviation based on the entire population
1471	*
1472	* Excel Function:
1473	* STDEVP(value1[,value2[, ...]])
1474	*
1475	* @deprecated 1.17.0
1476	* Use the STDEVP() method in the Statistical\StandardDeviations class instead
1477	* @see Statistical\StandardDeviations::STDEVP()
1478	*
1479	* @param mixed ...$args Data values
1480	*
1481	* @return float\|string
1482	*/
1483	public static function STDEVP(...$args)
1484	{
1485	return StandardDeviations::STDEVP(...$args);
1486	}
1487
1488	/**
1489	* STDEVPA.
1490	*
1491	* Calculates standard deviation based on the entire population, including numbers, text, and logical values
1492	*
1493	* Excel Function:
1494	* STDEVPA(value1[,value2[, ...]])
1495	*
1496	* @deprecated 1.17.0
1497	* Use the STDEVPA() method in the Statistical\StandardDeviations class instead
1498	* @see Statistical\StandardDeviations::STDEVPA()
1499	*
1500	* @param mixed ...$args Data values
1501	*
1502	* @return float\|string
1503	*/
1504	public static function STDEVPA(...$args)
1505	{
1506	return StandardDeviations::STDEVPA(...$args);
1507	}
1508
1509	/**
1510	* STEYX.
1511	*
1512	* @deprecated 1.18.0
1513	* Use the STEYX() method in the Statistical\Trends class instead
1514	* @see Statistical\Trends::STEYX()
1515	*
1516	* Returns the standard error of the predicted y-value for each x in the regression.
1517	*
1518	* @param mixed[] $yValues Data Series Y
1519	* @param mixed[] $xValues Data Series X
1520	*
1521	* @return float\|string
1522	*/
1523	public static function STEYX($yValues, $xValues)
1524	{
1525	return Trends::STEYX($yValues, $xValues);
1526	}
1527
1528	/**
1529	* TDIST.
1530	*
1531	* Returns the probability of Student's T distribution.
1532	*
1533	* @deprecated 1.18.0
1534	* Use the distribution() method in the Statistical\Distributions\StudentT class instead
1535	* @see Statistical\Distributions\StudentT::distribution()
1536	*
1537	* @param float $value Value for the function
1538	* @param float $degrees degrees of freedom
1539	* @param float $tails number of tails (1 or 2)
1540	*
1541	* @return array\|float\|string The result, or a string containing an error
1542	*/
1543	public static function TDIST($value, $degrees, $tails)
1544	{
1545	return Statistical\Distributions\StudentT::distribution($value, $degrees, $tails);
1546	}
1547
1548	/**
1549	* TINV.
1550	*
1551	* Returns the one-tailed probability of the Student-T distribution.
1552	*
1553	* @deprecated 1.18.0
1554	* Use the inverse() method in the Statistical\Distributions\StudentT class instead
1555	* @see Statistical\Distributions\StudentT::inverse()
1556	*
1557	* @param float $probability Probability for the function
1558	* @param float $degrees degrees of freedom
1559	*
1560	* @return array\|float\|string The result, or a string containing an error
1561	*/
1562	public static function TINV($probability, $degrees)
1563	{
1564	return Statistical\Distributions\StudentT::inverse($probability, $degrees);
1565	}
1566
1567	/**
1568	* TREND.
1569	*
1570	* Returns values along a linear Trend
1571	*
1572	* @deprecated 1.18.0
1573	* Use the TREND() method in the Statistical\Trends class instead
1574	* @see Statistical\Trends::TREND()
1575	*
1576	* @param mixed[] $yValues Data Series Y
1577	* @param mixed[] $xValues Data Series X
1578	* @param mixed[] $newValues Values of X for which we want to find Y
1579	* @param bool $const a logical value specifying whether to force the intersect to equal 0
1580	*
1581	* @return float[]
1582	*/
1583	public static function TREND($yValues, $xValues = [], $newValues = [], $const = true)
1584	{
1585	return Trends::TREND($yValues, $xValues, $newValues, $const);
1586	}
1587
1588	/**
1589	* TRIMMEAN.
1590	*
1591	* Returns the mean of the interior of a data set. TRIMMEAN calculates the mean
1592	* taken by excluding a percentage of data points from the top and bottom tails
1593	* of a data set.
1594	*
1595	* Excel Function:
1596	* TRIMEAN(value1[,value2[, ...]], $discard)
1597	*
1598	* @deprecated 1.18.0
1599	* Use the trim() method in the Statistical\Averages\Mean class instead
1600	* @see Statistical\Averages\Mean::trim()
1601	*
1602	* @param mixed $args Data values
1603	*
1604	* @return float\|string
1605	*/
1606	public static function TRIMMEAN(...$args)
1607	{
1608	return Statistical\Averages\Mean::trim(...$args);
1609	}
1610
1611	/**
1612	* VARFunc.
1613	*
1614	* Estimates variance based on a sample.
1615	*
1616	* Excel Function:
1617	* VAR(value1[,value2[, ...]])
1618	*
1619	* @deprecated 1.17.0
1620	* Use the VAR() method in the Statistical\Variances class instead
1621	* @see Statistical\Variances::VAR()
1622	*
1623	* @param mixed ...$args Data values
1624	*
1625	* @return float\|string (string if result is an error)
1626	*/
1627	public static function VARFunc(...$args)
1628	{
1629	return Variances::VAR(...$args);
1630	}
1631
1632	/**
1633	* VARA.
1634	*
1635	* Estimates variance based on a sample, including numbers, text, and logical values
1636	*
1637	* Excel Function:
1638	* VARA(value1[,value2[, ...]])
1639	*
1640	* @deprecated 1.17.0
1641	* Use the VARA() method in the Statistical\Variances class instead
1642	* @see Statistical\Variances::VARA()
1643	*
1644	* @param mixed ...$args Data values
1645	*
1646	* @return float\|string (string if result is an error)
1647	*/
1648	public static function VARA(...$args)
1649	{
1650	return Variances::VARA(...$args);
1651	}
1652
1653	/**
1654	* VARP.
1655	*
1656	* Calculates variance based on the entire population
1657	*
1658	* Excel Function:
1659	* VARP(value1[,value2[, ...]])
1660	*
1661	* @deprecated 1.17.0
1662	* Use the VARP() method in the Statistical\Variances class instead
1663	* @see Statistical\Variances::VARP()
1664	*
1665	* @param mixed ...$args Data values
1666	*
1667	* @return float\|string (string if result is an error)
1668	*/
1669	public static function VARP(...$args)
1670	{
1671	return Variances::VARP(...$args);
1672	}
1673
1674	/**
1675	* VARPA.
1676	*
1677	* Calculates variance based on the entire population, including numbers, text, and logical values
1678	*
1679	* Excel Function:
1680	* VARPA(value1[,value2[, ...]])
1681	*
1682	* @deprecated 1.17.0
1683	* Use the VARPA() method in the Statistical\Variances class instead
1684	* @see Statistical\Variances::VARPA()
1685	*
1686	* @param mixed ...$args Data values
1687	*
1688	* @return float\|string (string if result is an error)
1689	*/
1690	public static function VARPA(...$args)
1691	{
1692	return Variances::VARPA(...$args);
1693	}
1694
1695	/**
1696	* WEIBULL.
1697	*
1698	* Returns the Weibull distribution. Use this distribution in reliability
1699	* analysis, such as calculating a device's mean time to failure.
1700	*
1701	* @deprecated 1.18.0
1702	* Use the distribution() method in the Statistical\Distributions\Weibull class instead
1703	* @see Statistical\Distributions\Weibull::distribution()
1704	*
1705	* @param float $value
1706	* @param float $alpha Alpha Parameter
1707	* @param float $beta Beta Parameter
1708	* @param bool $cumulative
1709	*
1710	* @return array\|float\|string (string if result is an error)
1711	*/
1712	public static function WEIBULL($value, $alpha, $beta, $cumulative)
1713	{
1714	return Statistical\Distributions\Weibull::distribution($value, $alpha, $beta, $cumulative);
1715	}
1716
1717	/**
1718	* ZTEST.
1719	*
1720	* Returns the one-tailed P-value of a z-test.
1721	*
1722	* For a given hypothesized population mean, x, Z.TEST returns the probability that the sample mean would be
1723	* greater than the average of observations in the data set (array) — that is, the observed sample mean.
1724	*
1725	* @deprecated 1.18.0
1726	* Use the zTest() method in the Statistical\Distributions\StandardNormal class instead
1727	* @see Statistical\Distributions\StandardNormal::zTest()
1728	*
1729	* @param mixed $dataSet
1730	* @param float $m0 Alpha Parameter
1731	* @param float $sigma Beta Parameter
1732	*
1733	* @return array\|float\|string (string if result is an error)
1734	*/
1735	public static function ZTEST($dataSet, $m0, $sigma = null)
1736	{
1737	return Statistical\Distributions\StandardNormal::zTest($dataSet, $m0, $sigma);
1738	}
1739	}
1740