org.vishia.util

Class CalculatorExpr

java.lang.Object

org.vishia.util.CalculatorExpr

public class CalculatorExpr
extends java.lang.Object

This class provides a calculator for expressions. The expression is given either as a simple string format or from a ZbnfJavaOutput output from a Zbnf parsing process. It is converted to the internal format for a stack oriented running model.

This class contains the expression itself and the capability to calculate in multi thread (since 2019-06). The calculation can be execute with one or some given values (usual float, integer type) or it can access any Java internal variables using the capability of DataAccess.

• Use setExpr(String) to convert a String given expression to the internal format.
• Use calc(float) for simple operations with one float input, especially for scaling values. It is fast.
• Use calc(Object...) for universal expression calculation.
• Use calcDataAccess(Map, Object...) to calculate with access to other Java data.
• Use new CalculatorExpr.Data to get a data storage to calculate for one thread, able to reuse in the same thread.
• Use calcDataAccess(Data, Map, Object...) with resued data for the same thread.
• Use a ZBNF parser with a proper script and CalculatorExpr.SetExprBase.SetExpr to parse via possibility of Java data access. That is done in the JZcmd script language.

If the expression works with simple variable or constant values, it is fast. For example it is able to use in a higher frequently graphic application to scale values.



To test the capability and the correctness use org.vishia.util.test.TestCalculatorExpr.

Nested Class Summary

Nested Classes

Modifier and Type	Class and Description
static class	CalculatorExpr.Data It is the data instance for the caluclation.
protected static interface	CalculatorExpr.ExpressionType Common interface to check and maybe change the type of expression.
protected static class	CalculatorExpr.ExprTypes
static class	CalculatorExpr.Operand Operand for a part of the expression, refer from CalculatorExpr.Operation.
static class	CalculatorExpr.Operation An Operation in the list of operations.
static class	CalculatorExpr.Operator An operator for the current value (accu), the given second value maybe the operand from the CalculatorExpr.Operation, or for some additional values in stack.
protected static class	CalculatorExpr.Operators This class contains all Operators as static references.
static class	CalculatorExpr.SetExprBase This class and its inner class CalculatorExpr.SetExprBase.SetExpr is a helper class which contains a CalculatorExpr as composite.
static class	CalculatorExpr.Value A value, maybe a constant, any given Object or an access description to a java program element.

Field Summary

Fields

Modifier and Type	Field and Description
private java.util.List<CalculatorExpr.Operation>	listOperations_ All Operations which acts with the accumulator and the stack of values.
private java.lang.Appendable	log
protected static java.util.Map<java.lang.String,CalculatorExpr.Operator>	operators Map of all available operators associated with its String expression.
protected static java.util.Map<java.lang.String,CalculatorExpr.Operator>	unaryOperators
static java.lang.String	version Version, history and license.

Constructor Summary

Constructors

Constructor and Description
CalculatorExpr() Map of all available unary operators associated with its String expression.
CalculatorExpr(java.lang.String sExpr, java.util.Map<java.lang.String,DataAccess.IntegerIx> nameVariables, java.lang.Class<?> reflData) Deprecated. it should be possible to use #CalculatorExpr(StringPartScan, Map, Class) in all cases.
CalculatorExpr(StringPartScan sExpr, java.util.Map<java.lang.String,DataAccess.IntegerIx> nameVariables, java.lang.Class<?> reflData, boolean bSpecialSyntax) Constructs an String given expression with some variables.

Method Summary

