You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
koffice/kspread/kspread_functions_statistic...

1244 lines
35 KiB

/* This file is part of the KDE project
Copyright (C) 1998-2002 The KSpread Team
www.koffice.org/kspread
Copyright (C) 2005 Tomas Mecir <mecirt@gmail.com>
This library is free software; you can redistribute it and/or
modify it under the terms of the GNU Library General Public
License as published by the Free Software Foundation; either
version 2 of the License.
This library is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
Library General Public License for more details.
You should have received a copy of the GNU Library General Public License
along with this library; see the file COPYING.LIB. If not, write to
the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
* Boston, MA 02110-1301, USA.
*/
// built-in statistical functions
#include "functions.h"
#include "valuecalc.h"
#include "valueconverter.h"
// needed for MODE
#include <qmap.h>
using namespace KSpread;
// prototypes (sorted!)
Value func_arrang (valVector args, ValueCalc *calc, FuncExtra *);
Value func_average (valVector args, ValueCalc *calc, FuncExtra *);
Value func_averagea (valVector args, ValueCalc *calc, FuncExtra *);
Value func_avedev (valVector args, ValueCalc *calc, FuncExtra *);
Value func_betadist (valVector args, ValueCalc *calc, FuncExtra *);
Value func_bino (valVector args, ValueCalc *calc, FuncExtra *);
Value func_chidist (valVector args, ValueCalc *calc, FuncExtra *);
Value func_combin (valVector args, ValueCalc *calc, FuncExtra *);
Value func_confidence (valVector args, ValueCalc *calc, FuncExtra *);
Value func_correl_pop (valVector args, ValueCalc *calc, FuncExtra *);
Value func_covar (valVector args, ValueCalc *calc, FuncExtra *);
Value func_devsq (valVector args, ValueCalc *calc, FuncExtra *);
Value func_devsqa (valVector args, ValueCalc *calc, FuncExtra *);
Value func_expondist (valVector args, ValueCalc *calc, FuncExtra *);
Value func_fdist (valVector args, ValueCalc *calc, FuncExtra *);
Value func_fisher (valVector args, ValueCalc *calc, FuncExtra *);
Value func_fisherinv (valVector args, ValueCalc *calc, FuncExtra *);
Value func_gammadist (valVector args, ValueCalc *calc, FuncExtra *);
Value func_gammaln (valVector args, ValueCalc *calc, FuncExtra *);
Value func_gauss (valVector args, ValueCalc *calc, FuncExtra *);
Value func_geomean (valVector args, ValueCalc *calc, FuncExtra *);
Value func_harmean (valVector args, ValueCalc *calc, FuncExtra *);
Value func_hypgeomdist (valVector args, ValueCalc *calc, FuncExtra *);
Value func_kurtosis_est (valVector args, ValueCalc *calc, FuncExtra *);
Value func_kurtosis_pop (valVector args, ValueCalc *calc, FuncExtra *);
Value func_large (valVector args, ValueCalc *calc, FuncExtra *);
Value func_loginv (valVector args, ValueCalc *calc, FuncExtra *);
Value func_lognormdist (valVector args, ValueCalc *calc, FuncExtra *);
Value func_median (valVector args, ValueCalc *calc, FuncExtra *);
Value func_mode (valVector args, ValueCalc *calc, FuncExtra *);
Value func_negbinomdist (valVector args, ValueCalc *calc, FuncExtra *);
Value func_normdist (valVector args, ValueCalc *calc, FuncExtra *);
Value func_norminv (valVector args, ValueCalc *calc, FuncExtra *);
Value func_normsinv (valVector args, ValueCalc *calc, FuncExtra *);
Value func_phi (valVector args, ValueCalc *calc, FuncExtra *);
Value func_poisson (valVector args, ValueCalc *calc, FuncExtra *);
Value func_skew_est (valVector args, ValueCalc *calc, FuncExtra *);
Value func_skew_pop (valVector args, ValueCalc *calc, FuncExtra *);
Value func_small (valVector args, ValueCalc *calc, FuncExtra *);
Value func_standardize (valVector args, ValueCalc *calc, FuncExtra *);
Value func_stddev (valVector args, ValueCalc *calc, FuncExtra *);
Value func_stddeva (valVector args, ValueCalc *calc, FuncExtra *);
Value func_stddevp (valVector args, ValueCalc *calc, FuncExtra *);
Value func_stddevpa (valVector args, ValueCalc *calc, FuncExtra *);
Value func_stdnormdist (valVector args, ValueCalc *calc, FuncExtra *);
Value func_sumproduct (valVector args, ValueCalc *calc, FuncExtra *);
Value func_sumx2py2 (valVector args, ValueCalc *calc, FuncExtra *);
Value func_sumx2my2 (valVector args, ValueCalc *calc, FuncExtra *);
Value func_sumxmy2 (valVector args, ValueCalc *calc, FuncExtra *);
Value func_tdist (valVector args, ValueCalc *calc, FuncExtra *);
Value func_variance (valVector args, ValueCalc *calc, FuncExtra *);
Value func_variancea (valVector args, ValueCalc *calc, FuncExtra *);
Value func_variancep (valVector args, ValueCalc *calc, FuncExtra *);
Value func_variancepa (valVector args, ValueCalc *calc, FuncExtra *);
Value func_weibull (valVector args, ValueCalc *calc, FuncExtra *);
typedef QValueList<double> List;
// registers all statistical functions
void RegisterStatisticalFunctions()
{
FunctionRepository* repo = FunctionRepository::self();
Function *f;
f = new Function ("AVEDEV", func_avedev);
f->setParamCount (1, -1);
f->setAcceptArray ();
repo->add (f);
f = new Function ("AVERAGE", func_average);
f->setParamCount (1, -1);
f->setAcceptArray ();
repo->add (f);
f = new Function ("AVERAGEA", func_averagea);
f->setParamCount (1, -1);
f->setAcceptArray ();
repo->add (f);
f = new Function ("BETADIST", func_betadist);
f->setParamCount (3, 5);
repo->add (f);
f = new Function ("BINO", func_bino);
f->setParamCount (3);
repo->add (f);
f = new Function ("CHIDIST", func_chidist);
f->setParamCount (2);
repo->add (f);
f = new Function ("COMBIN", func_combin);
f->setParamCount (2);
repo->add (f);
f = new Function ("CONFIDENCE", func_confidence);
f->setParamCount (3);
repo->add (f);
f = new Function ("CORREL", func_correl_pop);
f->setParamCount (2);
f->setAcceptArray ();
repo->add (f);
f = new Function ("COVAR", func_covar);
f->setParamCount (2);
f->setAcceptArray ();
repo->add (f);
f = new Function ("DEVSQ", func_devsq);
f->setParamCount (1, -1);
f->setAcceptArray ();
repo->add (f);
f = new Function ("DEVSQA", func_devsqa);
f->setParamCount (1, -1);
f->setAcceptArray ();
repo->add (f);
f = new Function ("EXPONDIST", func_expondist);
f->setParamCount (3);
repo->add (f);
f = new Function ("FDIST", func_fdist);
f->setParamCount (3);
repo->add (f);
f = new Function ("FISHER", func_fisher);
repo->add (f);
f = new Function ("FISHERINV", func_fisherinv);
repo->add (f);
f = new Function ("GAMMADIST", func_gammadist);
f->setParamCount (4);
repo->add (f);
f = new Function ("GAMMALN", func_gammaln);
repo->add (f);
f = new Function ("GAUSS", func_gauss);
repo->add (f);
f = new Function ("GEOMEAN", func_geomean);
f->setParamCount (1, -1);
f->setAcceptArray ();
repo->add (f);
f = new Function ("HARMEAN", func_harmean);
f->setParamCount (1, -1);
f->setAcceptArray ();
repo->add (f);
f = new Function ("HYPGEOMDIST", func_hypgeomdist);
f->setParamCount (4);
repo->add (f);
f = new Function ("INVBINO", func_bino); // same as BINO, for 1.4 compat
repo->add (f);
f = new Function ("KURT", func_kurtosis_est);
f->setParamCount (1, -1);
f->setAcceptArray ();
repo->add (f);
f = new Function ("KURTP", func_kurtosis_pop);
f->setParamCount (1, -1);
f->setAcceptArray ();
repo->add (f);
f = new Function ("LARGE", func_large);
f->setParamCount (2);
f->setAcceptArray ();
repo->add (f);
f = new Function ("LOGINV", func_loginv);
f->setParamCount (3);
repo->add (f);
f = new Function ("LOGNORMDIST", func_lognormdist);
f->setParamCount (3);
repo->add (f);
f = new Function ("MEDIAN", func_median);
f->setParamCount (1, -1);
f->setAcceptArray ();
repo->add (f);
f = new Function ("MODE", func_mode);
f->setParamCount (1, -1);
f->setAcceptArray ();
repo->add (f);
f = new Function ("NEGBINOMDIST", func_negbinomdist);
f->setParamCount (3);
repo->add (f);
f = new Function ("NORMDIST", func_normdist);
f->setParamCount (4);
repo->add (f);
f = new Function ("NORMINV", func_norminv);
f->setParamCount (3);
repo->add (f);
f = new Function ("NORMSDIST", func_stdnormdist);
repo->add (f);
f = new Function ("NORMSINV", func_normsinv);
repo->add (f);
f = new Function ("PEARSON", func_correl_pop);
f->setParamCount (2);
f->setAcceptArray ();
repo->add (f);
f = new Function ("PERMUT", func_arrang);
f->setParamCount (2);
repo->add (f);
f = new Function ("PHI", func_phi);
repo->add (f);
f = new Function ("POISSON", func_poisson);
f->setParamCount (3);
repo->add (f);
f = new Function ("SKEW", func_skew_est);
f->setParamCount (1, -1);
f->setAcceptArray ();
repo->add (f);
f = new Function ("SKEWP", func_skew_pop);
f->setParamCount (1, -1);
f->setAcceptArray ();
repo->add (f);
f = new Function ("SMALL", func_small);
f->setParamCount (2);
f->setAcceptArray ();
repo->add (f);
f = new Function ("STANDARDIZE", func_standardize);
f->setParamCount (3);
repo->add (f);
f = new Function ("STDEV", func_stddev);
f->setParamCount (1, -1);
f->setAcceptArray ();
repo->add (f);
f = new Function ("STDEVA", func_stddeva);
f->setParamCount (1, -1);
f->setAcceptArray ();
repo->add (f);
f = new Function ("STDEVP", func_stddevp);
f->setParamCount (1, -1);
f->setAcceptArray ();
repo->add (f);
f = new Function ("STDEVPA", func_stddevpa);
f->setParamCount (1, -1);
f->setAcceptArray ();
repo->add (f);
f = new Function ("SUM2XMY", func_sumxmy2);
f->setParamCount (2);
f->setAcceptArray ();
repo->add (f);
f = new Function ("SUMPRODUCT", func_sumproduct);
f->setParamCount (2);
f->setAcceptArray ();
repo->add (f);
f = new Function ("SUMX2PY2", func_sumx2py2);
f->setParamCount (2);
f->setAcceptArray ();
repo->add (f);
f = new Function ("SUMX2MY2", func_sumx2my2);
f->setParamCount (2);
f->setAcceptArray ();
repo->add (f);
f = new Function ("TDIST", func_tdist);
f->setParamCount (3);
repo->add (f);
f = new Function ("VARIANCE", func_variance);
f->setParamCount (1, -1);
f->setAcceptArray ();
repo->add (f);
f = new Function ("VAR", func_variance);
f->setParamCount (1, -1);
f->setAcceptArray ();
repo->add (f);
f = new Function ("VARP", func_variancep);
f->setParamCount (1, -1);
f->setAcceptArray ();
repo->add (f);
f = new Function ("VARA", func_variancea);
f->setParamCount (1, -1);
f->setAcceptArray ();
repo->add (f);
f = new Function ("VARPA", func_variancepa);
f->setParamCount (1, -1);
f->setAcceptArray ();
repo->add (f);
f = new Function ("WEIBULL", func_weibull);
f->setParamCount (4);
repo->add (f);
}
// array-walk functions used in this file
void awSkew (ValueCalc *c, Value &res, Value val, Value p)
{
Value avg = p.element (0, 0);
Value stdev = p.element (1, 0);
// (val - avg) / stddev
Value d = c->div (c->sub (val, avg), stdev);
// res += d*d*d
res = c->add (res, c->mul (d, c->mul (d, d)));
}
void awSumInv (ValueCalc *c, Value &res, Value val, Value)
{
// res += 1/value
res = c->add (res, c->div (1.0, val));
}
void awAveDev (ValueCalc *c, Value &res, Value val,
Value p)
{
// res += abs (val - p)
res = c->add (res, c->abs (c->sub (val, p)));
}
void awKurtosis (ValueCalc *c, Value &res, Value val,
Value p)
{
Value avg = p.element (0, 0);
Value stdev = p.element (1, 0);
//d = (val - avg ) / stdev
Value d = c->div (c->sub (val, avg), stdev);
// res += d^4
res = c->add (res, c->pow (d, 4));
}
Value func_skew_est (valVector args, ValueCalc *calc, FuncExtra *)
{
int number = calc->count (args);
Value avg = calc->avg (args);
if (number < 3)
return Value::errorVALUE();
Value res = calc->stddev (args, avg);
if (res.isZero())
return Value::errorVALUE();
Value params (2, 1);
params.setElement (0, 0, avg);
params.setElement (1, 0, res);
Value tskew;
calc->arrayWalk (args, tskew, awSkew, params);
// ((tskew * number) / (number-1)) / (number-2)
return calc->div (calc->div (calc->mul (tskew, number), number-1), number-2);
}
Value func_skew_pop (valVector args, ValueCalc *calc, FuncExtra *)
{
int number = calc->count (args);
Value avg = calc->avg (args);
if (number < 1)
return Value::errorVALUE();
Value res = calc->stddevP (args, avg);
if (res.isZero())
return Value::errorVALUE();
Value params (2, 1);
params.setElement (0, 0, avg);
params.setElement (1, 0, res);
Value tskew;
calc->arrayWalk (args, tskew, awSkew, params);
// tskew / number
return calc->div (tskew, number);
}
class ContentSheet : public QMap<double, int> {};
void func_mode_helper (Value range, ValueCalc *calc, ContentSheet &sh)
{
if (!range.isArray())
{
double d = calc->conv()->asFloat (range).asFloat();
sh[d]++;
return;
}
for (unsigned int row = 0; row < range.rows(); ++row)
for (unsigned int col = 0; col < range.columns(); ++col) {
Value v = range.element (col, row);
if (v.isArray())
func_mode_helper (v, calc, sh);
else {
double d = calc->conv()->asFloat (v).asFloat();
sh[d]++;
}
}
}
Value func_mode (valVector args, ValueCalc *calc, FuncExtra *)
{
// does NOT support anything other than doubles !!!
ContentSheet sh;
for (unsigned int i = 0; i < args.count(); ++i)
func_mode_helper (args[i], calc, sh);
// retrieve value with max.count
int maxcount = 0;
double max = 0.0;
ContentSheet::iterator it;
for (it = sh.begin(); it != sh.end(); ++it)
if (it.data() > maxcount) {
max = it.key();
maxcount = it.data();
}
return Value (max);
}
Value func_covar_helper (Value range1, Value range2,
ValueCalc *calc, Value avg1, Value avg2)
{
// two arrays -> cannot use arrayWalk
if ((!range1.isArray()) && (!range2.isArray()))
// (v1-E1)*(v2-E2)
return calc->mul (calc->sub (range1, avg1), calc->sub (range2, avg2));
int rows = range1.rows();
int cols = range1.columns();
int rows2 = range2.rows();
int cols2 = range2.columns();
if ((rows != rows2) || (cols != cols2))
return Value::errorVALUE();
Value result = 0.0;
for (int row = 0; row < rows; ++row)
for (int col = 0; col < cols; ++col) {
Value v1 = range1.element (col, row);
Value v2 = range2.element (col, row);
if (v1.isArray() || v2.isArray())
result = calc->add (result,
func_covar_helper (v1, v2, calc, avg1, avg2));
else
// result += (v1-E1)*(v2-E2)
result = calc->add (result, calc->mul (calc->sub (v1, avg1),
calc->sub (v2, avg2)));
}
return result;
}
Value func_covar (valVector args, ValueCalc *calc, FuncExtra *)
{
Value avg1 = calc->avg (args[0]);
Value avg2 = calc->avg (args[1]);
int number = calc->count (args[0]);
int number2 = calc->count (args[1]);
if (number2 <= 0 || number2 != number)
return Value::errorVALUE();
Value covar = func_covar_helper (args[0], args[1], calc, avg1, avg2);
return calc->div (covar, number);
}
Value func_correl_pop (valVector args, ValueCalc *calc, FuncExtra *)
{
Value covar = func_covar (args, calc, 0);
Value stdevp1 = calc->stddevP (args[0]);
Value stdevp2 = calc->stddevP (args[1]);
if (calc->isZero (stdevp1) || calc->isZero (stdevp2))
return Value::errorDIV0();
// covar / (stdevp1 * stdevp2)
return calc->div (covar, calc->mul (stdevp1, stdevp2));
}
void func_array_helper (Value range, ValueCalc *calc,
List &array, int &number)
{
if (!range.isArray())
{
array << calc->conv()->asFloat (range).asFloat();
++number;
return;
}
for (unsigned int row = 0; row < range.rows(); ++row)
for (unsigned int col = 0; col < range.columns(); ++col) {
Value v = range.element (col, row);
if (v.isArray ())
func_array_helper (v, calc, array, number);
else {
array << calc->conv()->asFloat (v).asFloat();
++number;
}
}
}
Value func_large (valVector args, ValueCalc *calc, FuncExtra *)
{
// does NOT support anything other than doubles !!!
int k = calc->conv()->asInteger (args[1]).asInteger();
if ( k < 1 )
return false;
List array;
int number = 1;
func_array_helper (args[0], calc, array, number);
if ( k > number )
return Value::errorVALUE();
qHeapSort (array);
double d = *array.at (number - k - 1);
return Value (d);
}
Value func_small (valVector args, ValueCalc *calc, FuncExtra *)
{
// does NOT support anything other than doubles !!!
int k = calc->conv()->asInteger (args[1]).asInteger();
if ( k < 1 )
return false;
List array;
int number = 1;
func_array_helper (args[0], calc, array, number);
if ( k > number )
return Value::errorVALUE();
qHeapSort (array);
double d = *array.at (k - 1);
return Value (d);
}
Value func_geomean (valVector args, ValueCalc *calc, FuncExtra *)
{
Value count = calc->count (args);
Value prod = calc->product (args, 1.0);
if (calc->isZero (count))
return Value::errorDIV0();
return calc->pow (prod, calc->div (1.0, count));
}
Value func_harmean (valVector args, ValueCalc *calc, FuncExtra *)
{
Value count = calc->count (args);
if (calc->isZero (count))
return Value::errorDIV0();
Value suminv;
calc->arrayWalk (args, suminv, awSumInv, 0);
return calc->div (suminv, count);
}
Value func_loginv (valVector args, ValueCalc *calc, FuncExtra *)
{
Value p = args[0];
Value m = args[1];
Value s = args[2];
if (calc->lower (p, 0) || calc->greater (p, 1))
return Value::errorVALUE();
if (!calc->greater (s, 0))
return Value::errorVALUE();
Value result = 0.0;
if (calc->equal (p, 1)) //p==1
result = Value::errorVALUE();
else if (calc->greater (p, 0)) { //p>0
Value gaussInv = calc->gaussinv (p);
// exp (gaussInv * s + m)
result = calc->exp (calc->add (calc->mul (s, gaussInv), m));
}
return result;
}
Value func_devsq (valVector args, ValueCalc *calc, FuncExtra *)
{
Value res;
calc->arrayWalk (args, res, calc->awFunc ("devsq"), calc->avg (args, false));
return res;
}
Value func_devsqa (valVector args, ValueCalc *calc, FuncExtra *)
{
Value res;
calc->arrayWalk (args, res, calc->awFunc ("devsqa"), calc->avg (args));
return res;
}
Value func_kurtosis_est (valVector args, ValueCalc *calc, FuncExtra *)
{
int count = calc->count (args);
if (count < 4)
return Value::errorVALUE();
Value avg = calc->avg (args);
Value devsq;
calc->arrayWalk (args, devsq, calc->awFunc ("devsqa"), avg);
if (devsq.isZero ())
return Value::errorDIV0();
Value params (2, 1);
params.setElement (0, 0, avg);
params.setElement (1, 0, devsq);
Value x4;
calc->arrayWalk (args, x4, awKurtosis, params);
double den = (double) (count - 2) * (count - 3);
double nth = (double) count * (count + 1) / ((count - 1) * den);
double t = 3.0 * (count - 1) * (count - 1) / den;
// res = x4 * nth - t
return calc->sub (calc->mul (x4, nth), t);
}
Value func_kurtosis_pop (valVector args, ValueCalc *calc, FuncExtra *)
{
int count = calc->count (args);
if (count < 4)
return Value::errorVALUE();
Value avg = calc->avg (args);
Value devsq;
calc->arrayWalk (args, devsq, calc->awFunc ("devsqa"), avg);
if (devsq.isZero ())
return Value::errorDIV0();
Value params (2, 1);
params.setElement (0, 0, avg);
params.setElement (1, 0, devsq);
Value x4;
calc->arrayWalk (args, x4, awKurtosis, params);
// x4 / count - 3
return calc->sub (calc->div (x4, count), 3);
}
Value func_standardize (valVector args, ValueCalc *calc, FuncExtra *)
{
Value x = args[0];
Value m = args[1];
Value s = args[2];
if (!calc->greater (s, 0)) // s must be >0
return Value::errorVALUE();
// (x - m) / s
return calc->div (calc->sub (x, m), s);
}
Value func_hypgeomdist (valVector args, ValueCalc *calc, FuncExtra *)
{
int x = calc->conv()->asInteger (args[0]).asInteger();
int n = calc->conv()->asInteger (args[1]).asInteger();
int M = calc->conv()->asInteger (args[2]).asInteger();
int N = calc->conv()->asInteger (args[3]).asInteger();
if ( x < 0 || n < 0 || M < 0 || N < 0 )
return Value::errorVALUE();
if ( x > M || n > N )
return Value::errorVALUE();
Value d1 = calc->combin (M, x);
Value d2 = calc->combin (N - M, n - x);
Value d3 = calc->combin (N, n);
// d1 * d2 / d3
return calc->div (calc->mul (d1, d2), d3);
}
Value func_negbinomdist (valVector args, ValueCalc *calc, FuncExtra *)
{
int x = calc->conv()->asInteger (args[0]).asInteger();
int r = calc->conv()->asInteger (args[1]).asInteger();
Value p = args[2];
if ((x + r - 1) <= 0)
return Value::errorVALUE();
if (calc->lower (p, 0) || calc->greater (p, 1))
return Value::errorVALUE();
Value d1 = calc->combin (x + r - 1, r - 1);
// d2 = pow (p, r) * pow (1 - p, x)
Value d2 = calc->mul (calc->pow (p, r),
calc->pow (calc->sub (1, p), x));
return calc->mul (d1, d2);
}
// Function: permut
Value func_arrang (valVector args, ValueCalc *calc, FuncExtra *)
{
Value n = args[0];
Value m = args[1];
if (calc->lower (n, m)) // problem if n<m
return Value::errorVALUE();
if (calc->lower (m, 0)) // problem if m<0 (n>=m so that's okay)
return Value::errorVALUE();
// fact(n) / (fact(n-m)
return calc->fact (n, calc->sub (n, m));
}
// Function: average
Value func_average (valVector args, ValueCalc *calc, FuncExtra *)
{
return calc->avg (args, false);
}
// Function: averagea
Value func_averagea (valVector args, ValueCalc *calc, FuncExtra *)
{
return calc->avg (args);
}
// Function: avedev
Value func_avedev (valVector args, ValueCalc *calc, FuncExtra *)
{
Value result;
calc->arrayWalk (args, result, awAveDev, calc->avg (args));
return result;
}
// Function: median
Value func_median (valVector args, ValueCalc *calc, FuncExtra *)
{
// does NOT support anything other than doubles !!!
List array;
int number = 1;
for (unsigned int i = 0; i < args.count(); ++i)
func_array_helper (args[i], calc, array, number);
qHeapSort (array);
double d = *array.at (number / 2 + number % 2);
return Value (d);
}
// Function: variance
Value func_variance (valVector args, ValueCalc *calc, FuncExtra *)
{
int count = calc->count (args, false);
if (count < 2)
return Value::errorVALUE();
Value result = func_devsq (args, calc, 0);
return calc->div (result, count-1);
}
// Function: vara
Value func_variancea (valVector args, ValueCalc *calc, FuncExtra *)
{
int count = calc->count (args);
if (count < 2)
return Value::errorVALUE();
Value result = func_devsqa (args, calc, 0);
return calc->div (result, count-1);
}
// Function: varp
Value func_variancep (valVector args, ValueCalc *calc, FuncExtra *)
{
int count = calc->count (args, false);
if (count == 0)
return Value::errorVALUE();
Value result = func_devsq (args, calc, 0);
return calc->div (result, count);
}
// Function: varpa
Value func_variancepa (valVector args, ValueCalc *calc, FuncExtra *)
{
int count = calc->count (args);
if (count == 0)
return Value::errorVALUE();
Value result = func_devsqa (args, calc, 0);
return calc->div (result, count);
}
// Function: stddev
Value func_stddev (valVector args, ValueCalc *calc, FuncExtra *)
{
return calc->stddev (args, false);
}
// Function: stddeva
Value func_stddeva (valVector args, ValueCalc *calc, FuncExtra *)
{
return calc->stddev (args);
}
// Function: stddevp
Value func_stddevp (valVector args, ValueCalc *calc, FuncExtra *)
{
return calc->stddevP (args, false);
}
// Function: stddevpa
Value func_stddevpa (valVector args, ValueCalc *calc, FuncExtra *)
{
return calc->stddevP (args);
}
// Function: combin
Value func_combin (valVector args, ValueCalc *calc, FuncExtra *)
{
return calc->combin (args[0], args[1]);
}
// Function: bino
Value func_bino (valVector args, ValueCalc *calc, FuncExtra *)
{
Value n = args[0];
Value m = args[1];
Value comb = calc->combin (n, m);
Value prob = args[2];
if (calc->lower (prob,0) || calc->greater (prob,1))
return Value::errorVALUE();
// result = comb * pow (prob, m) * pow (1 - prob, n - m)
Value pow1 = calc->pow (prob, m);
Value pow2 = calc->pow (calc->sub (1, prob), calc->sub (n, m));
return calc->mul (comb, calc->mul (pow1, pow2));
}
// Function: phi
Value func_phi (valVector args, ValueCalc *calc, FuncExtra *)
//distribution function for a standard normal distribution
{
return calc->phi (args[0]);
}
// Function: gauss
Value func_gauss (valVector args, ValueCalc *calc, FuncExtra *)
{
//returns the integral values of the standard normal cumulative distribution
return calc->gauss (args[0]);
}
// Function: gammadist
Value func_gammadist (valVector args, ValueCalc *calc, FuncExtra *)
{
Value x = args[0];
Value alpha = args[1];
Value beta = args[2];
int kum = calc->conv()->asInteger (args[3]).asInteger(); // 0 or 1
Value result;
if (calc->lower (x, 0.0) || (!calc->greater (alpha, 0.0)) ||
(!calc->greater (beta, 0.0)))
return Value::errorVALUE();
if (kum == 0) { //density
Value G = calc->GetGamma (alpha);
// result = pow (x, alpha - 1.0) / exp (x / beta) / pow (beta, alpha) / G
Value pow1 = calc->pow (x, calc->sub (alpha, 1.0));
Value pow2 = calc->exp (calc->div (x, beta));
Value pow3 = calc->pow (beta, alpha);
result = calc->div (calc->div (calc->div (pow1, pow2), pow3), G);
}
else
result = calc->GetGammaDist (x, alpha, beta);
return Value (result);
}
// Function: betadist
Value func_betadist (valVector args, ValueCalc *calc, FuncExtra *)
{
Value x = args[0];
Value alpha = args[1];
Value beta = args[2];
Value fA = 0.0;
Value fB = 1.0;
if (args.count() > 3) fA = args[3];
if (args.count() == 5) fB = args[4];
//x < fA || x > fB || fA == fB || alpha <= 0.0 || beta <= 0.0
if (calc->lower (x, fA) || calc->greater (x, fB) || calc->equal (fA, fB) ||
(!calc->greater (alpha, 0.0)) || (!calc->greater (beta, 0.0)))
return Value::errorVALUE();
// xx = (x - fA) / (fB - fA) // scaling
Value xx = calc->div (calc->sub (x, fA), calc->sub (fB, fA));
return calc->GetBeta (xx, alpha, beta);
}
// Function: fisher
Value func_fisher (valVector args, ValueCalc *calc, FuncExtra *) {
//returns the Fisher transformation for x
// 0.5 * ln ((1.0 + fVal) / (1.0 - fVal))
Value fVal = args[0];
Value num = calc->div (calc->add (fVal, 1.0), calc->sub (1.0, fVal));
return calc->mul (calc->ln (num), 0.5);
}
// Function: fisherinv
Value func_fisherinv (valVector args, ValueCalc *calc, FuncExtra *) {
//returns the inverse of the Fisher transformation for x
Value fVal = args[0];
// (exp (2.0 * fVal) - 1.0) / (exp (2.0 * fVal) + 1.0)
Value ex = calc->exp (calc->mul (fVal, 2.0));
return calc->div (calc->sub (ex, 1.0), calc->add (ex, 1.0));
}
// Function: normdist
Value func_normdist (valVector args, ValueCalc *calc, FuncExtra *) {
//returns the normal cumulative distribution
Value x = args[0];
Value mue = args[1];
Value sigma = args[2];
Value k = args[3];
if (!calc->greater (sigma, 0.0))
return Value::errorVALUE();
// (x - mue) / sigma
Value Y = calc->div (calc->sub (x, mue), sigma);
if (calc->isZero (k)) // density
return calc->div (calc->phi (Y), sigma);
else // distribution
return calc->add (calc->gauss (Y), 0.5);
}
// Function: lognormdist
Value func_lognormdist (valVector args, ValueCalc *calc, FuncExtra *) {
//returns the cumulative lognormal distribution
Value x = args[0];
Value mue = args[1];
Value sigma = args[2];
if (!calc->greater (sigma, 0.0) || (!calc->greater (x, 0.0)))
return Value::errorVALUE();
// (ln(x) - mue) / sigma
Value Y = calc->div (calc->sub (calc->ln (x), mue), sigma);
return calc->add (calc->gauss (Y), 0.5);
}
// Function: normsdist
Value func_stdnormdist (valVector args, ValueCalc *calc, FuncExtra *)
{
//returns the cumulative lognormal distribution, mue=0, sigma=1
return calc->add (calc->gauss (args[0]), 0.5);
}
// Function: expondist
Value func_expondist (valVector args, ValueCalc *calc, FuncExtra *) {
//returns the exponential distribution
Value x = args[0];
Value lambda = args[1];
Value kum = args[2];
Value result = 0.0;
if (!calc->greater (lambda, 0.0))
return Value::errorVALUE();
// ex = exp (-lambda * x)
Value ex = calc->exp (calc->mul (calc->mul (lambda, -1), x));
if (calc->isZero (kum)) { //density
if (!calc->lower (x, 0.0))
// lambda * ex
result = calc->mul (lambda, ex);
}
else { //distribution
if (calc->greater (x, 0.0))
// 1.0 - ex
result = calc->sub (1.0, ex);
}
return result;
}
// Function: weibull
Value func_weibull (valVector args, ValueCalc *calc, FuncExtra *) {
//returns the Weibull distribution
Value x = args[0];
Value alpha = args[1];
Value beta = args[2];
Value kum = args[3];
Value result;
if ((!calc->greater (alpha, 0.0)) || (!calc->greater (beta, 0.0)) ||
calc->lower (x, 0.0))
return Value::errorVALUE();
// ex = exp (-pow (x / beta, alpha))
Value ex;
ex = calc->exp (calc->mul (calc->pow (calc->div (x, beta), alpha), -1));
if (calc->isZero (kum)) // density
{
// result = alpha / pow(beta,alpha) * pow(x,alpha-1.0) * ex
result = calc->div (alpha, calc->pow (beta, alpha));
result = calc->mul (result, calc->mul (calc->pow (x,
calc->sub (alpha, 1)), ex));
}
else // distribution
result = calc->sub (1.0, ex);
return result;
}
// Function: normsinv
Value func_normsinv (valVector args, ValueCalc *calc, FuncExtra *) {
//returns the inverse of the standard normal cumulative distribution
Value x = args[0];
if (!(calc->greater (x, 0.0) && calc->lower (x, 1.0)))
return Value::errorVALUE();
return calc->gaussinv (x);
}
// Function: norminv
Value func_norminv (valVector args, ValueCalc *calc, FuncExtra *) {
//returns the inverse of the normal cumulative distribution
Value x = args[0];
Value mue = args[1];
Value sigma = args[2];
if (!calc->greater (sigma, 0.0))
return Value::errorVALUE();
if (!(calc->greater (x, 0.0) && calc->lower (x, 1.0)))
return Value::errorVALUE();
// gaussinv (x)*sigma + mue
return calc->add (calc->mul (calc->gaussinv (x), sigma), mue);
}
// Function: gammaln
Value func_gammaln (valVector args, ValueCalc *calc, FuncExtra *) {
//returns the natural logarithm of the gamma function
if (calc->greater (args[0], 0.0))
return calc->GetLogGamma (args[0]);
return Value::errorVALUE();
}
// Function: poisson
Value func_poisson (valVector args, ValueCalc *calc, FuncExtra *) {
//returns the Poisson distribution
Value x = args[0];
Value lambda = args[1];
Value kum = args[2];
// lambda < 0.0 || x < 0.0
if (calc->lower (lambda, 0.0) || calc->lower (x, 0.0))
return Value::errorVALUE();
Value result;
// ex = exp (-lambda)
Value ex = calc->exp (calc->mul (lambda, -1));
if (calc->isZero (kum)) { // density
if (calc->isZero (lambda))
result = 0;
else
// ex * pow (lambda, x) / fact (x)
result = calc->div (calc->mul (ex, calc->pow (lambda, x)), calc->fact (x));
}
else { // distribution
if (calc->isZero (lambda))
result = 1;
else
{
result = 1.0;
Value fFak = 1.0;
unsigned long nEnd = calc->conv()->asInteger (x).asInteger();
for (unsigned long i = 1; i <= nEnd; i++)
{
// fFak *= i
fFak = calc->mul (fFak, i);
// result += pow (lambda, i) / fFak
result = calc->add (result, calc->div (calc->pow (lambda, i), fFak));
}
result = calc->mul (result, ex);
}
}
return result;
}
// Function: confidence
Value func_confidence (valVector args, ValueCalc *calc, FuncExtra *) {
//returns the confidence interval for a population mean
Value alpha = args[0];
Value sigma = args[1];
Value n = args[2];
// sigma <= 0.0 || alpha <= 0.0 || alpha >= 1.0 || n < 1
if ((!calc->greater (sigma, 0.0)) || (!calc->greater (alpha, 0.0)) ||
(!calc->lower (alpha, 1.0)) || calc->lower (n, 1))
return Value::errorVALUE();
// g = gaussinv (1.0 - alpha / 2.0)
Value g = calc->gaussinv (calc->sub (1.0, calc->div (alpha, 2.0)));
// g * sigma / sqrt (n)
return calc->div (calc->mul (g, sigma), calc->sqrt (n));
}
// Function: tdist
Value func_tdist (valVector args, ValueCalc *calc, FuncExtra *) {
//returns the t-distribution
Value T = args[0];
Value fDF = args[1];
int flag = calc->conv()->asInteger (args[2]).asInteger();
if (calc->lower (fDF, 1) || calc->lower (T, 0.0) || (flag != 1 && flag != 2))
return Value::errorVALUE();
// arg = fDF / (fDF + T * T)
Value arg = calc->div (fDF, calc->add (fDF, calc->sqr (T)));
Value R;
R = calc->mul (calc->GetBeta (arg, calc->div (fDF, 2.0), 0.5), 0.5);
if (flag == 1)
return R;
return calc->mul (R, 2); // flag is 2 here
}
// Function: fdist
Value func_fdist (valVector args, ValueCalc *calc, FuncExtra *) {
//returns the f-distribution
Value x = args[0];
Value fF1 = args[1];
Value fF2 = args[2];
// x < 0.0 || fF1 < 1 || fF2 < 1 || fF1 >= 1.0E10 || fF2 >= 1.0E10
if (calc->lower (x, 0.0) || calc->lower (fF1, 1) || calc->lower (fF2, 1) ||
(!calc->lower (fF1, 1.0E10)) || (!calc->lower (fF2, 1.0E10)))
return Value::errorVALUE();
// arg = fF2 / (fF2 + fF1 * x)
Value arg = calc->div (fF2, calc->add (fF2, calc->mul (fF1, x)));
// alpha = fF2/2.0
Value alpha = calc->div (fF2, 2.0);
// beta = fF1/2.0
Value beta = calc->div (fF1, 2.0);
return calc->GetBeta (arg, alpha, beta);
}
// Function: chidist
Value func_chidist (valVector args, ValueCalc *calc, FuncExtra *) {
//returns the chi-distribution
Value fChi = args[0];
Value fDF = args[1];
// fDF < 1 || fDF >= 1.0E5 || fChi < 0.0
if (calc->lower (fDF, 1) || (!calc->lower (fDF, 1.0E5)) ||
calc->lower (fChi, 0.0))
return Value::errorVALUE();
// 1.0 - GetGammaDist (fChi / 2.0, fDF / 2.0, 1.0)
return calc->sub (1.0, calc->GetGammaDist (calc->div (fChi, 2.0),
calc->div (fDF, 2.0), 1.0));
}
// two-array-walk functions used in the two-sum functions
void tawSumproduct (ValueCalc *c, Value &res, Value v1,
Value v2) {
// res += v1*v2
res = c->add (res, c->mul (v1, v2));
}
void tawSumx2py2 (ValueCalc *c, Value &res, Value v1,
Value v2) {
// res += sqr(v1)+sqr(v2)
res = c->add (res, c->add (c->sqr (v1), c->sqr (v2)));
}
void tawSumx2my2 (ValueCalc *c, Value &res, Value v1,
Value v2) {
// res += sqr(v1)-sqr(v2)
res = c->add (res, c->sub (c->sqr (v1), c->sqr (v2)));
}
void tawSumxmy2 (ValueCalc *c, Value &res, Value v1,
Value v2) {
// res += sqr(v1-v2)
res = c->add (res, c->sqr (c->sub (v1, v2)));
}
// Function: sumproduct
Value func_sumproduct (valVector args, ValueCalc *calc, FuncExtra *)
{
Value result;
calc->twoArrayWalk (args[0], args[1], result, tawSumproduct);
return result;
}
// Function: sumx2py2
Value func_sumx2py2 (valVector args, ValueCalc *calc, FuncExtra *)
{
Value result;
calc->twoArrayWalk (args[0], args[1], result, tawSumx2py2);
return result;
}
// Function: sumx2my2
Value func_sumx2my2 (valVector args, ValueCalc *calc, FuncExtra *)
{
Value result;
calc->twoArrayWalk (args[0], args[1], result, tawSumx2my2);
return result;
}
// Function: sum2xmy
Value func_sumxmy2 (valVector args, ValueCalc *calc, FuncExtra *)
{
Value result;
calc->twoArrayWalk (args[0], args[1], result, tawSumxmy2);
return result;
}