|
|
|
/* 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.
|
|
|
|
*/
|
|
|
|
|
|
|
|
#ifndef KSPREAD_VALUECALC
|
|
|
|
#define KSPREAD_VALUECALC
|
|
|
|
|
|
|
|
#include <map>
|
|
|
|
|
|
|
|
#include <tqvaluelist.h>
|
|
|
|
#include <tqvaluevector.h>
|
|
|
|
|
|
|
|
#include "kspread_value.h"
|
|
|
|
|
|
|
|
namespace KSpread
|
|
|
|
{
|
|
|
|
class Doc;
|
|
|
|
class ValueCalc;
|
|
|
|
class ValueConverter;
|
|
|
|
|
|
|
|
// Condition structures
|
|
|
|
enum Comp { isEqual, isLess, isGreater, lessEqual, greaterEqual, notEqual };
|
|
|
|
enum Type { numeric, string };
|
|
|
|
|
|
|
|
struct Condition
|
|
|
|
{
|
|
|
|
Comp comp;
|
|
|
|
int index;
|
|
|
|
double value;
|
|
|
|
TQString stringValue;
|
|
|
|
Type type;
|
|
|
|
};
|
|
|
|
|
|
|
|
typedef TQValueList<Condition> ConditionList;
|
|
|
|
|
|
|
|
typedef void (*arrayWalkFunc) (ValueCalc *, Value &result,
|
|
|
|
Value val, Value param);
|
|
|
|
|
|
|
|
/**
|
|
|
|
The ValueCalc class is used to perform all sorts of calculations.
|
|
|
|
No other means of calculation should be performed, to achieve
|
|
|
|
transparency, and to ease addition of new datatypes.
|
|
|
|
|
|
|
|
Currently, most functions simply convert data to double and work with that.
|
|
|
|
The idea is such that after we add support for bigger precision, we only need
|
|
|
|
to adjust this class and the parsing/formatting/converting classes. All
|
|
|
|
function implementations will remain exactly the same.
|
|
|
|
|
|
|
|
Of course, for some functions, it might be impossible to apply them
|
|
|
|
on all datatypes, but since all of them can be applied on both
|
|
|
|
doubles and GnuMP-based numbers, that is not of much concern ;)
|
|
|
|
*/
|
|
|
|
|
|
|
|
class ValueCalc {
|
|
|
|
public:
|
|
|
|
ValueCalc (ValueConverter* c);
|
|
|
|
|
|
|
|
ValueConverter *conv () { return converter; };
|
|
|
|
|
|
|
|
// some functions need access to the document
|
|
|
|
void setDoc (Doc *d) { _doc = d; };
|
|
|
|
Doc *doc () { return _doc; };
|
|
|
|
|
|
|
|
/** basic arithmetic operations */
|
|
|
|
Value add (const Value &a, const Value &b);
|
|
|
|
Value sub (const Value &a, const Value &b);
|
|
|
|
Value mul (const Value &a, const Value &b);
|
|
|
|
Value div (const Value &a, const Value &b);
|
|
|
|
Value mod (const Value &a, const Value &b);
|
|
|
|
Value pow (const Value &a, const Value &b);
|
|
|
|
Value sqr (const Value &a);
|
|
|
|
Value sqrt (const Value &a);
|
|
|
|
Value add (const Value &a, double b);
|
|
|
|
Value sub (const Value &a, double b);
|
|
|
|
Value mul (const Value &a, double b);
|
|
|
|
Value div (const Value &a, double b);
|
|
|
|
Value pow (const Value &a, double b);
|
|
|
|
Value abs (const Value &a);
|
|
|
|
|
|
|
|
/** comparison and related */
|
|
|
|
bool isZero (const Value &a);
|
|
|
|
bool isEven (const Value &a);
|
|
|
|
/** numerical comparison */
|
|
|
|
bool equal (const Value &a, const Value &b);
|
|
|
|
/** numerical comparison with a little epsilon tolerance */
|
|
|
|
bool approxEqual (const Value &a, const Value &b);
|
|
|
|
/** numerical comparison */
|
|
|
|
bool greater (const Value &a, const Value &b);
|
|
|
|
/** numerical comparison - greater or equal */
|
|
|
|
bool gequal (const Value &a, const Value &b);
|
|
|
|
/** numerical comparison */
|
|
|
|
bool lower (const Value &a, const Value &b);
|
|
|
|
/** string comparison */
|
|
|
|
bool strEqual (const Value &a, const Value &b);
|
|
|
|
int sign (const Value &a);
|
|
|
|
|
|
|
|
/** rounding */
|
|
|
|
Value roundDown (const Value &a, const Value &digits);
|
|
|
|
Value roundUp (const Value &a, const Value &digits);
|
|
|
|
Value round (const Value &a, const Value &digits);
|
|
|
|
Value roundDown (const Value &a, int digits = 0);
|
|
|
|
Value roundUp (const Value &a, int digits = 0);
|
|
|
|
Value round (const Value &a, int digits = 0);
|
|
|
|
|
|
|
|
/** logarithms and exponentials */
|
|
|
|
Value log (const Value &number, const Value &base);
|
|
|
|
Value log (const Value &number, double base = 10);
|
|
|
|
Value ln (const Value &number);
|
|
|
|
Value exp (const Value &number);
|
|
|
|
|
|
|
|
/** constants */
|
|
|
|
Value pi ();
|
|
|
|
Value eps ();
|
|
|
|
|
|
|
|
/** random number from <0.0, range) */
|
|
|
|
Value random (double range = 1.0);
|
|
|
|
Value random (Value range);
|
|
|
|
|
|
|
|
/** some computational functions */
|
|
|
|
Value fact (const Value &which);
|
|
|
|
Value fact (const Value &which, const Value &end);
|
|
|
|
Value fact (int which, int end = 0);
|
|
|
|
/** double factorial (every other number multiplied) */
|
|
|
|
Value factDouble (int which);
|
|
|
|
Value factDouble (Value which);
|
|
|
|
|
|
|
|
/** combinations */
|
|
|
|
Value combin (int n, int k);
|
|
|
|
Value combin (Value n, Value k);
|
|
|
|
|
|
|
|
/** greatest common divisor */
|
|
|
|
Value gcd (const Value &a, const Value &b);
|
|
|
|
/** lowest common multiplicator */
|
|
|
|
Value lcm (const Value &a, const Value &b);
|
|
|
|
|
|
|
|
/** base conversion 10 -> base */
|
|
|
|
Value base (const Value &val, int base = 16, int prec = 0);
|
|
|
|
/** base conversion base -> 10 */
|
|
|
|
Value fromBase (const Value &val, int base = 16);
|
|
|
|
|
|
|
|
/** goniometric functions */
|
|
|
|
Value sin (const Value &number);
|
|
|
|
Value cos (const Value &number);
|
|
|
|
Value tg (const Value &number);
|
|
|
|
Value cotg (const Value &number);
|
|
|
|
Value asin (const Value &number);
|
|
|
|
Value acos (const Value &number);
|
|
|
|
Value atg (const Value &number);
|
|
|
|
Value atan2 (const Value &y, const Value &x);
|
|
|
|
|
|
|
|
/** hyperbolic functions */
|
|
|
|
Value sinh (const Value &number);
|
|
|
|
Value cosh (const Value &number);
|
|
|
|
Value tgh (const Value &number);
|
|
|
|
Value asinh (const Value &number);
|
|
|
|
Value acosh (const Value &number);
|
|
|
|
Value atgh (const Value &number);
|
|
|
|
|
|
|
|
/** some statistical stuff
|
|
|
|
TODO: we may want to move these over to a separate class or something,
|
|
|
|
as the functions are mostly big */
|
|
|
|
Value phi (Value x);
|
|
|
|
Value gauss (Value xx);
|
|
|
|
Value gaussinv (Value xx);
|
|
|
|
Value GetGamma (Value _x);
|
|
|
|
Value GetLogGamma (Value _x);
|
|
|
|
Value GetGammaDist (Value _x, Value _alpha,
|
|
|
|
Value _beta);
|
|
|
|
Value GetBeta (Value _x, Value _alpha,
|
|
|
|
Value _beta);
|
|
|
|
|
|
|
|
/** bessel functions - may also end up being separated from here */
|
|
|
|
Value besseli (Value v, Value x);
|
|
|
|
Value besselj (Value v, Value x);
|
|
|
|
Value besselk (Value v, Value x);
|
|
|
|
Value besseln (Value v, Value x);
|
|
|
|
|
|
|
|
/** error functions (see: man erf) */
|
|
|
|
Value erf (Value x);
|
|
|
|
Value erfc (Value x);
|
|
|
|
|
|
|
|
/** array/range walking */
|
|
|
|
void arrayWalk (const Value &range, Value &res,
|
|
|
|
arrayWalkFunc func, Value param);
|
|
|
|
/** Walk the array in function-like style.
|
|
|
|
This method is here to avoid duplication in function handlers. */
|
|
|
|
void arrayWalk (TQValueVector<Value> &range, Value &res,
|
|
|
|
arrayWalkFunc func, Value param);
|
|
|
|
void twoArrayWalk (const Value &a1, const Value &a2,
|
|
|
|
Value &res, arrayWalkFunc func);
|
|
|
|
void twoArrayWalk (TQValueVector<Value> &a1,
|
|
|
|
TQValueVector<Value> &a2, Value &res, arrayWalkFunc func);
|
|
|
|
arrayWalkFunc awFunc (const TQString &name);
|
|
|
|
void registerAwFunc (const TQString &name, arrayWalkFunc func);
|
|
|
|
|
|
|
|
/** basic range functions */
|
|
|
|
// if full is true, A-version is used (means string/bool values included)
|
|
|
|
Value sum (const Value &range, bool full = true);
|
|
|
|
Value sumsq (const Value &range, bool full = true);
|
|
|
|
Value sumIf (const Value &range,
|
|
|
|
const Value &checkRange, const Condition &cond);
|
|
|
|
int count (const Value &range, bool full = true);
|
|
|
|
int countIf (const Value &range, const Condition &cond);
|
|
|
|
Value avg (const Value &range, bool full = true);
|
|
|
|
Value max (const Value &range, bool full = true);
|
|
|
|
Value min (const Value &range, bool full = true);
|
|
|
|
Value product (const Value &range, Value init,
|
|
|
|
bool full = true);
|
|
|
|
Value stddev (const Value &range, bool full = true);
|
|
|
|
Value stddev (const Value &range, Value avg,
|
|
|
|
bool full = true);
|
|
|
|
Value stddevP (const Value &range, bool full = true);
|
|
|
|
Value stddevP (const Value &range, Value avg,
|
|
|
|
bool full = true);
|
|
|
|
|
|
|
|
/** range functions using value lists */
|
|
|
|
Value sum (TQValueVector<Value> range, bool full = true);
|
|
|
|
int count (TQValueVector<Value> range, bool full = true);
|
|
|
|
Value avg (TQValueVector<Value> range, bool full = true);
|
|
|
|
Value max (TQValueVector<Value> range, bool full = true);
|
|
|
|
Value min (TQValueVector<Value> range, bool full = true);
|
|
|
|
Value product (TQValueVector<Value> range, Value init,
|
|
|
|
bool full = true);
|
|
|
|
Value stddev (TQValueVector<Value> range, bool full = true);
|
|
|
|
Value stddev (TQValueVector<Value> range, Value avg,
|
|
|
|
bool full = true);
|
|
|
|
Value stddevP (TQValueVector<Value> range, bool full = true);
|
|
|
|
Value stddevP (TQValueVector<Value> range, Value avg,
|
|
|
|
bool full = true);
|
|
|
|
|
|
|
|
/**
|
|
|
|
This method parses the condition in string text to the condition cond.
|
|
|
|
It sets the condition's type and value.
|
|
|
|
*/
|
|
|
|
void getCond (Condition &cond, Value val);
|
|
|
|
|
|
|
|
/**
|
|
|
|
Returns true if value d matches the condition cond, built with getCond().
|
|
|
|
Otherwise, it returns false.
|
|
|
|
*/
|
|
|
|
bool matches (const Condition &cond, Value d);
|
|
|
|
|
|
|
|
protected:
|
|
|
|
ValueConverter* converter;
|
|
|
|
/** return result formatting, based on these two values */
|
|
|
|
Value::Format format (Value::Format a, Value::Format b);
|
|
|
|
|
|
|
|
Doc *_doc;
|
|
|
|
|
|
|
|
/** registered array-walk functions */
|
|
|
|
std::map<TQString, arrayWalkFunc> awFuncs;
|
|
|
|
};
|
|
|
|
|
|
|
|
} //namespace KSpread
|
|
|
|
|
|
|
|
|
|
|
|
#endif // KSPREAD_VALUECALC
|
|
|
|
|