Modifier and Type	Method and Description
void	addOperation(CalculatorExpr.Operation operation) Adds the given operation to the list of operations.
double	calc(double input) Calculates the expression with only one input.
float	calc(float input) Calculates the expression with only one input.
CalculatorExpr.Value	calc(java.lang.Object... args) Calculates the expression with some inputs, often only 1 input.
CalculatorExpr.Value	calcDataAccess(CalculatorExpr.Data data, java.util.Map<java.lang.String,DataAccess.Variable<java.lang.Object>> javaVariables, java.lang.Object... args) Calculates the expression with possible access to any stored object data with access via reflection.
CalculatorExpr.Value	calcDataAccess(java.util.Map<java.lang.String,DataAccess.Variable<java.lang.Object>> javaVariables, java.lang.Object... args) Creates new CalculatorExpr.Data for calculation and calls calcDataAccess(Data, Map, Object...), see there
long	calcLong(int input) Calculates the expression with only one input.
long	calcLong(long input) Calculates the expression with only one input.
(package private) static void	convertObj(CalculatorExpr.Value val2jar, java.lang.Object oval2)
(package private) int	debug()
static CalculatorExpr.Operator	getOperator(java.lang.String op) Gets a operator to prepare operations.
private CalculatorExpr.Value	getValue(CalculatorExpr.Data data, CalculatorExpr.Operation oper, java.util.Map<java.lang.String,DataAccess.Variable<java.lang.Object>> javaVariables, java.lang.Object[] args)
CalculatorExpr.Operand	isSimpleSetExpr()
java.util.List<CalculatorExpr.Operation>	listOperations() Gets the list of operations in return polish notation.
static int	masksh(int val, int mask, byte nrofBits) shift operation, after them mask.
float	Oldcalc(float input) Calculates the expression with only one float input.
float	Oldcalc(int input) Calculates the expression with only one integer input.
protected void	parseAddExpr(StringPartScan spExpr, java.util.Map<java.lang.String,DataAccess.IntegerIx> nameVariables, java.lang.Class<?> reflData, java.lang.String startOperation, int recursion) The expression is an add or subtract expression.
protected void	parseAndExpr(StringPartScan spExpr, java.util.Map<java.lang.String,DataAccess.IntegerIx> nameVariables, java.lang.Class<?> reflData, java.lang.String startOperation, boolean bSpecialSyntax, int recursion)
protected void	parseArgument(StringPartScan spExpr, java.util.Map<java.lang.String,DataAccess.IntegerIx> nameVariables, java.lang.Class<?> reflData, java.lang.String operation, int recursion) Parses one argument for a #parseMultExpr(StringPartScan, String, int) or maybe a #parseAddExpr(StringPartScan, String, int) on absens of multiply operation.
protected void	parseCmpExpr(StringPartScan spExpr, java.util.Map<java.lang.String,DataAccess.IntegerIx> nameVariables, java.lang.Class<?> reflData, java.lang.String startOperation, boolean bSpecialSyntax, int recursion) The expression is an compare expression.
private void	parseException(StringPartScan sExpr)
protected void	parseExpr(StringPartScan spExpr, java.util.Map<java.lang.String,DataAccess.IntegerIx> nameVariables, java.lang.Class<?> reflData, java.lang.String startOperation, boolean bSpecialSyntax, int recursion) Parses a textual given expression.
protected java.lang.String	parseMultExpr(StringPartScan spExpr, java.util.Map<java.lang.String,DataAccess.IntegerIx> nameVariables, java.lang.Class<?> reflData, java.lang.String startOperation, int recursion) The more inner expression is a multiply or divide expression.
java.lang.String	setExpr(java.lang.String sExpr) Converts the given expression in a stack operable form.
java.lang.String	setExpr(java.lang.String sExpr, java.lang.Class<?> reflData) Converts the given expression in a stack operable form.
java.lang.String	setExpr(java.lang.String sExpr, java.util.Map<java.lang.String,DataAccess.IntegerIx> nameVariables, java.lang.Class<?> reflData) Deprecated. it should be possible to use #setExpr(StringPartScan, Map, Class) in all cases.
java.lang.String	setExpr(StringPartScan spExpr, java.lang.Class<?> reflData, boolean bSpecialSyntax) Converts the given expression in a stack operable form.
java.lang.String	setExpr(StringPartScan spExpr, java.util.Map<java.lang.String,DataAccess.IntegerIx> nameVariables, java.lang.Class<?> reflData, boolean bSpecialSyntax) Converts the given expression in a stack operable form (Reverse Polish Notation) to execute.
java.lang.String	setExpr(java.lang.String sExpr, java.lang.String[] sIdentifier) Converts the given expression in a stack operable form.
void	setLog(java.lang.Appendable log)
void	setRpnExpr(java.lang.CharSequence sExpr, java.util.Map<java.lang.String,DataAccess.IntegerIx> nameVariables, java.lang.Class<?> reflData) Sets the expression from a Revers Polish Notation form.
int	setRpnExpr(StringPartScan sExpr, java.util.Map<java.lang.String,DataAccess.IntegerIx> nameVariables, java.lang.Class<?> reflData) Sets the expression from a Revers Polish Notation form.
static int	sh(int val, int nrofBits) This is the ordinary shift operation
static int	shmask(int val, byte nrofBits, int mask) shift operation, after them mask.
static java.lang.String[]	splitFnNameAndParams(java.lang.String expr) Separates a name and the parameter list from a given String.
static java.lang.String[]	splitFnParams(java.lang.String expr) Separates String parameters from a list.
java.lang.String	toString()

Methods inherited from class java.lang.Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, wait, wait, wait

Field Detail

version

public static final java.lang.String version

Version, history and license.

• 2023-06-08: parseCmpExpr(StringPartScan, Map, Class, String, boolean, int) now regards also ?lt etc.
• 2023-05-13: TODO using String or StringPartScan for parseExpr(StringPartScan, Map, Class, String, boolean, int) etc. : If the expression is simple, only an identifier, then a String is sufficient and a StringPartScan needs waste memory. From calling level it may be known that the argument is only simple. But the simplicity can be used only in a deeper level of nesting. To optimize it may be sufficient to provide both as argument, whereby the StringPartScan argument may be null. It should be null if the simplicity is known from calling level. Then the simple String is used as input for the expression.
  The advantage: No two versions of setExpr(String) and setExpr(StringPartScan, Class, boolean) as it would be necessary for all deeper levels to optimize.
  Disadvantage: One argument more for all calls. But this one argument more may be lesser effort as extra memory space.
