mirror of
https://github.com/jkriege2/JKQtPlotter.git
synced 2024-12-25 10:01:38 +08:00
876 lines
37 KiB
C++
876 lines
37 KiB
C++
/*
|
|
Copyright (c) 2008-2022 Jan W. Krieger (<jan@jkrieger.de>)
|
|
|
|
|
|
|
|
This software is free software: you can redistribute it and/or modify
|
|
it under the terms of the GNU Lesser General Public License (LGPL) as published by
|
|
the Free Software Foundation, either version 2.1 of the License, or
|
|
(at your option) any later version.
|
|
|
|
This program 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 Lesser General Public License (LGPL) for more details.
|
|
|
|
You should have received a copy of the GNU Lesser General Public License (LGPL)
|
|
along with this program. If not, see <http://www.gnu.org/licenses/>.
|
|
*/
|
|
|
|
|
|
#include <iostream>
|
|
#include <string>
|
|
#include <cstdio>
|
|
#include <vector>
|
|
#include <map>
|
|
#include <sstream>
|
|
#include <exception>
|
|
#include <ctype.h>
|
|
#include <list>
|
|
#include <utility>
|
|
#include "jkqtmath/jkqtmath_imexport.h"
|
|
|
|
#ifndef JKQTPMATHPARSER_H
|
|
#define JKQTPMATHPARSER_H
|
|
|
|
|
|
|
|
|
|
/*! \brief A simple function parser to parse (build memory tree representation) and
|
|
evaluate simple mathematical expressions
|
|
\ingroup jkqtptools_math_parser
|
|
|
|
|
|
This class implements a simple function parser which can parse
|
|
mathematical expressions like <code> z=a*3+2.34^2*sin(pi*sqrt(x))</code> .
|
|
More than one expression can be separated by semicolon ';'. The result of
|
|
a parse operation will be a memory structure (tree) representing the given
|
|
expression.
|
|
The parser can cope with constants and (user defined) variables and supports
|
|
the data types number (double precision floating point), boolean (true/false)
|
|
and string. It already contains a lot of fundamental mathematical functions
|
|
(i.e. nearly all the functions from C StdLib).
|
|
|
|
\section jkmp_constantsAndVars constants and variables:
|
|
This class provides management utilities for constants and variables. Variables
|
|
can also be defined as external variables, when a pointer to corresponding
|
|
memory is provided by the calling program. The parser supports a variable
|
|
assign operation \code a=<expression>\endcode which allows to define new
|
|
variables during evaluation. There are some mathematical standard constants
|
|
registered by calling JKQTPMathParser::addStandardVariables():
|
|
- \c pi = \f$ \pi \f$
|
|
- \c e = \f$ \exp(1) \f$
|
|
- \c sqrt2 = \f$ \sqrt{2} \f$
|
|
- \c version = the parser version
|
|
- \c log2e = \f$ \log_2(e) \f$
|
|
- \c log10e = \f$ \log_{10}(e) \f$
|
|
- \c ln2 = \f$ \ln(2)=\log_{e}(2) \f$
|
|
- \c ln10 = \f$ \ln(10)=\log_{e}(10) \f$
|
|
- \c h = \f$ 6.6260689633\cdot 10^{-34}\;\mathrm{J\cdot s} \f$ (planck constant)
|
|
- \c hbar = \f$ \hbar=\frac{h}{2\pi}= 1.05457162853\cdot 10^{-34}\;\mathrm{J\cdot s} \f$ (planck constant)
|
|
- \c epsilon0 = \f$ \epsilon_0= 8.854187817\cdot 10^{-12}\;\mathrm{\frac{F}{m}} \f$ (electric constant)
|
|
- \c mu0 = \f$ \mu_0=2\pi\cdot 10^{-7}= 12.566370614\cdot 10^{-7}\;\mathrm{\frac{N}{A^2}} \f$ (magnetic constant)
|
|
- \c c = \f$ 299792458\;\mathrm{\frac{m}{s}} \f$ (speed of light in vacuum)
|
|
- \c ce = \f$ 1.60217648740\cdot 10^{-19}\;\mathrm{C}\f$ (elementary charge)
|
|
- \c muB = \f$ \mu_B= 927.40091523\cdot 10^{-26}\;\mathrm{\frac{J}{T}} \f$ (Bohr magneton)
|
|
- \c muB_eV = \f$ \mu_B=5.788381755579\cdot 10^{-5}\;\mathrm{\frac{eV}{T}} \f$ (Bohr magneton)
|
|
- \c muN = \f$ \mu_N=5.0507832413\cdot 10^{-27}\;\mathrm{\frac{J}{T}} \f$ (nuclear magneton)
|
|
- \c muN_eV = \f$ \mu_N=3.152451232645\cdot 10^{-8}\;\mathrm{\frac{eV}{T}} \f$ (nuclear magneton)
|
|
- \c me = \f$ m_e= 9.1093821545\cdot 10^{-31}\;\mathrm{kg} \f$ (mass of electron)
|
|
- \c mp = \f$ m_p= 1.67262163783\cdot 10^{-27}\;\mathrm{kg} \f$ (mass of proton)
|
|
- \c mn = \f$ m_n= 1.67492721184\cdot 10^{-27}\;\mathrm{kg} \f$ (mass of neutron)
|
|
- \c NA = \f$ N_A= 6.0221417930\cdot 10^{23} \f$ (Avogadro constant = particles in 1 mol)
|
|
- \c kB = \f$ k_B=1.380650424\cdot 10^{-23}\;\mathrm{\frac{J}{K}} \f$ (Boltzman constant)
|
|
- \c kB_eV = \f$ k_B=8.61734315\cdot 10^{-5}\;\mathrm{\frac{eV}{K}} \f$ (Boltzman constant)
|
|
.
|
|
You can add user-defined contants by calling JKQTPMathParser::addVariableDouble()
|
|
JKQTPMathParser::addVariableBoolean() or JKQTPMathParser::addVariableString()
|
|
|
|
|
|
\section jkmp_functions functions:
|
|
this class provides a wide range of (mathematical) functions:
|
|
- sinc, gauss, slit, theta, tanc, sigmoid
|
|
- asin, acos, atan, atan2,
|
|
- sin, cos, tan,
|
|
- sinh, cosh, tanh
|
|
- log, log2, log10,
|
|
- exp, sqr, sqrt
|
|
- abs, sign
|
|
- if
|
|
- erf, erfc, lgamma, tgamma, j0, j1, jn, y0, y1, yn
|
|
- rand, srand
|
|
- ceil, floor, trunc, round,
|
|
- fmod, min, max
|
|
- floattostr, booltostr/bool2str, inttostr, num2str
|
|
- tosystempathseparator
|
|
- setdefault
|
|
- strdate
|
|
- cmdparam, argv
|
|
.
|
|
|
|
these functions are registered by calling JKQTPMathParser::addStandardFunctions().
|
|
you can add new functions by calling JKQTPMathParser::addFunction();
|
|
|
|
\section jkmp_resultsofparsing result of parsing and evaluation:
|
|
The result of calling JKQTPMathParser::parse()
|
|
will be a tree-like structure in memory. The parse() function will return
|
|
a pointer to the root node of this structure. All nodes inherit from
|
|
jkmpNode class. To evaluate such a structure simply call jkmpNode::evaluate()
|
|
of the root node. This will then return a jkmpResult structure which contains
|
|
the result. This scheme allows for once parsing and multiply evaluating an expression.
|
|
So if you want to define a function by an expression you can provide an
|
|
external variable x as the argument and then evaluate the function for
|
|
each x.
|
|
|
|
\section jkmp_ebnf EBNF definition of the parsed expressions
|
|
|
|
<pre> logical_expression -> logical_term
|
|
| logical_expression <b>or</b> logical_term
|
|
| logical_expression <b>||</b> logical_term</pre>
|
|
<pre> logical_term -> comp_expression
|
|
| logical_term <b>and</b> comp_expression
|
|
| logical_term <b>&&</b> comp_expression</pre>
|
|
<pre> comp_expression -> math_expression
|
|
| expression <b>==</b> math_expression
|
|
| expression <b>!=</b> math_expression
|
|
| expression <b>>=</b> math_expression
|
|
| expression <b><=</b> math_expression
|
|
| expression <b>></b> math_expression
|
|
| expression <b><</b> math_expression</pre>
|
|
<pre> math_expression -> term
|
|
| math_expression <b>+</b> math_term
|
|
| math_expression <b>-</b> math_term</pre>
|
|
<pre> math_term -> primary
|
|
| term <b>*</b> primary
|
|
| term <b>/</b> primary
|
|
| term ( <b>%</b> | <b>mod</b> ) primary</pre>
|
|
<pre> primary -> <b>true</b> | <b>false</b>
|
|
| string_constant
|
|
| NUMBER
|
|
| NAME
|
|
| NAME <b>=</b> logical_expression
|
|
| <b>+</b> primary | <b>-</b> primary | <b>!</b> primary | <b>not</b> primary
|
|
| <b>(</b> logical_expression <b>)</b>
|
|
| NAME<b>(</b> parameter_list <b>)</b>
|
|
| primary <b>^</b> primary</pre>
|
|
<pre> string_constant -> <b>"</b> STRING <b>"</b> | <b>'</b> STRING <b>'</b></pre>
|
|
<pre> parameter_list -> \f$ \lambda \f$ | logical_expression | logical_expression <b>,</b> parameter_list</pre>
|
|
|
|
|
|
|
|
|
|
\section jkmp_example Simple Example of Usage
|
|
\code
|
|
try {
|
|
JKQTPMathParser mp; // instanciate
|
|
jkmpNode* n;
|
|
jkmpResult r;
|
|
// parse some numeric expression
|
|
n=mp.parse("pi^2+4*sin(65*pi/exp(3.45))");
|
|
r=n->evaluate();
|
|
cout<<r.num<<endl;
|
|
//delete n;
|
|
|
|
// parse some boolean expression
|
|
n=mp.parse("true==false");
|
|
r=n->evaluate();
|
|
if (r.type==jkmpBool) {
|
|
if (r.boolean) cout<<"true";
|
|
else cout<<"false";
|
|
}
|
|
if (r.type==jkmpDouble) cout<<r.num<<endl;
|
|
if (r.type==jkmpString) cout<<r.str<<endl;
|
|
delete n;
|
|
|
|
// parse some string expression
|
|
n=mp.parse("var1='false'; var1+'true'");
|
|
r=n->evaluate();
|
|
if (r.type==jkmpString) cout<<r.str<<endl;
|
|
delete n;
|
|
} catch(std::exception& E) {
|
|
cout<<"ERROR!!!\n "<<E.what()<<endl<<endl;
|
|
}
|
|
\endcode
|
|
|
|
|
|
|
|
\section jkmp_errorhandling Error Handling
|
|
|
|
In the above example we use error handling by use of exception (default behauviour).
|
|
|
|
|
|
It is also possible to change the error handling from using exceptions to calling a specific
|
|
error handling function. This can be usefull in programs that don't support exceptions.
|
|
To do so, use this cod:
|
|
\code
|
|
void error(const std::string& message) {
|
|
cout<<"error: "+message;
|
|
system("PAUSE");
|
|
abort();
|
|
}
|
|
|
|
int main() {
|
|
JKQTPMathParser mp;
|
|
mp.setException_function(error); // make error ahndler known
|
|
...
|
|
}
|
|
\endcode
|
|
*/
|
|
class jkqtmath_LIB_EXPORT JKQTPMathParser
|
|
{
|
|
public:
|
|
|
|
/** @name Abstract Syntax Tree / Memory Representation of Expressions */
|
|
/**@{*/
|
|
|
|
/** \brief possible result types */
|
|
enum jkmpResultType {jkmpDouble, /*!< \brief a floating-point number with double precision. This is also used to deal with integers */
|
|
jkmpString, /*!< \brief a string of characters */
|
|
jkmpBool}; /*!< \brief a boolean value true|false */
|
|
|
|
|
|
|
|
/** \brief result of any expression*/
|
|
struct jkqtmath_LIB_EXPORT jkmpResult {
|
|
jkmpResult();
|
|
|
|
bool isValid;
|
|
jkmpResultType type; /*!< \brief type of the result */
|
|
std::string str; /*!< \brief contains result if \c type==jkmpString */
|
|
double num; /*!< \brief contains result if \c type==jkmpDouble */
|
|
bool boolean; /*!< \brief contains result if \c type==jkmpBool */
|
|
|
|
/** \brief convert the value this struct representens into a std::string */
|
|
std::string toString();
|
|
|
|
/** \brief convert the value this struct representens into a std::string and adds the name of the datatype in \c [...] */
|
|
std::string toTypeString();
|
|
};
|
|
|
|
|
|
/** \brief This struct is for managing variables. Unlike jkmpResult this struct
|
|
* only contains pointers to the data */
|
|
struct jkqtmath_LIB_EXPORT jkmpVariable {
|
|
jkmpVariable();
|
|
jkmpResultType type; /*!< \brief type of the variable */
|
|
bool internal; /*!< \brief this is an internal variable */
|
|
std::string *str; /*!< \brief this points to the variable data if \c type==jkmpString */
|
|
double *num; /*!< \brief this points to the variable data if \c type==jkmpDouble */
|
|
bool *boolean; /*!< \brief this points to the variable data if \c type==jkmpBool */
|
|
};
|
|
|
|
/** \brief This struct is for managing temporary variables. It is generally like jkmpVariable. */
|
|
struct jkqtmath_LIB_EXPORT jkmpTempVariable {
|
|
jkmpTempVariable();
|
|
std::string name; /*!< \brief name of the variable */
|
|
jkmpResultType type; /*!< \brief type of the variable */
|
|
bool internal; /*!< \brief this is an internal variable */
|
|
std::string *str; /*!< \brief this points to the variable data if \c type==jkmpString */
|
|
double *num; /*!< \brief this points to the variable data if \c type==jkmpDouble */
|
|
bool *boolean; /*!< \brief this points to the variable data if \c type==jkmpBool */
|
|
};
|
|
|
|
|
|
|
|
/** \brief This is a function prototype for adding new mathematical functions
|
|
* to the parser
|
|
*
|
|
* If you want to add more math functions (like sin, cos , abs ...) to the
|
|
* parser, you will have to implement it with this prototype and then register
|
|
* it with JKQTPMathParser::addFunction(). The first parameter points to an array
|
|
* containing the input parameters while the second one specifies the number
|
|
* of supplied parameters. The result has to be of type jkmpResult.
|
|
*
|
|
* All error handling has to be done inside the function definition. Here is a
|
|
* simple example:
|
|
* \code
|
|
* jkmpResult Abs(jkmpResult* params, unsigned char n){
|
|
* jkmpResult r;
|
|
* r.type=jkmpDouble;
|
|
* if (n!=1) jkmpError("abs accepts 1 argument");
|
|
* if (params[0].type!=jkmpDouble) jkmpError("abs needs double argument");
|
|
* r.num=fabs(params[0].num);
|
|
* return r;
|
|
* }
|
|
* \endcode
|
|
*/
|
|
typedef jkmpResult (*jkmpEvaluateFunc)(jkmpResult*, unsigned char, JKQTPMathParser*);
|
|
|
|
|
|
/** \brief description of a user registered function */
|
|
struct jkqtmath_LIB_EXPORT jkmpFunctionDescriptor {
|
|
jkmpFunctionDescriptor(jkmpEvaluateFunc function_=nullptr);
|
|
jkmpEvaluateFunc function; /*!< \brief a pointer to the function implementation */
|
|
std::string name; /*!< \brief name of the function */
|
|
};
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/**
|
|
* \brief This class is the abstract base class for nodes.
|
|
* All allowed node types must inherit from jkmpNode
|
|
*/
|
|
class jkqtmath_LIB_EXPORT jkmpNode {
|
|
protected:
|
|
JKQTPMathParser* parser; /*!< \brief points to the parser object that is used to evaluate this node */
|
|
jkmpNode* parent; /*!< \brief points to the parent node */
|
|
public:
|
|
jkmpNode(JKQTPMathParser* parser_=nullptr, jkmpNode* parent_=nullptr);
|
|
/** \brief virtual class destructor */
|
|
virtual ~jkmpNode();
|
|
|
|
/** \brief evaluate this node */
|
|
virtual jkmpResult evaluate()=0;
|
|
|
|
/** \brief return a pointer to the JKQTPMathParser */
|
|
JKQTPMathParser *getParser();
|
|
|
|
/** \brief set the JKQTPMathParser */
|
|
void setParser(JKQTPMathParser* mp);
|
|
|
|
/** \brief returns a pointer to the parent node */
|
|
jkmpNode *getParent();
|
|
|
|
/** \brief sets the parent node */
|
|
void setParent(jkmpNode* par);
|
|
};
|
|
|
|
|
|
/**
|
|
* \brief This class represents a binary arithmetic operation:
|
|
* add (+), subtract (-), multiply (*), divide (/), a to the power of b (a^b)
|
|
*/
|
|
class jkqtmath_LIB_EXPORT jkmpBinaryArithmeticNode: public jkmpNode {
|
|
private:
|
|
jkmpNode* left, *right;
|
|
char operation;
|
|
public:
|
|
/** \brief constructor for a jkmpBinaryArithmeticNode
|
|
* \param op the operation to be performed: add (+), subtract (-), multiply (*), divide (/), a to the power of b (a^b)
|
|
* \param l left child node/operand
|
|
* \param r right child node/operand
|
|
* \param p a pointer to a JKQTPMathParser object
|
|
* \param par a pointer to the parent node
|
|
*/
|
|
jkmpBinaryArithmeticNode(char op, jkmpNode* l, jkmpNode* r, JKQTPMathParser* p, jkmpNode* par);
|
|
|
|
/** \brief standard destructor, also destroy the children (recursively) */
|
|
virtual ~jkmpBinaryArithmeticNode() override;
|
|
|
|
/** \brief evaluate this node */
|
|
virtual jkmpResult evaluate() override;
|
|
};
|
|
|
|
/** \brief internal names for logic operations */
|
|
enum class jkmpLOP{
|
|
LOPand='a',
|
|
LOPor='o',
|
|
LOPxor='x',
|
|
LOPnor='n',
|
|
LOPnand='A'
|
|
};
|
|
|
|
|
|
/** \brief This class represents a binary boolean operation: and, or, xor, nor, nand */
|
|
class jkqtmath_LIB_EXPORT jkmpBinaryBoolNode: public jkmpNode {
|
|
private:
|
|
jkmpNode* left, *right;
|
|
jkmpLOP operation;
|
|
public:
|
|
/** \brief constructor for a jkmpBinaryBoolNode
|
|
* \param op the operation to be performed: (a)nd, (o)r, (x)or, (n)or, nand (A)
|
|
* \param l left child node/operand
|
|
* \param r right child node/operand
|
|
* \param p a pointer to a JKQTPMathParser object
|
|
* \param par a pointer to the parent node
|
|
*/
|
|
jkmpBinaryBoolNode(jkmpLOP op, jkmpNode* l, jkmpNode* r, JKQTPMathParser* p, jkmpNode* par);
|
|
|
|
/** \brief standard destructor, also destroy the children (recursively) */
|
|
virtual ~jkmpBinaryBoolNode() override;
|
|
|
|
/** \brief evaluate this node */
|
|
virtual jkmpResult evaluate() override;
|
|
};
|
|
|
|
|
|
/** \brief jkmpCOMPdefs internal names for compare operations */
|
|
enum class jkmpCOMP {
|
|
equal='=',
|
|
nequal='!',
|
|
lesser='<',
|
|
greater='>',
|
|
lesserequal='a',
|
|
greaterequal='b'
|
|
};
|
|
|
|
/** \brief This class represents a binary compare operation: !=, ==, >=, <=, >, < */
|
|
class jkqtmath_LIB_EXPORT jkmpCompareNode: public jkmpNode {
|
|
private:
|
|
jkmpNode* left, *right;
|
|
jkmpCOMP operation;
|
|
public:
|
|
/** \brief constructor for a jkmpCompareNode
|
|
* \param op the operation to be performed: != (!), == (=), >= (b), <= (a), (>), (<)
|
|
* \param l left child node/operand
|
|
* \param r right child node/operand
|
|
* \param p a pointer to a JKQTPMathParser object
|
|
* \param par a pointer to the parent node
|
|
*/
|
|
jkmpCompareNode(jkmpCOMP op, jkmpNode* l, jkmpNode* r, JKQTPMathParser* p, jkmpNode* par);
|
|
|
|
/** \brief standard destructor, also destroy the children (recursively) */
|
|
virtual ~jkmpCompareNode () override;
|
|
|
|
/** \brief evaluate this node */
|
|
virtual jkmpResult evaluate() override;
|
|
};
|
|
|
|
/** \brief This class represents a unary operations: ! (bool negation), - (arithmetic negation) */
|
|
class jkqtmath_LIB_EXPORT jkmpUnaryNode: public jkmpNode {
|
|
private:
|
|
jkmpNode* child;
|
|
char operation;
|
|
public:
|
|
/** \brief constructor for a jkmpUnaryNode
|
|
* \param op the operation to be performed: (!), (-)
|
|
* \param c child node/operand
|
|
* \param p a pointer to a JKQTPMathParser object
|
|
* \param par a pointer to the parent node
|
|
*/
|
|
jkmpUnaryNode(char op, jkmpNode* c, JKQTPMathParser* p, jkmpNode* par);
|
|
|
|
/** \brief standard destructor, also destroy the children (recursively) */
|
|
virtual ~jkmpUnaryNode() override;
|
|
|
|
/** \brief evaluate this node */
|
|
virtual jkmpResult evaluate() override;
|
|
};
|
|
|
|
/**
|
|
* \brief This class represents a variable assignment (<code>a = expression</code>) */
|
|
class jkqtmath_LIB_EXPORT jkmpVariableAssignNode: public jkmpNode {
|
|
private:
|
|
jkmpNode* child;
|
|
std::string variable;
|
|
//char operation;
|
|
public:
|
|
/** \brief standard destructor, also destroy the children (recursively) */
|
|
virtual ~jkmpVariableAssignNode() override;
|
|
|
|
/** \brief constructor for a jkmpVariableAssignNode
|
|
* \param var name of the variable to assign to
|
|
* \param c child node/right-hand-side expression
|
|
* \param p a pointer to a JKQTPMathParser object
|
|
* \param par a pointer to the parent node
|
|
*/
|
|
jkmpVariableAssignNode(const std::string& var, jkmpNode* c, JKQTPMathParser* p, jkmpNode* par);
|
|
|
|
/** \brief evaluate this node */
|
|
virtual jkmpResult evaluate() override;
|
|
};
|
|
|
|
/** \brief This class represents a number, a string contant or a boolean contant (\c true / \c false ) */
|
|
class jkqtmath_LIB_EXPORT jkmpConstantNode: public jkmpNode {
|
|
private:
|
|
jkmpResult data;
|
|
public:
|
|
/** \brief constructor for a jkmpConstantNode
|
|
* \param d the value of the constant
|
|
* \param p a pointer to a JKQTPMathParser object
|
|
* \param par a pointer to the parent node
|
|
*/
|
|
jkmpConstantNode(jkmpResult d, JKQTPMathParser* p, jkmpNode* par);
|
|
|
|
/** \brief evaluate this node */
|
|
virtual jkmpResult evaluate() override;
|
|
};
|
|
|
|
/** \brief This class represents a variable. */
|
|
class jkqtmath_LIB_EXPORT jkmpVariableNode: public jkmpNode {
|
|
private:
|
|
std::string var;
|
|
public:
|
|
/** \brief constructor for a jkmpVariableNode
|
|
* \param name name of the variable
|
|
* \param p a pointer to a JKQTPMathParser object
|
|
* \param par a pointer to the parent node
|
|
*/
|
|
jkmpVariableNode(const std::string& name, JKQTPMathParser* p, jkmpNode* par);
|
|
|
|
/** \brief evaluate this node */
|
|
virtual jkmpResult evaluate() override;
|
|
};
|
|
|
|
/** \brief This class represents an arbitrary function.
|
|
*
|
|
* When initialized this class will get the function description that is
|
|
* linked to the supplied function name from JKQTPMathParser object. This
|
|
* information is saved locally and won't be changed when evaluating!
|
|
*
|
|
* Functions may have 8 parameters at the most.
|
|
*/
|
|
class jkqtmath_LIB_EXPORT jkmpFunctionNode: public jkmpNode {
|
|
private:
|
|
std::string fun;
|
|
jkmpNode** child;
|
|
unsigned char n;
|
|
jkmpEvaluateFunc function;
|
|
public:
|
|
/** \brief constructor for a jkmpFunctionNode
|
|
* \param name name of the function
|
|
* \param c a pointer to an array of jkmpNode objects that represent the parameter expressions
|
|
* \param num number of children in c
|
|
* \param p a pointer to a JKQTPMathParser object
|
|
* \param par a pointer to the parent node
|
|
*/
|
|
jkmpFunctionNode(const std::string& name, jkmpNode** c, unsigned char num, JKQTPMathParser* p, jkmpNode* par);
|
|
|
|
/** \brief standard destructor, also destroy the children (recursively) */
|
|
virtual ~jkmpFunctionNode() override;
|
|
|
|
/** \brief evaluate this node */
|
|
virtual jkmpResult evaluate() override;
|
|
};
|
|
|
|
/**
|
|
* \brief This class represents a list of jkmpNode.
|
|
*
|
|
* when evaluating the result will be the result of the last node in the list.
|
|
*/
|
|
class jkqtmath_LIB_EXPORT jkmpNodeList: public jkmpNode {
|
|
private:
|
|
std::vector<jkmpNode*> list;
|
|
public:
|
|
/** \brief constructor for a jkmpNodeList
|
|
* \param p a pointer to a JKQTPMathParser object
|
|
*/
|
|
jkmpNodeList(JKQTPMathParser* p);
|
|
|
|
/** \brief standard destructor, also destroy the children (recursively) */
|
|
virtual ~jkmpNodeList() override;
|
|
|
|
/** \brief add a jkmpNode n to the list */
|
|
void add(jkmpNode* n);
|
|
|
|
/** \brief evaluate the node */
|
|
virtual jkmpResult evaluate() override;
|
|
|
|
/** \brief get the number of nodes in the list */
|
|
int getCount();
|
|
};
|
|
|
|
/**@}*/
|
|
|
|
|
|
public:
|
|
|
|
|
|
|
|
/**@}*/
|
|
|
|
|
|
public:
|
|
|
|
/** @name Error Handling */
|
|
/**@{*/
|
|
|
|
|
|
/** \brief error handling: exceptions of the type of this class will be thrown if an error occurs
|
|
*
|
|
* \attention If you do not want to use the exception handling which throws
|
|
* jkmpException exceptions, but want to write your own error handling, you should write your own
|
|
* error handler and assign it (function pointer) to the global variable jkmathparser_exception_function.
|
|
* If this is not nullptr this function will be called instead of throwing an exception.
|
|
*/
|
|
class jkqtmath_LIB_EXPORT jkmpException : public std::exception {
|
|
private:
|
|
/** \brief the error message */
|
|
std::string errormessage;
|
|
public:
|
|
/** \brief class constructors */
|
|
jkmpException();
|
|
|
|
/** \brief constructor with supplied error message */
|
|
jkmpException(const std::string& msg);
|
|
|
|
/** \brief class destructors */
|
|
virtual ~jkmpException() override;
|
|
|
|
/** \brief returns the assigned errormessage */
|
|
std::string getMessage() const;
|
|
|
|
/** \brief returns the error description as C string */
|
|
virtual const char* what() const noexcept override;
|
|
};
|
|
|
|
/** \brief type for a custom error handler. This an alternative error handling */
|
|
typedef void (*jkmpexceptionf)(std::string);
|
|
|
|
|
|
/** \brief function that throws an exception or calls an error handler */
|
|
void jkmpError(const std::string& st);
|
|
|
|
private:
|
|
/** \brief if this is nullptr then an exception may be thrown otherwise this should point to an error handler that will be called. */
|
|
jkmpexceptionf jkmathparser_exception_function;
|
|
|
|
public:
|
|
/** \brief activate error handling by use of an exception function */
|
|
void setException_function(jkmpexceptionf exception_function);
|
|
|
|
/** \brief deactivate error handling by use of an exception function */
|
|
void resetException_function();
|
|
/**@}*/
|
|
|
|
|
|
protected:
|
|
/** @name Tokenizer */
|
|
/**@{*/
|
|
/** \brief the possible tokens that can be recognized by the tokenizer in JKQTPMathParser::getToken() */
|
|
enum jkmpTokenType {
|
|
END, /*!< \brief end token */
|
|
PRINT, /*!< \brief a semicolon ';' */
|
|
PARAMETER_DIV, /*!< \brief a comma ',' between two function parameters */
|
|
STRING_DELIM, /*!< \brief a string delimiter ' or " */
|
|
NAME, /*!< \brief a name (consisting of characters) of a variable or function */
|
|
NUMBER, /*!< \brief a number in scientific notation */
|
|
PLUS, /*!< \brief a plus operator '+' */
|
|
MINUS, /*!< \brief a minus operator '-' */
|
|
MUL, /*!< \brief a multiplication operator '*' */
|
|
DIV, /*!< \brief a division operator '/' */
|
|
MODULO, /*!< \brief a modulo operator '%' */
|
|
ASSIGN, /*!< \brief a variable assignment = */
|
|
LBRACKET, /*!< \brief left brackets '(' */
|
|
RBRACKET, /*!< \brief right brackets ')' */
|
|
POWER, /*!< \brief a power operator '^' */
|
|
FACTORIAL_LOGIC_NOT, /*!< \brief a factorial operator or a logical NOT '!' */
|
|
LOGIC_NOT, /*!< \brief a logical NOT '!' / 'not' */
|
|
LOGIC_AND, /*!< \brief a logical AND operator '&&' / 'and' */
|
|
LOGIC_OR, /*!< \brief a logical OR operator '||' / 'or' */
|
|
LOGIC_XOR, /*!< \brief a logical XOR operator 'xor' */
|
|
LOGIC_NOR, /*!< \brief a logical NOR operator 'nor' */
|
|
LOGIC_NAND, /*!< \brief a logical NAND operator 'nand' */
|
|
LOGIC_TRUE, /*!< \brief 'true' */
|
|
LOGIC_FALSE, /*!< \brief 'false' */
|
|
COMP_EQUALT, /*!< \brief equals operation '==' */
|
|
COMP_UNEQUAL, /*!< \brief unequal operation '!=' */
|
|
COMP_GREATER, /*!< \brief greater than operation '>' */
|
|
COMP_SMALLER, /*!< \brief smaller than operation '<' */
|
|
COMP_GEQUAL, /*!< \brief greater than or equal operation '>=' */
|
|
COMP_SEQUAL, /*!< \brief smaller than or equal operation '<=' */
|
|
};
|
|
|
|
|
|
/** \brief return the given token as human-readable string */
|
|
std::string tokentostring(jkmpTokenType token);
|
|
|
|
/** \brief return the current token as human-readable string */
|
|
std::string currenttokentostring();
|
|
|
|
/** \brief Tokenizer: extract the next token from the input */
|
|
jkmpTokenType getToken();
|
|
|
|
/** \brief return a delimited text, i.e. extract the texte between the delimiters <code>"</code> in: of <code>"Hallo!"</code>, i.e. returns <code> Hallo!</code>
|
|
* This is used to parse string constants.
|
|
*
|
|
* This functions actually reads pascal style delimited string constants. So if you want to use the delimiter as part of the string you will have to
|
|
* write it as doubled character. So <code>'Jan''s Test'</code> stands for <code>Jan's Test</code>.
|
|
*/
|
|
std::string readDelim(char delimiter);
|
|
|
|
/** \brief the current token while parsing a string */
|
|
jkmpTokenType CurrentToken;
|
|
|
|
/** \brief the string value of the current token (when applicable) during the parsing step */
|
|
std::string StringValue;
|
|
|
|
/** \brief the string value of the current token (when applicable) during the parsing step */
|
|
double NumberValue;
|
|
|
|
/** \brief this stream is used to read in the program. An object is created and assigned
|
|
* (and destroyed) by the parse()-function */
|
|
std::istringstream* program;
|
|
|
|
|
|
/**@}*/
|
|
|
|
|
|
/** @name Parser */
|
|
/**@{*/
|
|
|
|
/** \brief recognizes an compExpression while parsing. If \a get ist \c true, this function first retrieves a new token by calling getToken() */
|
|
jkmpNode* compExpression(bool get);
|
|
|
|
/** \brief recognizes a logicalExpression while parsing. If \a get ist \c true, this function first retrieves a new token by calling getToken() */
|
|
jkmpNode* logicalExpression(bool get);
|
|
|
|
/** \brief recognizes a logicalTerm while parsing. If \a get ist \c true, this function first retrieves a new token by calling getToken() */
|
|
jkmpNode* logicalTerm(bool get);
|
|
|
|
/** \brief recognizes a mathExpression while parsing. If \a get ist \c true, this function first retrieves a new token by calling getToken() */
|
|
jkmpNode* mathExpression(bool get);
|
|
|
|
/** \brief recognizes a term while parsing. If \a get ist \c true, this function first retrieves a new token by calling getToken() */
|
|
jkmpNode* mathTerm(bool get);
|
|
|
|
/** \brief recognizes a primary while parsing. If \a get ist \c true, this function first retrieves a new token by calling getToken() */
|
|
jkmpNode* primary(bool get);
|
|
|
|
/**@}*/
|
|
|
|
/** \brief vector containing all temporary variables */
|
|
std::vector<jkmpTempVariable> tempvariables;
|
|
|
|
/** \brief map to manage all currently defined variables */
|
|
std::map<std::string, jkmpVariable> variables;
|
|
|
|
/** \brief map to manage all currently rtegistered functions */
|
|
std::map<std::string, jkmpFunctionDescriptor> functions;
|
|
|
|
/** \brief set the defining struct of the given variable */
|
|
void setVariable(const std::string& name, jkmpResult value);
|
|
/** \brief set the defining struct of the given variable */
|
|
void setVariableDouble(const std::string& name, double value);
|
|
|
|
|
|
/** \brief adds a temporary variable */
|
|
void addTempVariable(const std::string& name, jkmpResult value);
|
|
|
|
protected:
|
|
/** \brief storage for program argument cound, used by the standard functions \c cmdparam and \c argv \see setArgCV() and getArgCVParam() */
|
|
int argc;
|
|
/** \brief storage for program arguments, used by the standard functions \c cmdparam and \c argv \see setArgCV() and getArgCVParam() */
|
|
char **argv;
|
|
|
|
public:
|
|
/** \brief class constructor
|
|
*
|
|
* \note This also registers all standatd functions and constants by calling addStandardFunctions() and addStandardVariables()
|
|
*/
|
|
JKQTPMathParser();
|
|
|
|
/** \brief class destructor */
|
|
virtual ~JKQTPMathParser();
|
|
|
|
|
|
/** \brief register a new function
|
|
* \param name name of the new function
|
|
* \param function a pointer to the implementation
|
|
*/
|
|
void addFunction(const std::string& name, jkmpEvaluateFunc function);
|
|
|
|
/** \brief register a new external variable of type double
|
|
* \param name name of the new variable
|
|
* \param v pointer to the variable memory
|
|
*/
|
|
void addVariableDouble(const std::string& name, double* v);
|
|
|
|
/** \brief register a new external variable of type string
|
|
* \param name name of the new variable
|
|
* \param v pointer to the variable memory
|
|
*/
|
|
void addVariableString(const std::string& name, std::string* v);
|
|
|
|
/** \brief register a new external variable of type boolean
|
|
* \param name name of the new variable
|
|
* \param v pointer to the variable memory
|
|
*/
|
|
void addVariableBoolean(const std::string& name, bool* v);
|
|
|
|
|
|
/** \brief register a new internal variable of type double
|
|
* \param name name of the new variable
|
|
* \param v initial value of this variable
|
|
*/
|
|
void addVariableDouble(const std::string& name, double v);
|
|
|
|
/** \brief register a new internal variable of type string
|
|
* \param name name of the new variable
|
|
* \param v initial value of this variable
|
|
*/
|
|
void addVariableString(const std::string& name, const std::string& v);
|
|
|
|
/** \brief register a new internal variable of type boolean
|
|
* \param name name of the new variable
|
|
* \param v initial value of this variable
|
|
*/
|
|
void addVariableBoolean(const std::string& name, bool v);
|
|
|
|
/** \brief register a new internal variable of type boolean
|
|
* \param name name of the new variable
|
|
* \param result initial value of this variable
|
|
*/
|
|
void addVariable(const std::string& name, jkmpResult result);
|
|
|
|
|
|
|
|
/** \brief returns the value of the given variable */
|
|
jkmpResult getVariable(const std::string& name);
|
|
/** \brief returns the value of the given variable */
|
|
jkmpResult getVariableOrInvalid(const std::string& name);
|
|
|
|
/** \brief returns the defining structure of the given variable */
|
|
jkmpVariable getVariableDef(const std::string& name);
|
|
|
|
|
|
/** \brief evaluates a registered function
|
|
* \param name name of the (registered function) to be evaluated
|
|
* \param params array of the input parameters
|
|
* \param n number of input parameters (<=8)
|
|
*/
|
|
jkmpResult evaluateFunction(const std::string& name, jkmpResult* params, unsigned char n);
|
|
|
|
/** \brief returns the defining structure of the given function */
|
|
jkmpEvaluateFunc getFunctionDef(const std::string& name);
|
|
|
|
/** \brief tests whether a temporary variable exists */
|
|
bool tempvariableExists(const std::string& name);
|
|
|
|
/** \brief tests whether a variable exists */
|
|
bool variableExists(const std::string& name);
|
|
|
|
/** \brief tests whether a function exists */
|
|
bool functionExists(const std::string& name);
|
|
|
|
/** \brief deletes all defined variables. the memory of internal variables
|
|
* will be released. the external memory will not be released.
|
|
*/
|
|
void clearVariables();
|
|
|
|
/** \brief delete the specified variabale and releases its internal memory.*/
|
|
void deleteVariable(const std::string& name);
|
|
|
|
/** \brief clears the list of internal functions*/
|
|
void clearFunctions();
|
|
|
|
/** \brief registers standard variables */
|
|
void addStandardVariables();
|
|
|
|
/** \brief registers standard functions*/
|
|
void addStandardFunctions();
|
|
|
|
/** \brief parses the given expression*/
|
|
jkmpNode* parse(const std::string& prog);
|
|
|
|
/** \brief evaluate the given expression */
|
|
jkmpResult evaluate(const std::string& prog);
|
|
|
|
/** \brief prints a list of all registered variables */
|
|
void printVariables();
|
|
|
|
/** \brief returns all registered variables */
|
|
std::vector<std::pair<std::string, jkmpVariable> > getVariables();
|
|
|
|
/** \brief store programs command-line arguments, so they are available in the parser, used by the standard functions \c cmdparam and \c argv */
|
|
void setArgCV(int argc, char **argv);
|
|
|
|
/** \brief return one of programs command-line arguments, or \a defaultResult if it is not present, used by the standard functions \c cmdparam and \c argv */
|
|
std::string getArgCVParam(const std::string& name, const std::string& defaultResult);
|
|
};
|
|
|
|
#endif // JKQTPMATHPARSER_H
|