Das " . htmlentities_utf8($aktion[$terminaktion->typ]) . " des folgenden Termins wurde beantragt und wird nun von den Moderatoren geprüft. Sobald der Termin bearbeitet wurde, wird eine E-Mail-Benachrichtigung verschickt.
Das " . htmlentities_utf8($aktion[$terminaktion->typ]) . " des folgenden Termins wurde " . ($terminaktion->status == 0 ? ($ueberarbeiten ? "in überarbeiteter Form akzeptiert" : "akzeptiert") : "abgelehnt") . ".
Das " . htmlentities_utf8($aktion[$terminaktion->typ]) . " des folgenden Termins wurde beantragt und wird nun von den Moderatoren geprüft. Sobald der Termin bearbeitet wurde, wird eine E-Mail-Benachrichtigung verschickt.
Das " . htmlentities_utf8($aktion[$terminaktion->typ]) . " des folgenden Termins wurde " . ($terminaktion->status == 0 ? ($ueberarbeiten ? "in überarbeiteter Form akzeptiert" : "akzeptiert") : "abgelehnt") . ".
* Math parser library features at a glance include:
- *
+ *
* Easy to use, simple class API.
* Functions with 0 or more number of parameters in the form of: f(x,y,z, ...)
* Functions with unknown number of parameters, e.g. SUM(a,b,c,...)
@@ -54,356 +56,303 @@
* a secure, simple math evaluator alternative to eval(). Please keep in mind, MathParser only evaluates
* mathematical expressions given using a simple syntax that consists of numbers, variables, function calls
* and paranthesis. MathParser does not evaluate PHP expressions.
- *
- * Predefined functions are:
- *
- * SQR: Square function which can be used as SQR(X)
- *
- * SIN: Sinus function which can be used as SIN(X), X is a real-type expression.
- * Sin returns the sine of the angle X in radians.
- *
- * COS: Cosinus function which can be used as COS(X), X is a real-type expression.
- * COS returns the cosine of the angle X in radians.
- *
- * ATAN: ArcTangent function which can be used as ATAN(X)
- * Returns the arctangent of a number as a numeric value between -PI/2 and PI/2 radians.
- *
- * SINH: Sinus Hyperbolic function which can be used as SINH(X)
- *
- * COSH: Cosinus Hyperbolic function which can be used as COSH(X)
- *
- * COTAN: which can be used as COTAN(X)
- *
- * TAN: which can be used as TAN(X)
- *
- * EXP: which can be used as EXP(X)
- *
- * LN: natural log, which can be used as LN(X)
- *
- * LOG: 10 based log, which can be used as LOG(X)
- *
- * SQRT: which can be used as SQRT(X)
- *
- * ABS: absolute value, which can be used as ABS(X)
- *
- * SIGN: SIGN(X) returns -1 if X<0; +1 if X>0, 0 if X=0; it can be used as SQR(X)
- *
- * TRUNC: Discards the fractional part of a number. e.g. TRUNC(-3.2) is -3, TRUNC(3.2) is 3.
- *
- * CEIL: CEIL(-3.2) = 3, CEIL(3.2) = 4
- *
- * FLOOR: FLOOR(-3.2) = -4, FLOOR(3.2) = 3
- *
- * VAL: VAL("3.1") = 3.1 Returns the floating point numeric value of the string argument.
- *
- * Predefined functions that take two parameters are:
- *
- * POW: The Power function raises Base to any power. For fractional exponents or
- * exponents greater than MaxInt, Base must be greater than 0.
- *
- * LOGN: The LogN function returns the log base N of X. Example: LOGN(10, 100) = 2
- *
- * MIN: MIN(2, 3) is 2.
- *
- * MAX: MAX(2, 3) is 3.
- *
- * IF: The IF(b, case1, case2) function provides branching capability.
- * If b is not 0, then it returns case1, else it returns case2.
- * Behavior is similar to PHP's: return b ? case1 : case2;
- * If b==0 then case1 will not be Evaluated, and vice versa.
- * Example: IF(HEIGHT, 3/HEIGHT, 3) will make sure 3/HEIGHT does not cause division by zero.
- *
- * Predefined functions that take no parameters are:
- * RND: RND() function generates a random number (double value) between 0 and 1.
- *
- * STR: STR(123) function returns the string representation of the passed value: "123".
- *
- * SUBSTR: SUBSTR("Hello", 1,3) function returns the substring just like PHP substr function.
- * The first parameter is the string, the second parameter is which index (0 based) to start copying,
- * and the last parameter is the number of characters to copy. For example, SUBSTR("Hello", 1,3) returns "ell".
- *
- * STRLEN: STRLEN("abc") function returns the length of the string parameter. For example, for "abc" it returns 3.
- *
- * CONCAT: CONCAT("abc","def",...) function returns the concatanated strings: "abcdef".
- * There is no preset limit on the number of parameters.
- *
- * TRIM: TRIM(" abc ") function returns the trimmed version of the string parameter: " abc " -> "abc".
- *
- * SUM: SUM(2,3,5,...) functions returns the sum of it's arguments. There is no preset limit on the number of parameters.
- *
+ *
+ * Predefined functions are:
+ *
+ * SQR: Square function which can be used as SQR(X)
+ *
+ * SIN: Sinus function which can be used as SIN(X), X is a real-type expression.
+ * Sin returns the sine of the angle X in radians.
+ *
+ * COS: Cosinus function which can be used as COS(X), X is a real-type expression.
+ * COS returns the cosine of the angle X in radians.
+ *
+ * ATAN: ArcTangent function which can be used as ATAN(X)
+ * Returns the arctangent of a number as a numeric value between -PI/2 and PI/2 radians.
+ *
+ * SINH: Sinus Hyperbolic function which can be used as SINH(X)
+ *
+ * COSH: Cosinus Hyperbolic function which can be used as COSH(X)
+ *
+ * COTAN: which can be used as COTAN(X)
+ *
+ * TAN: which can be used as TAN(X)
+ *
+ * EXP: which can be used as EXP(X)
+ *
+ * LN: natural log, which can be used as LN(X)
+ *
+ * LOG: 10 based log, which can be used as LOG(X)
+ *
+ * SQRT: which can be used as SQRT(X)
+ *
+ * ABS: absolute value, which can be used as ABS(X)
+ *
+ * SIGN: SIGN(X) returns -1 if X<0; +1 if X>0, 0 if X=0; it can be used as SQR(X)
+ *
+ * TRUNC: Discards the fractional part of a number. e.g. TRUNC(-3.2) is -3, TRUNC(3.2) is 3.
+ *
+ * CEIL: CEIL(-3.2) = 3, CEIL(3.2) = 4
+ *
+ * FLOOR: FLOOR(-3.2) = -4, FLOOR(3.2) = 3
+ *
+ * VAL: VAL("3.1") = 3.1 Returns the floating point numeric value of the string argument.
+ *
+ * Predefined functions that take two parameters are:
+ *
+ * POW: The Power function raises Base to any power. For fractional exponents or
+ * exponents greater than MaxInt, Base must be greater than 0.
+ *
+ * LOGN: The LogN function returns the log base N of X. Example: LOGN(10, 100) = 2
+ *
+ * MIN: MIN(2, 3) is 2.
+ *
+ * MAX: MAX(2, 3) is 3.
+ *
+ * IF: The IF(b, case1, case2) function provides branching capability.
+ * If b is not 0, then it returns case1, else it returns case2.
+ * Behavior is similar to PHP's: return b ? case1 : case2;
+ * If b==0 then case1 will not be Evaluated, and vice versa.
+ * Example: IF(HEIGHT, 3/HEIGHT, 3) will make sure 3/HEIGHT does not cause division by zero.
+ *
+ * Predefined functions that take no parameters are:
+ * RND: RND() function generates a random number (double value) between 0 and 1.
+ *
+ * STR: STR(123) function returns the string representation of the passed value: "123".
+ *
+ * SUBSTR: SUBSTR("Hello", 1,3) function returns the substring just like PHP substr function.
+ * The first parameter is the string, the second parameter is which index (0 based) to start copying,
+ * and the last parameter is the number of characters to copy. For example, SUBSTR("Hello", 1,3) returns "ell".
+ *
+ * STRLEN: STRLEN("abc") function returns the length of the string parameter. For example, for "abc" it returns 3.
+ *
+ * CONCAT: CONCAT("abc","def",...) function returns the concatanated strings: "abcdef".
+ * There is no preset limit on the number of parameters.
+ *
+ * TRIM: TRIM(" abc ") function returns the trimmed version of the string parameter: " abc " -> "abc".
+ *
+ * SUM: SUM(2,3,5,...) functions returns the sum of it's arguments. There is no preset limit on the number of parameters.
+ *
+ * @since 1.0.0
*/
class MathParser
{
- /**
- * protected variable that holds the expression to parse.
- * @var string
- */
- protected $Expression;
- /**
- * non-public flag that shows if parsing is needed or not. if false, existing
- * parse tree will be re-used.
- * @var boolean
- */
- protected $Dirty;
- /**
- * when optimization on, after the parse tree is compiled, it will be further optimized
- * by removing sub branches that evaluate to a constant. This will make parse() operation
- * slower and getValue() operation faster.
- * @var boolean
- */
- protected $OptimizationOn;
+ /**
+ * protected variable that holds the expression to parse.
+ * @var string
+ * @since 1.0.0
+ */
+ protected string $Expression;
+ /**
+ * non-public flag that shows if parsing is needed or not. if false, existing
+ * parse tree will be re-used.
+ * @var boolean
+ * @since 1.0.0
+ */
+ protected bool $Dirty;
+ /**
+ * when optimization on, after the parse tree is compiled, it will be further optimized
+ * by removing sub branches that evaluate to a constant. This will make parse() operation
+ * slower and getValue() operation faster.
+ * @var boolean
+ * @since 1.0.0
+ */
+ protected bool $OptimizationOn;
- /**
- * Starting node for the internal compiled representation of the
- * expression in parsed form.
- * @var Node
- */
- protected $Node;
+ /**
+ * Starting node for the internal compiled representation of the
+ * expression in parsed form.
+ * @var $Node
+ * @since 1.0.0
+ */
+ protected $Node;
- /**
- * internal list of variables that are available for use in an expression.
- * @var array
- */
- protected $Variables;
+ /**
+ * internal list of variables that are available for use in an expression.
+ * @var array
+ * @since 1.0.0
+ */
+ protected array $Variables;
- /**
- * internal list of functions that take more than 2 parameters that are available for use in an expression.
- * @var array
- */
- protected $Functions;
+ /**
+ * internal list of functions that take more than 2 parameters that are available for use in an expression.
+ * @var array
+ * @since 1.0.0
+ */
+ protected array $Functions;
- /**
- * A dictionary that holds translated messages.
- * @var array
- */
- static protected $translator;
+ /**
+ * A dictionary that holds translated messages.
+ * @var array
+ * @since 1.0.0
+ */
+ static protected array $translator;
- /**
- * Does the expression allows string literals or not?
- * For example, is an expression like this allowed: "Hello"+"World"
- * @var boolean
- */
- protected $StringLiteralsAllowed = true;
+ /**
+ * Does the expression allows string literals or not?
+ * For example, is an expression like this allowed: "Hello"+"World"
+ * @var boolean
+ * @since 1.0.0
+ */
+ protected bool $StringLiteralsAllowed = true;
- /**
- * The parser can use ampersand(&) or the plus(+) operator for string concatenations.
- * You can set which one you want using StrConcatOperator property.
- * The default is ampersand(&). Valid values are STR_CONCAT_OP.PLUS or
- * STR_CONCAT_OP.AMPERSAND.
- * @var string
- */
- protected $StrConcatOperator;
+ /**
+ * The parser can use ampersand(&) or the plus(+) operator for string concatenations.
+ * You can set which one you want using StrConcatOperator property.
+ * The default is ampersand(&). Valid values are STR_CONCAT_OP.PLUS or
+ * STR_CONCAT_OP.AMPERSAND.
+ * @var string
+ * @since 1.0.0
+ */
+ protected string $StrConcatOperator;
- /*
- * Public for performance reasons.
- * @see getVariableResolver function for more info.
- * @var string
- */
- public $VariableResolver;
+ /**
+ * Public for performance reasons.
+ * @see getVariableResolver function for more info.
+ * @var string
+ * @since 1.0.0
+ */
+ public string $VariableResolver;
- /**
- * @ignore
- */
- static protected $add__;
- /**
- * @ignore
- */
- static protected $subtract__;
- /**
- * @ignore
- */
- static protected $mult__;
- /**
- * @ignore
- */
- static protected $div__;
- /**
- * @ignore
- */
- static protected $power__;
- /**
- * @ignore
- */
- static protected $mod__;
- /**
- * @ignore
- */
- static protected $unaryadd__;
- /**
- * @ignore
- */
- static protected $negate__;
- /**
- * @ignore
- */
- static protected $not__;
- /**
- * @ignore
- */
- static protected $notequals__;
- /**
- * @ignore
- */
- static protected $equals__;
- /**
- * @ignore
- */
- static protected $lt__;
- /**
- * @ignore
- */
- static protected $gt__;
- /**
- * @ignore
- */
- static protected $ltequals__;
- /**
- * @ignore
- */
- static protected $gtequals__;
- /**
- * @ignore
- */
- static protected $and__;
- /**
- * @ignore
- */
- static protected $or__;
+ /**
+ * @ignore
+ * @since 1.0.0
+ */
+ static protected Mathparser_ParserFunction $add__;
+ /**
+ * @ignore
+ * @since 1.0.0
+ */
+ static protected Mathparser_ParserFunction $subtract__;
+ /**
+ * @ignore
+ * @since 1.0.0
+ */
+ static protected Mathparser_ParserFunction $mult__;
+ /**
+ * @ignore
+ * @since 1.0.0
+ */
+ static protected Mathparser_ParserFunction $div__;
+ /**
+ * @ignore
+ * @since 1.0.0
+ */
+ static protected Mathparser_ParserFunction $power__;
+ /**
+ * @ignore
+ * @since 1.0.0
+ */
+ static protected Mathparser_ParserFunction $mod__;
+ /**
+ * @ignore
+ * @since 1.0.0
+ */
+ static protected Mathparser_ParserFunction $unaryadd__;
+ /**
+ * @ignore
+ * @since 1.0.0
+ */
+ static protected Mathparser_ParserFunction $negate__;
+ /**
+ * @ignore
+ * @since 1.0.0
+ */
+ static protected Mathparser_ParserFunction $not__;
+ /**
+ * @ignore
+ * @since 1.0.0
+ */
+ static protected Mathparser_ParserFunction $notequals__;
+ /**
+ * @ignore
+ * @since 1.0.0
+ */
+ static protected Mathparser_ParserFunction $equals__;
+ /**
+ * @ignore
+ * @since 1.0.0
+ */
+ static protected Mathparser_ParserFunction $lt__;
+ /**
+ * @ignore
+ * @since 1.0.0
+ */
+ static protected Mathparser_ParserFunction $gt__;
+ /**
+ * @ignore
+ * @since 1.0.0
+ */
+ static protected Mathparser_ParserFunction $ltequals__;
+ /**
+ * @ignore
+ * @since 1.0.0
+ */
+ static protected Mathparser_ParserFunction $gtequals__;
+ /**
+ * @ignore
+ * @since 1.0.0
+ */
+ static protected Mathparser_ParserFunction $and__;
+ /**
+ * @ignore
+ * @since 1.0.0
+ */
+ static protected Mathparser_ParserFunction $or__;
- /**
- * Implementation of plus (+) operator.
- * @ignore
- */
- protected $AddOp;
+ /**
+ * Implementation of plus (+) operator.
+ * @ignore
+ * @since 1.0.0
+ */
+ protected Mathparser_ParserFunction $AddOp;
- /**
- * Implementation of ampersand (&) operator for strings.
- * @ignore
- */
- protected $AndOp;
+ /**
+ * Implementation of ampersand (&) operator for strings.
+ * @ignore
+ * @since 1.0.0
+ */
+ protected Mathparser_ParserFunction $AndOp;
+ /**
+ * VariableResolver is used as a callback function that returns the values of variables when asked.
+ * This is useful when a variable cannot be defined before the parse operation.
+ * If VariableResolver property is set, it will be used to resolve variables that were not defined
+ * at the time parse operation has started. This means that syntax errors regarding undefined variables
+ * will not be caught at parse time. This VariableResolver (user implementation) will decide whether
+ * a variable name is valid or not.
+ * This is useful when for example the value comes from a database lookup. In some cases,
+ * the problem domain is too big to define the variables ahead of time. In such cases, it makes sense
+ * to parse with the assumption that it is a valid variable and resolve it's value when needed on demand during
+ * evaluation.
+ * @return string
+ * @since 1.0.0
+ */
+ public function getVariableResolver(): string
+ {
+ return $this->VariableResolver;
+ }
- /**
- * Can the expression contain string literals such as
- * "abc", "hello world" etc. If you do not want to support strings in the
- * expression, (want numeric processing only), then you can set this property
- * to false and then you can also remove string functions from the list of available
- * functions. Then the parser will solely work on numeric expressions.
- * The string literals may also be useful in numeric context where the string can refer
- * to a database table or column name and can be passed to functions that actually use these strings
- * to lookup these values in databases to return numeric values too.
- * @return boolean
- */
- public function getStringLiteralsAllowed()
- {
- return $this->StringLiteralsAllowed;
- }
- /**
- * @see getStringLiteralsAllowed
- * @param $value - boolean
- * @return void
- */
- public function setStringLiteralsAllowed($value)
- {
- $this->StringLiteralsAllowed = $value;
- if($value==true){
- if($this->StrConcatOperator=='&'){
- $this->AndOp = new Mathparser_ParserFunction('&', 'mp_and_str_', 2);
- }else if ($this->StrConcatOperator=='+'){
- $this->AddOp = new Mathparser_ParserFunction('+', 'mp_add_str_', 2);
- }else{
- throw new Exception('Invalid string concat operator: '.$this->StrConcatOperator);
- }
- }else{
- $this->AddOp = self::$add__;
- $this->AndOp = self::$and__;
- }
- }
+ /**
+ * Constructor for the MathParser.
+ * @throws Exception
+ * @since 1.0.0
+ */
+ public function __construct()
+ {
+ $this->Expression = '';
+ $this->Node = null;
+ $this->Dirty = true; //means it is not Parsed yet.
+ $this->OptimizationOn = false;
- /**
- * If you setStringLiteralsAllowed to true, MathParser allows string literals and
- * variables to be used in the expression. By default string values can be concatenated
- * to each other using plus (+) operator. StrConcatOperator property allows the user to
- * set ampersand instead (&). You can only set plus(+) or ampersand (&)
- * @return boolean
- */
- public function getStrConcatOperator(){
- return $this->StrConcatOperator;
- }
- /**
- * @see getStrConcatOperator
- * @param $value - boolean
- * @return void
- */
- public function setStrConcatOperator($value){
- $this->StrConcatOperator=$value;
- if($value=='&'){
- if($this->StringLiteralsAllowed){
- $this->AndOp = new Mathparser_ParserFunction('&', 'mp_and_str_', 2);
- $this->AddOp = self::$add__;
- }else{
- $this->AddOp = new Mathparser_ParserFunction('+', 'mp_add_str_', 2);
- $this->AndOp = self::$and__;
- }
- }else if ($value=='+'){
- if($this->StringLiteralsAllowed){
- $this->AddOp = new Mathparser_ParserFunction('+', 'mp_add_str_', 2);
- $this->AndOp = self::$and__;
- }else{
- $this->AndOp = new Mathparser_ParserFunction('&', 'mp_and_str_', 2);
- $this->AddOp = self::$add__;
- }
- }else{
- throw new Exception('Invalid string concat operator: '.$value);
- }
- }
+ $this->Variables = array();
+ $this->Functions = array();
- /**
- * VariableResolver is used as a callback function that returns the values of variables when asked.
- * This is useful when a variable cannot be defined before the parse operation.
- * If VariableResolver property is set, it will be used to resolve variables that were not defined
- * at the time parse operation has started. This means that syntax errors regarding undefined variables
- * will not be caught at parse time. This VariableResolver (user implementation) will decide whether
- * a variable name is valid or not.
- * This is useful when for example the value comes from a database lookup. In some cases,
- * the problem domain is too big to define the variables ahead of time. In such cases, it makes sense
- * to parse with the assumption that it is a valid variable and resolve it's value when needed on demand during
- * evaluation.
- * @return string
- */
- public function getVariableResolver()
- {
- return $this->VariableResolver;
- }
- /**
- * @see getVariableResolver
- * @param $value string
- */
- public function setVariableResolver($value){
- $this->VariableResolver=$value;
- if($value==null){
- $this->Dirty=true;
- }
- }
+ //Comment out if you don't want these functions and variables:
+ $this->createDefaultFuncs();
+ $this->createDefaultVars();
- /**
- * Constructor for the MathParser.
- */
- public function __construct()
- {
- $this->Expression = '';
- $this->Node = null;
- $this->Dirty = true; //means it is not Parsed yet.
- $this->OptimizationOn = false;
-
- $this->Variables = array();
- $this->Functions = array();
-
- //Comment out if you don't want these functions and variables:
- $this->createDefaultFuncs();
- $this->createDefaultVars();
-
- if(!isset(self::$add__)){
+ if (!isset(self::$add__)) {
self::$add__ = new Mathparser_ParserFunction('+', 'mp_add_', 2);
self::$subtract__ = new Mathparser_ParserFunction('-', 'mp_subtract_', 2);
self::$mult__ = new Mathparser_ParserFunction('*', 'mp_mult_', 2);
@@ -424,458 +373,378 @@ class MathParser
self::$and__ = new Mathparser_ParserFunction('&', 'mp_and_', 2);
self::$or__ = new Mathparser_ParserFunction('|', 'mp_or_', 2);
- }
+ }
- $this->AddOp = self::$add__;
- $this->AndOp = self::$and__;
- $this->StrConcatOperator='&'; //default.
- }
+ $this->AddOp = self::$add__;
+ $this->AndOp = self::$and__;
+ $this->StrConcatOperator = '&'; //default.
+ }
- /**
- * Returns the existing trasnlatable strings used to report error messages.
- * To use this component in a localized application, set the translated versions of
- * strings for each value that exists in the hashtable. By default, same hashtable is shared
- * between all instances of the parser. To change translation strings, set a new hashtable
- * of your own for the parser instance instead of editing the values contained in this hashtable if
- * you do not wish other parser instances not to be effected.
- * Returns dictionary (array) of key/value pairs where value is a Locale dependent, typically translated String, that
- * may contain placeholder parameters using %s.
- * @return array
- */
- public static function &getTranslationStrings()
- {
- if(!isset(self::$translator))
- {
- self::$translator = array();
+ /**
+ * Returns the existing translatable strings used to report error messages.
+ * To use this component in a localized application, set the translated versions of
+ * strings for each value that exists in the hashtable. By default, same hashtable is shared
+ * between all instances of the parser. To change translation strings, set a new hashtable
+ * of your own for the parser instance instead of editing the values contained in this hashtable if
+ * you do not wish other parser instances not to be effected.
+ * Returns dictionary (array) of key/value pairs where value is a Locale dependent, typically translated String, that
+ * may contain placeholder parameters using %s.
+ * @return array
+ * @since 1.0.0
+ */
+ public static function &getTranslationStrings(): array
+ {
+ if (!isset(self::$translator)) {
+ self::$translator = array();
- //#Strings used by the math Parser.
- self::$translator['ExpEmpty']='Expression is empty.';
+ //#Strings used by the math Parser.
+ self::$translator['ExpEmpty'] = 'Expression is empty.';
- //#parameter is the name of a variable:
- self::$translator['VarNtExst']='Variable %s does not exist.';
+ //#parameter is the name of a variable:
+ self::$translator['VarNtExst'] = 'Variable %s does not exist.';
- //variable is not numeric:
- self::$translator['VarNtDbl']='Variable %s is not numeric.';
+ //variable is not numeric:
+ self::$translator['VarNtDbl'] = 'Variable %s is not numeric.';
- //variable is not a string:
- self::$translator['VarNtStr']='Variable %s is not a string.';
+ //variable is not a string:
+ self::$translator['VarNtStr'] = 'Variable %s is not a string.';
- //variable is not a string or a double:
- self::$translator['VarNtDblStr']='Variable %s should be a Double or a String. It is {1}.';
+ //variable is not a string or a double:
+ self::$translator['VarNtDblStr'] = 'Variable %s should be a Double or a String. It is {1}.';
- //variable already exists:
- self::$translator['VarExt']='Variable %s already exists.';
+ //variable already exists:
+ self::$translator['VarExt'] = 'Variable %s already exists.';
- //#parameter is the name of a variable:
- self::$translator['NtVarNm']='%s is not a valid variable name.';
+ //#parameter is the name of a variable:
+ self::$translator['NtVarNm'] = '%s is not a valid variable name.';
- //#parameter is the math expression that failed to Parse:
- self::$translator['SntxErr']='Syntax error in expression %s';
+ //#parameter is the math expression that failed to Parse:
+ self::$translator['SntxErr'] = 'Syntax error in expression %s';
- //#parameter is a function name:
- self::$translator['NtFncNm']='%s is not a valid function name.';
+ //#parameter is a function name:
+ self::$translator['NtFncNm'] = '%s is not a valid function name.';
- //#parameter is a function name:
- self::$translator['FncExst']='Function %s already exists.';
+ //#parameter is a function name:
+ self::$translator['FncExst'] = 'Function %s already exists.';
- //#Parameters are function name and number of parameters:
- self::$translator['WrngNPrms']='Function %s must accept at least 0 parameters not %s.';
+ //#Parameters are function name and number of parameters:
+ self::$translator['WrngNPrms'] = 'Function %s must accept at least 0 parameters not %s.';
- self::$translator['WrngNPrms2']='Function %s requires at least %s parameters.';
+ self::$translator['WrngNPrms2'] = 'Function %s requires at least %s parameters.';
- //#sub expression is not valid:
- self::$translator['ExpNtVld']='Sub expression "%s" in "%s" is not valid.';
+ //#sub expression is not valid:
+ self::$translator['ExpNtVld'] = 'Sub expression "%s" in "%s" is not valid.';
- self::$translator['InvNPrm']='Invalid number of parameters in "%s".';
+ self::$translator['InvNPrm'] = 'Invalid number of parameters in "%s".';
- //#bracket mismatch.
- self::$translator['BrcktMis']='Bracket mismatch in expression "%s" at index %s.';
+ //#bracket mismatch.
+ self::$translator['BrcktMis'] = 'Bracket mismatch in expression "%s" at index %s.';
- //#missing brackets.
- self::$translator['MisBrckt']='Missing bracket ")" in expression "%s".';
+ //#missing brackets.
+ self::$translator['MisBrckt'] = 'Missing bracket ")" in expression "%s".';
- //applying logical and & to string values:
- self::$translator['InvConcatOper']='Parameter #2 %s is not a numeric value. Cannot apply logical and (&) operator. If you want to concatenate 2 strings, use STR() function to convert first parameter to string.';
+ //applying logical and & to string values:
+ self::$translator['InvConcatOper'] = 'Parameter #2 %s is not a numeric value. Cannot apply logical and (&) operator. If you want to concatenate 2 strings, use STR() function to convert first parameter to string.';
- //applying logical and + to string values:
- self::$translator['InvConcatOper2']='Parameter #2 %s is not a numeric value. Cannot apply plus (+) operator. If you want to concatenate 2 strings, use STR() function to convert first parameter to string.';
+ //applying logical and + to string values:
+ self::$translator['InvConcatOper2'] = 'Parameter #2 %s is not a numeric value. Cannot apply plus (+) operator. If you want to concatenate 2 strings, use STR() function to convert first parameter to string.';
- //converting str to number:
- self::$translator['InvNum']='Cannot convert to a number. %s is not a numeric value.';
- }
- return self::$translator;
- }
+ //converting str to number:
+ self::$translator['InvNum'] = 'Cannot convert to a number. %s is not a numeric value.';
+ }
+ return self::$translator;
+ }
- /**
- * Sets the key/value pairs where value is a translated message string for the parser to use while constructing messages.
- * This mechanism allows the parser instances in the same VM efficiently
- * use different locales independent of each other. not for each instance of the parser.
- * Messages may contain parameter placeholders. For example:
- * "Variable %s does not exist". You need to have your own messages translated
- * accordingly.
- * @param string
- * @return void
- */
- public function setTranslationStrings($strings)
- {
- self::$translator = $strings;
- }
+ /**
+ * Variable property is a way to set and get variable values.
+ * setVariable function creates the variable if the variable does not exist.
+ * Variable name is not case sensitive. Throws exception if the variable needs
+ * to be created and the name is not a valid variable name. CreateVar is just an
+ * alias for this method.
+ * @param $varName - Name of the variable whose value is being set.
+ * @param $newVal - New value of the variable. It should be either a Double or a String.
+ * @param $fn_valueProvider - The delegate that returns the value for a variable when asked by name.
+ * When a $fn_valueProvider is set for a Variable, it's assigned value will not be used and instead the $fn_valueProvider of type
+ *
function VariableDelegate($parser, $varName);
+ * will be called. This is useful in cases when the value of a variable comes from a database and it is not easy to set it's value
+ * (or it is costly) ahead of time. So, when you want to compute the variable value only when it is needed, then you can register a $fn_valueProvider
+ * to be called. You can use the same $fn_valueProvider for all or some of your variables or you can have a different valueProvider for each variable.
+ * @return void
+ * @throws Exception
+ * @since 1.0.0
+ */
+ public function setVariable($varName, $newVal, $fn_valueProvider = null): void
+ {
+ if ($varName == null) {
+ throw new Exception("Variable name cannot be null.");
+ }
+ if (is_numeric($newVal)) {
+ $newVal = (float)$newVal;
+ } else
+ if (!is_string($newVal)) {
+ throw new Exception("Variable should be floating point or string value: " . $newVal);
+ }
+ $upcName = strtoupper($varName);
+ $existing = $this->Variables[$upcName];
+ if ($existing != null) {
+ $existing->Value = $newVal;
+ } else {
+ if (!$this->isValidName($upcName)) {
+ throw new Exception($this->getMessage1("NtVarNm", $varName));
+ }
+ //create the variable:
+ $var = new Mathparser_Variable($upcName, $newVal, $fn_valueProvider);
+ $this->Variables[$upcName] = $var;
+ $this->Dirty = true;
+ }
+ }
- /**
- * Variable property is a way to set and get variable values.
- * Throws Exception if the variable does not exist.
- * Variable name is not case sensitive.
- * @param string
- * @return Returns the current value of the variable. It is either Double or String.
- */
- public function getVariable($varName)
- {
- if ($varName==null)
- {
- throw new Exception("Variable name cannot be null.");
- }
- $upcName = strtoupper($varName);
- $aVariable = $this->Variables[$upcName];
- if ($aVariable==null)
- {
- throw new Exception($this->getMessage1("VarNtExst", $varName));
- }
- return $aVariable->Value;
- }
+ /**
+ * Evaluates the expression and returns the result of it. If it cannot be parsed or
+ * evaluated then this method throws Exception.
+ *
+ * Calling this method is identical to calling getValue()
+ * @return double|string - Returns the value of the parsed expression.
+ * The return type is an object that can be interpreted as either Double or String.
+ * @throws Mathparser_ParserException
+ * @since 1.0.0
+ */
+ public function evaluate(): float|string
+ {
+ if ($this->Dirty) { //if the expression has been changed, we need to Parse it again
+ $this->parse();
+ }
+ return $this->Node->getValue(); //this will start the chain reaction to get the
+ //value of all nodes
+ }
- /**
- * Variable property is a way to set and get variable values.
- * setVariable function creates the variable if the variable does not exist.
- * Variable name is not case sensitive. Throws exception if the variable needs
- * to be created and the name is not a valid variable name. CreateVar is just an
- * alias for this method.
- * @param $varName - Name of the variable whose value is being set.
- * @param $newVal - New value of the variable. It should be either a Double or a String.
- * @param $fn_valueProvider - The delegate that returns the value for a variable when asked by name.
- * When a $fn_valueProvider is set for a Variable, it's assigned value will not be used and instead the $fn_valueProvider of type
- *
function VariableDelegate($parser, $varName);
- * will be called. This is useful in cases when the value of a variable comes from a database and it is not easy to set it's value
- * (or it is costly) ahead of time. So, when you want to compute the variable value only when it is needed, then you can register a $fn_valueProvider
- * to be called. You can use the same $fn_valueProvider for all or some of your variables or you can have a different valueProvider for each variable.
- * @return void
- */
- public function setVariable($varName, $newVal, $fn_valueProvider=null)
- {
- if ($varName==null)
- {
- throw new Exception("Variable name cannot be null.");
- }
- if(is_numeric($newVal))
- {
- $newVal = (float)$newVal;
- }else
- if(!is_string($newVal)){
- throw new Exception("Variable should be floating point or string value: ".$newVal);
- }
- $upcName = strtoupper($varName);
- $existing = $this->Variables[$upcName];
- if ($existing!=null)
- {
- $existing->Value = $newVal;
- }
- else
- {
- if (!$this->isValidName($upcName))
- {
- throw new Exception($this->getMessage1("NtVarNm", $varName));
- }
- //create the variable:
- $var = new Mathparser_Variable($this, $upcName, $newVal, $fn_valueProvider);
- $this->Variables[$upcName] = $var;
- $this->Dirty = true;
- }
- }
+ /**
+ * Parses the expression and forms a parse tree. Throws Exception if it cannot parse.
+ * Upon successful completion of parsing, it will set the Dirty flag to false, so that
+ * unless the expression is changed or variables and functions added or removed,
+ * expression does not need to be re-parsed. Users may want to call the parse method
+ * directly to check the validity of an input expression using a try-except block.
+ *
+ * If OptimizationOn property is true, Parse method will optimize the parse tree by
+ * evaluating constant branches of the parse tree at that moment, so that Evaluate
+ * function will run faster.
+ * @return void
+ * @throws Mathparser_ParserException
+ * @throws Exception
+ * @since 1.0.0
+ */
+ public function parse(): void
+ {
+ if (!isset($this->Expression) || !(strlen($this->Expression) > 0)) {
+ $this->Node = null;
+ throw new Exception($this->getMessage("ExpEmpty"));
+ }
- /**
- * Evaluates the expression and returns the result of it. If it cannot be parsed or
- * evaluated then this method throws Exception.
- *
- * Calling this method is identical to calling getValue()
- * @return Returns the value of the parsed expression.
- * The return type is an object that can be interpreted as either Double or String.
- */
- public function evaluate()
- {
- if ($this->Dirty)
- { //if the expression has been changed, we need to Parse it again
- $this->parse();
- }
- return $this->Node->getValue(); //this will start the chain reaction to get the
- //value of all nodes
- }
+ $formula = $this->Expression;
+ $this->upperCase($formula);
+ //echo $formula;
- /**
- * Parses the expression and forms a parse tree. Throws Exception if it cannot parse.
- * Upon successful completion of parsing, it will set the Dirty flag to false, so that
- * unless the expression is changed or variables and functions added or removed,
- * expression does not need to be re-parsed. Users may want to call the parse method
- * directly to check the validity of an input expression using a try-except block.
- *
- * If OptimizationOn property is true, Parse method will optimize the parse tree by
- * evaluating constant branches of the parse tree at that moment, so that Evaluate
- * function will run faster.
- * @return void
- */
- public function parse()
- {
- if (!isset($this->Expression) || ! ( strlen($this->Expression) > 0))
- {
- $this->Node = null;
- throw new Exception($this->getMessage("ExpEmpty"));
- }
+ $len = strlen($formula);
+ $brackets = self::checkBrackets($formula);
+ if ($brackets > -1 && $brackets < $len) {
+ throw new Mathparser_ParserException($this->getMessage2("BrcktMis", $formula, $brackets), substr($formula, $brackets), $formula);
+ } else
+ if ($brackets == 'len') {
+ throw new Mathparser_ParserException($this->getMessage1("MisBrckt", $formula), $formula, $formula);
+ }
- $formula = $this->Expression;
- $this->upperCase($formula);
- //echo $formula;
-
- $len = strlen($formula);
- $brackets = self::checkBrackets($formula);
- if($brackets>-1 && $brackets<$len)
- {
- throw new Mathparser_ParserException($this->getMessage2("BrcktMis", $formula, $brackets), substr($formula, $brackets), $formula);
- }
- else
- if($brackets=='len')
- {
- throw new Mathparser_ParserException($this->getMessage1("MisBrckt", $formula), $formula, $formula);
- }
+ if (($this->Node = $this->createParseTree($formula)) == null) {
+ throw new Mathparser_ParserException($this->getMessage2("ExpNtVld", $formula, $formula), $formula, $formula);
+ }
- if (($this->Node = $this->createParseTree($formula)) == null)
- {
- throw new Mathparser_ParserException($this->getMessage2("ExpNtVld", $formula, $formula), $formula, $formula);
- }
+ if ($this->OptimizationOn) {
+ $this->optimize(); //will make sure FNode tree is lean and mean
+ }
+ $this->Dirty = false; //note that we Parsed it once. Unless the expression is changed we do not need to reParse it.
+ }
- if ($this->OptimizationOn)
- {
- $this->optimize(); //will make sure FNode tree is lean and mean
- }
- $this->Dirty = false; //note that we Parsed it once. Unless the expression is changed we do not need to reParse it.
- }
+ /**
+ * Uppercases the expression in char array form without touching the string literals.
+ * @param $c - to convert to uppercase.
+ * @return void
+ * @since 1.0.0
+ */
+ private function upperCase(&$c): void
+ {
+ $len = strlen($c);
+ $insideStringConst = false;
+ for ($i = 0; $i < $len; $i++) {
+ $ch = $c[$i];
+ if ($ch == '"')//support string literals in the expression.
+ {
+ $insideStringConst = !$insideStringConst;
+ continue;
+ }
+ if (!$insideStringConst) {
+ $c[$i] = strtoupper($ch);
+ }
+ }
+ }
- /**
- * Uppercases the expression in char array form without touching the string literals.
- * @param string to convert to uppercase.
- * @return void
- */
- private function upperCase(&$c)
- {
- $len = strlen($c);
- $insideStringConst = false;
- for ($i = 0; $i<$len; $i++)
- {
- $ch = $c[$i];
- if($ch=='"')//support string literals in the expression.
- {
- $insideStringConst = !$insideStringConst;
- continue;
- }
- if(!$insideStringConst)
- {
- $c[$i] = strtoupper($ch);
- }
- }
- }
- /**
- * Removes the spaces in the expression without touching the string literals.
- * Uppercases non-string literal portions of the expression.
- * @param s
- */
- /*
- private function RemoveSpacesExceptLiteralsAndUpperCase($s)
- {
- if(strpos($s,' ')===false)
- {
- return $s; //no spaces involved, return.
- }
- $len = strlen($s);
- $ch;
- $insideStringConst = false;
- $sb = '';
- for ($i = 0; $i<$len; $i++)
- {
- $ch = $s[$i];
- if($ch=='\"')//support string literals in the expression.
- {
- $insideStringConst = !$insideStringConst;
- $sb.=$ch;
- continue;
- }
- if(!$insideStringConst)
- {
- if($ch!=' ')//if it is not a space, we want it.
- {
- $sb.=strtoupper($ch);
- }
- }
- else
- {
- $sb.=$ch;
- }
- }
- return $sb;
- }
- */
+ /**
+ * Creates a variable with given name and initial value.
+ * If the variable already exists, sets it's value to the specified value.
+ * Throws Exception if $varName is not a valid variable name.
+ * @param $varName - Variable name (case insensitive).
+ * @param $varValue - Initial value for the variable.
+ * @param $valueProvider - The callback delegate (a plain old PHP function) that decides the value of the variable at runtime.
+ *
function VariableDelegate($parser, $varName);
+ * @throws Exception
+ * @since 1.0.0
+ */
+ public function createVar($varName, $varValue, $valueProvider = null): void
+ {
+ $this->setVariable($varName, $varValue, $valueProvider);
+ }
- /**
- * Creates a variable with given name and initial value.
- * If the variable already exists, sets it's value to the specified value.
- * Throws Exception if $varName is not a valid variable name.
- * @param varName - Variable name (case insensitive).
- * @param varValue - Initial value for the variable.
- * @param valueProvider - The callback delegate (a plain old PHP function) that decides the value of the variable at runtime.
- *
function VariableDelegate($parser, $varName);
- *
- */
- public function createVar($varName, $varValue, $valueProvider=null)
- {
- $this->setVariable($varName, $varValue, $valueProvider);
- }
+ /**
+ * CreateFunc method creates a new function that takes n number of parameters (could be 0) in
+ * the parser's list of functions. If the function name already exists then this method throws Exception.
+ * Function name is not case sensitive.
+ *
+ * The second parameter is the name of the user defined function that is globally available:
+ *
+ * function funcName($parameter1 [, $parameter2,...]);
+ *
+ * During evaluation of the expression, when the registered function name is
+ * encountered, the user supplied funcName will be called and variables will be passed.
+ *
+ * This user defined function
+ * will need to return a result (representing the value of the function)
+ * based on the parameters passed as an array of double values.
+ * If the number of parameters that a function takes is not known ahead of time,
+ * then the $paramCount parameter should be -1. Otherwise, it will be the
+ * number of parameters that will be passed to the function at runtime. Knowing the number of
+ * parameters ahead of time helps detect syntax errors during parsing. For example, if SIN(x) function
+ * descriptor did not tell us that it was taking only 1 parameter, then an expression like:
+ * SIN(x,y) would not cause syntax error during parsing, and if the implementation of SIN(x) did not check
+ * actual runtime number of parameters passed, then the problem could go undetected
+ * and the second y parameter could be ignored silently.
+ * @param $newFuncName - Name of the new function to create.
+ * @param $funcAddr - name of the PHP function that will be invoked when parser needs to execute this user defined function.
+ * @param $paramCount - number of parameters that this function takes. -1 means any number of parameters.
+ * @throws Exception
+ * @since 1.0.0
+ */
+ public function createFunc($newFuncName, $funcAddr, $paramCount): void
+ {
+ if ($newFuncName == null) {
+ throw new Exception("Function name cannot be null.");
+ }
+ if ($funcAddr == null) {
+ throw new Exception("Function implementation cannot be null.");
+ }
- /**
- * CreateFunc method creates a new function that takes n number of parameters (could be 0) in
- * the parser's list of functions. If the function name already exists then this method throws Exception.
- * Function name is not case sensitive.
- *
- * The second parameter is the name of the user defined function that is globally available:
- *
- * function funcName($parameter1 [, $parameter2,...]);
- *
- * During evaluation of the expression, when the registered function name is
- * encountered, the user supplied funcName will be called and variables will be passed.
- *
- * This user defined function
- * will need to return a result (representing the value of the function)
- * based on the parameters passed as an array of double values.
- * If the number of parameters that a function takes is not known ahead of time,
- * then the $paramCount parameter should be -1. Otherwise, it will be the
- * number of parameters that will be passed to the function at runtime. Knowing the number of
- * parameters ahead of time helps detect syntax errors during parsing. For example, if SIN(x) function
- * descriptor did not tell us that it was taking only 1 parameter, then an expression like:
- * SIN(x,y) would not cause syntax error during parsing, and if the implementation of SIN(x) did not check
- * actual runtime number of parameters passed, then the problem could go undetected
- * and the second y parameter could be ignored silently.
- * @param $newFuncName - Name of the new function to create.
- * @param $funcAddr - name of the PHP function that will be invoked when parser needs to execute this user defined function.
- * @param $paramCount - number of parameters that this function takes. -1 means any number of parameters.
- */
- public function createFunc($newFuncName, $funcAddr, $paramCount )
- {
- if ($newFuncName==null){ throw new Exception("Function name cannot be null."); }
- if ($funcAddr==null){ throw new Exception("Function implementation cannot be null."); }
+ $upcName = strtoupper($newFuncName);
+ if (!$this->isValidName($upcName)) { //must contain uppercase letters only
+ throw new Exception($this->getMessage1("NtFncNm", $newFuncName));
+ }
- $upcName = strtoupper($newFuncName);
- if (!$this->isValidName($upcName))
- { //must contain uppercase letters only
- throw new Exception($this->getMessage1("NtFncNm", $newFuncName));
- }
+ if ($this->isFunction($upcName)) {
+ throw new Exception($this->getMessage1("FncExst", $newFuncName));
+ } else if ($paramCount < -1)//-1 means num params unknown.
+ {
+ throw new Exception($this->getMessage2("WrngNPrms", $newFuncName, (string)$paramCount));
+ } else {
+ $func = new Mathparser_ParserFunction($upcName, $funcAddr, $paramCount);
+ //if newFuncName doesn't exist it is inserted:
+ $this->Functions[$upcName] = $func;
+ }
+ $this->Dirty = true; //previously bad expression may now be ok, we should reParse it
+ }
- if ($this->isFunction($upcName))
- {
- throw new Exception($this->getMessage1("FncExst", $newFuncName));
- }
- else if($paramCount<-1)//-1 means num params unknown.
- {
- throw new Exception($this->getMessage2("WrngNPrms", $newFuncName, (string)$paramCount));
- }
- else
- {
- $func = new Mathparser_ParserFunction($upcName, $funcAddr, $paramCount);
- //if newFuncName doesn't exist it is inserted:
- $this->Functions[$upcName]=$func;
- }
- $this->Dirty= true; //previously bad expression may now be ok, we should reParse it
- }
-
- /**
- * CreateDefaultFuncs method creates some predefined functions in the parser's list of functions.
- *
- * Predefined functions are:
- *
- * SQR: Square function which can be used as SQR(X)
- *
- * SIN: Sinus function which can be used as SIN(X), X is a real-type expression.
- * Sin returns the sine of the angle X in radians.
- *
- * COS: Cosinus function which can be used as COS(X), X is a real-type expression.
- * COS returns the cosine of the angle X in radians.
- *
- * ATAN: ArcTangent function which can be used as ATAN(X)
- * Returns the arctangent of a number as a numeric value between -PI/2 and PI/2 radians.
- *
- * SINH: Sinus Hyperbolic function which can be used as SINH(X)
- *
- * COSH: Cosinus Hyperbolic function which can be used as COSH(X)
- *
- * COTAN: which can be used as COTAN(X)
- *
- * TAN: which can be used as TAN(X)
- *
- * EXP: which can be used as EXP(X)
- *
- * LN: natural log, which can be used as LN(X)
- *
- * LOG: 10 based log, which can be used as LOG(X)
- *
- * SQRT: which can be used as SQRT(X)
- *
- * ABS: absolute value, which can be used as ABS(X)
- *
- * SIGN: SIGN(X) returns -1 if X<0; +1 if X>0, 0 if X=0; it can be used as SQR(X)
- *
- * TRUNC: Discards the fractional part of a number. e.g. TRUNC(-3.2) is -3, TRUNC(3.2) is 3.
- *
- * CEIL: CEIL(-3.2) = 3, CEIL(3.2) = 4
- *
- * FLOOR: FLOOR(-3.2) = -4, FLOOR(3.2) = 3
- *
- * VAL: VAL("3.1") = 3.1 Returns the floating point numeric value of the string argument.
- *
- * Predefined functions that take two parameters are:
- *
- * POW: The Power function raises Base to any power. For fractional exponents or
- * exponents greater than MaxInt, Base must be greater than 0.
- *
- * LOGN: The LogN function returns the log base N of X. Example: LOGN(10, 100) = 2
- *
- * MIN: MIN(2, 3) is 2.
- *
- * MAX: MAX(2, 3) is 3.
- *
- * IF: The IF(b, case1, case2) function provides branching capability.
- * If b is not 0, then it returns case1, else it returns case2.
- * Behavior is similar to PHP's: return b ? case1 : case2;
- * If b==0 then case1 will not be Evaluated, and vice versa.
- * Example: IF(HEIGHT, 3/HEIGHT, 3) will make sure 3/HEIGHT does not cause division by zero.
- *
- * Predefined functions that take no parameters are:
- * RND: RND() function generates a random number (double value) between 0 and 1.
- *
- * STR: STR(123) function returns the string representation of the passed value: "123".
- *
- * SUBSTR: SUBSTR("Hello", 1,3) function returns the substring just like PHP substring function.
- * The first parameter is the string, the second parameter is which index (0 based) to start copying,
- * and the last parameter is the number of characters to copy. For example, SUBSTR("Hello", 1,3) returns "ell".
- *
- * STRLEN: STRLEN("abc") function returns the length of the string parameter. For example, for "abc" it returns 3.
- *
- * CONCAT: CONCAT("abc","def",...) function returns the concatanated strings: "abcdef".
- * There is no preset limit on the number of parameters.
- *
- * TRIM: TRIM(" abc ") function returns the trimmed version of the string parameter: " abc " -> "abc".
- *
- * SUM: SUM(2,3,5,...) functions returns the sum of it's arguments. There is no preset limit on the number of parameters.
- *
- * User functions can be added using CreateFunc method.
- * Functions and Variables can be deleted using DeleteVar, DeleteFunc,
- * DeleteAllVars, DeleteAllFuncs methods.
- */
- public function createDefaultFuncs()
- {
+ /**
+ * CreateDefaultFuncs method creates some predefined functions in the parser's list of functions.
+ *
+ * Predefined functions are:
+ *
+ * SQR: Square function which can be used as SQR(X)
+ *
+ * SIN: Sinus function which can be used as SIN(X), X is a real-type expression.
+ * Sin returns the sine of the angle X in radians.
+ *
+ * COS: Cosinus function which can be used as COS(X), X is a real-type expression.
+ * COS returns the cosine of the angle X in radians.
+ *
+ * ATAN: ArcTangent function which can be used as ATAN(X)
+ * Returns the arctangent of a number as a numeric value between -PI/2 and PI/2 radians.
+ *
+ * SINH: Sinus Hyperbolic function which can be used as SINH(X)
+ *
+ * COSH: Cosinus Hyperbolic function which can be used as COSH(X)
+ *
+ * COTAN: which can be used as COTAN(X)
+ *
+ * TAN: which can be used as TAN(X)
+ *
+ * EXP: which can be used as EXP(X)
+ *
+ * LN: natural log, which can be used as LN(X)
+ *
+ * LOG: 10 based log, which can be used as LOG(X)
+ *
+ * SQRT: which can be used as SQRT(X)
+ *
+ * ABS: absolute value, which can be used as ABS(X)
+ *
+ * SIGN: SIGN(X) returns -1 if X<0; +1 if X>0, 0 if X=0; it can be used as SQR(X)
+ *
+ * TRUNC: Discards the fractional part of a number. e.g. TRUNC(-3.2) is -3, TRUNC(3.2) is 3.
+ *
+ * CEIL: CEIL(-3.2) = 3, CEIL(3.2) = 4
+ *
+ * FLOOR: FLOOR(-3.2) = -4, FLOOR(3.2) = 3
+ *
+ * VAL: VAL("3.1") = 3.1 Returns the floating point numeric value of the string argument.
+ *
+ * Predefined functions that take two parameters are:
+ *
+ * POW: The Power function raises Base to any power. For fractional exponents or
+ * exponents greater than MaxInt, Base must be greater than 0.
+ *
+ * LOGN: The LogN function returns the log base N of X. Example: LOGN(10, 100) = 2
+ *
+ * MIN: MIN(2, 3) is 2.
+ *
+ * MAX: MAX(2, 3) is 3.
+ *
+ * IF: The IF(b, case1, case2) function provides branching capability.
+ * If b is not 0, then it returns case1, else it returns case2.
+ * Behavior is similar to PHP's: return b ? case1 : case2;
+ * If b==0 then case1 will not be Evaluated, and vice versa.
+ * Example: IF(HEIGHT, 3/HEIGHT, 3) will make sure 3/HEIGHT does not cause division by zero.
+ *
+ * Predefined functions that take no parameters are:
+ * RND: RND() function generates a random number (double value) between 0 and 1.
+ *
+ * STR: STR(123) function returns the string representation of the passed value: "123".
+ *
+ * SUBSTR: SUBSTR("Hello", 1,3) function returns the substring just like PHP substring function.
+ * The first parameter is the string, the second parameter is which index (0 based) to start copying,
+ * and the last parameter is the number of characters to copy. For example, SUBSTR("Hello", 1,3) returns "ell".
+ *
+ * STRLEN: STRLEN("abc") function returns the length of the string parameter. For example, for "abc" it returns 3.
+ *
+ * CONCAT: CONCAT("abc","def",...) function returns the concatanated strings: "abcdef".
+ * There is no preset limit on the number of parameters.
+ *
+ * TRIM: TRIM(" abc ") function returns the trimmed version of the string parameter: " abc " -> "abc".
+ *
+ * SUM: SUM(2,3,5,...) functions returns the sum of it's arguments. There is no preset limit on the number of parameters.
+ *
+ * User functions can be added using CreateFunc method.
+ * Functions and Variables can be deleted using DeleteVar, DeleteFunc,
+ * DeleteAllVars, DeleteAllFuncs methods.
+ * @throws Exception
+ * @since 1.0.0
+ */
+ public function createDefaultFuncs(): void
+ {
$this->createFunc("SQR", 'mp_square_', 1);
$this->createFunc("SIN", 'sin', 1);
$this->createFunc("COS", 'cos', 1);
@@ -905,1347 +774,1044 @@ class MathParser
$this->createFunc("IF", 'if_', 3);
$this->createFunc("STRLEN", 'strlen', 1);
- $this->createFunc("STR", 'strval',1);
- $this->createFunc("SUBSTR", 'substr',3);
- $this->createFunc("CONCAT", 'mp_concat_',-1);
- $this->createFunc("TRIM", 'trim',1);
- $this->createFunc("RTRIM", 'rtrim',1);
- $this->createFunc("LTRIM", 'ltrim',1);
- $this->createFunc("CHR", 'chr',1);
- $this->createFunc("NUM", 'mp_num_',1);
+ $this->createFunc("STR", 'strval', 1);
+ $this->createFunc("SUBSTR", 'substr', 3);
+ $this->createFunc("CONCAT", 'mp_concat_', -1);
+ $this->createFunc("TRIM", 'trim', 1);
+ $this->createFunc("RTRIM", 'rtrim', 1);
+ $this->createFunc("LTRIM", 'ltrim', 1);
+ $this->createFunc("CHR", 'chr', 1);
+ $this->createFunc("NUM", 'mp_num_', 1);
$this->createFunc("SUM", 'sum_', -1);
- }
+ }
- /**
- * X, Y and PI variables can be predefined and can be immediately used in the expression.
- * Initial values of X and Y are 0. PI is 3.14159265358979
- */
- public function createDefaultVars()
- {
- try
- {
- $this->createVar("PI", 3.14159265358979, null);
- $this->createVar("X", 0.0, null);
- $this->createVar("Y", 0.0, null);
- }
- catch(Exception $e)
- {
- //we know that these are valid names, so there won't be an exception.
- }
- }
+ /**
+ * X, Y and PI variables can be predefined and can be immediately used in the expression.
+ * Initial values of X and Y are 0. PI is 3.14159265358979
+ * @since 1.0.0
+ */
+ public function createDefaultVars(): void
+ {
+ try {
+ $this->createVar("PI", 3.14159265358979);
+ $this->createVar("X", 0.0);
+ $this->createVar("Y", 0.0);
+ } catch (Exception $e) {
+ //we know that these are valid names, so there won't be an exception.
+ Log::add("Pi, X or Y could not be created: " . $e->getMessage(), Log::WARNING,"com_sportsmanager");
+ }
+ }
- /**
- * DeleteVar method deletes an existing variable from the list of available variables.
- * If the variable does not exist, then DeleteVar does nothing.
- *
- * When a variable is deleted Dirty flag is set to true so that next time
- * the Evaluate function is called the expression will be reparsed.
- * Variable name is not case sensitive.
- * @param varName - Name of the variable to delete.
- */
- public function deleteVar($varName)
- {
- if ($varName==null)
- {
- throw new Exception("Variable name cannot be null.");
- }
- //this function deletes the variable only if it finds it.
- $upcName = strtoupper($varName);
- unset($this->Variables[$upcName]);
- //TODO: Is this right?
- //$this->Variables = array_values($this->Variables);
- $this->Dirty = true;
- }
- /**
- * DeleteFunc method deletes an existing function from the list of available functions.
- * If the function does not exist, deleteFunc does nothing.
- *
- * When a function is deleted Dirty flag is set to true so that next time the
- * Evaluate function is called the expression will be reparsed.
- * Function name is not case sensitive.
- * @param funcName - Name of the function to delete.
- */
- public function deleteFunc($funcName)
- {
- if ($funcName==null)
- {
- throw new Exception("Function name cannot be null.");
- }
- $upcName = strtoupper($funcName);
- unset($this->Functions[$upcName]);
- //$this->Functions = array_values($this->Functions);
- $this->Dirty = true;
- }
+ /**
+ * Returns true if a function with the name 'funcName' is present in any of
+ * the current functions lists. Returns true if a function with the given name is defined. False otherwise.
+ * @param string $funcName - Name of the function in question.
+ * @return boolean
+ * @throws Exception
+ * @since 1.0.0
+ */
+ public function isFunction(string $funcName): bool
+ {
+ if ($funcName == null) {
+ throw new Exception("Function name cannot be null.");
+ }
+ $funcName = strtoupper($funcName);
+ return isset($this->Functions[$funcName]);
+ }
- /**
- * DeleteAllVars method deletes all variables from the list of available variables.
- *
- * This action may be useful when number of unused variables is too high that
- * causes performance to degrade.
- *
- * When a variable is deleted Dirty flag is set to true so that next time the
- * Evaluate function is called the expression will be reparsed.
- */
- public function deleteAllVars()
- {
- $this->Variables = array();
- $this->Dirty = true;
- }
+ /**
+ * Optimizes the parse tree by finding branches that evaluate to a constant and
+ * replacing them with a leaf representing the constant.
+ * Until the expression is changed and reparsed, further evaluation requests will be
+ * quicker.
+ *
+ * If the same expression will not be evaluated repeatedly with varying
+ * values of parameters used in it, then optimization will not bring any gain,
+ * but will slow performance.
+ *
+ * If OptimizationOn property is set to true, this method is called automatically when an
+ * evaluation is requested by calling Evaluate method or getValue() method.
+ * @ignore
+ * @since 1.0.0
+ */
+ public function optimize(): void
+ {
+ $this->Node = self::optimizeNode($this->Node);
+ }
- /**
- * DeleteAllFuncs method deletes all variables from the list of available functions.
- *
- * This action may be useful when number of unused functions is too high that
- * causes performance to degrade.
- *
- * When a function is deleted Dirty flag is set to true so that next time the
- * Evaluate function is called the expression will be reparsed.
- */
- public function deleteAllFuncs()
- {
- $this->Functions = array();
- $this->Dirty = true;
- }
- /**
- * FreeParseTree can be explicitly called to free the resources taken by the
- * allocated Parse tree when an expression is parsed. FreeParseTree sets the Dirty
- * flag to true so that next time the Evaluate function is called, expression will
- * be parsed forming a new, valid parse tree to be evaluated.
- */
- public function freeParseTree()
- {
- //delete FNode;
- $this->Node = null; //this should free it all
- $this->Dirty = true; //so that next time we call Evaluate, it will call the Parse method.
- }
- /**
- * Returns true if a variable with the name 'varName' is used in the current expression.
- * Variable name is not case sensitive. Throws exception if expression is not parsed
- * and cannot be parsed.
- * @param varName - Name of the variable in question.
- * @return Returns true if the variable with the given name was actually used in the current expression. Returns false otherwise.
- */
- public function isVariableUsed($varName)
- {
- if ($varName==null){ throw new Exception("Variable name cannot be null."); }
+ /**
+ * Value property is a read only property which returns the result of the expression.
+ * throws Exception if expression cannot be parsed. Return value is either Double or String.
+ * @return double|string
+ * @throws Mathparser_ParserException
+ * @since 1.0.0
+ */
+ public function getValue(): float|string
+ {
+ return $this->evaluate();
+ }
- if($this->Dirty)
- {
- parse(); //to create Parse tree if it is not created yet.
- }
+ //------------------------------------------------------------------------------
+ //END OF PUBLIC METHODS.
+ //------------------------------------------------------------------------------
- $varName = strtoupper($varName);
- return $this->Node->isVariableUsed($varName);
- }
- /**
- * Returns true if a function with the name 'funcName' is used in the current expression.
- * Function name is not case sensitive. Throws exception if expression is not parsed and cannot be parsed.
- * Returns true if the function with the given name was actually used in the current expression.
- * Returns false otherwise.
- * @param string $funcName - Name of the function in question.
- * @return boolean
- */
- public function isFunctionUsed($funcName)
- {
- if ($funcName==null){ throw new Exception("Function name cannot be null."); }
- if ($this->Dirty)
- {
- parse(); //to create Parse tree if it is not created yet.
- }
+ /**
+ * @param $index
+ * @param $c
+ * @return bool
+ * @ignore
+ * Valid char definition for function and variable names.
+ * @since 1.0.0
+ */
+ private function isValidChar($index, $c): bool
+ {
+ if ($index == 0) {
+ if (($c >= 'A' && $c <= 'Z')) {
+ return true;
+ }
+ if ($c == '_') {
+ return true;
+ }
+ return false;
+ }
+ if ((($c >= '0' && $c <= '9') || ($c >= 'A' && $c <= 'Z'))) {
+ return true;
+ }
+ if ($c == '_') {
+ return true;
+ }
+ return false;
+ }
- $funcName = strtoupper($funcName);
- return $this->Node->isFunctionUsed($funcName);
- }
- /**
- * Returns true if a variable with the name 'varName' is present in the current variables list.
- * For backward compatibility, IsVariable returns true for constants also.
- * For constants, you can use IsConstant. Returns true if the variable exists in the list of
- * variables of the parser instance. false otherwise.
- * @param string $varName - Name of the variable in question.
- * @return boolean
- */
- public function isVariable($varName)
- {
- if ($varName==null){ throw new Exception("Variable name cannot be null."); }
- $varName = strtoupper($varName);
- return isset($this->Variables[$varName]);
- }
+ /**
+ * Valid name definition for function and variable names.
+ * @param $name
+ * @return bool
+ * @ignore
+ * @since 1.0.0
+ */
+ private function isValidName($name): bool
+ {
+ $len = strlen($name);
+ for ($i = 0; $i < $len; $i++) {
+ if (!$this->isValidChar($i, $name[$i])) {
+ return false;
+ }
+ }
+ return true;
+ }
+ //------------------------------------------------------------------------------
- /**
- * Returns true if a function with the name 'funcName' is present in any of
- * the current functions lists. Returns true if a function with the given name is defined. False otherwise.
- * @param string $funcName - Name of the function in question.
- * @return boolean
- */
- public function isFunction($funcName)
- {
- if ($funcName==null){ throw new Exception("Function name cannot be null."); }
- $funcName = strtoupper($funcName);
- return isset($this->Functions[$funcName]);
- }
+ /**
+ * Makes sure number of opening brackets "(" are equal to
+ * the number of closing brackets ")" and they are consistent.
+ * @param $formula
+ * @return int
+ * @ignore
+ * @since 1.0.0
+ */
+ protected static function checkBrackets($formula): int
+ {
+ //this function checks to see if the order and double of brackets are correct
+ //it will say ok if it sees something like 3+()()
+ $n = 0;
+ $len = strlen($formula);
+ $insideStringConst = false;
+ for ($i = 0; $i < $len; $i++) { //if length<1 loop won't execute
+ $ch = $formula[$i];
+ if ($ch == '\"')//support string literals in the expression.
+ {
+ $insideStringConst = !$insideStringConst;
+ continue;
+ }
+ if (!$insideStringConst) {
+ if ($ch == '(')
+ ++$n;
+ else if ($ch == ')')
+ --$n;
- /**
- * Returns the list of variables used in the current expression as an array of Strings.
- * Each element of the array is guaranteed not to be null.
- * If variables are not defined ahead of time, then $VariableResolver must have been set.
- * Otherwise, when an undefined variable is found in the expression, ParserException will be thrown.
- * Return array of variable names that are currently defined for this parser instance.
- * @return array
- */
- public function getVariablesUsed()
- {
- if ($this->Dirty && $this->Expression!=null && strlen($this->Expression)>0)
- {
- parse();
- }
- return findVariablesUsed($this->Node);
- }
+ if ($n < 0) return $i; //at any moment if expression is valid we cannot have more ) then (
+ }
+ }
+ return ($n == 0) ? -1 : $len; //true if double of brackets matches
+ }
+ //------------------------------------------------------------------------------
- /**
- * @ignore
- * @param object $aNode
- * @return array
- */
- static function findVariablesUsed($aNode)
- {
- $list = array();
- if ($aNode instanceof Mathparser_VarNode)
- {
- $list[]=$aNode->VarName;
- }
- else if ($aNode.nodes)
- {
- foreach ($aNode.nodes as $n)
- {
- if ( $n instanceof Mathparser_VarNode )
- {
- $list[]=$n->VarName;
- }
- else
- {
- $list = array_merge($list, findVariablesUsed($n));
- }
- }
- }
- return $list;
- }
+ /**
+ * Removes unncessary outer brackets in an expression.
+ * @param $formula
+ * @return mixed|string
+ * @ignore
+ * @since 1.0.0
+ */
+ protected static function removeOuterBrackets($formula): mixed
+ {
+ //has to be careful about (X+1)-(Y-1)
+ //should not remove the outer brackets here thinking that they are unnecessary
+ //but should remove when ((X+1)-(Y-1))
+ $temp = $formula;
+ $Len = strlen($temp);
+ while (($Len > 2) && ($temp[0] == '(') && ($temp[$Len - 1] == ')')) {
+ $temp = trim(substr($temp, 1, $Len - 2));
+ if (self::checkBrackets($temp) == -1) { //if we did not screw up then assign to the return value
+ $formula = $temp;
+ }
+ $Len = strlen($temp);
+ }
+ return $formula;
+ }
+ //------------------------------------------------------------------------------
- /**
- * Returns the list of variables as an array of Strings.
- * Each element of the array is guaranteed not to be null.
- * Returns array of variable names that are currently defined for this parser instance.
- * @return array
- */
- public function getVariables()
- {
- return array_keys($this->Variables);
- }
+ /**
+ * Determines if a given string is a valid double number or not.
+ * If it is valid, the actual double value is returned out in the out parameter dblVal.
+ * @param $formula - Expression to parse.
+ * @param $dblVal - Output double value
+ * @ignore
+ * @since 1.0.0
+ */
+ protected static function isValidDouble($formula, &$dblVal): bool
+ {
+ if (is_numeric($formula)) {
+ $dblVal = (float)$formula;
+ return true;
+ }
+ return false;
+ }
- /**
- * Returns a String array of function names declared for this parser.
- * Elements of the array are guaranteed not to be null.
- * Returns array of function names that are currently defined for this parser instance.
- * @return array
- */
- public function getFunctions()
- {
- return array_keys($this->Functions);
- }
+ /**
+ * Returns the string literal if this formula is a string literal such as "abc".
+ * Escape character is " inside the string. Meaning, to have quotes inside the
+ * string it would be like this:
+ * "abc""defg".
+ * Returns null if this is not a valid string literal.
+ * @param $formula - The sub expression in question.
+ * @return string|null the string that is inside the "" after "" escapes inside the string are processed. Null if the string is not valid.
+ * @ignore
+ * @since 1.0.0
+ */
+ private static function getStringLiteral($formula): ?string
+ {
+ $len = strlen($formula);
+ if (!($len > 1 && $formula[0] == '"' && $formula[$len - 1] == '"')) {
+ return null;
+ }
+ $temp = substr($formula, 1, $len - 2);
+ if (self::checkEscapes($temp)) {
+ return str_replace('""', '"', $temp);
+ }
+ return null;
+ }
- /**
- * Optimizes the parse tree by finding branches that evaluate to a constant and
- * replacing them with a leaf representing the constant.
- * Until the expression is changed and reparsed, further evaluation requests will be
- * quicker.
- *
- * If the same expression will not be evaluated repeatedly with varying
- * values of parameters used in it, then optimization will not bring any gain,
- * but will slow performance.
- *
- * If OptimizationOn property is set to true, this method is called automatically when an
- * evaluation is requested by calling Evaluate method or getValue() method.
- * @ignore
- */
- public function optimize()
- {
- $this->Node = self::optimizeNode($this->Node);
- }
+ /**
+ * @param $formula
+ * @return boolean
+ * @ignore
+ * @since 1.0.0
+ */
+ private static function checkEscapes($formula): bool
+ {
+ //this function checks to see if the escaped quotes match.
+ $len = strlen($formula);
+ $insideStringConst = false;
+ for ($i = 0; $i < $len; $i++) { //if length<1 loop won't execute
+ $ch = $formula[$i];
+ if ($ch == '"') //support string literals in the expression.
+ {
+ if ($insideStringConst) {
+ return false; //too many quotes.
+ }
+ ++$i;
+ if ($i < $len && $formula[$i] == '"') {
+ $insideStringConst = true;
+ } else {
+ return false;
+ }
+ continue;
+ }
+ $insideStringConst = false;
+ }
+ return true;
+ }
+ //------------------------------------------------------------------------------
- /**
- * Value property is a read only property which returns the result of the expression.
- * throws Exception if expression cannot be parsed. Return value is either Double or String.
- * @return mixed
- */
- public function getValue()
- {
- return $this->evaluate();
- }
+ /**
+ * Compiles the parse tree of the given expression.
+ * @param $expToParse - Mathematical expression.
+ * @return mixed node of the parse tree.
+ * @throws Mathparser_ParserException
+ * @since 1.0.0
+ * @ignore
+ */
+ protected function createParseTree($expToParse): mixed
+ {
+ $expToParse = trim($expToParse);
+ if (($len = strlen($expToParse)) == 0) {
+ return null;
+ }
- /**
- * Value property is a read only property which returns the result of the expression.
- * throws Exception if expression cannot be parsed. Return value is is a Double.
- * @return float
- */
- public function getValueAsDouble()
- {
- $obj = $this->evaluate();
- //if(is_string($obj))
- //{
- // return (float)$obj;
- //}
- return (float)$obj;
- }
+ $formula = $this->removeOuterBrackets($expToParse); //remove unnecessary brackets
- /**
- * Value property is a read only property which returns the result of the expression.
- * throws Exception if expression cannot be parsed. Return value is a string.
- * @return string
- */
- public function getValueAsString()
- {
- return (string)evaluate();
- }
-
- //------------------------------------------------------------------------------
- //END OF PUBLIC METHODS.
- //------------------------------------------------------------------------------
+ if (strlen($formula) != $len) {
+ $formula = trim($formula);
+ if (strlen($formula) == 0) {
+ return null;
+ }
+ }
- /**
- * @ignore
- * Valid char definition for function and variable names.
- * @param index
- * @param c
- */
- private function isValidChar($index, $c)
- {
- if ($index==0)
- {
- if ( ($c>='A' && $c<='Z') )
- {
- return true;
- }
- if ($c=='_'){ return true; }
- return false;
- }
- if ( (($c>='0' && $c<='9') || ($c>='A' && $c<='Z')) )
- {
- return true;
- }
- if ($c=='_'){ return true; }
- return false;
- }
- /**
- * Valid name definition for function and variable names.
- * @param name
- * @ignore
- */
- private function isValidName($name)
- {
- $len = strlen($name);
- for ($i=0; $i<$len; $i++)
- {
- if(!$this->isValidChar($i, $name[$i]))
- {
- return false;
- }
- }
- return true;
- }
- //------------------------------------------------------------------------------
- /**
- * Makes sure number of opening brackets "(" are equal to
- * the number of closing brackets ")" and they are consistent.
- * @param formula
- * @ignore
- */
- protected static function checkBrackets($formula)
- {
- //this function checks to see if the order and double of brackets are correct
- //it will say ok if it sees something like 3+()()
- $n=0;
- $len = strlen($formula);
- $ch;
- $insideStringConst = false;
- for ($i = 0; $i<$len; $i++)
- { //if length<1 loop won't execute
- $ch = $formula[$i];
- if($ch=='\"')//support string literals in the expression.
- {
- $insideStringConst = !$insideStringConst;
- continue;
- }
- if(!$insideStringConst)
- {
- if ($ch == '(')
- ++$n;
- else if ($ch == ')')
- --$n;
+ //is this text a simple double value?
+ $dblVal = null;
+ if ($this->isValidDouble($formula, $dblVal)) { //attach a double node in the structure
+ return new Mathparser_BasicNode($dblVal); //we create a double node and attach it to the *Node reference.
+ }
- if ($n<0) return $i; //at any moment if expression is valid we cannot have more ) then (
- }
- }
- return ($n == 0) ? -1 : $len; //true if double of brackets matches
- }
- //------------------------------------------------------------------------------
- /**
- * Removes unncessary outer brackets in an expression.
- * @param formula
- * @ignore
- */
- protected static function removeOuterBrackets($formula)
- {
- //has to be careful about (X+1)-(Y-1)
- //should not remove the outer brackets here thinking that they are unnecessary
- //but should remove when ((X+1)-(Y-1))
- $temp = $formula;
- $Len = strlen($temp);
- while (($Len>2) && ($temp[0] == '(') && ($temp[$Len-1] == ')') )
- {
- $temp = trim(substr($temp, 1, $Len-2));
- if (self::checkBrackets($temp)==-1)
- { //if we did not screw up then assign to the return value
- $formula = $temp;
- }
- $Len = strlen($temp);
- }
- return $formula;
- }
- //------------------------------------------------------------------------------
- /**
- * Determines if a given string is a valid double number or not.
- * If it is valid, the actual double value is returned out in the out parameter dblVal.
- * @param formula - Expression to parse.
- * @param dblVal - Output double value
- * @ignore
- */
- protected static function isValidDouble($formula, &$dblVal )
- {
- if(is_numeric($formula)){
- $dblVal = (float)$formula;
- return true;
- }
- return false;
- }
- /**
- * Returns the string literal if this formula is a string literal such as "abc".
- * Escape character is " inside the string. Meaning, to have quotes inside the
- * string it would be like this:
- * "abc""defg".
- * Returns null if this is not a valid string literal.
- * @param formula - The sub expression in question.
- * @return the string that is inside the "" after "" escapes inside the string are processed. Null if the string is not valid.
- * @ignore
- */
- private static function getStringLiteral($formula)
- {
- $len=strlen($formula);
- if (!($len>1 && $formula[0]=='"' && $formula[$len-1]=='"'))
- {
- return null;
- }
- $temp = substr($formula, 1,$len-2);
- if(self::checkEscapes($temp))
- {
- return str_replace('""', '"', $temp);
- }
- return null;
- }
+ if ($this->StringLiteralsAllowed) {
+ $tempFormula = $this->getStringLiteral($formula);
+ if ($tempFormula != null) {
+ return new Mathparser_BasicNode($tempFormula); //we create a double node and attach it to the *Node reference.
+ }
+ }
- /**
- * @ignore
- * @param $formula
- * @return boolean
- */
- private static function checkEscapes($formula)
- {
- //this function checks to see if the escaped quotes match.
- $len = strlen($formula);
- $ch;
- $insideStringConst = false;
- for ($i = 0; $i<$len; $i++)
- { //if length<1 loop won't execute
- $ch = $formula[$i];
- if($ch=='"') //support string literals in the expression.
- {
- if($insideStringConst)
- {
- return false; //too many quotes.
- }
- ++$i;
- if($i<$len && $formula[$i]=='"')
- {
- $insideStringConst = true;
- }
- else
- {
- return false;
- }
- continue;
- }
- $insideStringConst = false;
- }
- return true;
- }
- //------------------------------------------------------------------------------
- /**
- * Compiles the parse tree of the given expression.
- * @param expToParse - Mathematical expression.
- * @return Root node of the parse tree.
- * @ignore
- */
- protected function createParseTree($expToParse)
- {
- $expToParse = trim($expToParse);
- if (($len=strlen($expToParse))==0)
- {
- return null;
- }
+ //if it is not a simple double or a string, maybe it is a variable?
+ $varNode = $this->createVarNode($formula);
+ if ($varNode != null) {
+ return $varNode;
+ }
- $formula = $this->removeOuterBrackets($expToParse); //remove unnecessary brackets
-
- if(strlen($formula)!=$len)
- {
- $formula = trim($formula);
- if (strlen($formula)==0)
- {
- return null;
- }
- }
+ //if it is not a variable
+ $LastOper = $this->findLastOper($formula);
- //is this text a simple double value?
- $dblVal;
- if ($this->isValidDouble($formula, $dblVal) )
- { //attach a double node in the structure
- return new Mathparser_BasicNode($dblVal); //we create a double node and attach it to the *Node reference.
- }
+ $funcAddr = null;
+ if (!($LastOper > 0)) //if it is 0 then it is a unary operation which is a one param function
+ {
+ $param = null;
+ if ($this->isOneParamFunc($formula, $funcAddr, $param, $LastOper)) {
+ if (($leftNode = $this->createParseTree($param)) == null) {
+ throw new Mathparser_ParserException($this->getMessage2("ExpNtVld", $param, $formula), $param, $formula);
+ }
+ if ($funcAddr != null) {
+ return new Mathparser_NParamNode(array($leftNode), $funcAddr);
+ }
+ }
+ }
- if($this->StringLiteralsAllowed)
- {
- $tempFormula = $this->getStringLiteral($formula);
- if ( $tempFormula!=null )
- {
- return new Mathparser_BasicNode($tempFormula); //we create a double node and attach it to the *Node reference.
- }
- }
+ $paramLeft = null;
+ $paramRight = null;
+ if ($this->isTwoParamFunc($formula, $funcAddr, $paramLeft, $paramRight, $LastOper)) {
+ if (($leftNode = $this->createParseTree($paramLeft)) == null) {
+ throw new Mathparser_ParserException($this->getMessage2("ExpNtVld", $paramLeft, $formula), $paramLeft, $formula);
+ }
+ if (($rightNode = $this->createParseTree($paramRight)) == null) {
+ throw new Mathparser_ParserException($this->getMessage2("ExpNtVld", $paramRight, $formula), $paramRight, $formula);
+ }
+ //if there is a function address returned then we use it, otherwise we use function name
+ if ($funcAddr != null) {
+ return new Mathparser_NParamNode(array($leftNode, $rightNode), $funcAddr);
+ }
+ }
- //if it is not a simple double or a string, maybe it is a variable?
- $varNode = $this->createVarNode($formula);
- if($varNode!=null)
- {
- return $varNode;
- }
+ $parms = null;
+ //if it is none of the above:
+ if ($this->isNParamFunc($formula, /*out*/ $funcAddr, /*out*/ $parms)) {
+ if (!isset($parms)) {
+ //We now allow functions with no parameters.
+ throw new Mathparser_ParserException($this->getMessage1("InvNPrm", $formula), $formula, $formula);
+ }
+ $nParam = count($parms);
+ $nodes = array();
+ for ($i = 0; $i < $nParam; $i++) {
+ if (($leftNode = $this->createParseTree($parms[$i])) == null) {
+ throw new Mathparser_ParserException($this->getMessage2("ExpNtVld", $parms[$i], $formula), $parms[$i], $formula);
+ }
+ $nodes[$i] = $leftNode;
+ }
- //if it is not a variable
- $leftNode = null;
- $rightNode = null;
- $LastOper= $this->findLastOper($formula);
+ //if there is a function address returned then we use it, otherwise we use function name
+ if ($funcAddr != null) {
+ return new Mathparser_NParamNode($nodes, $funcAddr);
+ }
+ }
+ //when code reaches here it means we did not return true so after compiling the expression.
+ return null;
+ }
- $funcAddr=null;
- if (! ($LastOper>0) ) //if it is 0 then it is a unary operation which is a one param function
- {
- $param=null;
- if ( $this->isOneParamFunc($formula, $funcAddr, $param, $LastOper) )
- {
- if (($leftNode = $this->createParseTree($param)) == null )
- {
- throw new Mathparser_ParserException($this->getMessage2("ExpNtVld", $param, $formula), $param, $formula);
- }
- if ($funcAddr != null)
- {
- return new Mathparser_NParamNode(array($leftNode), $funcAddr);
- }
- }
- }
+ //------------------------------------------------------------------------------
- $paramLeft=null;
- $paramRight=null;
- if ($this->isTwoParamFunc($formula, $funcAddr, $paramLeft, $paramRight, $LastOper) )
- {
- if (($leftNode = $this->createParseTree($paramLeft)) == null)
- {
- throw new Mathparser_ParserException($this->getMessage2("ExpNtVld", $paramLeft, $formula), $paramLeft, $formula);
- }
- if (($rightNode = $this->createParseTree($paramRight)) == null )
- {
- throw new Mathparser_ParserException($this->getMessage2("ExpNtVld", $paramRight, $formula), $paramRight, $formula);
- }
- //if there is a function address returned then we use it, otherwise we use function name
- if ($funcAddr != null)
- {
- return new Mathparser_NParamNode(array($leftNode, $rightNode), $funcAddr);
- }
- }
-
- $parms=null;
- //if it is none of the above:
- if ($this->isNParamFunc($formula, /*out*/ $funcAddr, /*out*/ $parms, $LastOper) )
- {
- if (!isset($parms))
- {
- //We now allow functions with no parameters.
- throw new Mathparser_ParserException($this->getMessage1("InvNPrm", $formula), $formula, $formula);
- }
- $nParam = count($parms);
- $nodes = array();
- for ($i=0; $i<$nParam; $i++)
- {
- if ( ($leftNode = $this->createParseTree($parms[$i]) )== null)
- {
- throw new Mathparser_ParserException($this->getMessage2("ExpNtVld", $parms[$i], $formula), $parms[$i], $formula);
- }
- $nodes[$i] = $leftNode;
- }
+ /**
+ * Finds the index of the last math operation in an expression.
+ * @param $formula - Math expression.
+ * @return int index of the last operand.
+ * @ignore
+ * @since 1.0.0
+ */
+ private static function findLastOper($formula): int
+ { //returns -1 if it cannot find anything
+ $Precedence = 13; //There are 12 operands and 13 is higher then all
+ $BracketLevel = 0; //shows the level of brackets we moved through
+ $Result = -1;
+ $Len = strlen($formula);
+ $lastWasOperator = 0;
+ $insideStringLiteral = false;
+ for ($i = 0; $i < $Len; $i++) //from left to right scan...
+ {
+ $current_ch = $formula[$i];
+ if ($current_ch == '"') {
+ $insideStringLiteral = !$insideStringLiteral;
+ $lastWasOperator = 0;
+ continue;
+ }
+ if ($insideStringLiteral) {
+ continue; //skip string literals.
+ }
+ if ($lastWasOperator > 2) {
+ return -1;
+ }
+ switch ($current_ch) {
+ case ')' :
+ --$BracketLevel; //counting bracket levels
+ $lastWasOperator = 0;
+ break;
+ case '(' :
+ ++$BracketLevel;
+ $lastWasOperator = 0;
+ break;
- //if there is a function address returned then we use it, otherwise we use function name
- if ($funcAddr != null)
- {
- return new Mathparser_NParamNode($nodes, $funcAddr);
- }
- }
- //when code reaches here it means we did not return true so after compiling the expression.
- return null;
- }
- //------------------------------------------------------------------------------
- /**
- * Finds the index of the last math operation in an expression.
- * @param formula - Math expression.
- * @return index of the last operand.
- * @ignore
- */
- private static function findLastOper($formula)
- { //returns -1 if it cannot find anything
- $Precedence = 13; //There are 12 operands and 13 is higher then all
- $BracketLevel = 0; //shows the level of brackets we moved through
- $Result = -1;
- $Len = strlen($formula);
- $lastWasOperator = 0;
- $insideStringLiteral = false;
- for ($i = 0; $i<$Len; $i++) //from left to right scan...
- {
- $current_ch = $formula[$i];
- if($current_ch=='"')
- {
- $insideStringLiteral = !$insideStringLiteral;
- $lastWasOperator=0;
- continue;
- }
- if($insideStringLiteral)
- {
- continue; //skip string literals.
- }
- if ($lastWasOperator>2)
- {
- return -1;
- }
- switch ($current_ch)
- {
- case ')' :
- --$BracketLevel; //counting bracket levels
- $lastWasOperator = 0;
- break;
- case '(' :
- ++$BracketLevel;
- $lastWasOperator = 0;
- break;
+ case '|' :
+ if (!($BracketLevel > 0 || $lastWasOperator > 0))
+ if ($Precedence >= 1) {
+ $Precedence = 1;
+ $Result = $i;
+ }
+ ++$lastWasOperator;
+ break;
- case '|' :
- if (! ($BracketLevel > 0 || $lastWasOperator>0) )
- if ($Precedence >= 1 )
- {
- $Precedence = 1;
- $Result = $i;
- }
- ++$lastWasOperator;
- break;
+ case '&' :
+ if (!($BracketLevel > 0 || $lastWasOperator > 0))
+ if ($Precedence >= 2) {
+ $Precedence = 2;
+ $Result = $i;
+ }
+ ++$lastWasOperator;
+ break;
- case '&' :
- if (! ($BracketLevel > 0 || $lastWasOperator>0) )
- if ($Precedence >= 2 )
- {
- $Precedence = 2;
- $Result = $i;
- }
- ++$lastWasOperator;
- break;
+ case '!' :
+ if (!($BracketLevel > 0 || $lastWasOperator > 0))
+ if ($Precedence >= 3) {
+ $Precedence = 3;
+ $Result = $i;
+ }
+ ++$lastWasOperator;
+ break;
- case '!' :
- if (! ($BracketLevel > 0 || $lastWasOperator>0) )
- if ($Precedence >= 3 )
- {
- $Precedence = 3;
- $Result = $i;
- }
- ++$lastWasOperator;
- break;
+ case '=' :
+ if (!($BracketLevel > 0 || $lastWasOperator > 0))
+ if ($Precedence >= 4) {
+ $Precedence = 4;
+ $Result = $i;
+ }
+ if ($lastWasOperator > 0) {
+ $prevOperIndex = $i - $lastWasOperator;
+ if ($formula[$prevOperIndex] == '<' || $formula[$prevOperIndex] == '>') {
+ break; //skip incrementing lastWasOperator variable.
+ }
+ }
- case '=' :
- if (! ($BracketLevel > 0 || $lastWasOperator>0) )
- if ($Precedence >= 4 )
- {
- $Precedence = 4;
- $Result = $i;
- }
- if($lastWasOperator>0)
- {
- $prevOperIndex = $i-$lastWasOperator;
- if($formula[$prevOperIndex]=='<' || $formula[$prevOperIndex]=='>')
- {
- break; //skip incrementing lastWasOperator variable.
- }
- }
+ ++$lastWasOperator;
+ break;
- ++$lastWasOperator;
- break;
+ case '>' :
+ if (!($BracketLevel > 0 || $lastWasOperator > 0))
+ if ($Precedence >= 5) {
+ $Precedence = 5;
+ $Result = $i;
+ }
+ if ($lastWasOperator > 0) {
+ if ($formula[$i - $lastWasOperator] == '<') {
+ break;
+ }
+ }
- case '>' :
- if (! ($BracketLevel > 0 || $lastWasOperator>0) )
- if ($Precedence >= 5 )
- {
- $Precedence = 5;
- $Result = $i;
- }
- if($lastWasOperator>0)
- {
- if($formula[$i-$lastWasOperator]=='<')
- {
- break;
- }
- }
+ ++$lastWasOperator;
+ break;
- ++$lastWasOperator;
- break;
+ case '<' :
+ if (!($BracketLevel > 0 || $lastWasOperator > 0))
+ if ($Precedence >= 5) {
+ $Precedence = 5;
+ $Result = $i;
+ }
+ ++$lastWasOperator;
+ break;
- case '<' :
- if (! ($BracketLevel > 0 || $lastWasOperator>0) )
- if ($Precedence >= 5 )
- {
- $Precedence = 5;
- $Result = $i;
- }
- ++$lastWasOperator;
- break;
+ case '-' :
+ if (!($BracketLevel > 0 || $lastWasOperator > 0)) //a main operation has to be outside the brackets
+ if ($Precedence >= 7) //seeking for lowest precedence
+ {
+ $Precedence = 7;
+ $Result = $i; //record the current index.
+ }
+ ++$lastWasOperator;
+ break;
+ case '+' :
+ if (!($BracketLevel > 0 || $lastWasOperator > 0))
+ if ($Precedence >= 7) {
+ $Precedence = 7;
+ $Result = $i;
+ }
+ ++$lastWasOperator;
+ break;
+ case '/':
+ case '*':
+ case '%' :
+ if (!($BracketLevel > 0 || $lastWasOperator > 0))
+ if ($Precedence >= 9) {
+ $Precedence = 9;
+ $Result = $i;
+ }
+ ++$lastWasOperator;
+ break;
+ case '^' :
+ if (!($BracketLevel > 0 || $lastWasOperator > 0))
+ if ($Precedence >= 12) {
+ $Precedence = 12;
+ $Result = $i;
+ }
+ ++$lastWasOperator;
+ break;
- case '-' :
- if (! ($BracketLevel > 0 || $lastWasOperator>0) ) //a main operation has to be outside the brackets
- if ($Precedence >= 7) //seeking for lowest precedence
- {
- $Precedence = 7;
- $Result = $i; //record the current index.
- }
- ++$lastWasOperator;
- break;
- case '+' :
- if (! ($BracketLevel > 0 || $lastWasOperator>0) )
- if ($Precedence >= 7 )
- {
- $Precedence = 7;
- $Result = $i;
- }
- ++$lastWasOperator;
- break;
- case '%' :
- if (! ($BracketLevel > 0 || $lastWasOperator>0) )
- if ($Precedence >= 9 )
- {
- $Precedence = 9;
- $Result = $i;
- }
- ++$lastWasOperator;
- break;
- case '/' :
- if (! ($BracketLevel > 0 || $lastWasOperator>0) )
- if ($Precedence >= 9 )
- {
- $Precedence = 9;
- $Result = $i;
- }
- ++$lastWasOperator;
- break;
- case '*' :
- if (! ($BracketLevel > 0 || $lastWasOperator>0) )
- if ($Precedence >= 9 )
- {
- $Precedence = 9;
- $Result = $i;
- }
- ++$lastWasOperator;
- break;
- case '^' :
- if (! ($BracketLevel > 0 || $lastWasOperator>0) )
- if ($Precedence >= 12 )
- {
- $Precedence = 12;
- $Result = $i;
- }
- ++$lastWasOperator;
- break;
+ case 'E' :
+ if ($i > 0 && $lastWasOperator == 0) {
+ $ch = $formula[$i - 1];
+ if ($ch >= '0' && $ch <= '9') {//this E may be part of a number in scientific notation.
+ $j = $i;
+ while ($j > 0) { //trace back.
+ --$j;
+ $ch = $formula[$j];
+ if ($ch == '.' || ($ch >= '0' && $ch <= '9')) { //if it is not a function or variable name.
+ continue;
+ }
+ if ($ch == '_' || ($ch >= 'A' && $ch <= 'Z')) {//is it a func or var name?
+ $lastWasOperator = 0;
+ break; //break the while loop.
+ }
+ ++$lastWasOperator; //it must be an operator or a paranthesis.
+ break; //break the while loop.
+ }
+ if ($j == 0 && ($ch >= '0' && $ch <= '9')) {
+ ++$lastWasOperator;
+ }
+ } else {
+ $lastWasOperator = 0;
+ }
+ } else {
+ $lastWasOperator = 0;
+ }
+ break;
+ case ' ': //space:
+ break;
+ default :
+ $lastWasOperator = 0;
+ break;
+ }
+ }
+ return $Result;
+ }
+ //------------------------------------------------------------------------------
- case 'E' :
- if ($i > 0 && $lastWasOperator==0)
- {
- $ch = $formula[$i-1];
- if ($ch >= '0' && $ch <= '9')
- {//this E may be part of a number in scientific notation.
- $j=$i;
- while($j > 0)
- { //trace back.
- --$j;
- $ch = $formula[$j];
- if ($ch=='.' || ($ch >= '0' && $ch <= '9'))
- { //if it is not a function or variable name.
- continue;
- }
- if ($ch=='_' || ($ch>='A' && $ch<='Z'))
- {//is it a func or var name?
- $lastWasOperator = 0;
- break; //break the while loop.
- }
- ++$lastWasOperator; //it must be an operator or a paranthesis.
- break; //break the while loop.
- }
- if ($j==0 && ($ch >= '0' && $ch <= '9'))
- {
- ++$lastWasOperator;
- }
- }
- else
- {
- $lastWasOperator = 0;
- }
- }
- else
- {
- $lastWasOperator = 0;
- }
- break;
- case ' ': //space:
- break;
- default :
- $lastWasOperator=0;
- break;
- }
- }
- return $Result;
- }
- //------------------------------------------------------------------------------
- /**
- * Determines if a given expression by itself is a function that takes 2 parameters.
- * For example: and input of "MAX(x,y+1)" would return true.
- * @param formula - expression
- * @param funcAddr - The IFunction that this expression represents (if it is a function call)
- * @param paramLeft - Left parameter whose values will be sent out in a wrapper utility object.
- * @param paramRight - Right parameter group whose values will be sent out in a wrapper utility object.
- * @param CurrChar - current operand index in the expression
- * @return true if formula is a valid two parameter function.
- * @ignore
- */
- private function isTwoParamFunc( $formula,
- /*out*/ &$funcAddr, /*out*/ &$paramLeft, /*out*/ &$paramRight,
- $CurrChar //gives the last operation index in the string
- )
- {
- $funcAddr = null;
- $paramLeft = null;
- $paramRight = null;
- $Len= strlen($formula);
+ /**
+ * Determines if a given expression by itself is a function that takes 2 parameters.
+ * For example: and input of "MAX(x,y+1)" would return true.
+ * @param $formula - expression
+ * @param $funcAddr - The IFunction that this expression represents (if it is a function call)
+ * @param $paramLeft - Left parameter whose values will be sent out in a wrapper utility object.
+ * @param $paramRight - Right parameter group whose values will be sent out in a wrapper utility object.
+ * @param $CurrChar - current operand index in the expression
+ * @return true if formula is a valid two parameter function.
+ * @ignore
+ * @since 1.0.0
+ */
+ private function isTwoParamFunc($formula, &$funcAddr, &$paramLeft, &$paramRight,
+ $CurrChar //gives the last operation index in the string
+ ): bool
+ {
+ $funcAddr = null;
+ $paramLeft = null;
+ $paramRight = null;
+ $Len = strlen($formula);
- if ($CurrChar>0 ) //if function in question is an operand
- {
- if($CurrChar>$Len-2)
- {
- return false;
- }
- $CurrCh = $formula[$CurrChar];
+ if ($CurrChar > 0) //if function in question is an operand
+ {
+ if ($CurrChar > $Len - 2) {
+ return false;
+ }
+ $CurrCh = $formula[$CurrChar];
- //was it an operand also? we want to find <>, >=, <=
- if($CurrCh=='<')
- {
- $nextCh = $formula[$CurrChar+1]; //look ahead.
- if($nextCh=='>')
- {
- $funcAddr = self::$notequals__;
- $paramLeft = substr($formula, 0, $CurrChar);
- $paramRight= substr($formula, $CurrChar+2);
- }
- else if ($nextCh=='=')
- {
- $funcAddr = self::$ltequals__;
- $paramLeft = substr($formula, 0, $CurrChar);
- $paramRight= substr($formula, $CurrChar+2);
- }
- else
- {
- $funcAddr = self::$lt__; //default case.
- $paramLeft = substr($formula, 0, $CurrChar);
- $paramRight= substr($formula, $CurrChar+1);
- }
+ //was it an operand also? we want to find <>, >=, <=
+ if ($CurrCh == '<') {
+ $nextCh = $formula[$CurrChar + 1]; //look ahead.
+ if ($nextCh == '>') {
+ $funcAddr = self::$notequals__;
+ $paramLeft = substr($formula, 0, $CurrChar);
+ $paramRight = substr($formula, $CurrChar + 2);
+ } else if ($nextCh == '=') {
+ $funcAddr = self::$ltequals__;
+ $paramLeft = substr($formula, 0, $CurrChar);
+ $paramRight = substr($formula, $CurrChar + 2);
+ } else {
+ $funcAddr = self::$lt__; //default case.
+ $paramLeft = substr($formula, 0, $CurrChar);
+ $paramRight = substr($formula, $CurrChar + 1);
+ }
- if (! (strlen($paramLeft)>0) )
- {
- return false;
- }
- if (! (strlen($paramRight)>0) )
- {
- return false;
- }
- return true; //all output is assigned, now we return true.
- }
- else if($CurrCh=='>')
- {
- $nextCh = $formula[$CurrChar+1];
- if($nextCh=='=')
- {
- $funcAddr = self::$gtequals__;
- $paramLeft = substr($formula, 0, $CurrChar);
- $paramRight= substr($formula, $CurrChar+2);
- }
- else
- {
- $funcAddr = self::$gt__; //default case.
- $paramLeft = substr($formula, 0, $CurrChar);
- $paramRight= substr($formula, $CurrChar+1);
- }
- if (! (strlen($paramLeft)>0) )
- {
- return false;
- }
- if (! (strlen($paramRight)>0) )
- {
- return false;
- }
- return true; //all output is assigned, now we return true.
- }
- else
- {
+ if (!(strlen($paramLeft) > 0)) {
+ return false;
+ }
+ if (!(strlen($paramRight) > 0)) {
+ return false;
+ }
+ return true; //all output is assigned, now we return true.
+ } else if ($CurrCh == '>') {
+ $nextCh = $formula[$CurrChar + 1];
+ if ($nextCh == '=') {
+ $funcAddr = self::$gtequals__;
+ $paramLeft = substr($formula, 0, $CurrChar);
+ $paramRight = substr($formula, $CurrChar + 2);
+ } else {
+ $funcAddr = self::$gt__; //default case.
+ $paramLeft = substr($formula, 0, $CurrChar);
+ $paramRight = substr($formula, $CurrChar + 1);
+ }
+ if (!(strlen($paramLeft) > 0)) {
+ return false;
+ }
+ if (!(strlen($paramRight) > 0)) {
+ return false;
+ }
+ return true; //all output is assigned, now we return true.
+ } else {
- $paramLeft = substr($formula, 0, $CurrChar);
- if (! (strlen($paramLeft)>0) )
- {
- return false;
- }
+ $paramLeft = substr($formula, 0, $CurrChar);
+ if (!(strlen($paramLeft) > 0)) {
+ return false;
+ }
- $paramRight= substr($formula, $CurrChar+1);
- if (! (strlen($paramRight)>0) )
- {
- return false;
- }
+ $paramRight = substr($formula, $CurrChar + 1);
+ if (!(strlen($paramRight) > 0)) {
+ return false;
+ }
- switch ($formula[$CurrChar])
- {
- //analytical operators:
- case '+': $funcAddr = $this->AddOp; break;
- case '-': $funcAddr = self::$subtract__; break;
- case '*': $funcAddr = self::$mult__; break;
- case '/': $funcAddr = self::$div__; break;
- case '^': $funcAddr = self::$power__; break;
- case '%': $funcAddr = self::$mod__; break;
+ switch ($formula[$CurrChar]) {
+ //analytical operators:
+ case '+':
+ $funcAddr = $this->AddOp;
+ break;
+ case '-':
+ $funcAddr = self::$subtract__;
+ break;
+ case '*':
+ $funcAddr = self::$mult__;
+ break;
+ case '/':
+ $funcAddr = self::$div__;
+ break;
+ case '^':
+ $funcAddr = self::$power__;
+ break;
+ case '%':
+ $funcAddr = self::$mod__;
+ break;
- //logical operators:
- case '<': $funcAddr = self::$lt__; break;
- case '>': $funcAddr = self::$gt__; break;
- case '=': $funcAddr = self::$equals__; break;
- case '&': $funcAddr = $this->AndOp; break;
- case '|': $funcAddr = self::$or__; break;
- }
- }
- return true; //all output is assigned, now we return true.
- }
- //if we reach here, result is false
- //if main operation is not an operand but a function
- //$BracketLevel;
- //$paramStart;
- $temp='';
- if ($formula[$Len-1] == ')') //last character must be brackets closing function param list
- {
- $i= 0;
- while ($this->isValidChar($i, $formula[$i]))
- {
- $temp.=($formula[$i]);
- ++$i;
- }
- while($formula[$i]==' ')
- {
- ++$i;
- }
+ //logical operators:
+ case '<':
+ $funcAddr = self::$lt__;
+ break;
+ case '>':
+ $funcAddr = self::$gt__;
+ break;
+ case '=':
+ $funcAddr = self::$equals__;
+ break;
+ case '&':
+ $funcAddr = $this->AndOp;
+ break;
+ case '|':
+ $funcAddr = self::$or__;
+ break;
+ }
+ }
+ return true; //all output is assigned, now we return true.
+ }
+ //if we reach here, result is false
+ //if main operation is not an operand but a function
+ $temp = '';
+ if ($formula[$Len - 1] == ')') //last character must be brackets closing function param list
+ {
+ $i = 0;
+ while ($this->isValidChar($i, $formula[$i])) {
+ $temp .= ($formula[$i]);
+ ++$i;
+ }
+ while ($formula[$i] == ' ') {
+ ++$i;
+ }
- if (($formula[$i] == '(') && ($i < $Len-1) )
- {
- $func = $this->Functions[$temp];
- if ($func != null && $func->paramCount==2)
- {
- $funcAddr = $func;
- $paramStart= $i+1;
- $BracketLevel= 1;
- $insideStringLiteral = false;
- while (! ($i>$Len-1-1) ) //last character is a ')', that's why we use i>Len-1
- {
- ++$i;
- switch( $formula[$i] )
- {
- case '"': $insideStringLiteral = !$insideStringLiteral; break;
- case '(': if(!$insideStringLiteral)++$BracketLevel; break;
- case ')': if(!$insideStringLiteral)--$BracketLevel; break;
- case ',':
- if ((!$insideStringLiteral) && (1 == $BracketLevel) && ($i<$Len-2) ) //last character is a ')', that's why we use i>Len-2
- {
- $paramLeft= substr($formula, $paramStart, $i-$paramStart);
- $paramRight= substr($formula, $i+1, $Len-1-($i+1)); //last character is a ')', that's why we use Len-1-i
- return true; //we are sure that it is a two parameter function
- }
- break;
- }
- }
- }
- }
- }
- return false; //means we could not find it
- }
- //------------------------------------------------------------------------------
- /**
- * Determines if a given expression by itself is a function that takes 1 parameter.
- * For example: and input of "SIN(x)" would return true.
- * @param formula - expression
- * @param funcAddr - The IFunction that this node represents.
- * @param param - the parameter that will be passed into this function.
- * @param CurrChar - current operand index in the expression
- * @return true if formula is a valid one parameter function.
- * @ignore
- */
- private function isOneParamFunc( $formula,
- /*out*/ &$funcAddr, /*out*/ &$param,
- $CurrChar
- )
- {
- $funcAddr = null;
- $param = null;
- $paramStart;
- $Len= strlen($formula);
- if ($CurrChar == 0) //if function in question is an unary operand
- {
- $param= substr($formula, 1);
- if (! (strlen($param)>0) )
- {
- return false;
- }
+ if (($formula[$i] == '(') && ($i < $Len - 1)) {
+ $func = $this->Functions[$temp];
+ if ($func != null && $func->paramCount == 2) {
+ $funcAddr = $func;
+ $paramStart = $i + 1;
+ $BracketLevel = 1;
+ $insideStringLiteral = false;
+ while (!($i > $Len - 1 - 1)) //last character is a ')', that's why we use i>Len-1
+ {
+ ++$i;
+ switch ($formula[$i]) {
+ case '"':
+ $insideStringLiteral = !$insideStringLiteral;
+ break;
+ case '(':
+ if (!$insideStringLiteral) ++$BracketLevel;
+ break;
+ case ')':
+ if (!$insideStringLiteral) --$BracketLevel;
+ break;
+ case ',':
+ if ((!$insideStringLiteral) && (1 == $BracketLevel) && ($i < $Len - 2)) //last character is a ')', that's why we use i>Len-2
+ {
+ $paramLeft = substr($formula, $paramStart, $i - $paramStart);
+ $paramRight = substr($formula, $i + 1, $Len - 1 - ($i + 1)); //last character is a ')', that's why we use Len-1-i
+ return true; //we are sure that it is a two parameter function
+ }
+ break;
+ }
+ }
+ }
+ }
+ }
+ return false; //means we could not find it
+ }
+ //------------------------------------------------------------------------------
- switch ($formula[$CurrChar])
- {
- case '+': $funcAddr = self::$unaryadd__; break;
- case '-': $funcAddr = self::$negate__; break;
- case '!': $funcAddr = self::$not__; break;
- default: return false; //only + and - can be unary operators
- }
- return true; //all output is assigned, now we exit.
- }
- //if we reach here, result is false
- //if main operation is not an operand but a function
- if ($formula[$Len-1] == ')') //last character must be brackets closing function param list
- {
- $i= 0;
- $temp = '';
- while ($this->isValidChar($i, $formula[$i]))
- {
- $temp.=($formula[$i]);
- ++$i;
- }
- while($formula[$i]==' ')
- {
- ++$i;
- }
- if (($formula[$i] == '(') && ($i < $Len-2) )
- {
- $func = $this->Functions[$temp];
- if ($func != null && $func->paramCount==1)
- {
- $funcAddr = $func;
- $paramStart= $i+1;
- $param= substr($formula, $paramStart, $Len-1-$paramStart); //check example: SIN(30)
- return true; //we are sure that it is a two parameter function
- }
- }
- }
- return false;
- }
- //------------------------------------------------------------------------------
- /**
- * Determines if a given expression by itself is a function that takes N parameters.
- * For example: and input of "IF(x, 3/x, 3)" would return true.
- * @param formula - expression
- * @param funcAddr - the IFunction that this node represents.
- * @param parms - the parameters that this function takes in this expression.
- * @param CurrChar - current operand index in the expression
- * @return true if formula is a valid N parameter function.
- * @ignore
- */
- private function isNParamFunc( $formula,
- /*out*/ &$funcAddr, /*out*/ &$parms,
- $CurrChar //gives the last operation index in the string
- )
- {
- $funcAddr = null;
- $parms = null;
- //if main operation is not an operand but a function
- $Len= strlen($formula);
- $temp = '';
- if ($formula[$Len-1] == ')') //last character must be brackets closing function param list
- {
- $i= 0;
- while ($this->isValidChar($i, $formula[$i]))
- {
- $temp.=($formula[$i]);
- ++$i;
- }
- while($formula[$i]==' ')
- {
- ++$i;
- }
- if (($formula[$i] == '(') && ($i < $Len-1) )
- {
- //we first check if it is one param func or two param func,
- //so here if it is a func, we know it is N param func.
- $funcAddr = $this->Functions[$temp];
+ /**
+ * Determines if a given expression by itself is a function that takes 1 parameter.
+ * For example: and input of "SIN(x)" would return true.
+ * @param $formula - expression
+ * @param $funcAddr - The IFunction that this node represents.
+ * @param $param - the parameter that will be passed into this function.
+ * @param $CurrChar - current operand index in the expression
+ * @return true if formula is a valid one parameter function.
+ * @ignore
+ * @since 1.0.0
+ */
+ private function isOneParamFunc($formula, &$funcAddr, &$param, $CurrChar): bool
+ {
+ $funcAddr = null;
+ $param = null;
+ $Len = strlen($formula);
+ if ($CurrChar == 0) //if function in question is an unary operand
+ {
+ $param = substr($formula, 1);
+ if (!(strlen($param) > 0)) {
+ return false;
+ }
- if ($funcAddr != null)
- {
- $nParams = $funcAddr->paramCount;
- if($nParams>-1)
- {
- $parms = array();
- if($nParams==0) //a function that takes no param.
- {
- if($formula[$i+1]==')')
- {
- return true;
- }
- }
- $paramStart = $i+1;
- $BracketLevel= 1;
- $pIndex = 0;
- $insideStringLiteral = false;
- while (! ($i>$Len-1-1) ) //last character is a ')', that's why we use i>Len-1
- {
- ++$i;
- switch( $formula[$i] )
- {
- case '"': $insideStringLiteral = !$insideStringLiteral; break;
- case '(': if(!$insideStringLiteral)++$BracketLevel; break;
- case ')': if(!$insideStringLiteral)--$BracketLevel; break;
- case ',':
- if ((!$insideStringLiteral) && (1 == $BracketLevel) && ($i<$Len-2) ) //last character is a ')', that's why we use i>Len-2
- {
- //must have at least 2 params for this part to work:
- if ($nParams>-1 && !($pIndex<$nParams) )
- {
- return false; //wrong number of parameters.
- }
- $parms[$pIndex++] = substr($formula, $paramStart, $i-$paramStart);
+ switch ($formula[$CurrChar]) {
+ case '+':
+ $funcAddr = self::$unaryadd__;
+ break;
+ case '-':
+ $funcAddr = self::$negate__;
+ break;
+ case '!':
+ $funcAddr = self::$not__;
+ break;
+ default:
+ return false; //only + and - can be unary operators
+ }
+ return true; //all output is assigned, now we exit.
+ }
+ //if we reach here, result is false
+ //if main operation is not an operand but a function
+ if ($formula[$Len - 1] == ')') //last character must be brackets closing function param list
+ {
+ $i = 0;
+ $temp = '';
+ while ($this->isValidChar($i, $formula[$i])) {
+ $temp .= ($formula[$i]);
+ ++$i;
+ }
+ while ($formula[$i] == ' ') {
+ ++$i;
+ }
+ if (($formula[$i] == '(') && ($i < $Len - 2)) {
+ $func = $this->Functions[$temp];
+ if ($func != null && $func->paramCount == 1) {
+ $funcAddr = $func;
+ $paramStart = $i + 1;
+ $param = substr($formula, $paramStart, $Len - 1 - $paramStart); //check example: SIN(30)
+ return true; //we are sure that it is a two parameter function
+ }
+ }
+ }
+ return false;
+ }
- if($pIndex==$nParams-1)
- {
- //assign the last one:
- $parms[$pIndex] = substr($formula, $i+1, $Len-1-($i+1));
- return true;
- }
- $paramStart = $i+1;
- }
- break;
- }
- }
- }
- else
- {
- $list = array();
- $paramStart = $i+1;
- $BracketLevel= 1;
- $insideStringLiteral = false;
- while (! ($i>$Len-1-1) ) //last character is a ')', that's why we use i>Len-1
- {
- ++$i;
- switch( $formula[$i] )
- {
- case '"': $insideStringLiteral = !$insideStringLiteral; break;
- case '(': if(!$insideStringLiteral) ++$BracketLevel; break;
- case ')': if(!$insideStringLiteral) --$BracketLevel; break;
- case ',':
- if (!$insideStringLiteral && (1 == $BracketLevel) && ($i<$Len-2) ) //last character is a ')', that's why we use i>Len-2
- {
- $list[]=substr($formula, $paramStart, $i-$paramStart);
- $paramStart = $i+1;
- }
- break;
- }
- }
- //add the remaining:
- //list.Add( formula.Substring(paramStart, Len-1-paramStart) );
- $remaining = trim(substr($formula, $paramStart, $Len - 1 - $paramStart));
- if (strlen($remaining)>0)
- {
- $list[]=$remaining;
- }
+ //------------------------------------------------------------------------------
- $parms = $list;
- return true;
- }
- }
- }
- }
- return false; //means we could not find it
- }
- //------------------------------------------------------------------------------
- /**
- * Optimizes a compiled tree where root is the given Node.
- * @param aNode - Root node.
- * @return Starting root node of the optimized tree.
- * @ignore
- */
- static function optimizeNode($aNode)
- {
- $aNode->optimize();
- //Below code changes the value of the Node pointer,
- //thus it cannot be done inside a polymorphic method of the
- //class instance pointed to by that pointer.
- //Therefore, "instanceof" is required.
- if ($aNode instanceof Mathparser_NParamNode)
- {
- $count = count($aNode->nodes);
- for ($i=0; $i<$count; $i++)
- {
- //if any node is not constant, just return as is:
- if ( !($aNode->nodes[$i] instanceof Mathparser_BasicNode) )
- {
- return $aNode;
- }
- }
- //if all parameters of the function are constants (basic nodes):
- return new Mathparser_BasicNode($nParamNode->getValue());
- }
- return $aNode;
- }
- //------------------------------------------------------------------------------
+ /**
+ * Determines if a given expression by itself is a function that takes N parameters.
+ * For example: and input of "IF(x, 3/x, 3)" would return true.
+ * @param $formula - expression
+ * @param $funcAddr - the IFunction that this node represents.
+ * @param $parms - the parameters that this function takes in this expression.
+ * @return true if formula is a valid N parameter function.
+ * @ignore
+ * @since 1.0.0
+ */
+ private function isNParamFunc($formula, &$funcAddr, &$parms): bool
+ {
+ $funcAddr = null;
+ $parms = null;
+ //if main operation is not an operand but a function
+ $Len = strlen($formula);
+ $temp = '';
+ if ($formula[$Len - 1] == ')') //last character must be brackets closing function param list
+ {
+ $i = 0;
+ while ($this->isValidChar($i, $formula[$i])) {
+ $temp .= ($formula[$i]);
+ ++$i;
+ }
+ while ($formula[$i] == ' ') {
+ ++$i;
+ }
+ if (($formula[$i] == '(') && ($i < $Len - 1)) {
+ //we first check if it is one param func or two param func,
+ //so here if it is a func, we know it is N param func.
+ $funcAddr = $this->Functions[$temp];
- /**
- * Expression property represents the mathematical expression which is input to be Evaluated by the user.
- *
- * The expression can contain variables such as X, Y, T, HEIGHT, WEIGHT and so on.
- * The values of these constants are set before the expression is evaluated.
- * The values of the variables can be set before the expression is evaluated or the values can be provided
- * during evaluation using a PHP function registered as $VariableResolver.
- * @return string
- */
- public function getExpression()
- {
- return $this->Expression;
- }
- /**
- * @see getExpression
- * @param $value
- * @return unknown_type
- */
- public function setExpression($value)
- {
- if ($value!=$this->Expression)
- {
- $this->Expression = $value;
- $this->Dirty = true;
- }
- }
+ if ($funcAddr != null) {
+ $nParams = $funcAddr->paramCount;
+ if ($nParams > -1) {
+ $parms = array();
+ if ($nParams == 0) //a function that takes no param.
+ {
+ if ($formula[$i + 1] == ')') {
+ return true;
+ }
+ }
+ $paramStart = $i + 1;
+ $BracketLevel = 1;
+ $pIndex = 0;
+ $insideStringLiteral = false;
+ while (!($i > $Len - 1 - 1)) //last character is a ')', that's why we use i>Len-1
+ {
+ ++$i;
+ switch ($formula[$i]) {
+ case '"':
+ $insideStringLiteral = !$insideStringLiteral;
+ break;
+ case '(':
+ if (!$insideStringLiteral) ++$BracketLevel;
+ break;
+ case ')':
+ if (!$insideStringLiteral) --$BracketLevel;
+ break;
+ case ',':
+ if ((!$insideStringLiteral) && (1 == $BracketLevel) && ($i < $Len - 2)) //last character is a ')', that's why we use i>Len-2
+ {
+ //must have at least 2 params for this part to work:
+ if ($nParams > -1 && !($pIndex < $nParams)) {
+ return false; //wrong number of parameters.
+ }
+ $parms[$pIndex++] = substr($formula, $paramStart, $i - $paramStart);
- /**
- * Set OptimizationOn to let the bcParser component evaluate constant expressions
- * at parse time. The optimized parse tree will enhance subsequant evaluation
- * operations, though initial parsing will be slower.
- *
- * Optimization is good if you are going to parse once and evaluate the same
- * expression many many times with different variable values.
- * @return boolean
- */
- public function isOptimizationOn()
- {
- return $this->OptimizationOn;
- }
- /**
- * @see isOptimizationOn
- * @param boolean $value
- * @return void
- */
- public function setOptimizationOn($value)
- {
- $this->OptimizationOn = $value;
- }
+ if ($pIndex == $nParams - 1) {
+ //assign the last one:
+ $parms[$pIndex] = substr($formula, $i + 1, $Len - 1 - ($i + 1));
+ return true;
+ }
+ $paramStart = $i + 1;
+ }
+ break;
+ }
+ }
+ } else {
+ $list = array();
+ $paramStart = $i + 1;
+ $BracketLevel = 1;
+ $insideStringLiteral = false;
+ while (!($i > $Len - 1 - 1)) //last character is a ')', that's why we use i>Len-1
+ {
+ ++$i;
+ switch ($formula[$i]) {
+ case '"':
+ $insideStringLiteral = !$insideStringLiteral;
+ break;
+ case '(':
+ if (!$insideStringLiteral) ++$BracketLevel;
+ break;
+ case ')':
+ if (!$insideStringLiteral) --$BracketLevel;
+ break;
+ case ',':
+ if (!$insideStringLiteral && (1 == $BracketLevel) && ($i < $Len - 2)) //last character is a ')', that's why we use i>Len-2
+ {
+ $list[] = substr($formula, $paramStart, $i - $paramStart);
+ $paramStart = $i + 1;
+ }
+ break;
+ }
+ }
+ //add the remaining:
+ $remaining = trim(substr($formula, $paramStart, $Len - 1 - $paramStart));
+ if (strlen($remaining) > 0) {
+ $list[] = $remaining;
+ }
- /**
- * This method can be overridden to return a Node that is fancy enough to lookup
- * values from a database etc to come up with variable values at evaluation time.
- * @param string $varName
- * @return object
- */
- protected function createVarNode($varName)
- {
- //if it is not a simple double, maybe it is a variable?
- $variable = $this->Variables[$varName];
- if ($variable!=null)
- {
- return new Mathparser_VarNode($variable, $varName); //recursion will end on these points when we get to the basics
- }
- else if($this->VariableResolver!=null)
- {
- $Len = strlen($varName);
- for($i=0; $i<$Len; $i++)
- {
- $ch = $varName[$i];
- if(!$this->isValidChar($i, $ch))
- {
- return null;
- }
- }
- return new Mathparser_UnknownVarNode($this, $varName);
- }
- return null;
- }
+ $parms = $list;
+ return true;
+ }
+ }
+ }
+ }
+ return false; //means we could not find it
+ }
- /**
- * Translation support.
- * @ignore
- */
- static function getMessage($key)
- {
- try
- {
- if (self::$translator == null) {
- self::getTranslationStrings();
- }
- $s = self::$translator[$key];
- if ($s==null){ $s = $key; }
- return $s;
- }
- catch(Exception $e)
- {
- return $key;
- }
- }
- /**
- * Translation support.
- * @ignore
- */
- static function getMessage1($key, $param)
- {
- $temp = self::getMessage($key);
- //assuming {0} is not used in the real string,
- //and it is only a placeholder for the first parameter.
- return sprintf($temp, $param);
- }
- /**
- * Translation support.
- * @ignore
- */
- static function getMessage2($key, $param0, $param1)
- {
- $temp = self::getMessage($key);
- return sprintf($temp, $param0, $param1);
- }
+ //------------------------------------------------------------------------------
+
+ /**
+ * Optimizes a compiled tree where root is the given Node.
+ * @param $aNode - Root node.
+ * @return mixed - Starting root node of the optimized tree.
+ * @ignore
+ * @since 1.0.0
+ */
+ static function optimizeNode($aNode): mixed
+ {
+ $aNode->optimize();
+ //Below code changes the value of the Node pointer,
+ //thus it cannot be done inside a polymorphic method of the
+ //class instance pointed to by that pointer.
+ //Therefore, "instanceof" is required.
+ if ($aNode instanceof Mathparser_NParamNode) {
+ $count = count($aNode->nodes);
+ for ($i = 0; $i < $count; $i++) {
+ //if any node is not constant, just return as is:
+ if (!($aNode->nodes[$i] instanceof Mathparser_BasicNode)) {
+ return $aNode;
+ }
+ }
+ //if all parameters of the function are constants (basic nodes):
+ return new Mathparser_BasicNode($aNode->getValue());
+ }
+ return $aNode;
+ }
+ //------------------------------------------------------------------------------
+
+ /**
+ * Expression property represents the mathematical expression which is input to be Evaluated by the user.
+ *
+ * The expression can contain variables such as X, Y, T, HEIGHT, WEIGHT and so on.
+ * The values of these constants are set before the expression is evaluated.
+ * The values of the variables can be set before the expression is evaluated or the values can be provided
+ * during evaluation using a PHP function registered as $VariableResolver.
+ * @return string
+ * @since 1.0.0
+ */
+ public function getExpression(): string
+ {
+ return $this->Expression;
+ }
+
+ /**
+ * @param $value
+ * @return void
+ * @see getExpression
+ * @since 1.0.0
+ */
+ public function setExpression($value): void
+ {
+ if ($value != $this->Expression) {
+ $this->Expression = $value;
+ $this->Dirty = true;
+ }
+ }
+
+ /**
+ * This method can be overridden to return a Node that is fancy enough to lookup
+ * values from a database etc to come up with variable values at evaluation time.
+ * @param string $varName
+ * @return Mathparser_UnknownVarNode|Mathparser_VarNode|null
+ * @since 1.0.0
+ */
+ protected function createVarNode(string $varName): Mathparser_UnknownVarNode|null|Mathparser_VarNode
+ {
+ //if it is not a simple double, maybe it is a variable?
+ $variable = $this->Variables[$varName];
+ if ($variable != null) {
+ return new Mathparser_VarNode($variable); //recursion will end on these points when we get to the basics
+ } else if ($this->VariableResolver != null) {
+ $Len = strlen($varName);
+ for ($i = 0; $i < $Len; $i++) {
+ $ch = $varName[$i];
+ if (!$this->isValidChar($i, $ch)) {
+ return null;
+ }
+ }
+ return new Mathparser_UnknownVarNode($this, $varName);
+ }
+ return null;
+ }
+
+ /**
+ * Translation support.
+ * @ignore
+ * @since 1.0.0
+ */
+ static function getMessage($key)
+ {
+ try {
+ if (self::$translator == null) {
+ self::getTranslationStrings();
+ }
+ $s = self::$translator[$key];
+ if ($s == null) {
+ $s = $key;
+ }
+ return $s;
+ } catch (Exception $e) {
+ Log::add("Could not translate: " . $e->getMessage(), Log::WARNING,"com_sportsmanager");
+ return $key;
+ }
+ }
+
+ /**
+ * Translation support.
+ * @ignore
+ * @since 1.0.0
+ */
+ static function getMessage1($key, $param): string
+ {
+ $temp = self::getMessage($key);
+ //assuming {0} is not used in the real string,
+ //and it is only a placeholder for the first parameter.
+ return sprintf($temp, $param);
+ }
+
+ /**
+ * Translation support.
+ * @ignore
+ * @since 1.0.0
+ */
+ static function getMessage2($key, $param0, $param1 = ''): string
+ {
+ $temp = self::getMessage($key);
+ return sprintf($temp, $param0, $param1);
+ }
} //End of Math Parser Implementation.
@@ -2253,246 +1819,288 @@ class MathParser
/**
* Internal support class to help internal representation of a variable and a constant.
* @ignore
+ * @since 1.0.0
*/
class Mathparser_Variable
{
- /**
- * The parent parser instance, used to call the VariableResolver if needed.
- */
- private $Parser;
+ /**
+ * Name of this variable.
+ * @since 1.0.0
+ */
+ public string $Name;
- /**
- * Name of this variable.
- */
- public $Name;
+ /**
+ * The preset value of this variable.
+ * @since 1.0.0
+ */
+ public float|string $Value;
- /**
- * The preset value of this variable.
- */
- public $Value;
+ /**
+ * The delegate function name (string value) that supplies variable values.
+ * If this is not null, then it is called to get
+ * the value for this variable.
+ *
function VariableResolver($parser, $varName);
+ * @since 1.0.0
+ */
+ public string $ValueProvider;
- /**
- * The delegate function name (string value) that supplies variable values.
- * If this is not null, then it is called to get
- * the value for this variable.
- *
function VariableResolver($parser, $varName);
- */
- public $ValueProvider;
-
- /**
- * If the $this->ValueProvider is set, then this method uses it to get the runtime value.
- * Otherwise, this method returns the value of $this->Value;
- *
- */
- public function getRuntimeValue(){
- return !isset($this->ValueProvider) ? $this->Value : $this->ValueProvider($this->Parser, $this->Name);
- }
-
- public function __construct($parser, $aName, $newVal, $valueProvider) {
- $this->Parser = $parser;
- $this->Name = $aName;
- $this->Value = $newVal;
- $this->ValueProvider = $valueProvider;
- }
+ public function __construct($aName, $newVal, $valueProvider)
+ {
+ $this->Name = $aName;
+ $this->Value = $newVal;
+ $this->ValueProvider = $valueProvider;
+ }
}
/**
* Internal support class to represent a user defined function.
* User defined functions can be used in expressions.
* @ignore
+ * @since 1.0.0
*/
-class Mathparser_ParserFunction {
- /**
- * $EventHandler that is the name of the actual PHP function to call.
- */
- public $EventHandler;
- /**
- * Name of the user defined function as used in an expression.
- */
- public $Name;
- /**
- * Number of parameters that the user defined function accepts.
- * -1 means any number of parameters.
- * 0 means no parameters, 1 means 1 parameter like SIN(X) etc.
- */
- public $paramCount;
- /**
- * Constructor.
- * @param $name - Name of the user defined function as used in an expression.
- * @param $eventHandler is the name of the actual PHP function to call.
- * @param $paramCount Number of parameters that the user defined function accepts.
- */
- public function __construct($name, $eventHandler, $paramCount){
- $this->EventHandler = $eventHandler;
- $this->Name = $name;
- $this->paramCount = $paramCount;
- }
+class Mathparser_ParserFunction
+{
+ /**
+ * $EventHandler that is the name of the actual PHP function to call.
+ * @since 1.0.0
+ */
+ public $EventHandler;
+ /**
+ * Name of the user defined function as used in an expression.
+ * @since 1.0.0
+ */
+ public string $Name;
+ /**
+ * Number of parameters that the user defined function accepts.
+ * -1 means any number of parameters.
+ * 0 means no parameters, 1 means 1 parameter like SIN(X) etc.
+ * @since 1.0.0
+ */
+ public int $paramCount;
+
+ /**
+ * Constructor.
+ * @param $name - Name of the user defined function as used in an expression.
+ * @param $eventHandler - is the name of the actual PHP function to call.
+ * @param $paramCount - Number of parameters that the user defined function accepts.
+ * @since 1.0.0
+ */
+ public function __construct($name, $eventHandler, $paramCount)
+ {
+ $this->EventHandler = $eventHandler;
+ $this->Name = $name;
+ $this->paramCount = $paramCount;
+ }
}
/**
* Internal support class that represents constants such as 3, 5, 7 in the formula.
* @ignore
+ * @since 1.0.0
*/
-class Mathparser_BasicNode extends Mathparser_Node {
- public $Value;
+class Mathparser_BasicNode extends Mathparser_Node
+{
+ public $Value;
- public function __construct($Val) {
- $this->Value = $Val;
- }
- public function getValue() {
- return $this->Value;
- }
- public function getValueAsDouble() {
- if(is_float($this->Value))
- {
- return $this->Value;
- }
- else if(is_numeric($this->Value))
- {
- return (float)$this->Value;
- }
- throw new Exception("Value is not numeric: ".$this->Value);
- }
- public function getValueAsString() {
- return (string)$this->Value;
- }
- //------------------------------------------------------------------------------
- public function isVariableUsed($Name) {
- return false; //a basic node does not store any variable or function info
- }
- //------------------------------------------------------------------------------
- public function isFunctionUsed($Name) {
- return false; //a basic node does not store any variable or function info
- }
- //------------------------------------------------------------------------------
- //since basic node cannot be Optimized further, this function does nothing
- public function optimize() {
- //Optimize Evaluates constant values at compile time.
- //do nothing.
- }
+ public function __construct($Val)
+ {
+ $this->Value = $Val;
+ }
+ public function getValue()
+ {
+ return $this->Value;
+ }
+
+ /**
+ * @throws Exception
+ * @since 1.0.0
+ */
+ public function getValueAsDouble(): float
+ {
+ if (is_float($this->Value)) {
+ return $this->Value;
+ } else if (is_numeric($this->Value)) {
+ return (float)$this->Value;
+ }
+ throw new Exception("Value is not numeric: " . $this->Value);
+ }
+
+ public function getValueAsString(): string
+ {
+ return (string)$this->Value;
+ }
+
+ //------------------------------------------------------------------------------
+
+ public function isVariableUsed($Name): bool
+ {
+ return false; //a basic node does not store any variable or function info
+ }
+
+ //------------------------------------------------------------------------------
+
+ public function isFunctionUsed($Name): bool
+ {
+ return false; //a basic node does not store any variable or function info
+ }
+
+ //------------------------------------------------------------------------------
+
+ //since basic node cannot be Optimized further, this function does nothing
+ public function optimize()
+ {
+ //Optimize Evaluates constant values at compile time.
+ //do nothing.
+ }
}
/**
* Internal support class that represents N parameter functions such as IF(X, Y, Z) etc.
* @ignore
+ * @since 1.0.0
*/
-class Mathparser_NParamNode extends Mathparser_Node {
- public $nodes; //array of nodes (these are the parameters).
- public $fPtr; //function to execute
+class Mathparser_NParamNode extends Mathparser_Node
+{
+ public array $nodes; //array of nodes (these are the parameters).
+ public $fPtr; //function to execute
- public function __construct($n, $FuncAddr) {
- $this->nodes = &$n;
- $this->fPtr = $FuncAddr;
- }
- public function getValue() {
- if($this->fPtr->Name=='IF'){
- //special case for short circuit boolean logic.
- //helps to avoid div by zero etc.
- //assume there are 3 parameters:
- $cond = $this->nodes[0]->getValue();
- if($cond==0){ //false:
- return $this->nodes[2]->getValue();
- }else{
- return $this->nodes[1]->getValue();
- }
- }else{
- $p = array();
- $count = count($this->nodes);
- for($i=0; $i<$count; $i++){
- $p[]=$this->nodes[$i]->getValue();
- }
- return call_user_func_array($this->fPtr->EventHandler, $p);
- }
- }
- public function getValueAsDouble() {
- $Value = $this->getValue();
- if(is_float($Value))
- {
- return $Value;
- }
- else if(is_numeric($Value))
- {
- return (float)$Value;
- }
- throw new Exception("Value is not numeric: ".$Value);
- }
- public function getValueAsString() {
- return (string)$this->getValue();
- }
+ public function __construct($n, $FuncAddr)
+ {
+ $this->nodes = &$n;
+ $this->fPtr = $FuncAddr;
+ }
- public function isFunctionUsed($Name) {
- if($this->fPtr->Name==$Name){
- return true;
- }
- $i=0;
- foreach ($this->nodes as $n) {
- if ($n->isFunctionUsed($Name)) {
- return true;
- }
- }
- return false;
- }
- public function isVariableUsed($Name) {
- $i=0;
- foreach ($this->nodes as $n) {
- if ($n->isVariableUsed($Name)) {
- return true;
- }
- }
- return false;
- }
+ public function getValue()
+ {
+ if ($this->fPtr->Name == 'IF') {
+ //special case for short circuit boolean logic.
+ //helps to avoid div by zero etc.
+ //assume there are 3 parameters:
+ $cond = $this->nodes[0]->getValue();
+ if ($cond == 0) { //false:
+ return $this->nodes[2]->getValue();
+ } else {
+ return $this->nodes[1]->getValue();
+ }
+ } else {
+ $p = array();
+ $count = count($this->nodes);
+ for ($i = 0; $i < $count; $i++) {
+ $p[] = $this->nodes[$i]->getValue();
+ }
+ return call_user_func_array($this->fPtr->EventHandler, $p);
+ }
+ }
- public function optimize() {
- $i=0;
- foreach ($this->nodes as $n) {
- $this->nodes[$i] = MathParser::optimizeNode($n);
- $i++;
- }
- }
-};
+ /**
+ * @throws Exception
+ * @since 1.0.0
+ */
+ public function getValueAsDouble(): float
+ {
+ $Value = $this->getValue();
+ if (is_float($Value)) {
+ return $Value;
+ } else if (is_numeric($Value)) {
+ return (float)$Value;
+ }
+ throw new Exception("Value is not numeric: " . $Value);
+ }
+
+ public function getValueAsString(): string
+ {
+ return (string)$this->getValue();
+ }
+
+ public function isFunctionUsed($Name): bool
+ {
+ if ($this->fPtr->Name == $Name) {
+ return true;
+ }
+ foreach ($this->nodes as $n) {
+ if ($n->isFunctionUsed($Name)) {
+ return true;
+ }
+ }
+ return false;
+ }
+
+ public function isVariableUsed($Name): bool
+ {
+ foreach ($this->nodes as $n) {
+ if ($n->isVariableUsed($Name)) {
+ return true;
+ }
+ }
+ return false;
+ }
+
+ public function optimize(): void
+ {
+ $i = 0;
+ foreach ($this->nodes as $n) {
+ $this->nodes[$i] = MathParser::optimizeNode($n);
+ $i++;
+ }
+ }
+}
/**
* Internal support class that represents a variable Node.
* @ignore
+ * @since 1.0.0
*/
-class Mathparser_VarNode extends Mathparser_Node {
- private $pVar; //address of the variable in the variable list
- public function __construct ($variable) {
- $this->pVar = $variable;
- }
- public function getValue() {
- return $this->pVar->getRuntimeValue();
- }
- public function getValueAsDouble() {
- $Value = $this->pVar->getRuntimeValue();
- if(is_float($Value))
- {
- return $Value;
- }
- else if(is_numeric($Value))
- {
- return (float)$Value;
- }
- throw new Exception("Value is not numeric: ".$Value);
- }
- public function getValueAsString() {
- return (string)$this->pVar->getRuntimeValue();
- }
+class Mathparser_VarNode extends Mathparser_Node
+{
+ private $pVar; //address of the variable in the variable list
- public function isVariableUsed($Name) {
- return $this->pVar->Name==$Name;
- }
- public function isFunctionUsed($Name)
- {
- return false;
- }
- //since there is no parameter used to get the value of a variable, no further
- //optimization can be made.
- public function optimize() { //Optimize Evaluates constant values at compile time.
- //do nothing
- }
+ public function __construct($variable)
+ {
+ $this->pVar = $variable;
+ }
+
+ public function getValue()
+ {
+ return $this->pVar->getRuntimeValue();
+ }
+
+ /**
+ * @throws Exception
+ * @since 1.0.0
+ */
+ public function getValueAsDouble(): float
+ {
+ $Value = $this->pVar->getRuntimeValue();
+ if (is_float($Value)) {
+ return $Value;
+ } else if (is_numeric($Value)) {
+ return (float)$Value;
+ }
+ throw new Exception("Value is not numeric: " . $Value);
+ }
+
+ public function getValueAsString(): string
+ {
+ return (string)$this->pVar->getRuntimeValue();
+ }
+
+ public function isVariableUsed($Name): bool
+ {
+ return $this->pVar->Name == $Name;
+ }
+
+ public function isFunctionUsed($Name): bool
+ {
+ return false;
+ }
+ //since there is no parameter used to get the value of a variable, no further
+ //optimization can be made.
+ public function optimize()
+ { //Optimize Evaluates constant values at compile time.
+ //do nothing
+ }
}
@@ -2500,89 +2108,105 @@ class Mathparser_VarNode extends Mathparser_Node {
* Internal support class that represents a variable Node that was not defined before the parse.
* We will resolve it's value during evaluation.
* @ignore
+ * @since 1.0.0
*/
class Mathparser_UnknownVarNode extends Mathparser_Node
{
- private $VarName; //name of the variable that was defined on the fly.
+ private string $VarName; //name of the variable that was defined on the fly.
- private $MathParser;
- public function __construct($parser, $varName)
- {
- $this->MathParser = $parser;
- $this->VarName = $varName;
- }
- public function getValue()
- {
- return call_user_func($this->MathParser->VariableResolver, $this->MathParser, $this->VarName);
- }
- public function getValueAsDouble()
- {
- $Value = $this->getValue();
- if(is_float($Value))
- {
- return $Value;
- }
- else if(is_numeric($Value))
- {
- return (float)$Value;
- }
- throw new Exception("Value is not numeric: ".$Value);
- }
- public function getValueAsString()
- {
- return (string) $this->getValue() ;
- }
+ private $MathParser;
- public function isVariableUsed($Name)
- {
- return $this->VarName==$Name;
- }
- public function isFunctionUsed($Name)
- {
- return false;
- }
- //since there is no parameter used to get the value of a variable, no further
- //optimization can be made.
- public function optimize()
- { //Optimize Evaluates constant values at compile time.
- //do nothing
- }
+ public function __construct($parser, $varName)
+ {
+ $this->MathParser = $parser;
+ $this->VarName = $varName;
+ }
+
+ public function getValue()
+ {
+ return call_user_func($this->MathParser->VariableResolver, $this->MathParser, $this->VarName);
+ }
+
+ /**
+ * @throws Exception
+ * @since 1.0.0
+ */
+ public function getValueAsDouble(): float
+ {
+ $Value = $this->getValue();
+ if (is_float($Value)) {
+ return $Value;
+ } else if (is_numeric($Value)) {
+ return (float)$Value;
+ }
+ throw new Exception("Value is not numeric: " . $Value);
+ }
+
+ public function getValueAsString(): string
+ {
+ return (string)$this->getValue();
+ }
+
+ public function isVariableUsed($Name): bool
+ {
+ return $this->VarName == $Name;
+ }
+
+ public function isFunctionUsed($Name): bool
+ {
+ return false;
+ }
+ //since there is no parameter used to get the value of a variable, no further
+ //optimization can be made.
+ public function optimize()
+ { //Optimize Evaluates constant values at compile time.
+ //do nothing
+ }
}
/**
* Base class for expression tree nodes.
* @ignore
+ * @since 1.0.0
*/
abstract class Mathparser_Node
{
- /**
- * Returns the computed value of this Node.
- */
- abstract public function getValue();
- /**
- * Returns the computed value of this Node as a double precision value.
- */
- abstract public function getValueAsDouble();
- /**
- * Returns the value as a String.
- */
- abstract public function getValueAsString();
+ /**
+ * Returns the computed value of this Node.
+ * @since 1.0.0
+ */
+ abstract public function getValue();
- /**
- * Is this variable used in the expression under this node?
- */
- abstract public function isVariableUsed($Name);
+ /**
+ * Returns the computed value of this Node as a double precision value.
+ * @since 1.0.0
+ */
+ abstract public function getValueAsDouble();
- /**
- * Is this function used in the expression under this node?
- */
- abstract public function isFunctionUsed($Name);
+ /**
+ * Returns the value as a String.
+ * @since 1.0.0
+ */
+ abstract public function getValueAsString();
- /**
- * Optimize Evaluates constant values at compile time (When parse() is called).
- * Once this is done, Evaluate will run faster.
- */
- abstract public function optimize();
+ /**
+ * Is this variable used in the expression under this node?
+ * @since 1.0.0
+ */
+ abstract public function isVariableUsed($Name);
+
+ /**
+ * Is this function used in the expression under this node?
+ * @since 1.0.0
+ */
+ abstract public function isFunctionUsed($Name);
+
+ /**
+ * Optimize Evaluates constant values at compile time (When parse() is called).
+ * Once this is done, Evaluate will run faster.
+ * @since 1.0.0
+ */
+ abstract public function optimize();
}
/**
@@ -2590,368 +2214,437 @@ abstract class Mathparser_Node
* expression cannot be parsed. These methods are:
* parse(), evaluate(), getValue()
* User defined functions can choose to throw this exception too.
+ * @since 1.0.0
*/
class Mathparser_ParserException extends Exception
{
- /**
- * Member variable that holds the error portion of the expression.
- */
- public $err;
+ /**
+ * Member variable that holds the error portion of the expression.
+ * @since 1.0.0
+ */
+ public $err;
- /**
- * Member variable that holds the parsed expression itself.
- */
- public $exp;
+ /**
+ * Member variable that holds the parsed expression itself.
+ * @since 1.0.0
+ */
+ public $exp;
- /**
- * Constructor.
- */
- public function __construct($msg, $errPart, $expression)
- {
- parent::__construct($msg);
- $this->err = $errPart;
- $this->exp = $expression;
- }
- /**
- * Returns the expression string that cannot be parsed.
- */
- public function getInvalidPortionOfExpression()
- {
- return $this->err;
- }
-
- /**
- * Returns the subexpression that is the immediate parent of the error portion.
- * For example, if the expression is 3+LN(MAX(4,))
- * then getInvalidPortionOfExpression() would return MAX(4,) and getSubExpression()
- * would return LN(MAX(4,))
-