• 2023-05-13: Operand#Operand(String, Map, Class, Map) with given dataConst possible for the operand. It is used in OutTextPreparer especially for the String which refers to s called sub-OutTextPreparer which is an Operand. But it is usable for also other situations where as a Map may be given to select with a dataPath and where it is not pre-defined that this is part of the Map or another dataPath.
• 2022-03-14: Hartmut some refactoring, also for better docu, all ExprTypes in a sub class
• 2022-03-14: Hartmut calcDataAccess(Map, Object...): Now multidim array for Object possible.
• 2022-03-14: Hartmut parseExpr(StringPartScan, Map, Class, String, boolean, int) now regard precedence of && higher as ||, that was faulty before.
• 2022-03-14: setRpnExpr(CharSequence, Map, Class) now with unary operators, used, ok
• 2022-03-12: Hartmut calcDataAccess(Data, Map, Object...) enhanced, now can access a numeric array.
• 2022-03-12: Hartmut new setRpnExpr(CharSequence, Map, Class).
• 2022-03-12: Hartmut new setLog(Appendable) if this is set writes a log to the given output. For debug.
• 2022-03-12: Hartmut add "#" for put stack and "=" for assign to the textual operators.
• 2022-03-12: Hartmut enhance Operation#Operation(String, Operand) possible stackOperand
• 2022-03-12: Hartmut new CalculatorExpr.Operators.assignOperation but not really used.
• 2019-08-20: some operations throws ParseException on syntax errors.
• 2019-08-26 Hartmut: Some operations with boolean bSpecialSyntax, used in parseCmpExpr(StringPartScan, Map, Class, String, boolean, int) to prevent accepting ">". It has another meaning in some envronments, for example <datapath> in an OutTextPreparer.
• 2019-06-20 Hartmut; chg setExpr(String, Map, Class) etc. with reflectionData. It is used in #parseArgument(StringPartScan, Class, String, int): If a given DataPath is not found in the variables, it is searched as constant input in the reflection class.
• 2019-06-18 Hartmut; new CalculatorExpr.Operand.expr, an Operand can contain a nested expression. It is used as argument value etc. But for OutTextPreparer too. Operand#Operand(Map, String, Object) checks whether the given path presents an expression.
• 2019-06-18 Hartmut: instead CalculatorExpr.Operation.value the value is stored in CalculatorExpr.Operand.dataConst. More systematic. Operand contains all what is an operand.
• 2019-06-18 Hartmut: #setExpr(StringPartScan) with Stringpart as part of whole parsing in OutTextPreparer.
• 2019-06-12 Hartmut
  • Refactoring CalculatorExpr.Operand is used in OutTextPreparer too, content was part of CalculatorExpr.Operation before.
  • new CalculatorExpr#CalculatorExpr(String, Map): Set the expression on construction as line of action.
  • new #parseExpr(StringPartScan, String, int) and #parseCmpExpr(StringPartScan, String, int) to translate full expression possibilities without ZBNF (before it was only used in JZtxtcmd with parsing with ZBNF).
  • new CalculatorExpr.Operators.cmpContainsOperation etc. Syntax operand ?contains 'text'
