/usr/include/BALL/MATHS/parsedFunction.h is in libball1.4-dev 1.4.1+20111206-3.
This file is owned by root:root, with mode 0o644.
The actual contents of the file can be viewed below.
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 | // -*- Mode: C++; tab-width: 2; -*-
// vi: set ts=2:
//
#ifndef BALL_MATHS_PARSEDFUNCTION_H
#define BALL_MATHS_PARSEDFUNCTION_H
#ifndef BALL_DATATYPE_STRINGHASHMAP_H
# include <BALL/DATATYPE/stringHashMap.h>
#endif
#include <numeric>
using std::unary_function;
extern double ParsedFunctionResult;
extern int ParsedFunctionparse();
extern void ParsedFunction_initBuffer(const char*);
extern void ParsedFunction_delBuffer();
namespace BALL
{
/** \addtogroup FunctionClasses
* @{
*/
extern StringHashMap<double*> *ParsedFunctionConstants;
extern StringHashMap<double (*)(double)> *ParsedFunctionFunctions;
/** ParsedFunction.
This function type contains a double - valued function string like
\f$var1=atan(.5); sin(cos(atan(asin(exp(X+var1)))))\f$.
When the operator () is called, \f$X\f$ is replaced with
the argument of the operator call and the function string
is parsed and evaluated.
*/
template <typename arg>
class ParsedFunction
: public unary_function<arg, double>
{
public:
/** @name Constructors and Destructors
*/
//@{
/// Default constructor
ParsedFunction();
/// Detailed constructor.
ParsedFunction(const String& expression);
/// Copy constructor
ParsedFunction(const ParsedFunction& func);
/// Destructor
~ParsedFunction();
//@}
/** @name Accessors
*/
//@{
/** Evaluate the function at point \f$p\f$.
* @throw Exception::ParseError if a syntax error was encountered
*/
double operator () (arg p);
//@}
/** @name Parsing
*/
//@{
/** This function initializes the function table and the constant table of our parser.
*/
void initTable();
//@}
/** The table of constants
*/
StringHashMap<double*> constants_;
/** The table of functions
*/
StringHashMap<double (*)(double)> functions_;
protected:
String expression_;
};
template <typename arg>
ParsedFunction<arg>::ParsedFunction()
: constants_(),
functions_(),
expression_("")
{
initTable();
}
template <typename arg>
ParsedFunction<arg>::ParsedFunction(const String& expression)
: constants_(),
functions_(),
expression_(expression)
{
initTable();
}
template <typename arg>
ParsedFunction<arg>::ParsedFunction(const ParsedFunction& func)
{
constants_ = func.constants_;
functions_ = func.functions_;
expression_ = func.expression_;
initTable();
}
template <typename arg>
ParsedFunction<arg>::~ParsedFunction()
{
}
template <typename arg>
double ParsedFunction<arg>::operator () (arg argument)
{
constants_["X"] = (double*)&argument;
ParsedFunctionConstants = &constants_;
ParsedFunctionFunctions = &functions_;
ParsedFunction_initBuffer(expression_.c_str());
ParsedFunctionparse();
ParsedFunction_delBuffer();
return ParsedFunctionResult;
}
template <>
BALL_EXPORT double ParsedFunction<float>::operator () (float argument);
template <>
BALL_EXPORT double ParsedFunction<double>::operator () (double argument);
template <typename arg>
void ParsedFunction<arg>::initTable()
{
// initialize the functions table
functions_["sin"] = (double(*)(double))&sin;
functions_["cos"] = (double(*)(double))&cos;
functions_["asin"] = (double(*)(double))&asin;
functions_["acos"] = (double(*)(double))&acos;
functions_["tan"] = (double(*)(double))&tan;
functions_["atan"] = (double(*)(double))&atan;
functions_["ln"] = (double(*)(double))&log;
functions_["exp"] = (double(*)(double))&exp;
functions_[""] = 0;
}
/** @} */
}
#endif // BALL_MATHS_PARSEDFUNCTION_H
|