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.
1993 lines
47 KiB
1993 lines
47 KiB
/* This file is part of the KDE project
|
|
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, or (at your option) any later version.
|
|
|
|
This library is distributed in the hope that it will be useful,
|
|
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
|
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.
|
|
*/
|
|
|
|
#include "valuecalc.h"
|
|
|
|
#include "valueconverter.h"
|
|
|
|
#include <kdebug.h>
|
|
#include <errno.h>
|
|
#include <float.h>
|
|
#include <math.h>
|
|
#include <stdlib.h>
|
|
#include <time.h>
|
|
|
|
using namespace KSpread;
|
|
|
|
|
|
// Array-walk functions registered on ValueCalc object
|
|
|
|
void awSum (ValueCalc *c, Value &res, Value val, Value)
|
|
{
|
|
if ((!val.isEmpty()) && (!val.isBoolean()) && (!val.isString()))
|
|
res = c->add (res, val);
|
|
}
|
|
|
|
void awSumA (ValueCalc *c, Value &res, Value val, Value)
|
|
{
|
|
if (!val.isEmpty())
|
|
res = c->add (res, val);
|
|
}
|
|
|
|
void awSumSq (ValueCalc *c, Value &res, Value val, Value)
|
|
{
|
|
if (!val.isEmpty())
|
|
res = c->add (res, c->sqr (val));
|
|
}
|
|
|
|
void awSumSqA (ValueCalc *c, Value &res, Value val, Value)
|
|
{
|
|
if ((!val.isEmpty()) && (!val.isBoolean()) && (!val.isString()))
|
|
res = c->add (res, c->sqr (val));
|
|
}
|
|
|
|
void awCount (ValueCalc *c, Value &res, Value val, Value)
|
|
{
|
|
if ((!val.isEmpty()) && (!val.isBoolean()) && (!val.isString()))
|
|
res = c->add (res, 1);
|
|
}
|
|
|
|
void awCountA (ValueCalc *c, Value &res, Value val, Value)
|
|
{
|
|
if (!val.isEmpty())
|
|
res = c->add (res, 1);
|
|
}
|
|
|
|
void awMax (ValueCalc *c, Value &res, Value val, Value)
|
|
{
|
|
if ((!val.isEmpty()) && (!val.isBoolean()) && (!val.isString()))
|
|
if (res.isEmpty())
|
|
res = val;
|
|
else
|
|
if (c->greater (val, res)) res = val;
|
|
}
|
|
|
|
void awMaxA (ValueCalc *c, Value &res, Value val, Value)
|
|
{
|
|
if (!val.isEmpty())
|
|
if (res.isEmpty())
|
|
// convert to number, so that we don't return string/bool
|
|
res = c->conv()->asNumeric (val);
|
|
else
|
|
if (c->greater (val, res))
|
|
// convert to number, so that we don't return string/bool
|
|
res = c->conv()->asNumeric (val);
|
|
}
|
|
|
|
void awMin (ValueCalc *c, Value &res, Value val, Value)
|
|
{
|
|
if ((!val.isEmpty()) && (!val.isBoolean()) && (!val.isString()))
|
|
if (res.isEmpty())
|
|
res = val;
|
|
else
|
|
if (c->lower (val, res)) res = val;
|
|
}
|
|
|
|
void awMinA (ValueCalc *c, Value &res, Value val, Value)
|
|
{
|
|
if (!val.isEmpty())
|
|
if (res.isEmpty())
|
|
// convert to number, so that we don't return string/bool
|
|
res = c->conv()->asNumeric (val);
|
|
else
|
|
if (c->lower (val, res))
|
|
// convert to number, so that we don't return string/bool
|
|
res = c->conv()->asNumeric (val);
|
|
}
|
|
|
|
void awProd (ValueCalc *c, Value &res, Value val, Value)
|
|
{
|
|
if ((!val.isEmpty()) && (!val.isBoolean()) && (!val.isString()))
|
|
res = c->mul (res, val);
|
|
}
|
|
|
|
void awProdA (ValueCalc *c, Value &res, Value val, Value)
|
|
{
|
|
if (!val.isEmpty())
|
|
res = c->mul (res, val);
|
|
}
|
|
|
|
// sum of squares of deviations, used to compute standard deviation
|
|
void awDevSq (ValueCalc *c, Value &res, Value val,
|
|
Value avg)
|
|
{
|
|
if (!val.isEmpty())
|
|
res = c->add (res, c->sqr (c->sub (val, avg)));
|
|
}
|
|
|
|
// sum of squares of deviations, used to compute standard deviation
|
|
void awDevSqA (ValueCalc *c, Value &res, Value val,
|
|
Value avg)
|
|
{
|
|
if ((!val.isEmpty()) && (!val.isBoolean()) && (!val.isString()))
|
|
res = c->add (res, c->sqr (c->sub (val, avg)));
|
|
}
|
|
|
|
|
|
bool isDate (Value val) {
|
|
Value::Format fmt = val.format();
|
|
if ((fmt == Value::fmt_Date) || (fmt == Value::fmt_DateTime))
|
|
return true;
|
|
return false;
|
|
}
|
|
|
|
// ***********************
|
|
// ****** ValueCalc ******
|
|
// ***********************
|
|
|
|
ValueCalc::ValueCalc (ValueConverter* c): converter( c )
|
|
{
|
|
// initialize the random number generator
|
|
srand (time (0));
|
|
|
|
// register array-walk functions
|
|
registerAwFunc ("sum", awSum);
|
|
registerAwFunc ("suma", awSumA);
|
|
registerAwFunc ("sumsq", awSumSq);
|
|
registerAwFunc ("sumsqa", awSumSqA);
|
|
registerAwFunc ("count", awCount);
|
|
registerAwFunc ("counta", awCountA);
|
|
registerAwFunc ("max", awMax);
|
|
registerAwFunc ("maxa", awMaxA);
|
|
registerAwFunc ("min", awMin);
|
|
registerAwFunc ("mina", awMinA);
|
|
registerAwFunc ("prod", awProd);
|
|
registerAwFunc ("proda", awProdA);
|
|
registerAwFunc ("devsq", awDevSq);
|
|
registerAwFunc ("devsqa", awDevSq);
|
|
}
|
|
|
|
Value ValueCalc::add (const Value &a, const Value &b)
|
|
{
|
|
if (a.isError()) return a;
|
|
if (b.isError()) return b;
|
|
Value res;
|
|
if (a.isInteger() && b.isEmpty() || a.isEmpty() && b.isInteger()
|
|
|| a.isInteger() && b.isInteger())
|
|
{
|
|
int aa, bb;
|
|
aa = converter->asInteger (a).asInteger();
|
|
bb = converter->asInteger (b).asInteger();
|
|
res = Value (aa + bb);
|
|
}
|
|
else
|
|
{
|
|
double aa, bb;
|
|
aa = converter->asFloat (a).asFloat();
|
|
bb = converter->asFloat (b).asFloat();
|
|
res = Value (aa + bb);
|
|
}
|
|
|
|
if (a.isNumber() || a.isEmpty())
|
|
res.setFormat (format (a.format(), b.format()));
|
|
// operation on two dates should produce a number
|
|
if (isDate(a) && isDate(b))
|
|
res.setFormat (Value::fmt_Number);
|
|
|
|
return res;
|
|
}
|
|
|
|
Value ValueCalc::sub (const Value &a, const Value &b)
|
|
{
|
|
if (a.isError()) return a;
|
|
if (b.isError()) return b;
|
|
double aa, bb;
|
|
aa = converter->asFloat (a).asFloat();
|
|
bb = converter->asFloat (b).asFloat();
|
|
Value res = Value (aa - bb);
|
|
|
|
if (a.isNumber() || a.isEmpty())
|
|
res.setFormat (format (a.format(), b.format()));
|
|
// operation on two dates should produce a number
|
|
if (isDate(a) && isDate(b))
|
|
res.setFormat (Value::fmt_Number);
|
|
|
|
return res;
|
|
}
|
|
|
|
Value ValueCalc::mul (const Value &a, const Value &b)
|
|
{
|
|
if (a.isError()) return a;
|
|
if (b.isError()) return b;
|
|
double aa, bb;
|
|
aa = converter->asFloat (a).asFloat();
|
|
bb = converter->asFloat (b).asFloat();
|
|
Value res = Value (aa * bb);
|
|
|
|
if (a.isNumber() || a.isEmpty())
|
|
res.setFormat (format (a.format(), b.format()));
|
|
// operation on two dates should produce a number
|
|
if (isDate(a) && isDate(b))
|
|
res.setFormat (Value::fmt_Number);
|
|
|
|
return res;
|
|
}
|
|
|
|
Value ValueCalc::div (const Value &a, const Value &b)
|
|
{
|
|
if (a.isError()) return a;
|
|
if (b.isError()) return b;
|
|
double aa, bb;
|
|
aa = converter->asFloat (a).asFloat();
|
|
bb = converter->asFloat (b).asFloat();
|
|
Value res;
|
|
if (bb == 0.0)
|
|
return Value::errorDIV0();
|
|
else
|
|
res = Value (aa / bb);
|
|
|
|
if (a.isNumber() || a.isEmpty())
|
|
res.setFormat (format (a.format(), b.format()));
|
|
// operation on two dates should produce a number
|
|
if (isDate(a) && isDate(b))
|
|
res.setFormat (Value::fmt_Number);
|
|
|
|
return res;
|
|
}
|
|
|
|
Value ValueCalc::mod (const Value &a, const Value &b)
|
|
{
|
|
if (a.isError()) return a;
|
|
if (b.isError()) return b;
|
|
double aa, bb;
|
|
aa = converter->asFloat (a).asFloat();
|
|
bb = converter->asFloat (b).asFloat();
|
|
Value res;
|
|
if (bb == 0.0)
|
|
return Value::errorDIV0();
|
|
else
|
|
{
|
|
double m = fmod (aa, bb);
|
|
// the following adjustments are needed by OpenFormula:
|
|
// can't simply use fixed increases/decreases, because the implementation
|
|
// of fmod may differ on various platforms, and we should always return
|
|
// the same results ...
|
|
if ((bb > 0) && (aa < 0)) // result must be positive here
|
|
while (m < 0) m += bb;
|
|
if (bb < 0) // result must be negative here, but not lower than bb
|
|
{
|
|
// bb is negative, hence the following two are correct
|
|
while (m < bb) m -= bb; // same as m+=fabs(bb)
|
|
while (m > 0) m += bb; // same as m-=fabs(bb)
|
|
}
|
|
|
|
res = Value (m);
|
|
}
|
|
|
|
if (a.isNumber() || a.isEmpty())
|
|
res.setFormat (format (a.format(), b.format()));
|
|
if (isDate(a) && isDate(b))
|
|
res.setFormat (Value::fmt_Number);
|
|
|
|
return res;
|
|
}
|
|
|
|
Value ValueCalc::pow (const Value &a, const Value &b)
|
|
{
|
|
if (a.isError()) return a;
|
|
if (b.isError()) return b;
|
|
double aa, bb;
|
|
aa = converter->asFloat (a).asFloat();
|
|
bb = converter->asFloat (b).asFloat();
|
|
Value res = Value (::pow (aa, bb));
|
|
|
|
if (a.isNumber() || a.isEmpty())
|
|
res.setFormat (format (a.format(), b.format()));
|
|
// operation on date(s) should produce a number
|
|
if (isDate(a) || isDate(b))
|
|
res.setFormat (Value::fmt_Number);
|
|
|
|
return res;
|
|
}
|
|
|
|
Value ValueCalc::sqr (const Value &a)
|
|
{
|
|
if (a.isError()) return a;
|
|
return mul (a, a);
|
|
}
|
|
|
|
Value ValueCalc::sqrt (const Value &a)
|
|
{
|
|
if (a.isError()) return a;
|
|
Value res = Value (::sqrt (converter->asFloat(a).asFloat()));
|
|
if (a.isNumber() || a.isEmpty())
|
|
res.setFormat (a.format());
|
|
// operation on date(s) should produce a number
|
|
if (isDate(a))
|
|
res.setFormat (Value::fmt_Number);
|
|
|
|
return res;
|
|
}
|
|
|
|
Value ValueCalc::add (const Value &a, double b)
|
|
{
|
|
if (a.isError()) return a;
|
|
Value res = Value (converter->asFloat(a).asFloat() + b);
|
|
|
|
if (a.isNumber() || a.isEmpty())
|
|
res.setFormat (a.format());
|
|
|
|
return res;
|
|
}
|
|
|
|
Value ValueCalc::sub (const Value &a, double b)
|
|
{
|
|
if (a.isError()) return a;
|
|
Value res = Value (converter->asFloat(a).asFloat() - b);
|
|
|
|
if (a.isNumber() || a.isEmpty())
|
|
res.setFormat (a.format());
|
|
|
|
return res;
|
|
}
|
|
|
|
Value ValueCalc::mul (const Value &a, double b)
|
|
{
|
|
if (a.isError()) return a;
|
|
Value res = Value (converter->asFloat(a).asFloat() * b);
|
|
|
|
if (a.isNumber() || a.isEmpty())
|
|
res.setFormat (a.format());
|
|
|
|
return res;
|
|
}
|
|
|
|
Value ValueCalc::div (const Value &a, double b)
|
|
{
|
|
if (a.isError()) return a;
|
|
Value res;
|
|
if (b == 0.0)
|
|
return Value::errorDIV0();
|
|
|
|
res = Value (converter->asFloat(a).asFloat() / b);
|
|
|
|
if (a.isNumber() || a.isEmpty())
|
|
res.setFormat (a.format());
|
|
|
|
return res;
|
|
}
|
|
|
|
Value ValueCalc::pow (const Value &a, double b)
|
|
{
|
|
if (a.isError()) return a;
|
|
Value res = Value (::pow (converter->asFloat(a).asFloat(), b));
|
|
|
|
if (a.isNumber() || a.isEmpty())
|
|
res.setFormat (a.format());
|
|
|
|
return res;
|
|
}
|
|
|
|
Value ValueCalc::abs (const Value &a)
|
|
{
|
|
if (a.isError()) return a;
|
|
return Value (fabs (converter->asFloat (a).asFloat()));
|
|
}
|
|
|
|
bool ValueCalc::isZero (const Value &a)
|
|
{
|
|
if (a.isError()) return false;
|
|
return (converter->asFloat (a).asFloat() == 0.0);
|
|
}
|
|
|
|
bool ValueCalc::isEven (const Value &a)
|
|
{
|
|
if (a.isError()) return false;
|
|
return ((converter->asInteger (a).asInteger() % 2) == 0);
|
|
}
|
|
|
|
bool ValueCalc::equal (const Value &a, const Value &b)
|
|
{
|
|
return (converter->asFloat (a).asFloat() == converter->asFloat (b).asFloat());
|
|
}
|
|
|
|
/*********************************************************************
|
|
*
|
|
* Helper function to avoid problems with rounding floating point
|
|
* values. Idea for this kind of solution taken from Openoffice.
|
|
*
|
|
*********************************************************************/
|
|
bool ValueCalc::approxEqual (const Value &a, const Value &b)
|
|
{
|
|
double aa = converter->asFloat (a).asFloat();
|
|
double bb = converter->asFloat (b).asFloat();
|
|
if (aa == bb)
|
|
return true;
|
|
double x = aa - bb;
|
|
return (x < 0.0 ? -x : x) < ((aa < 0.0 ? -aa : aa) * DBL_EPSILON);
|
|
}
|
|
|
|
bool ValueCalc::strEqual (const Value &a, const Value &b)
|
|
{
|
|
return (converter->asString (a).asString() == converter->asString (b).asString());
|
|
}
|
|
|
|
bool ValueCalc::greater (const Value &a, const Value &b)
|
|
{
|
|
double aa = converter->asFloat (a).asFloat();
|
|
double bb = converter->asFloat (b).asFloat();
|
|
return (aa > bb);
|
|
}
|
|
|
|
bool ValueCalc::gequal (const Value &a, const Value &b)
|
|
{
|
|
return (greater (a,b) || approxEqual (a,b));
|
|
}
|
|
|
|
bool ValueCalc::lower (const Value &a, const Value &b)
|
|
{
|
|
return greater (b, a);
|
|
}
|
|
|
|
Value ValueCalc::roundDown (const Value &a,
|
|
const Value &digits) {
|
|
return roundDown (a, converter->asInteger (digits).asInteger());
|
|
}
|
|
|
|
Value ValueCalc::roundUp (const Value &a,
|
|
const Value &digits) {
|
|
return roundUp (a, converter->asInteger (digits).asInteger());
|
|
}
|
|
|
|
Value ValueCalc::round (const Value &a,
|
|
const Value &digits) {
|
|
return round (a, converter->asInteger (digits).asInteger());
|
|
}
|
|
|
|
Value ValueCalc::roundDown (const Value &a, int digits)
|
|
{
|
|
// shift in one direction, round, shift back
|
|
Value val = a;
|
|
if (digits > 0)
|
|
for (int i = 0; i < digits; ++i)
|
|
val = mul (val, 10);
|
|
if (digits < 0)
|
|
for (int i = 0; i < digits; ++i)
|
|
val = div (val, 10);
|
|
|
|
val = Value (floor (converter->asFloat (val).asFloat()));
|
|
|
|
if (digits > 0)
|
|
for (int i = 0; i < digits; ++i)
|
|
val = div (val, 10);
|
|
if (digits < 0)
|
|
for (int i = 0; i < digits; ++i)
|
|
val = mul (val, 10);
|
|
return val;
|
|
}
|
|
|
|
Value ValueCalc::roundUp (const Value &a, int digits)
|
|
{
|
|
// shift in one direction, round, shift back
|
|
Value val = a;
|
|
if (digits > 0)
|
|
for (int i = 0; i < digits; ++i)
|
|
val = mul (val, 10);
|
|
if (digits < 0)
|
|
for (int i = 0; i < digits; ++i)
|
|
val = div (val, 10);
|
|
|
|
val = Value (ceil (converter->asFloat (val).asFloat()));
|
|
|
|
if (digits > 0)
|
|
for (int i = 0; i < digits; ++i)
|
|
val = div (val, 10);
|
|
if (digits < 0)
|
|
for (int i = 0; i < digits; ++i)
|
|
val = mul (val, 10);
|
|
return val;
|
|
}
|
|
|
|
Value ValueCalc::round (const Value &a, int digits)
|
|
{
|
|
// shift in one direction, round, shift back
|
|
Value val = a;
|
|
if (digits > 0)
|
|
for (int i = 0; i < digits; ++i)
|
|
val = mul (val, 10);
|
|
if (digits < 0)
|
|
for (int i = 0; i < digits; ++i)
|
|
val = div (val, 10);
|
|
|
|
val = Value (int(converter->asFloat (val).asFloat()+0.5));
|
|
|
|
if (digits > 0)
|
|
for (int i = 0; i < digits; ++i)
|
|
val = div (val, 10);
|
|
if (digits < 0)
|
|
for (int i = 0; i < digits; ++i)
|
|
val = mul (val, 10);
|
|
return val;
|
|
}
|
|
|
|
int ValueCalc::sign (const Value &a)
|
|
{
|
|
double val = converter->asFloat (a).asFloat ();
|
|
if (val == 0) return 0;
|
|
if (val > 0) return 1;
|
|
return -1;
|
|
}
|
|
|
|
|
|
Value ValueCalc::log (const Value &number,
|
|
const Value &base)
|
|
{
|
|
double logbase = converter->asFloat (base).asFloat();
|
|
if (logbase == 1.0)
|
|
return Value::errorDIV0();
|
|
if (logbase <= 0.0)
|
|
return Value::errorNA();
|
|
|
|
logbase = log10 (logbase);
|
|
Value res = Value (log10 (converter->asFloat (number).asFloat()) / logbase);
|
|
|
|
if (number.isNumber() || number.isEmpty())
|
|
res.setFormat (number.format());
|
|
|
|
return res;
|
|
}
|
|
|
|
Value ValueCalc::ln (const Value &number)
|
|
{
|
|
Value res = Value (::log (converter->asFloat (number).asFloat()));
|
|
|
|
if (number.isNumber() || number.isEmpty())
|
|
res.setFormat (number.format());
|
|
|
|
return res;
|
|
}
|
|
|
|
Value ValueCalc::log (const Value &number, double base)
|
|
{
|
|
if (base <= 0.0)
|
|
return Value::errorNA();
|
|
if (base == 1.0)
|
|
return Value::errorDIV0();
|
|
|
|
double num = converter->asFloat (number).asFloat();
|
|
Value res = Value (log10 (num) / log10 (base));
|
|
|
|
if (number.isNumber() || number.isEmpty())
|
|
res.setFormat (number.format());
|
|
|
|
return res;
|
|
}
|
|
|
|
Value ValueCalc::exp (const Value &number)
|
|
{
|
|
return Value (::exp (converter->asFloat (number).asFloat()));
|
|
}
|
|
|
|
Value ValueCalc::pi ()
|
|
{
|
|
// retun PI in double-precision
|
|
// if arbitrary precision gets in, this should be extended to return
|
|
// more if need be
|
|
return Value (M_PI);
|
|
}
|
|
|
|
Value ValueCalc::eps ()
|
|
{
|
|
// #### This should adjust according to the actual number system used
|
|
// (float, double, long double, ...)
|
|
return Value (DBL_EPSILON);
|
|
}
|
|
|
|
Value ValueCalc::random (double range)
|
|
{
|
|
return Value (range * (double) rand() / (RAND_MAX + 1.0));
|
|
}
|
|
|
|
Value ValueCalc::random (Value range)
|
|
{
|
|
return random (converter->asFloat (range).asFloat());
|
|
}
|
|
|
|
Value ValueCalc::fact (const Value &which)
|
|
{
|
|
// we can simply use integers - no one is going to compute factorial of
|
|
// anything bigger than 2^32
|
|
return fact (converter->asInteger (which).asInteger());
|
|
}
|
|
|
|
Value ValueCalc::fact (const Value &which,
|
|
const Value &end)
|
|
{
|
|
// we can simply use integers - no one is going to compute factorial of
|
|
// anything bigger than 2^32
|
|
return fact (converter->asInteger (which).asInteger(),
|
|
converter->asInteger (end).asInteger ());
|
|
}
|
|
|
|
Value ValueCalc::fact (int which, int end) {
|
|
if (which < 0)
|
|
return Value (-1);
|
|
if (which == 0)
|
|
return Value (1);
|
|
// no multiplication if val==end
|
|
if (which == end)
|
|
return Value (1);
|
|
|
|
return (mul (fact (which-1, end), which));
|
|
}
|
|
|
|
Value ValueCalc::factDouble (int which)
|
|
{
|
|
if (which < 0)
|
|
return Value (-1);
|
|
if ((which == 0) || (which == 1))
|
|
return Value (1);
|
|
|
|
return (mul (factDouble (which-2), which));
|
|
}
|
|
|
|
Value ValueCalc::factDouble (Value which)
|
|
{
|
|
return factDouble (converter->asInteger (which).asInteger());
|
|
}
|
|
|
|
Value ValueCalc::combin (int n, int k)
|
|
{
|
|
if (n >= 15)
|
|
{
|
|
double result = ::exp(lgamma (n + 1) - lgamma (k + 1) - lgamma (n-k+1));
|
|
return Value (floor(result + 0.5));
|
|
}
|
|
else
|
|
return div (div (fact (n), fact (k)), fact (n - k));
|
|
}
|
|
|
|
Value ValueCalc::combin (Value n, Value k)
|
|
{
|
|
int nn = converter->asInteger (n).asInteger();
|
|
int kk = converter->asInteger (k).asInteger();
|
|
return combin (nn, kk);
|
|
}
|
|
|
|
Value ValueCalc::gcd (const Value &a, const Value &b)
|
|
{
|
|
// Euler's GCD algorithm
|
|
Value aa = round (a);
|
|
Value bb = round (b);
|
|
|
|
if (approxEqual (aa, bb)) return aa;
|
|
|
|
if (aa.isZero()) return bb;
|
|
if (bb.isZero()) return aa;
|
|
|
|
|
|
if (greater (aa, bb))
|
|
return gcd (bb, mod (aa, bb));
|
|
else
|
|
return gcd (aa, mod (bb, aa));
|
|
}
|
|
|
|
Value ValueCalc::lcm (const Value &a, const Value &b)
|
|
{
|
|
Value aa = round (a);
|
|
Value bb = round (b);
|
|
|
|
if (approxEqual (aa, bb)) return aa;
|
|
|
|
if (aa.isZero()) return bb;
|
|
if (bb.isZero()) return aa;
|
|
|
|
Value g = gcd (aa, bb);
|
|
if (g.isZero()) // GCD is zero for some weird reason
|
|
return mul (aa, bb);
|
|
|
|
return div (mul (aa, bb), g);
|
|
}
|
|
|
|
Value ValueCalc::base (const Value &val, int base, int prec)
|
|
{
|
|
if (base == 10) return round (val, prec);
|
|
if (prec < 0) prec = 2;
|
|
if ((base < 2) || (base > 36))
|
|
return Value::errorVALUE();
|
|
|
|
double value = converter->asFloat (val).asFloat();
|
|
TQString result = TQString::number ((int)value, base);
|
|
|
|
if (prec > 0)
|
|
{
|
|
result += "."; value = value - (int)value;
|
|
|
|
int ix;
|
|
for( int i = 0; i < prec; i++ )
|
|
{
|
|
ix = (int) value * base;
|
|
result += "0123456789abcdefghijklmnopqrstuvwxyz"[ix];
|
|
value = base * (value - (double)ix/base);
|
|
}
|
|
}
|
|
|
|
return Value (result.upper());
|
|
}
|
|
|
|
Value ValueCalc::fromBase (const Value &val, int base)
|
|
{
|
|
TQString str = converter->asString (val).asString();
|
|
bool ok;
|
|
double num = str.toLong (&ok, base);
|
|
if (ok)
|
|
return Value (num);
|
|
return Value::errorVALUE();
|
|
}
|
|
|
|
|
|
Value ValueCalc::sin (const Value &number)
|
|
{
|
|
Value res = Value (::sin (converter->asFloat (number).asFloat()));
|
|
|
|
if (number.isNumber() || number.isEmpty())
|
|
res.setFormat (number.format());
|
|
|
|
return res;
|
|
}
|
|
|
|
Value ValueCalc::cos (const Value &number)
|
|
{
|
|
Value res = Value (::cos (converter->asFloat (number).asFloat()));
|
|
|
|
if (number.isNumber() || number.isEmpty())
|
|
res.setFormat (number.format());
|
|
|
|
return res;
|
|
}
|
|
|
|
Value ValueCalc::tg (const Value &number)
|
|
{
|
|
Value res = Value (::tan (converter->asFloat (number).asFloat()));
|
|
|
|
if (number.isNumber() || number.isEmpty())
|
|
res.setFormat (number.format());
|
|
|
|
return res;
|
|
}
|
|
|
|
Value ValueCalc::cotg (const Value &number)
|
|
{
|
|
Value res = Value (div (1, ::tan (converter->asFloat (number).asFloat())));
|
|
|
|
if (number.isNumber() || number.isEmpty())
|
|
res.setFormat (number.format());
|
|
|
|
return res;
|
|
}
|
|
|
|
Value ValueCalc::asin (const Value &number)
|
|
{
|
|
errno = 0;
|
|
Value res = Value (::asin (converter->asFloat (number).asFloat()));
|
|
if (errno)
|
|
return Value::errorVALUE();
|
|
|
|
if (number.isNumber() || number.isEmpty())
|
|
res.setFormat (number.format());
|
|
|
|
return res;
|
|
}
|
|
|
|
Value ValueCalc::acos (const Value &number)
|
|
{
|
|
errno = 0;
|
|
Value res = Value (::acos (converter->asFloat (number).asFloat()));
|
|
if (errno)
|
|
return Value::errorVALUE();
|
|
|
|
if (number.isNumber() || number.isEmpty())
|
|
res.setFormat (number.format());
|
|
|
|
return res;
|
|
}
|
|
|
|
Value ValueCalc::atg (const Value &number)
|
|
{
|
|
errno = 0;
|
|
Value res = Value (::atan (converter->asFloat (number).asFloat()));
|
|
if (errno)
|
|
return Value::errorVALUE();
|
|
|
|
if (number.isNumber() || number.isEmpty())
|
|
res.setFormat (number.format());
|
|
|
|
return res;
|
|
}
|
|
|
|
Value ValueCalc::atan2 (const Value &y, const Value &x)
|
|
{
|
|
double yy = converter->asFloat (y).asFloat();
|
|
double xx = converter->asFloat (x).asFloat();
|
|
return Value (::atan2 (yy, xx));
|
|
}
|
|
|
|
Value ValueCalc::sinh (const Value &number)
|
|
{
|
|
Value res = Value (::sinh (converter->asFloat (number).asFloat()));
|
|
|
|
if (number.isNumber() || number.isEmpty())
|
|
res.setFormat (number.format());
|
|
|
|
return res;
|
|
}
|
|
|
|
Value ValueCalc::cosh (const Value &number)
|
|
{
|
|
Value res = Value (::cosh (converter->asFloat (number).asFloat()));
|
|
|
|
if (number.isNumber() || number.isEmpty())
|
|
res.setFormat (number.format());
|
|
|
|
return res;
|
|
}
|
|
|
|
Value ValueCalc::tgh (const Value &number)
|
|
{
|
|
Value res = Value (::tanh (converter->asFloat (number).asFloat()));
|
|
|
|
if (number.isNumber() || number.isEmpty())
|
|
res.setFormat (number.format());
|
|
|
|
return res;
|
|
}
|
|
|
|
Value ValueCalc::asinh (const Value &number)
|
|
{
|
|
errno = 0;
|
|
Value res = Value (::asinh (converter->asFloat (number).asFloat()));
|
|
if (errno)
|
|
return Value::errorVALUE();
|
|
|
|
if (number.isNumber() || number.isEmpty())
|
|
res.setFormat (number.format());
|
|
|
|
return res;
|
|
}
|
|
|
|
Value ValueCalc::acosh (const Value &number)
|
|
{
|
|
errno = 0;
|
|
Value res = Value (::acosh (converter->asFloat (number).asFloat()));
|
|
if (errno)
|
|
return Value::errorVALUE();
|
|
|
|
if (number.isNumber() || number.isEmpty())
|
|
res.setFormat (number.format());
|
|
|
|
return res;
|
|
}
|
|
|
|
Value ValueCalc::atgh (const Value &number)
|
|
{
|
|
errno = 0;
|
|
Value res = Value (::atanh (converter->asFloat (number).asFloat()));
|
|
if (errno)
|
|
return Value::errorVALUE();
|
|
|
|
if (number.isNumber() || number.isEmpty())
|
|
res.setFormat (number.format());
|
|
|
|
return res;
|
|
}
|
|
|
|
Value ValueCalc::phi (Value x)
|
|
{
|
|
Value constant (0.39894228040143268);
|
|
|
|
// constant * exp(-(x * x) / 2.0);
|
|
Value x2neg = mul (sqr (x), -1);
|
|
return mul (constant, exp (div (x2neg, 2.0)));
|
|
}
|
|
|
|
static double taylor_helper (double* pPolynom, uint nMax, double x)
|
|
{
|
|
double nVal = pPolynom[nMax];
|
|
for (int i = nMax-1; i >= 0; i--) {
|
|
nVal = pPolynom[i] + (nVal * x);
|
|
}
|
|
return nVal;
|
|
}
|
|
|
|
Value ValueCalc::gauss (Value xx)
|
|
// this is a weird function
|
|
{
|
|
double x = converter->asFloat (xx).asFloat();
|
|
|
|
double t0[] =
|
|
{ 0.39894228040143268, -0.06649038006690545, 0.00997355701003582,
|
|
-0.00118732821548045, 0.00011543468761616, -0.00000944465625950,
|
|
0.00000066596935163, -0.00000004122667415, 0.00000000227352982,
|
|
0.00000000011301172, 0.00000000000511243, -0.00000000000021218 };
|
|
double t2[] =
|
|
{ 0.47724986805182079, 0.05399096651318805, -0.05399096651318805,
|
|
0.02699548325659403, -0.00449924720943234, -0.00224962360471617,
|
|
0.00134977416282970, -0.00011783742691370, -0.00011515930357476,
|
|
0.00003704737285544, 0.00000282690796889, -0.00000354513195524,
|
|
0.00000037669563126, 0.00000019202407921, -0.00000005226908590,
|
|
-0.00000000491799345, 0.00000000366377919, -0.00000000015981997,
|
|
-0.00000000017381238, 0.00000000002624031, 0.00000000000560919,
|
|
-0.00000000000172127, -0.00000000000008634, 0.00000000000007894 };
|
|
double t4[] =
|
|
{ 0.49996832875816688, 0.00013383022576489, -0.00026766045152977,
|
|
0.00033457556441221, -0.00028996548915725, 0.00018178605666397,
|
|
-0.00008252863922168, 0.00002551802519049, -0.00000391665839292,
|
|
-0.00000074018205222, 0.00000064422023359, -0.00000017370155340,
|
|
0.00000000909595465, 0.00000000944943118, -0.00000000329957075,
|
|
0.00000000029492075, 0.00000000011874477, -0.00000000004420396,
|
|
0.00000000000361422, 0.00000000000143638, -0.00000000000045848 };
|
|
double asympt[] = { -1.0, 1.0, -3.0, 15.0, -105.0 };
|
|
|
|
double xAbs = fabs(x);
|
|
uint xShort = static_cast<uint>(floor(xAbs));
|
|
double nVal = 0.0;
|
|
if (xShort == 0)
|
|
nVal = taylor_helper(t0, 11, (xAbs * xAbs)) * xAbs;
|
|
else if ((xShort >= 1) && (xShort <= 2))
|
|
nVal = taylor_helper(t2, 23, (xAbs - 2.0));
|
|
else if ((xShort >= 3) && (xShort <= 4))
|
|
nVal = taylor_helper(t4, 20, (xAbs - 4.0));
|
|
else
|
|
{
|
|
double phiAbs = converter->asFloat (phi (xAbs)).asFloat();
|
|
nVal = 0.5 + phiAbs * taylor_helper(asympt, 4, 1.0 / (xAbs * xAbs)) / xAbs;
|
|
}
|
|
|
|
if (x < 0.0)
|
|
return Value (-nVal);
|
|
else
|
|
return Value (nVal);
|
|
}
|
|
|
|
Value ValueCalc::gaussinv (Value xx)
|
|
// this is a weird function
|
|
{
|
|
double x = converter->asFloat (xx).asFloat();
|
|
|
|
double q,t,z;
|
|
|
|
q=x-0.5;
|
|
|
|
if(fabs(q)<=.425)
|
|
{
|
|
t=0.180625-q*q;
|
|
|
|
z=
|
|
q*
|
|
(
|
|
(
|
|
(
|
|
(
|
|
(
|
|
(
|
|
(
|
|
t*2509.0809287301226727+33430.575583588128105
|
|
)
|
|
*t+67265.770927008700853
|
|
)
|
|
*t+45921.953931549871457
|
|
)
|
|
*t+13731.693765509461125
|
|
)
|
|
*t+1971.5909503065514427
|
|
)
|
|
*t+133.14166789178437745
|
|
)
|
|
*t+3.387132872796366608
|
|
)
|
|
/
|
|
(
|
|
(
|
|
(
|
|
(
|
|
(
|
|
(
|
|
(
|
|
t*5226.495278852854561+28729.085735721942674
|
|
)
|
|
*t+39307.89580009271061
|
|
)
|
|
*t+21213.794301586595867
|
|
)
|
|
*t+5394.1960214247511077
|
|
)
|
|
*t+687.1870074920579083
|
|
)
|
|
*t+42.313330701600911252
|
|
)
|
|
*t+1.0
|
|
);
|
|
|
|
}
|
|
else
|
|
{
|
|
if(q>0) t=1-x;
|
|
else t=x;
|
|
|
|
t=::sqrt(-::log(t));
|
|
|
|
if(t<=5.0)
|
|
{
|
|
t+=-1.6;
|
|
|
|
z=
|
|
(
|
|
(
|
|
(
|
|
(
|
|
(
|
|
(
|
|
(
|
|
t*7.7454501427834140764e-4+0.0227238449892691845833
|
|
)
|
|
*t+0.24178072517745061177
|
|
)
|
|
*t+1.27045825245236838258
|
|
)
|
|
*t+3.64784832476320460504
|
|
)
|
|
*t+5.7694972214606914055
|
|
)
|
|
*t+4.6303378461565452959
|
|
)
|
|
*t+1.42343711074968357734
|
|
)
|
|
/
|
|
(
|
|
(
|
|
(
|
|
(
|
|
(
|
|
(
|
|
(
|
|
t*1.05075007164441684324e-9+5.475938084995344946e-4
|
|
)
|
|
*t+0.0151986665636164571966
|
|
)
|
|
*t+0.14810397642748007459
|
|
)
|
|
*t+0.68976733498510000455
|
|
)
|
|
*t+1.6763848301838038494
|
|
)
|
|
*t+2.05319162663775882187
|
|
)
|
|
*t+1.0
|
|
);
|
|
|
|
}
|
|
else
|
|
{
|
|
t+=-5.0;
|
|
|
|
z=
|
|
(
|
|
(
|
|
(
|
|
(
|
|
(
|
|
(
|
|
(
|
|
t*2.01033439929228813265e-7+2.71155556874348757815e-5
|
|
)
|
|
*t+0.0012426609473880784386
|
|
)
|
|
*t+0.026532189526576123093
|
|
)
|
|
*t+0.29656057182850489123
|
|
)
|
|
*t+1.7848265399172913358
|
|
)
|
|
*t+5.4637849111641143699
|
|
)
|
|
*t+6.6579046435011037772
|
|
)
|
|
/
|
|
(
|
|
(
|
|
(
|
|
(
|
|
(
|
|
(
|
|
(
|
|
t*2.04426310338993978564e-15+1.4215117583164458887e-7
|
|
)
|
|
*t+1.8463183175100546818e-5
|
|
)
|
|
*t+7.868691311456132591e-4
|
|
)
|
|
*t+0.0148753612908506148525
|
|
)
|
|
*t+0.13692988092273580531
|
|
)
|
|
*t+0.59983220655588793769
|
|
)
|
|
*t+1.0
|
|
);
|
|
|
|
}
|
|
|
|
if(q<0.0) z=-z;
|
|
}
|
|
|
|
return Value (z);
|
|
}
|
|
|
|
//helper for GetGamma and GetLogGamma
|
|
static double GammaHelp(double& x, bool& bReflect)
|
|
{
|
|
double c[6] = {76.18009173, -86.50532033, 24.01409822,
|
|
-1.231739516, 0.120858003E-2, -0.536382E-5};
|
|
if (x >= 1.0)
|
|
{
|
|
bReflect = false;
|
|
x -= 1.0;
|
|
}
|
|
else
|
|
{
|
|
bReflect = true;
|
|
x = 1.0 - x;
|
|
}
|
|
double s, anum;
|
|
s = 1.0;
|
|
anum = x;
|
|
for (uint i = 0; i < 6; i++)
|
|
{
|
|
anum += 1.0;
|
|
s += c[i]/anum;
|
|
}
|
|
s *= 2.506628275; // sqrt(2*PI)
|
|
return s;
|
|
}
|
|
|
|
Value ValueCalc::GetGamma (Value _x)
|
|
{
|
|
double x = converter->asFloat (_x).asFloat();
|
|
|
|
bool bReflect;
|
|
double G = GammaHelp(x, bReflect);
|
|
G = ::pow(x+5.5,x+0.5)*G/::exp(x+5.5);
|
|
if (bReflect)
|
|
G = M_PI*x/(G*::sin(M_PI*x));
|
|
return Value (G);
|
|
}
|
|
|
|
Value ValueCalc::GetLogGamma (Value _x)
|
|
{
|
|
double x = converter->asFloat (_x).asFloat();
|
|
|
|
bool bReflect;
|
|
double G = GammaHelp(x, bReflect);
|
|
G = (x+0.5)*::log(x+5.5)+::log(G)-(x+5.5);
|
|
if (bReflect)
|
|
G = ::log(M_PI*x)-G-::log(::sin(M_PI*x));
|
|
return Value (G);
|
|
}
|
|
|
|
Value ValueCalc::GetGammaDist (Value _x, Value _alpha,
|
|
Value _beta)
|
|
{
|
|
double x = converter->asFloat (_x).asFloat();
|
|
double alpha = converter->asFloat (_alpha).asFloat();
|
|
double beta = converter->asFloat (_beta).asFloat();
|
|
|
|
if (x == 0.0)
|
|
return Value (0.0);
|
|
|
|
x /= beta;
|
|
double gamma = alpha;
|
|
|
|
double c = 0.918938533204672741;
|
|
double d[10] = {
|
|
0.833333333333333333E-1,
|
|
-0.277777777777777778E-2,
|
|
0.793650793650793651E-3,
|
|
-0.595238095238095238E-3,
|
|
0.841750841750841751E-3,
|
|
-0.191752691752691753E-2,
|
|
0.641025641025641025E-2,
|
|
-0.295506535947712418E-1,
|
|
0.179644372368830573,
|
|
-0.139243221690590111E1
|
|
};
|
|
|
|
double dx = x;
|
|
double dgamma = gamma;
|
|
int maxit = 10000;
|
|
|
|
double z = dgamma;
|
|
double den = 1.0;
|
|
while ( z < 10.0 ) {
|
|
den *= z;
|
|
z += 1.0;
|
|
}
|
|
|
|
double z2 = z*z;
|
|
double z3 = z*z2;
|
|
double z4 = z2*z2;
|
|
double z5 = z2*z3;
|
|
double a = ( z - 0.5 ) * ::log(z) - z + c;
|
|
double b = d[0]/z + d[1]/z3 + d[2]/z5 + d[3]/(z2*z5) + d[4]/(z4*z5) +
|
|
d[5]/(z*z5*z5) + d[6]/(z3*z5*z5) + d[7]/(z5*z5*z5) + d[8]/(z2*z5*z5*z5);
|
|
// double g = exp(a+b) / den;
|
|
|
|
double sum = 1.0 / dgamma;
|
|
double term = 1.0 / dgamma;
|
|
double cut1 = dx - dgamma;
|
|
double cut2 = dx * 10000000000.0;
|
|
|
|
for ( int i=1; i<=maxit; i++ ) {
|
|
double ai = i;
|
|
term = dx * term / ( dgamma + ai );
|
|
sum += term;
|
|
double cutoff = cut1 + ( cut2 * term / sum );
|
|
if ( ai > cutoff ) {
|
|
double t = sum;
|
|
// return pow( dx, dgamma ) * exp( -dx ) * t / g;
|
|
return Value (::exp( dgamma * ::log(dx) - dx - a - b ) * t * den);
|
|
}
|
|
}
|
|
|
|
return Value (1.0); // should not happen ...
|
|
}
|
|
|
|
Value ValueCalc::GetBeta (Value _x, Value _alpha,
|
|
Value _beta)
|
|
{
|
|
if (equal (_beta, 1.0))
|
|
return pow (_x, _alpha);
|
|
else if (equal (_alpha, 1.0))
|
|
// 1.0 - pow (1.0-_x, _beta)
|
|
return sub (1.0, pow (sub (1.0, _x), _beta));
|
|
|
|
double x = converter->asFloat (_x).asFloat();
|
|
double alpha = converter->asFloat (_alpha).asFloat();
|
|
double beta = converter->asFloat (_beta).asFloat();
|
|
|
|
double fEps = 1.0E-8;
|
|
bool bReflect;
|
|
double cf, fA, fB;
|
|
|
|
if (x < (alpha+1.0)/(alpha+beta+1.0)) {
|
|
bReflect = false;
|
|
fA = alpha;
|
|
fB = beta;
|
|
}
|
|
else {
|
|
bReflect = true;
|
|
fA = beta;
|
|
fB = alpha;
|
|
x = 1.0 - x;
|
|
}
|
|
if (x < fEps)
|
|
cf = 0.0;
|
|
else {
|
|
double a1, b1, a2, b2, fnorm, rm, apl2m, d2m, d2m1, cfnew;
|
|
a1 = 1.0; b1 = 1.0;
|
|
b2 = 1.0 - (fA+fB)*x/(fA+1.0);
|
|
if (b2 == 0.0) {
|
|
a2 = b2;
|
|
fnorm = 1.0;
|
|
cf = 1.0;
|
|
}
|
|
else {
|
|
a2 = 1.0;
|
|
fnorm = 1.0/b2;
|
|
cf = a2*fnorm;
|
|
}
|
|
cfnew = 1.0;
|
|
for (uint j = 1; j <= 100; j++) {
|
|
rm = (double) j;
|
|
apl2m = fA + 2.0*rm;
|
|
d2m = rm*(fB-rm)*x/((apl2m-1.0)*apl2m);
|
|
d2m1 = -(fA+rm)*(fA+fB+rm)*x/(apl2m*(apl2m+1.0));
|
|
a1 = (a2+d2m*a1)*fnorm;
|
|
b1 = (b2+d2m*b1)*fnorm;
|
|
a2 = a1 + d2m1*a2*fnorm;
|
|
b2 = b1 + d2m1*b2*fnorm;
|
|
if (b2 != 0.0) {
|
|
fnorm = 1.0/b2;
|
|
cfnew = a2*fnorm;
|
|
if (fabs(cf-cfnew)/cf < fEps)
|
|
j = 101;
|
|
else
|
|
cf = cfnew;
|
|
}
|
|
}
|
|
if (fB < fEps)
|
|
b1 = 1.0E30;
|
|
else
|
|
b1 = ::exp(GetLogGamma(fA).asFloat()+GetLogGamma(fB).asFloat()-
|
|
GetLogGamma(fA+fB).asFloat());
|
|
|
|
cf *= ::pow(x, fA)*::pow(1.0-x,fB)/(fA*b1);
|
|
}
|
|
if (bReflect)
|
|
return Value (1.0-cf);
|
|
else
|
|
return Value (cf);
|
|
}
|
|
|
|
// ------------------------------------------------------
|
|
|
|
|
|
/*
|
|
*
|
|
* The code for calculating Bessel functions is taken
|
|
* from CCMATH, a mathematics library source.code.
|
|
*
|
|
* Original copyright follows:
|
|
*
|
|
* Copyright (C) 2000 Daniel A. Atkinson All rights reserved.
|
|
* This code may be redistributed under the terms of the GNU library
|
|
* public license (LGPL).
|
|
*/
|
|
|
|
static double ccmath_gaml(double x)
|
|
{ double g,h;
|
|
for(g=1.; x<30. ;g*=x,x+=1.); h=x*x;
|
|
g=(x-.5)*log(x)-x+.918938533204672-log(g);
|
|
g+=(1.-(1./6.-(1./3.-1./(4.*h))/(7.*h))/(5.*h))/(12.*x);
|
|
return g;
|
|
}
|
|
|
|
static double ccmath_psi(int m)
|
|
{ double s= -.577215664901533; int k;
|
|
for(k=1; k<m ;++k) s+=1./k;
|
|
return s;
|
|
}
|
|
|
|
static double ccmath_ibes(double v,double x)
|
|
{ double y,s,t,tp; int p,m;
|
|
y=x-9.; if(y>0.) y*=y; tp=v*v*.2+25.;
|
|
if(y<tp){ x/=2.; m=(int)x;
|
|
if(x>0.) s=t=exp(v*log(x)-ccmath_gaml(v+1.));
|
|
else{ if(v>0.) return 0.; else if(v==0.) return 1.;}
|
|
for(p=1,x*=x;;++p){ t*=x/(p*(v+=1.)); s+=t;
|
|
if(p>m && t<1.e-13*s) break;
|
|
}
|
|
}
|
|
else{ double u,a0=1.57079632679490;
|
|
s=t=1./sqrt(x*a0); x*=2.; u=0.;
|
|
for(p=1,y=.5; (tp=fabs(t))>1.e-14 ;++p,y+=1.){
|
|
t*=(v+y)*(v-y)/(p*x); if(y>v && fabs(t)>=tp) break;
|
|
if(!(p&1)) s+=t; else u-=t;
|
|
}
|
|
x/=2.; s=cosh(x)*s+sinh(x)*u;
|
|
}
|
|
return s;
|
|
}
|
|
|
|
static double ccmath_kbes(double v,double x)
|
|
{ double y,s,t,tp,f,a0=1.57079632679490;
|
|
int p,k,m;
|
|
if(x==0.) return HUGE_VAL;
|
|
y=x-10.5; if(y>0.) y*=y; tp=25.+.185*v*v;
|
|
if(y<tp && modf(v+.5,&t)!=0.){ y=1.5+.5*v;
|
|
if(x<y){ x/=2.; m=(int)x; tp=t=exp(v*log(x)-ccmath_gaml(v+1.));
|
|
if(modf(v,&y)==0.){ k=(int)y; tp*=v;
|
|
f=2.*log(x)-ccmath_psi(1)-ccmath_psi(k+1);
|
|
t/=2.; if(!(k&1)) t= -t; s=f*t;
|
|
for(p=1,x*=x;;++p){ f-=1./p+1./(v+=1.);
|
|
t*=x/(p*v); s+=(y=t*f);
|
|
if(p>m && fabs(y)<1.e-14) break; }
|
|
if(k>0){ x= -x; s+=(t=1./(tp*2.));
|
|
for(p=1,--k; k>0 ;++p,--k) s+=(t*=x/(p*k)); }
|
|
}
|
|
else{ f=1./(t*v*2.); t*=a0/sin(2.*a0*v); s=f-t;
|
|
for(p=1,x*=x,tp=v;;++p){
|
|
t*=x/(p*(v+=1.)); f*= -x/(p*(tp-=1.));
|
|
s+=(y=f-t); if(p>m && fabs(y)<1.e-14) break; }
|
|
}
|
|
}
|
|
else{ double tq,h,w,z,r;
|
|
t=12./pow(x,.333); k=(int)(t*t); y=2.*(x+k);
|
|
m=(int)v; v-=m; tp=v*v-.25; v+=1.; tq=v*v-.25;
|
|
for(s=h=1.,r=f=z=w=0.; k>0 ;--k,y-=2.){
|
|
t=(y*h-(k+1)*z)/(k-1-tp/k); z=h; f+=(h=t);
|
|
t=(y*s-(k+1)*w)/(k-1-tq/k); w=s; r+=(s=t); }
|
|
t=sqrt(a0/x)*exp(-x); s*=t/r; h*=t/f; x/=2.; if(m==0) s=h;
|
|
for(k=1; k<m ;++k){ t=v*s/x+h; h=s; s=t; v+=1.;}
|
|
}
|
|
}
|
|
else{ s=t=sqrt(a0/x); x*=2.;
|
|
for(p=1,y=.5; (tp=fabs(t))>1.e-14 ;++p,y+=1.){
|
|
t*=(v+y)*(v-y)/(p*x); if(y>v && fabs(t)>=tp) break; s+=t; }
|
|
s*=exp(-x/2.);
|
|
}
|
|
return s;
|
|
}
|
|
|
|
static double ccmath_jbes(double v,double x)
|
|
{ double y,s,t,tp; int p,m;
|
|
y=x-8.5; if(y>0.) y*=y; tp=v*v/4.+13.69;
|
|
if(y<tp){ x/=2.; m=(int)x;
|
|
if(x>0.) s=t=exp(v*log(x)-ccmath_gaml(v+1.));
|
|
else{ if(v>0.) return 0.; else if(v==0.) return 1.;}
|
|
for(p=1,x*= -x;;++p){ t*=x/(p*(v+=1.)); s+=t;
|
|
if(p>m && fabs(t)<1.e-13) break;
|
|
}
|
|
}
|
|
else{ double u,a0=1.57079632679490;
|
|
s=t=1./sqrt(x*a0); x*=2.; u=0.;
|
|
for(p=1,y=.5; (tp=fabs(t))>1.e-14 ;++p,y+=1.){
|
|
t*=(v+y)*(v-y)/(p*x); if(y>v && fabs(t)>=tp) break;
|
|
if(!(p&1)){ t= -t; s+=t;} else u-=t;
|
|
}
|
|
y=x/2.-(v+.5)*a0; s=cos(y)*s+sin(y)*u;
|
|
}
|
|
return s;
|
|
}
|
|
|
|
static double ccmath_nbes(double v,double x)
|
|
{ double y,s,t,tp,u,f,a0=3.14159265358979;
|
|
int p,k,m;
|
|
y=x-8.5; if(y>0.) y*=y; tp=v*v/4.+13.69;
|
|
if(y<tp){ if(x==0.) return HUGE_VAL;
|
|
x/=2.; m=(int)x; u=t=exp(v*log(x)-ccmath_gaml(v+1.));
|
|
if(modf(v,&y)==0.){ k=(int)y; u*=v;
|
|
f=2.*log(x)-ccmath_psi(1)-ccmath_psi(k+1);
|
|
t/=a0; x*= -x; s=f*t;
|
|
for(p=1;;++p){ f-=1./p+1./(v+=1.);
|
|
t*=x/(p*v); s+=(y=t*f); if(p>m && fabs(y)<1.e-13) break; }
|
|
if(k>0){ x= -x; s-=(t=1./(u*a0));
|
|
for(p=1,--k; k>0 ;++p,--k) s-=(t*=x/(p*k)); }
|
|
}
|
|
else{ f=1./(t*v*a0); t/=tan(a0*v); s=t-f;
|
|
for(p=1,x*=x,u=v;;++p){
|
|
t*= -x/(p*(v+=1.)); f*=x/(p*(u-=1.));
|
|
s+=(y=t-f); if(p>m && fabs(y)<1.e-13) break; }
|
|
}
|
|
}
|
|
else{ x*=2.; s=t=2./sqrt(x*a0); u=0.;
|
|
for(p=1,y=.5; (tp=fabs(t))>1.e-14 ;++p,y+=1.){
|
|
t*=(v+y)*(v-y)/(p*x); if(y>v && fabs(t)>tp) break;
|
|
if(!(p&1)){ t= -t; s+=t;} else u+=t;
|
|
}
|
|
y=(x-(v+.5)*a0)/2.; s=sin(y)*s+cos(y)*u;
|
|
}
|
|
return s;
|
|
}
|
|
|
|
|
|
/* ---------- end of CCMATH code ---------- */
|
|
|
|
|
|
Value ValueCalc::besseli (Value v, Value x)
|
|
{
|
|
double vv = converter->asFloat (v).asFloat ();
|
|
double xx = converter->asFloat (x).asFloat ();
|
|
return Value (ccmath_ibes (vv, xx));
|
|
}
|
|
|
|
Value ValueCalc::besselj (Value v, Value x)
|
|
{
|
|
double vv = converter->asFloat (v).asFloat ();
|
|
double xx = converter->asFloat (x).asFloat ();
|
|
return Value (ccmath_jbes (vv, xx));
|
|
}
|
|
|
|
Value ValueCalc::besselk (Value v, Value x)
|
|
{
|
|
double vv = converter->asFloat (v).asFloat ();
|
|
double xx = converter->asFloat (x).asFloat ();
|
|
return Value (ccmath_kbes (vv, xx));
|
|
}
|
|
|
|
Value ValueCalc::besseln (Value v, Value x)
|
|
{
|
|
double vv = converter->asFloat (v).asFloat ();
|
|
double xx = converter->asFloat (x).asFloat ();
|
|
return Value (ccmath_nbes (vv, xx));
|
|
}
|
|
|
|
// ------------------------------------------------------
|
|
|
|
Value ValueCalc::erf (Value x)
|
|
{
|
|
return Value (::erf (converter->asFloat (x).asFloat()));
|
|
}
|
|
|
|
Value ValueCalc::erfc (Value x)
|
|
{
|
|
return Value (::erfc (converter->asFloat (x).asFloat()));
|
|
}
|
|
|
|
// ------------------------------------------------------
|
|
|
|
void ValueCalc::arrayWalk (const Value &range,
|
|
Value &res, arrayWalkFunc func, Value param)
|
|
{
|
|
if (res.isError()) return;
|
|
if (!range.isArray ())
|
|
{
|
|
func (this, res, range, param);
|
|
return;
|
|
}
|
|
|
|
int rows = range.rows ();
|
|
int cols = range.columns ();
|
|
for (int r = 0; r < rows; r++)
|
|
for (int c = 0; c < cols; c++)
|
|
{
|
|
Value v = range.element (c, r);
|
|
if (v.isArray())
|
|
arrayWalk (v, res, func, param);
|
|
else {
|
|
func (this, res, v, param);
|
|
if (res.format() == Value::fmt_None)
|
|
res.setFormat (v.format());
|
|
}
|
|
}
|
|
}
|
|
|
|
void ValueCalc::arrayWalk (TQValueVector<Value> &range,
|
|
Value &res, arrayWalkFunc func, Value param)
|
|
{
|
|
if (res.isError()) return;
|
|
for (unsigned int i = 0; i < range.count(); ++i)
|
|
arrayWalk (range[i], res, func, param);
|
|
}
|
|
|
|
void ValueCalc::twoArrayWalk (const Value &a1, const Value &a2,
|
|
Value &res, arrayWalkFunc func)
|
|
{
|
|
if (res.isError()) return;
|
|
if (!a1.isArray ())
|
|
{
|
|
func (this, res, a1, a2);
|
|
return;
|
|
}
|
|
|
|
int rows = a1.rows ();
|
|
int cols = a1.columns ();
|
|
int rows2 = a2.rows ();
|
|
int cols2 = a2.columns ();
|
|
if ((rows != rows2) || (cols != cols2)) {
|
|
res = Value::errorVALUE();
|
|
return;
|
|
}
|
|
for (int r = 0; r < rows; r++)
|
|
for (int c = 0; c < cols; c++)
|
|
{
|
|
Value v1 = a1.element (c, r);
|
|
Value v2 = a2.element (c, r);
|
|
if (v1.isArray() && v2.isArray())
|
|
twoArrayWalk (v1, v2, res, func);
|
|
else {
|
|
func (this, res, v1, v2);
|
|
if (res.format() == Value::fmt_None)
|
|
res.setFormat (format (v1.format(), v2.format()));
|
|
}
|
|
}
|
|
}
|
|
|
|
void ValueCalc::twoArrayWalk (TQValueVector<Value> &a1,
|
|
TQValueVector<Value> &a2, Value &res, arrayWalkFunc func)
|
|
{
|
|
if (res.isError()) return;
|
|
if (a1.count() != a2.count()) {
|
|
res = Value::errorVALUE();
|
|
return;
|
|
}
|
|
for (unsigned int i = 0; i < a1.count(); ++i)
|
|
twoArrayWalk (a1[i], a2[i], res, func);
|
|
}
|
|
|
|
arrayWalkFunc ValueCalc::awFunc (const TQString &name)
|
|
{
|
|
if (awFuncs.count(name))
|
|
return awFuncs[name];
|
|
return 0;
|
|
}
|
|
|
|
void ValueCalc::registerAwFunc (const TQString &name, arrayWalkFunc func)
|
|
{
|
|
awFuncs[name] = func;
|
|
}
|
|
|
|
// ------------------------------------------------------
|
|
|
|
Value ValueCalc::sum (const Value &range, bool full)
|
|
{
|
|
Value res;
|
|
arrayWalk (range, res, awFunc (full ? "suma" : "sum"), 0);
|
|
return res;
|
|
}
|
|
|
|
Value ValueCalc::sum (TQValueVector<Value> range, bool full)
|
|
{
|
|
Value res;
|
|
arrayWalk (range, res, awFunc (full ? "suma" : "sum"), 0);
|
|
return res;
|
|
}
|
|
|
|
// sum of squares
|
|
Value ValueCalc::sumsq (const Value &range, bool full)
|
|
{
|
|
Value res;
|
|
arrayWalk (range, res, awFunc (full ? "sumsqa" : "sumsq"), 0);
|
|
return res;
|
|
}
|
|
|
|
Value ValueCalc::sumIf (const Value &range,
|
|
const Value &checkRange, const Condition &cond)
|
|
{
|
|
if (!range.isArray())
|
|
{
|
|
if (matches (cond, checkRange.element (0, 0)))
|
|
return converter->asNumeric (range);
|
|
return Value (0.0);
|
|
}
|
|
|
|
//if we are here, we have an array
|
|
Value res;
|
|
|
|
unsigned int rows = range.rows ();
|
|
unsigned int cols = range.columns ();
|
|
for (unsigned int r = 0; r < rows; r++)
|
|
for (unsigned int c = 0; c < cols; c++)
|
|
{
|
|
Value v = range.element (c, r);
|
|
Value newcheck = v;
|
|
if ((c < checkRange.columns()) && (r < checkRange.rows()))
|
|
newcheck = checkRange.element (c, r);
|
|
|
|
if (v.isArray())
|
|
res = add (res, sumIf (v, newcheck, cond));
|
|
else
|
|
if (matches (cond, newcheck))
|
|
res = add (res, v);
|
|
}
|
|
|
|
return res;
|
|
}
|
|
|
|
int ValueCalc::count (const Value &range, bool full)
|
|
{
|
|
Value res = 0;
|
|
arrayWalk (range, res, awFunc (full ? "counta" : "count"), 0);
|
|
return converter->asInteger (res).asInteger ();
|
|
}
|
|
|
|
int ValueCalc::count (TQValueVector<Value> range, bool full)
|
|
{
|
|
Value res = 0;
|
|
arrayWalk (range, res, awFunc (full ? "counta" : "count"), 0);
|
|
return converter->asInteger (res).asInteger ();
|
|
}
|
|
|
|
int ValueCalc::countIf (const Value &range, const Condition &cond)
|
|
{
|
|
if (!range.isArray())
|
|
{
|
|
if (matches (cond, range))
|
|
return range.isEmpty() ? 0 : 1;
|
|
return 0;
|
|
}
|
|
|
|
int res = 0;
|
|
|
|
int cols = range.columns ();
|
|
int rows = range.rows ();
|
|
for (int r = 0; r < rows; r++)
|
|
for (int c = 0; c < cols; c++)
|
|
{
|
|
Value v = range.element (c, r);
|
|
|
|
if (v.isArray())
|
|
res += countIf (v, cond);
|
|
else
|
|
if (matches (cond, v))
|
|
res++;
|
|
}
|
|
|
|
return res;
|
|
}
|
|
|
|
Value ValueCalc::avg (const Value &range, bool full)
|
|
{
|
|
int cnt = count (range, full);
|
|
if (cnt)
|
|
return div (sum (range, full), cnt);
|
|
return Value (0.0);
|
|
}
|
|
|
|
Value ValueCalc::avg (TQValueVector<Value> range, bool full)
|
|
{
|
|
int cnt = count (range, full);
|
|
if (cnt)
|
|
return div (sum (range, full), cnt);
|
|
return Value (0.0);
|
|
}
|
|
|
|
Value ValueCalc::max (const Value &range, bool full)
|
|
{
|
|
Value res;
|
|
arrayWalk (range, res, awFunc (full ? "maxa" : "max"), 0);
|
|
return res;
|
|
}
|
|
|
|
Value ValueCalc::max (TQValueVector<Value> range, bool full)
|
|
{
|
|
Value res;
|
|
arrayWalk (range, res, awFunc (full ? "maxa" : "max"), 0);
|
|
return res;
|
|
}
|
|
|
|
Value ValueCalc::min (const Value &range, bool full)
|
|
{
|
|
Value res;
|
|
arrayWalk (range, res, awFunc (full ? "mina" : "min"), 0);
|
|
return res;
|
|
}
|
|
|
|
Value ValueCalc::min (TQValueVector<Value> range, bool full)
|
|
{
|
|
Value res;
|
|
arrayWalk (range, res, awFunc (full ? "mina" : "min"), 0);
|
|
return res;
|
|
}
|
|
|
|
Value ValueCalc::product (const Value &range, Value init,
|
|
bool full)
|
|
{
|
|
Value res = init;
|
|
if (isZero (init)) // special handling of a zero, due to excel-compat
|
|
{
|
|
if (count (range, full) == 0)
|
|
return init;
|
|
res = 1.0;
|
|
}
|
|
arrayWalk (range, res, awFunc (full ? "proda" : "prod"), 0);
|
|
return res;
|
|
}
|
|
|
|
Value ValueCalc::product (TQValueVector<Value> range,
|
|
Value init, bool full)
|
|
{
|
|
Value res = init;
|
|
if (isZero (init)) // special handling of a zero, due to excel-compat
|
|
{
|
|
if (count (range, full) == 0)
|
|
return init;
|
|
res = 1.0;
|
|
}
|
|
arrayWalk (range, res, awFunc (full ? "proda" : "prod"), 0);
|
|
return res;
|
|
}
|
|
|
|
Value ValueCalc::stddev (const Value &range, bool full)
|
|
{
|
|
return stddev (range, avg (range, full), full);
|
|
}
|
|
|
|
Value ValueCalc::stddev (const Value &range, Value avg,
|
|
bool full)
|
|
{
|
|
Value res;
|
|
int cnt = count (range, full);
|
|
arrayWalk (range, res, awFunc (full ? "devsqa" : "devsq"), avg);
|
|
return sqrt (div (res, cnt-1));
|
|
}
|
|
|
|
Value ValueCalc::stddev (TQValueVector<Value> range, bool full)
|
|
{
|
|
return stddev (range, avg (range, full), full);
|
|
}
|
|
|
|
Value ValueCalc::stddev (TQValueVector<Value> range,
|
|
Value avg, bool full)
|
|
{
|
|
Value res;
|
|
int cnt = count (range, full);
|
|
arrayWalk (range, res, awFunc (full ? "devsqa" : "devsq"), avg);
|
|
return sqrt (div (res, cnt-1));
|
|
}
|
|
|
|
Value ValueCalc::stddevP (const Value &range, bool full)
|
|
{
|
|
return stddevP (range, avg (range, full), full);
|
|
}
|
|
|
|
Value ValueCalc::stddevP (const Value &range, Value avg,
|
|
bool full)
|
|
{
|
|
Value res;
|
|
int cnt = count (range, full);
|
|
arrayWalk (range, res, awFunc (full ? "devsqa" : "devsq"), avg);
|
|
return sqrt (div (res, cnt));
|
|
}
|
|
|
|
Value ValueCalc::stddevP (TQValueVector<Value> range, bool full)
|
|
{
|
|
return stddevP (range, avg (range, full), full);
|
|
}
|
|
|
|
Value ValueCalc::stddevP (TQValueVector<Value> range,
|
|
Value avg, bool full)
|
|
{
|
|
Value res;
|
|
int cnt = count (range, full);
|
|
arrayWalk (range, res, awFunc (full ? "devsqa" : "devsq"), avg);
|
|
return sqrt (div (res, cnt));
|
|
}
|
|
|
|
Value::Format ValueCalc::format (Value::Format a,
|
|
Value::Format b)
|
|
{
|
|
if ((a == Value::fmt_None) || (a == Value::fmt_Boolean))
|
|
return b;
|
|
return a;
|
|
}
|
|
|
|
|
|
// ------------------------------------------------------
|
|
|
|
void ValueCalc::getCond (Condition &cond, Value val)
|
|
{
|
|
// not a string - we simply take it as a numeric value
|
|
// that also handles floats, logical values, date/time and such
|
|
if (!val.isString()) {
|
|
cond.comp = isEqual;
|
|
cond.type = numeric;
|
|
cond.value = converter->asFloat (val).asFloat();
|
|
return;
|
|
}
|
|
TQString text = converter->asString (val).asString();
|
|
cond.comp = isEqual;
|
|
text = text.stripWhiteSpace();
|
|
|
|
if ( text.startsWith( "<=" ) )
|
|
{
|
|
cond.comp = lessEqual;
|
|
text = text.remove( 0, 2 );
|
|
}
|
|
else if ( text.startsWith( ">=" ) )
|
|
{
|
|
cond.comp = greaterEqual;
|
|
text = text.remove( 0, 2 );
|
|
}
|
|
else if ( text.startsWith( "!=" ) || text.startsWith( "<>" ) )
|
|
{
|
|
cond.comp = notEqual;
|
|
text = text.remove( 0, 2 );
|
|
}
|
|
else if ( text.startsWith( "==" ) )
|
|
{
|
|
cond.comp = isEqual;
|
|
text = text.remove( 0, 2 );
|
|
}
|
|
else if ( text.startsWith( "<" ) )
|
|
{
|
|
cond.comp = isLess;
|
|
text = text.remove( 0, 1 );
|
|
}
|
|
else if ( text.startsWith( ">" ) )
|
|
{
|
|
cond.comp = isGreater;
|
|
text = text.remove( 0, 1 );
|
|
}
|
|
else if ( text.startsWith( "=" ) )
|
|
{
|
|
cond.comp = isEqual;
|
|
text = text.remove( 0, 1 );
|
|
}
|
|
|
|
text = text.stripWhiteSpace();
|
|
|
|
bool ok = false;
|
|
double d = text.toDouble( &ok );
|
|
if ( ok )
|
|
{
|
|
cond.type = numeric;
|
|
cond.value = d;
|
|
}
|
|
else
|
|
{
|
|
cond.type = string;
|
|
cond.stringValue = text;
|
|
}
|
|
}
|
|
|
|
bool ValueCalc::matches (const Condition &cond, Value val)
|
|
{
|
|
if (val.isEmpty())
|
|
return false;
|
|
if (cond.type == numeric) {
|
|
double d = converter->asFloat (val).asFloat();
|
|
switch ( cond.comp )
|
|
{
|
|
case isEqual:
|
|
if (approxEqual (d, cond.value)) return true;
|
|
break;
|
|
|
|
case isLess:
|
|
if (d < cond.value) return true;
|
|
break;
|
|
|
|
case isGreater:
|
|
if (d > cond.value) return true;
|
|
break;
|
|
|
|
case lessEqual:
|
|
if (d <= cond.value) return true;
|
|
break;
|
|
|
|
case greaterEqual:
|
|
if (d >= cond.value) return true;
|
|
break;
|
|
|
|
case notEqual:
|
|
if (d != cond.value) return true;
|
|
break;
|
|
}
|
|
} else {
|
|
TQString d = converter->asString (val).asString();
|
|
switch ( cond.comp )
|
|
{
|
|
case isEqual:
|
|
if (d == cond.stringValue) return true;
|
|
break;
|
|
|
|
case isLess:
|
|
if (d < cond.stringValue) return true;
|
|
break;
|
|
|
|
case isGreater:
|
|
if (d > cond.stringValue) return true;
|
|
break;
|
|
|
|
case lessEqual:
|
|
if (d <= cond.stringValue) return true;
|
|
break;
|
|
|
|
case greaterEqual:
|
|
if (d >= cond.stringValue) return true;
|
|
break;
|
|
|
|
case notEqual:
|
|
if (d != cond.stringValue) return true;
|
|
break;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|