• 2019-06-11 Hartmut new CalculatorExpr.Data and calcDataAccess(Data, Map, Object...). All routines now can run in parallel threads, because the Data are separated.
• 2018-09-23 Hartmut bugfix in CalculatorExpr.Value.toNumValue(): CalculatorExpr.Value.etype was not set. The problem was obvious on a numeric value which were null because an exception in an JZtxtcmd script. The conversion to Num was done, the value was 0 with type == 'I' but the etype was not change from 'o' to 'I' Before using toNumValue it was not obvious that there was an exception. On the fly: CalculatorExpr.Value.toString() was faulty in this situation (only used in debugging view).
• 2018-08-28 Hartmut new CalculatorExpr.Value.toNumValue(), conversion especially from String, yet some TODO .
• 2017-10-27 Hartmut exception on cmp operation with #variableNotFoundExpr
• 2016-02-13 Hartmut bugfix: StringPartScan.scanFractionalNumber(long, boolean) has had a problem with negative numbers. fixed there, adapted here.
• 2015-07-05 Hartmut bugfix: On parenthesis expression there was an error if the CalculatorExpr.ExpressionType in parenthesis was another than the expression type of the stored accumulator. Then the expression type of the parenthesis has taken and the operation was faulty. Therefore general change: Store the ExpressionType in the accu in CalculatorExpr.Value.etype. It may be instead CalculatorExpr.Value.type_ but yet both is stored. Set the expression type always in that way that the expression type of the accumulator was taken and checked against the second operand. Remove the independent variable for the ExpressionType inside calcDataAccess(Map, Object...).
• 2015-07-04 Hartmut chg, need-feature: To check (float ?instanceof Float) a given boxed float value should be stored as CalculatorExpr.Value.oVal too to execute the instanceof operation. The instanceof operator is enhanced so that a simple type is recognized with ?instanceof BoxedType.
• 2015-05-04 Hartmut new: CalculatorExpr.Value.type() and CalculatorExpr.Value.longValue()
• 2014-12-06 Hartmut bugfix: If works with an "Num" Object in JZcmd resp if it gets an Object which is a CalculatorExpr.Value the Object is used correct now.
• 2014-12-06 Hartmut chg: calc(float) now uses the calcDataAccess(Map, Object...) which is complete. Some enhancements and tunings. TODO same for calc(double) etc.
• 2014-12-06 Hartmut chg: correct check of object values whether it is a numeric type.
• 2014-12-06 Hartmut chg: On DataAccess and FieldNotFoundException it is false if a boolean value is expected.
• 2014-12-06 Hartmut chg: Handling of AND and OR operation: A special operation CalculatorExpr.Operators.boolCheckAndOperation or CalculatorExpr.Operators.boolCheckOrOperation is necessary to finish the evaluation on AND or OR operation if the result is false or true already. The older solution: It checks whether the next operation is an AND or OR. But that does not recognize a boolean operation in parenthesis which may follow. because the AND or OR follows after the calculation of the parenthesis content only.
• 2014-11-15 Hartmut new: instanceof as compare operator.
• 2014-08-10 Hartmut bugfix: on push to stack operation the type of the new level should start with always because the new level is a new start type. The operation with the pushed value is done later, the adjusting of types should be done later too!
• 2014-02-22 Hartmut chg: now string >= string2 tests 'startswith' instead alphabetic comparison.
• 2014-02-22 Hartmut new: calcDataAccess(Map, Object...) accepts CalculatorExpr.Value as return of dataAccess. A Value is stored for Num variables in JZcmd especially.
• 2014-01-26 Hartmut bugfix: and-expression with !val && val did not work.
• 2014-01-26 Hartmut chg: To add a datapath now SetExpr#new_datapath() is offered, all details of a datapath are handled in DataAccess.DataAccessSet. To support more complex DataAccess.DatapathElement especially with expressions or datapath as arguments, the method CalculatorExpr.SetExprBase.SetExpr.newDataAccessSet() supports overriding in a derived class of CalculatorExpr.SetExprBase.SetExpr, see JZtxtcmdScript.JZcmdCalculatorExpr.
• 2013-10-19 Hartmut new: CalculatorExpr.SetExprBase.SetExpr should know all possibilities of DataAccess.DataAccessSet too because an expression may be an DataAccess only. Yet only SetExpr#new_newJavaClass() realized.
• 2013-10-19 Hartmut new: The CalculatorExpr gets the capability to generate String expressions using the JZtxtcmdExecuter class. This is because some arguments of methods may be a String. If the #genString is set, the CalculatorExpr is a String expression. Now this class, the DataAccess and the JZtxtcmdExecuter are one cluster of functionality.
• 2013-09-02 Hartmut new: CalculatorExpr.SetExpr to set from a ZbnfParseResult using ZbnfJavaOutput. This class can be invoked without ZbnfParser too, it is independent of it. But it isn't practicable.
• 2013-09-02 Hartmut new: CalculatorExpr: now supports unary ( expression in parenthesis ).
• 2013-08-18 Hartmut new: CalculatorExpr.Operation.unaryOperator
• 2013-08-19 Hartmut chg: The DataAccess.DatapathElement is a attribute of a CalculatorExpr.Operation, not of a CalculatorExpr.Value. A value is only a container for constant values or results.
• 2012-12-22 Hartmut new: Now a value can contain a list of DataAccess.DatapathElement to access inside java data to evaluate the value. The concept is synchronized with org.vishia.zbatch.ZbatchGenScript, but not depending on it. The JbatGenScript uses this class, this class participates on the development and requirements of jbat.
• Bugfix because String value and thrown Exception. The class needs a test environment. TODO
• 2012-12-22 some enhancements while using in org.vishia.ZbatchExecuter.TextGenerator.
• 2012-04-17 new calc(float) for float and int
• TODO unary operator, function
• 2011-10-15 Hartmut creation. The ideas were created in 1979..80 by me.

Copyright/Copyleft: For this source the LGPL Lesser General Public License, published by the Free Software Foundation is valid. It means:

1. You can use this source without any restriction for any desired purpose.
2. You can redistribute copies of this source to everybody.
3. Every user of this source, also the user of redistribute copies with or without payment, must accept this license for further using.
4. But the LPGL ist not appropriate for a whole software product, if this source is only a part of them. It means, the user must publish this part of source, but don't need to publish the whole source of the own product.
5. You can study and modify (improve) this source for own using or for redistribution, but you have to license the modified sources likewise under this LGPL Lesser General Public License. You mustn't delete this Copyright/Copyleft inscription in this source file.

If you are intent to use this sources without publishing its usage, you can get a second license subscribing a special contract with the author.

See Also:

Constant Field Values

listOperations_

private final java.util.List<CalculatorExpr.Operation> listOperations_

All Operations which acts with the accumulator and the stack of values. They will be executed one after another. All calculation rules of prior should be regarded in this order of operations already. It will not be checked here.

log

private java.lang.Appendable log

operators

protected static java.util.Map<java.lang.String,CalculatorExpr.Operator> operators

Map of all available operators associated with its String expression. It will be initialized see CalculatorExpr()

• "!set" Set the value to accu, set the accu to the stack.
• "+" "-" "*" "/" known arithmetic operators
• ">=" "<=" ">" "<" "==" "!=" knwon compare operators
• "<>" other form of not equal operator
• "ge" "le" "gt" "lt" "eq" "ne" other form of comparators
• "||" "&&" known logical opeators
• "instanceof"
• "=." ".=." ".=" for Strings

Unary operators:

• "b" Convert to boolean.
• "b!" boolean not operator
• "u~" bit negation operator
• "u-" numeric negation

unaryOperators

protected static java.util.Map<java.lang.String,CalculatorExpr.Operator> unaryOperators

Constructor Detail

CalculatorExpr

public CalculatorExpr()

Map of all available unary operators associated with its String expression. It will be initialized with:

CalculatorExpr

public CalculatorExpr(java.lang.String sExpr,
                      java.util.Map<java.lang.String,DataAccess.IntegerIx> nameVariables,
                      java.lang.Class<?> reflData)

Deprecated. it should be possible to use #CalculatorExpr(StringPartScan, Map, Class) in all cases.

Constructs an String given expression with some variables.

Parameters:

sExpr -

nameVariables -

CalculatorExpr

public CalculatorExpr(StringPartScan sExpr,
                      java.util.Map<java.lang.String,DataAccess.IntegerIx> nameVariables,
                      java.lang.Class<?> reflData,
                      boolean bSpecialSyntax)

Constructs an String given expression with some variables.

Parameters:

sExpr -

nameVariables - see DataAccess.DataAccess(StringPartScan, Map, Class, char)

reflData - see DataAccess.DataAccess(StringPartScan, Map, Class, char)

Method Detail

splitFnNameAndParams

public static java.lang.String[] splitFnNameAndParams(java.lang.String expr)

Separates a name and the parameter list from a given String.

Parameters:

expr - An expression in form " name (params)"

Returns:

A String[2]. The ret[0] is the expr without leading and trailing spaces if the expr does not contain a "(" The ret[0] is "" if the expr contains only white spaces before "(" or it starts with "(" The ret[0] contains the string part before "(" without leading and trailing spaces. The ret[1] contains the part between "(...)" without "()". The ret[1] is null if no "(" is found in expr.. If the trailing ")" is missing, it is accepting.

splitFnParams

public static java.lang.String[] splitFnParams(java.lang.String expr)

Separates String parameters from a list. Implementation yet: only split Planned: detects name(param, param) inside a parameter.

Parameters:

expr - Any expression with Strings separated with colon

Returns:

The split expression, all arguments are trimmed (without leading and trailing spaces).

sh

public static int sh(int val,
                     int nrofBits)

This is the ordinary shift operation

Parameters:

val -

nrofBits - >0: shift left, <0: shift rigth.

Returns:

on negative value and shift right: 1 shift in from left: sh( 0x80000000, -1) => 0xc0000000

shmask

public static int shmask(int val,
                         byte nrofBits,
                         int mask)

shift operation, after them mask. This operation is helpfull if bit rangess should be shifted.

Parameters:

val -

nrofBits - >0: shift left, <0: shift rigth.

mask - of result

Returns:

masksh

public static int masksh(int val,
                         int mask,
                         byte nrofBits)

shift operation, after them mask. This operation is helpfull if bit rangess should be shifted.

Parameters:

val -

nrofBits - >0: shift left, <0: shift rigth.

mask - of result

setLog

public void setLog(java.lang.Appendable log)

setExpr

public java.lang.String setExpr(java.lang.String sExpr,
                                java.lang.String[] sIdentifier)

Converts the given expression in a stack operable form. The parsing of sExpr starts with an adding expression. Its operators are read as multExpression.

Parameters:

sExpr - String given expression such as "X*(Y-1)+Z"

sIdentifier - Array of identifiers for variables.

Returns:

null if ok or an error description.

setExpr

public java.lang.String setExpr(java.lang.String sExpr,
                                java.util.Map<java.lang.String,DataAccess.IntegerIx> nameVariables,
                                java.lang.Class<?> reflData)

Deprecated. it should be possible to use #setExpr(StringPartScan, Map, Class) in all cases.

Converts the given expression in a stack operable form. The parsing of sExpr starts with an adding expression. Its operators are read as multExpression.

Parameters:

sExpr - String given expression such as "X*(Y-1)+Z"

sIdentifier - List of identifiers for variables.

Returns:

null if ok or an error description.

setExpr

public java.lang.String setExpr(StringPartScan spExpr,
                                java.util.Map<java.lang.String,DataAccess.IntegerIx> nameVariables,
                                java.lang.Class<?> reflData,
                                boolean bSpecialSyntax)

Converts the given expression in a stack operable form (Reverse Polish Notation) to execute.

• It calls parseExpr(StringPartScan, Map, Class, String, boolean, int) for OR expression parts
• which calls parseAndExpr(StringPartScan, Map, Class, String, boolean, int) for AND expression parts
• which calls parseCmpExpr(StringPartScan, Map, Class, String, boolean, int) for comparison expression parts
• which calls parseAddExpr(StringPartScan, Map, Class, String, int) for summation expression parts
• which calls parseMultExpr(StringPartScan, Map, Class, String, int) for multiplication / division expression parts
• which calls parseArgument(StringPartScan, Map, Class, String, int) for the arguments.

This nested calls evaluates the expression due to the common known preference rules. See the specific parts of expression for further explanation.

Parameters:

spExpr - given textual expression

nameVariables - An operand can be given as name of a variable from this index. Then for execution an array should be given as last argument of calcDataAccess(Map, Object...). It is the same approach as in DataAccess.DataAccess(StringPartScan, Map, Class, char).

reflData - An operand can be given with access to this data via reflection. Then for execution data with this reflection class should be given as argument of calcDataAccess(Map, Object...)

bSpecialSyntax - true then ">" is not accepted (as compare operator). It is for texts where the ">" has other meanings. The "gt" can be used to formulate "greater than" instead

Returns:

null if ok or an error description.

Throws:

java.text.ParseException

setExpr

public java.lang.String setExpr(java.lang.String sExpr)

Converts the given expression in a stack operable form. One variable with name "X" will be created. It means the expression can use "X" as variable. See setExpr(StringPartScan, Map, Class, boolean)

Parameters:

sExpr - For example "5.0*X" or "(X*X+1.5*X)"

See Also:

setExpr(String, String[])

setExpr

public java.lang.String setExpr(java.lang.String sExpr,
                                java.lang.Class<?> reflData)

Converts the given expression in a stack operable form. One variable with name "X" will be created. It means the expression can use "X" as variable.

Parameters:

sExpr - For example "5.0*X" or "(X*X+1.5*X)"

See Also:

setExpr(String, String[])

setExpr

public java.lang.String setExpr(StringPartScan spExpr,
                                java.lang.Class<?> reflData,
                                boolean bSpecialSyntax)

Converts the given expression in a stack operable form.

• It calls parseExpr(StringPartScan, Map, Class, String, boolean, int) for OR expression parts
• which calls parseAndExpr(StringPartScan, Map, Class, String, boolean, int) for AND expression parts
• which calls parseCmpExpr(StringPartScan, Map, Class, String, boolean, int) for comparison expression parts
• which calls parseAddExpr(StringPartScan, Map, Class, String, int) for summation expression parts
• which calls parseMultExpr(StringPartScan, Map, Class, String, int) for multiplication / division expression parts
• which calls parseArgument(StringPartScan, Map, Class, String, int) for the arguments.

This nested calls evaluates the expression due to the common known preference rules. See the specific parts of expression for further explanation.

Parameters:

sExpr - For example "5.0*X" or "(X*X+1.5*X)"

See Also:

setExpr(String, String[])

parseExpr

protected void parseExpr(StringPartScan spExpr,
                         java.util.Map<java.lang.String,DataAccess.IntegerIx> nameVariables,
                         java.lang.Class<?> reflData,
                         java.lang.String startOperation,
                         boolean bSpecialSyntax,
                         int recursion)
                  throws java.text.ParseException

Parses a textual given expression.

Parameters:

spExpr - given textual expression

nameVariables - An operand can be given as name of a variable from this index. Then for execution an array should be given as last argument of calcDataAccess(Map, Object...).

reflData - An operand can be given with access to this data via reflection. Then for execution data with this reflection class should be given as argument of calcDataAccess(Map, Object...)

startOperation -

bSpecialSyntax - true then ">" is not accepted (as compare operator). It is for texts where the ">" has other meanings. The "gt" can be used to formulate "greater than" instead

recursion - throws on 1000, only for safety

Throws:

java.text.ParseException

parseAndExpr

protected void parseAndExpr(StringPartScan spExpr,
                            java.util.Map<java.lang.String,DataAccess.IntegerIx> nameVariables,
                            java.lang.Class<?> reflData,
                            java.lang.String startOperation,
                            boolean bSpecialSyntax,
                            int recursion)
                     throws java.text.ParseException

Throws:

java.text.ParseException

parseCmpExpr

protected void parseCmpExpr(StringPartScan spExpr,
                            java.util.Map<java.lang.String,DataAccess.IntegerIx> nameVariables,
                            java.lang.Class<?> reflData,
                            java.lang.String startOperation,
                            boolean bSpecialSyntax,
                            int recursion)
                     throws java.text.ParseException

The expression is an compare expression. call recursively for any number of operands. call parseAddExpr(StringPartScan, Map, Class, String, int) to get the argument values.
The following operators are possible:

• == :
• != :
• >= :
• <= :
• > :
• < :
• ?ge : "greater or equal" used instead >= if > is not possible in the environment.
• ?le : "less or equal" used instead <= if < is not possible in the environment.
• ?gt : "greater than" used instead > if > is not possible in the environment.
• ?lt : "lesser than" used instead < if < is not possible in the environment.
• ?instanceof :left operand: any object, right operand: object of type class, true if left operand is or inherits the class
• ?contains : check whether the left string operand contains the right string
• ?starts : check whether the left string operand starts with the right string
• ?ends : check whether the left string operand ends with the right string

Parameters:

spExpr -

operation - The first operation. On start operand it is "!" for set.

Throws:

java.text.ParseException

parseAddExpr

protected void parseAddExpr(StringPartScan spExpr,
                            java.util.Map<java.lang.String,DataAccess.IntegerIx> nameVariables,
                            java.lang.Class<?> reflData,
                            java.lang.String startOperation,
                            int recursion)
                     throws java.text.ParseException

The expression is an add or subtract expression. call recursively for any number of operands. call #multExpr(StringPartScan, char) to get the argument values.

Parameters:

spExpr -

operation - The first operation. On start operand it is "!" for set.

Throws:

java.text.ParseException

parseMultExpr

protected java.lang.String parseMultExpr(StringPartScan spExpr,
                                         java.util.Map<java.lang.String,DataAccess.IntegerIx> nameVariables,
                                         java.lang.Class<?> reflData,
                                         java.lang.String startOperation,
                                         int recursion)
                                  throws java.text.ParseException

The more inner expression is a multiply or divide expression. call recursively for any number of operands. call #parseArgument(StringPartScan, String, int) to get the argument values.

Parameters:

spExpr -

operation - The first operation. On start operand it is "!" for set.

Returns:

Throws:

java.text.ParseException

parseArgument

protected void parseArgument(StringPartScan spExpr,
                             java.util.Map<java.lang.String,DataAccess.IntegerIx> nameVariables,
                             java.lang.Class<?> reflData,
                             java.lang.String operation,
                             int recursion)
                      throws java.text.ParseException

Parses one argument for a #parseMultExpr(StringPartScan, String, int) or maybe a #parseAddExpr(StringPartScan, String, int) on absens of multiply operation.

• The argument can be especially an expression in parenthesis, for that an #parseAddExpr(StringPartScan, String, int) is invoked for the inner expression.
• An identifier which is found in the variables
• An constant value.
• TODO functions (Math) are not supported yet.
• TODO access to java data, therewith to Math.sin() etc. are not supported yet. Use CalculatorExpr.SetExprBase.SetExpr to use that. Then an expression is parsed via ZBNF, used in the JZcmd script language.

Parameters:

spExpr -

operation -

recursion -

Throws:

java.text.ParseException

setRpnExpr

public void setRpnExpr(java.lang.CharSequence sExpr,
                       java.util.Map<java.lang.String,DataAccess.IntegerIx> nameVariables,
                       java.lang.Class<?> reflData)
                throws java.text.ParseException

Sets the expression from a Revers Polish Notation form.

Parameters:

sExpr - String given, maybe also StringBuffer etc. From that a StringPartScan.StringPartScan(CharSequence) will be created and setRpnExpr(StringPartScan, Map, Class) is called

nameVariables - Some variables which can be used given on execution in an array. See calcDataAccess(Data, Map, Object...)

reflData - Access to fields via Reflection also possible. (not done yet).

Throws:

java.text.ParseException

Since:

2022-03-12, not all is done yet, only important stuff for first tests.

setRpnExpr

public int setRpnExpr(StringPartScan sExpr,
                      java.util.Map<java.lang.String,DataAccess.IntegerIx> nameVariables,
                      java.lang.Class<?> reflData)
               throws java.text.ParseException

Sets the expression from a Revers Polish Notation form. Same as setRpnExpr(CharSequence, Map, Class). This is the working operation.
The syntax of RPN is: <operator> [<unary>]<operand>
whereby the operator::= is one of that stored in . It have to be follow by a space as separation to the operand.

Parameters:

sExpr - Given as StringPartScan.

nameVariables -

reflData -

Returns:

Throws:

java.text.ParseException

parseException

private void parseException(StringPartScan sExpr)
                     throws java.text.ParseException

Throws:

java.text.ParseException

addOperation

public void addOperation(CalculatorExpr.Operation operation)

Adds the given operation to the list of operations. The list of operations is executed one after another. All calculation rules such as parenthesis, prior of multiplication, functions arguments etc. should be regarded by the user.

Parameters:

operation -

listOperations

public java.util.List<CalculatorExpr.Operation> listOperations()

Gets the list of operations in return polish notation. Especially a datapath may completed with actual arguments of its called methods.

isSimpleSetExpr

public CalculatorExpr.Operand isSimpleSetExpr()

getOperator

public static CalculatorExpr.Operator getOperator(java.lang.String op)

Gets a operator to prepare operations.

Parameters:

op - Any of "+", "-" etc.

Returns:

null if op is faulty.

calc

public double calc(double input)

Calculates the expression with only one input. This is a simple variant for scaling values etc. It invokes internally calcDataAccess(Map, Object...) but without a access Map. It means it must not contain access to other data.

Parameters:

input - The only one input value.

Returns:

The result.

Oldcalc

public float Oldcalc(float input)

Calculates the expression with only one float input.

Parameters:

input - The only one input value (used for all variables, simple version).

Returns:

The result.

calc

public float calc(float input)

Calculates the expression with only one input. This is a simple variant for scaling values etc. It invokes internally calcDataAccess(Map, Object...) but without a access Map. It means it must not contain access to other data.

Parameters:

input - The only one input value.

Returns:

The result.

calcLong

public long calcLong(long input)

Calculates the expression with only one input. This is a simple variant for scaling values etc. It invokes internally calcDataAccess(Map, Object...) but without a access Map. It means it must not contain access to other data.

Parameters:

input - The only one input value.

Returns:

The result.

calcLong

public long calcLong(int input)

Calculates the expression with only one input. This is a simple variant for scaling values etc. It invokes internally calcDataAccess(Map, Object...) but without a access Map. It means it must not contain access to other data.

Parameters:

input - The only one input value.

Returns:

The result.

Oldcalc

public float Oldcalc(int input)

Calculates the expression with only one integer input.

Parameters:

input - The only one input value (used for all variables, simple version).

Returns:

The result.

calc

public CalculatorExpr.Value calc(java.lang.Object... args)

Calculates the expression with some inputs, often only 1 input. Before calculate, one should have defined the expression using setExpr(String) or setExpr(String, String[]) or via CalculatorExpr.SetExprBase.SetExpr. Calls then calcDataAccess(Data, Map, Object...) see there for argument args.

Parameters:

args - Array of some inputs

Returns:

The result of the expression.

calcDataAccess

public CalculatorExpr.Value calcDataAccess(java.util.Map<java.lang.String,DataAccess.Variable<java.lang.Object>> javaVariables,
                                           java.lang.Object... args)
                                    throws java.lang.Exception

Creates new CalculatorExpr.Data for calculation and calls calcDataAccess(Data, Map, Object...), see there

Parameters:

javaVariables -

args -

Returns:

Throws:

java.lang.Exception

calcDataAccess

public CalculatorExpr.Value calcDataAccess(CalculatorExpr.Data data,
                                           java.util.Map<java.lang.String,DataAccess.Variable<java.lang.Object>> javaVariables,
                                           java.lang.Object... args)
                                    throws java.lang.Exception

Calculates the expression with possible access to any stored object data with access via reflection.

Parameters:

data - re-used data instance (Stack and accu). Invoke

javaVariables - Any data which are access-able with its name. It is the first part of a datapath.

args - Some args given immediately. For example numerical args wrappend with Float etc or strings. Often not used. It is also possible that args has member as array, often an (numeric) array. Then it is simple to use values from the array. The index of this arguments are related to the 2. argument nameVariables in setExpr(String, Map, Class). Using this information the arguments have names. The linear index of the arguments is split to the index of the sub arrays. For example args has two sub arrays with 12 and 8 elements (of two different numerical types). Then ix=11 is [0][11] and ix=12 is [1][0] etc.

Returns:

The result wrapped with a Value instance. This Value contains also the type info.

Throws:

java.lang.Exception - Any exception is possible. Especially NoSuchFieldException or such if the access via reflection is done.

getValue

private CalculatorExpr.Value getValue(CalculatorExpr.Data data,
                                      CalculatorExpr.Operation oper,
                                      java.util.Map<java.lang.String,DataAccess.Variable<java.lang.Object>> javaVariables,
                                      java.lang.Object[] args)
                               throws java.lang.Exception

Throws:

java.lang.Exception

toString

public java.lang.String toString()

Overrides:

toString in class java.lang.Object

convertObj

static void convertObj(CalculatorExpr.Value val2jar,
                       java.lang.Object oval2)

debug

int debug()