java.lang.Object
- org.qdl_lang.evaluate.AbstractEvaluator
- - org.qdl_lang.evaluate.OpEvaluator

All Implemented Interfaces:

Serializable, EvaluatorInterface
```
public class OpEvaluator
extends AbstractEvaluator
```
Class charged with evaluating algebraic expressions.
Created by Jeff Gaynor
on 1/13/20 at 3:20 PM

See Also:

Serialized Form

Nested Class Summary
- Nested classes/interfaces inherited from class org.qdl_lang.evaluate.AbstractEvaluator
  AbstractEvaluator.CommonKeyIterator, AbstractEvaluator.fPointer, AbstractEvaluator.fpResult

Field Summary

Fields
Modifier and Type	Field	Description
`static String[]`	`ALL_MATH_OPS`	All Math operators.
`static ArrayList<String>`	`ALL_MONADS`
`static String`	`AND`
`static int`	`AND_VALUE`
`static String`	`AND2`
`static String`	`APPLY_OP_KEY`
`static int`	`APPLY_OP_VALUE`
`static String`	`ASSIGNMENT`
`static int`	`ASSIGNMENT_VALUE`
`static String`	`CEILING`
`static int`	`CEILING_VALUE`
`static String`	`CONTAINS_KEY`
`static int`	`CONTAINS_KEY_VALUE`
`static String`	`DIVIDE`
`static int`	`DIVIDE_VALUE`
`static String`	`DIVIDE2`
`static String`	`DOT`
`static int`	`DOT_VALUE`
`static String`	`EPSILON`
`static String`	`EPSILON_NOT`
`static int`	`EPSILON_NOT_VALUE`
`static int`	`EPSILON_VALUE`
`static String`	`EQUALS`
`static int`	`EQUALS_VALUE`
`static String`	`EQUALS2`
`static String`	`EXCISE`
`static int`	`EXCISE_VALUE`
`static String`	`EXPAND_OP_KEY`
`static int`	`EXPAND_OP_VALUE`
`static String`	`FLOOR`
`static int`	`FLOOR_VALUE`
`static String`	`FOR_ALL_KEY`
`static int`	`FOR_ALL_KEY_VALUE`
`static String`	`INTEGER_DIVIDE`
`static int`	`INTEGER_DIVIDE_VALUE`
`static String`	`INTERSECTION`
`static String`	`INTERSECTION_2`
`static int`	`INTERSECTION_VALUE`
`static String`	`IS_A`
`static int`	`IS_A_VALUE`
`static String`	`IS_DEFINED`
`static int`	`IS_DEFINED_VALUE`
`static String`	`IS_NOT_DEFINED`
`static int`	`IS_NOT_DEFINED_VALUE`
`static String`	`LESS_THAN`
`static String`	`LESS_THAN_EQUAL`
`static int`	`LESS_THAN_EQUAL_VALUE`
`static String`	`LESS_THAN_EQUAL2`
`static String`	`LESS_THAN_EQUAL3`
`static int`	`LESS_THAN_VALUE`
`static String`	`MASK_OP_KEY`
`static int`	`MASK_OP_VALUE`
`static String`	`MINUS`
`static String`	`MINUS_MINUS`
`static int`	`MINUS_MINUS_VALUE`
`static int`	`MINUS_VALUE`
`static String`	`MINUS2`
`static String`	`MORE_THAN`
`static String`	`MORE_THAN_EQUAL`
`static int`	`MORE_THAN_EQUAL_VALUE`
`static String`	`MORE_THAN_EQUAL2`
`static String`	`MORE_THAN_EQUAL3`
`static int`	`MORE_THAN_VALUE`
`static String`	`NOT`
`static String`	`NOT_CONTAINS_KEY`
`static int`	`NOT_CONTAINS_KEY_VALUE`
`static String`	`NOT_EQUAL`
`static int`	`NOT_EQUAL_VALUE`
`static String`	`NOT_EQUAL2`
`static int`	`NOT_VALUE`
`static String`	`NOT2`
`static String`	`NROOT`
`static int`	`NROOT_VALUE`
`static int`	`numericDigits`
`static ArrayList<String>`	`ONLY_MONADS`
`static String`	`OR`
`static int`	`OR_VALUE`
`static String`	`OR2`
`static String[]`	`OTHER_MATH_OPS`	This is for operators that are in the parser and never are created directly, e.g.
`static String`	`PLUS`
`static String`	`PLUS_PLUS`
`static int`	`PLUS_PLUS_VALUE`
`static int`	`PLUS_VALUE`
`static String`	`PLUS2`
`static String`	`POWER`
`static int`	`POWER_VALUE`
`static String`	`REDUCE_OP_KEY`
`static int`	`REDUCE_OP_VALUE`
`static String`	`REGEX_MATCH`
`static int`	`REGEX_MATCH_VALUE`
`static String`	`REGEX_MATCH2`
`static String`	`SYMMETRIC_DIFFERENCE`
`static String`	`TILDE`
`static String`	`TILDE_STILE`
`static int`	`TILDE_STILE_VALUE`
`static String`	`TILDE_STILE2`
`static int`	`TILDE_VALUE`
`static String`	`TIMES`
`static int`	`TIMES_VALUE`
`static String`	`TIMES2`
`static String`	`TO_SET`
`static int`	`TO_SET_VALUE`
`static String`	`TO_SET2`
`static String`	`TRANSPOSE_OP_KEY`
`static int`	`TRANSPOSE_OP_VALUE`
`static String`	`UNION`
`static String`	`UNION_2`
`static int`	`UNION_VALUE`

Fields inherited from class org.qdl_lang.evaluate.AbstractEvaluator
bigArgList, bigArgList0, FILE_OP_AUTO, FILE_OP_BINARY, FILE_OP_INPUT_STREAM, FILE_OP_TEXT_INI, FILE_OP_TEXT_STEM, FILE_OP_TEXT_STRING, FILE_OP_TEXT_WITHOUT_LIST_INI, fNames, MAX_ARG_COUNT

Fields inherited from interface org.qdl_lang.evaluate.EvaluatorInterface
UNKNOWN_VALUE

Constructor Summary

Constructors
Constructor Description

OpEvaluator()

Method Summary

All Methods Static Methods Instance Methods Concrete Methods
Modifier and Type	Method	Description
`protected QDLSet`	`applyToSet(QDLStem lArg, QDLSet rArg, QDLValue defaultValue, State state, Dyad dyad)`
`protected QDLStem`	`applyToStem(QDLStem lArg, QDLStem rArg, QDLValue defaultValue, State state, Dyad dyad)`
`boolean`	`dispatch(Polyad polyad, State state)`	Does the actual evaluation of the `Polyad`.
`protected void`	`doContainsKey(Dyad dyad, State state, boolean containsKey)`
`protected void`	`doDyadComparisonOperator(Dyad dyad, State state)`
`protected void`	`doDyadEqualsOperator(Dyad dyad, State state)`
`protected void`	`doDyadIntegerDivide(Dyad dyad, State state)`
`protected void`	`doDyadLogicalOperator(Dyad dyad, State state)`
`protected void`	`doDyadMinus(Dyad dyad, State state)`
`protected void`	`doDyadPlus(Dyad dyad, State state)`	For dyadic plus.
`protected void`	`doDyadTimesOrDivide(Dyad dyad, State state, boolean doTimes)`
`protected void`	`doIsDefinedDyad(Dyad dyad, State state, boolean isDefined)`
`protected void`	`doMonadicTilde(Monad monad, State state, boolean isStile)`
`protected void`	`doMonadIncOrDec(Monad monad, State state, boolean isPlusPlus)`	NOTE that at this point this only works for single variables -- you can't apply this to a stem.
`protected void`	`doMonadMinus(Monad monad, State state)`
`protected void`	`doMonadNot(Monad monad, State state)`
`protected void`	`doMonadPlus(Monad monad, State state)`
`protected void`	`doRegexMatch(Dyad dyad, State state)`	Contract is expression regex ≈ expression returns true if it matches expression as a string.
`protected void`	`doSetUnionOrInteresection(Dyad dyad, State state)`
`protected Object`	`doSingleApply(QDLValue lArg, DyadicFunctionReferenceNode fNode, QDLValue defaultValue, State state, Dyad dyad)`
`protected QDLValue`	`doSingleApply(QDLValue lArg, FunctionReferenceNode fNode, State actualState)`
`protected Object`	`doSingleApply(QDLValue lArg, FunctionReferenceNode fNode, QDLValue defaultValue, State state, Dyad dyad)`	apply the argument to a single function.
`protected void`	`doTilde(Dyad dyad, State state)`
`protected void`	`doUnaryPlusMinus(Monad monad, State state, Long sign)`	This will evaluate the expression and take its opposite.
`void`	`evaluate(Dyad dyad, State state)`
`void`	`evaluate(Monad monad, State state)`
`void`	`evaluate(Nilad nilad, State state)`
`boolean`	`evaluate(Polyad polyad, State state)`	Decides if a `Polyad` is evaluated by this evaluator and if not, returns false, if so, it evaluates it and returns true.
`void`	`evaluate2(Dyad dyad, State state)`
`void`	`evaluate2(Monad monad, State state)`
`protected Object`	`evaluateNextArgForApplies(QDLValue lArg, Object rArg, QDLValue defaultValue, State state, Dyad dyad)`
`int[]`	`getArgCount(String name)`	Return the arg counts for an operator.
`String[]`	`getFunctionNames()`
`static MathContext`	`getMathContext()`
`String`	`getNamespace()`
`static int`	`getNumericDigits()`
`int`	`getType(String oo)`	Given an operator, this will return the integer value associated with it for lookups later.
`boolean`	`isMathOperator(String x)`
`TreeSet<String>`	`listFunctions(boolean listFQ)`	No listing for these yet since they are not the standard func() pattern, e.g.
`static void`	`setNumericDigits(int newNumericDigits)`

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Field Detail
- AND
```
public static final String AND
```
  See Also:
  
  Constant Field Values
- AND2
```
public static final String AND2
```
  See Also:
  
  Constant Field Values
- ASSIGNMENT
```
public static final String ASSIGNMENT
```
  See Also:
  
  Constant Field Values
- CEILING
```
public static final String CEILING
```
  See Also:
  
  Constant Field Values
- DIVIDE
```
public static final String DIVIDE
```
  See Also:
  
  Constant Field Values
- DIVIDE2
```
public static final String DIVIDE2
```
  See Also:
  
  Constant Field Values
- EQUALS
```
public static final String EQUALS
```
  See Also:
  
  Constant Field Values
- EQUALS2
```
public static final String EQUALS2
```
  See Also:
  
  Constant Field Values
- EXCISE
```
public static final String EXCISE
```
  See Also:
  
  Constant Field Values
- FLOOR
```
public static final String FLOOR
```
  See Also:
  
  Constant Field Values
- INTEGER_DIVIDE
```
public static final String INTEGER_DIVIDE
```
  See Also:
  
  Constant Field Values
- SYMMETRIC_DIFFERENCE
```
public static final String SYMMETRIC_DIFFERENCE
```
  See Also:
  
  Constant Field Values
- LESS_THAN
```
public static final String LESS_THAN
```
  See Also:
  
  Constant Field Values
- LESS_THAN_EQUAL
```
public static final String LESS_THAN_EQUAL
```
  See Also:
  
  Constant Field Values
- LESS_THAN_EQUAL2
```
public static final String LESS_THAN_EQUAL2
```
  See Also:
  
  Constant Field Values
- LESS_THAN_EQUAL3
```
public static final String LESS_THAN_EQUAL3
```
  See Also:
  
  Constant Field Values
- MINUS
```
public static final String MINUS
```
  See Also:
  
  Constant Field Values
- MINUS2
```
public static final String MINUS2
```
  See Also:
  
  Constant Field Values
- MINUS_MINUS
```
public static final String MINUS_MINUS
```
  See Also:
  
  Constant Field Values
- MORE_THAN
```
public static final String MORE_THAN
```
  See Also:
  
  Constant Field Values
- MORE_THAN_EQUAL
```
public static final String MORE_THAN_EQUAL
```
  See Also:
  
  Constant Field Values
- MORE_THAN_EQUAL2
```
public static final String MORE_THAN_EQUAL2
```
  See Also:
  
  Constant Field Values
- MORE_THAN_EQUAL3
```
public static final String MORE_THAN_EQUAL3
```
  See Also:
  
  Constant Field Values
- NOT
```
public static final String NOT
```
  See Also:
  
  Constant Field Values
- NOT2
```
public static final String NOT2
```
  See Also:
  
  Constant Field Values
- NOT_EQUAL
```
public static final String NOT_EQUAL
```
  See Also:
  
  Constant Field Values
- NOT_EQUAL2
```
public static final String NOT_EQUAL2
```
  See Also:
  
  Constant Field Values
- OR
```
public static final String OR
```
  See Also:
  
  Constant Field Values
- OR2
```
public static final String OR2
```
  See Also:
  
  Constant Field Values
- PLUS
```
public static final String PLUS
```
  See Also:
  
  Constant Field Values
- PLUS2
```
public static final String PLUS2
```
  See Also:
  
  Constant Field Values
- PLUS_PLUS
```
public static final String PLUS_PLUS
```
  See Also:
  
  Constant Field Values
- POWER
```
public static final String POWER
```
  See Also:
  
  Constant Field Values
- NROOT
```
public static final String NROOT
```
  See Also:
  
  Constant Field Values
- UNION
```
public static final String UNION
```
  See Also:
  
  Constant Field Values
- UNION_2
```
public static final String UNION_2
```
  See Also:
  
  Constant Field Values
- INTERSECTION
```
public static final String INTERSECTION
```
  See Also:
  
  Constant Field Values
- INTERSECTION_2
```
public static final String INTERSECTION_2
```
  See Also:
  
  Constant Field Values
- TILDE
```
public static final String TILDE
```
  See Also:
  
  Constant Field Values
- TILDE_STILE
```
public static final String TILDE_STILE
```
  See Also:
  
  Constant Field Values
- TILDE_STILE2
```
public static final String TILDE_STILE2
```
  See Also:
  
  Constant Field Values
- TIMES
```
public static final String TIMES
```
  See Also:
  
  Constant Field Values
- TIMES2
```
public static final String TIMES2
```
  See Also:
  
  Constant Field Values
- DOT
```
public static final String DOT
```
  See Also:
  
  Constant Field Values
- REGEX_MATCH
```
public static final String REGEX_MATCH
```
  See Also:
  
  Constant Field Values
- REGEX_MATCH2
```
public static final String REGEX_MATCH2
```
  See Also:
  
  Constant Field Values
- TO_SET
```
public static final String TO_SET
```
  See Also:
  
  Constant Field Values
- TO_SET2
```
public static final String TO_SET2
```
  See Also:
  
  Constant Field Values
- EPSILON
```
public static final String EPSILON
```
  See Also:
  
  Constant Field Values
- EPSILON_NOT
```
public static final String EPSILON_NOT
```
  See Also:
  
  Constant Field Values
- IS_A
```
public static final String IS_A
```
  See Also:
  
  Constant Field Values
- IS_DEFINED
```
public static final String IS_DEFINED
```
  See Also:
  
  Constant Field Values
- IS_NOT_DEFINED
```
public static final String IS_NOT_DEFINED
```
  See Also:
  
  Constant Field Values
- CONTAINS_KEY
```
public static final String CONTAINS_KEY
```
  See Also:
  
  Constant Field Values
- NOT_CONTAINS_KEY
```
public static final String NOT_CONTAINS_KEY
```
  See Also:
  
  Constant Field Values
- FOR_ALL_KEY
```
public static final String FOR_ALL_KEY
```
  See Also:
  
  Constant Field Values
- MASK_OP_KEY
```
public static final String MASK_OP_KEY
```
  See Also:
  
  Constant Field Values
- TRANSPOSE_OP_KEY
```
public static final String TRANSPOSE_OP_KEY
```
  See Also:
  
  Constant Field Values
- REDUCE_OP_KEY
```
public static final String REDUCE_OP_KEY
```
  See Also:
  
  Constant Field Values
- EXPAND_OP_KEY
```
public static final String EXPAND_OP_KEY
```
  See Also:
  
  Constant Field Values
- APPLY_OP_KEY
```
public static final String APPLY_OP_KEY
```
  See Also:
  
  Constant Field Values
- ASSIGNMENT_VALUE
```
public static final int ASSIGNMENT_VALUE
```
  See Also:
  
  Constant Field Values
- PLUS_VALUE
```
public static final int PLUS_VALUE
```
  See Also:
  
  Constant Field Values
- MINUS_VALUE
```
public static final int MINUS_VALUE
```
  See Also:
  
  Constant Field Values
- PLUS_PLUS_VALUE
```
public static final int PLUS_PLUS_VALUE
```
  See Also:
  
  Constant Field Values
- MINUS_MINUS_VALUE
```
public static final int MINUS_MINUS_VALUE
```
  See Also:
  
  Constant Field Values
- AND_VALUE
```
public static final int AND_VALUE
```
  See Also:
  
  Constant Field Values
- OR_VALUE
```
public static final int OR_VALUE
```
  See Also:
  
  Constant Field Values
- EQUALS_VALUE
```
public static final int EQUALS_VALUE
```
  See Also:
  
  Constant Field Values
- NOT_EQUAL_VALUE
```
public static final int NOT_EQUAL_VALUE
```
  See Also:
  
  Constant Field Values
- LESS_THAN_VALUE
```
public static final int LESS_THAN_VALUE
```
  See Also:
  
  Constant Field Values
- LESS_THAN_EQUAL_VALUE
```
public static final int LESS_THAN_EQUAL_VALUE
```
  See Also:
  
  Constant Field Values
- MORE_THAN_VALUE
```
public static final int MORE_THAN_VALUE
```
  See Also:
  
  Constant Field Values
- MORE_THAN_EQUAL_VALUE
```
public static final int MORE_THAN_EQUAL_VALUE
```
  See Also:
  
  Constant Field Values
- NOT_VALUE
```
public static final int NOT_VALUE
```
  See Also:
  
  Constant Field Values
- TIMES_VALUE
```
public static final int TIMES_VALUE
```
  See Also:
  
  Constant Field Values
- DIVIDE_VALUE
```
public static final int DIVIDE_VALUE
```
  See Also:
  
  Constant Field Values
- POWER_VALUE
```
public static final int POWER_VALUE
```
  See Also:
  
  Constant Field Values
- INTEGER_DIVIDE_VALUE
```
public static final int INTEGER_DIVIDE_VALUE
```
  See Also:
  
  Constant Field Values
- TILDE_VALUE
```
public static final int TILDE_VALUE
```
  See Also:
  
  Constant Field Values
- DOT_VALUE
```
public static final int DOT_VALUE
```
  See Also:
  
  Constant Field Values
- TILDE_STILE_VALUE
```
public static final int TILDE_STILE_VALUE
```
  See Also:
  
  Constant Field Values
- REGEX_MATCH_VALUE
```
public static final int REGEX_MATCH_VALUE
```
  See Also:
  
  Constant Field Values
- UNION_VALUE
```
public static final int UNION_VALUE
```
  See Also:
  
  Constant Field Values
- INTERSECTION_VALUE
```
public static final int INTERSECTION_VALUE
```
  See Also:
  
  Constant Field Values
- FLOOR_VALUE
```
public static final int FLOOR_VALUE
```
  See Also:
  
  Constant Field Values
- CEILING_VALUE
```
public static final int CEILING_VALUE
```
  See Also:
  
  Constant Field Values
- TO_SET_VALUE
```
public static final int TO_SET_VALUE
```
  See Also:
  
  Constant Field Values
- EPSILON_VALUE
```
public static final int EPSILON_VALUE
```
  See Also:
  
  Constant Field Values
- EPSILON_NOT_VALUE
```
public static final int EPSILON_NOT_VALUE
```
  See Also:
  
  Constant Field Values
- IS_A_VALUE
```
public static final int IS_A_VALUE
```
  See Also:
  
  Constant Field Values
- IS_DEFINED_VALUE
```
public static final int IS_DEFINED_VALUE
```
  See Also:
  
  Constant Field Values
- IS_NOT_DEFINED_VALUE
```
public static final int IS_NOT_DEFINED_VALUE
```
  See Also:
  
  Constant Field Values
- CONTAINS_KEY_VALUE
```
public static final int CONTAINS_KEY_VALUE
```
  See Also:
  
  Constant Field Values
- NOT_CONTAINS_KEY_VALUE
```
public static final int NOT_CONTAINS_KEY_VALUE
```
  See Also:
  
  Constant Field Values
- FOR_ALL_KEY_VALUE
```
public static final int FOR_ALL_KEY_VALUE
```
  See Also:
  
  Constant Field Values
- MASK_OP_VALUE
```
public static final int MASK_OP_VALUE
```
  See Also:
  
  Constant Field Values
- TRANSPOSE_OP_VALUE
```
public static final int TRANSPOSE_OP_VALUE
```
  See Also:
  
  Constant Field Values
- REDUCE_OP_VALUE
```
public static final int REDUCE_OP_VALUE
```
  See Also:
  
  Constant Field Values
- EXPAND_OP_VALUE
```
public static final int EXPAND_OP_VALUE
```
  See Also:
  
  Constant Field Values
- APPLY_OP_VALUE
```
public static final int APPLY_OP_VALUE
```
  See Also:
  
  Constant Field Values
- NROOT_VALUE
```
public static final int NROOT_VALUE
```
  See Also:
  
  Constant Field Values
- EXCISE_VALUE
```
public static final int EXCISE_VALUE
```
  See Also:
  
  Constant Field Values
- OTHER_MATH_OPS
```
public static String[] OTHER_MATH_OPS
```
  This is for operators that are in the parser and never are created directly, e.g. → or #. "->"
- ALL_MATH_OPS
```
public static String[] ALL_MATH_OPS
```
  All Math operators. These are used in function references.
- ALL_MONADS
```
public static ArrayList<String> ALL_MONADS
```
- ONLY_MONADS
```
public static ArrayList<String> ONLY_MONADS
```
- numericDigits
```
public static int numericDigits
```

Constructor Detail
- OpEvaluator
```
public OpEvaluator()
```

Method Detail

getArgCount
```
public int[] getArgCount(String name)
```
Return the arg counts for an operator.

Parameters:

name -

Returns:

getNamespace
```
public String getNamespace()
```

isMathOperator

public boolean isMathOperator(String x)

getFunctionNames
```
public String[] getFunctionNames()
```
Specified by:

getFunctionNames in class AbstractEvaluator

getMathContext

public static MathContext getMathContext()

getNumericDigits
```
public static int getNumericDigits()
```

setNumericDigits

public static void setNumericDigits(int newNumericDigits)

listFunctions
```
public TreeSet<String> listFunctions(boolean listFQ)
```
No listing for these yet since they are not the standard func() pattern, e.g. a < b.

Specified by:

listFunctions in interface EvaluatorInterface

Overrides:

listFunctions in class AbstractEvaluator

Returns:

getType
```
public int getType(String oo)
```
Given an operator, this will return the integer value associated with it for lookups later. ExpressionNodes store the value, not the operator.

Parameters:

oo -

Returns:

evaluate

public void evaluate(Dyad dyad,
                     State state)

evaluate2

public void evaluate2(Dyad dyad,
                      State state)

applyToSet

protected QDLSet applyToSet(QDLStem lArg,
                            QDLSet rArg,
                            QDLValue defaultValue,
                            State state,
                            Dyad dyad)

evaluateNextArgForApplies

protected Object evaluateNextArgForApplies(QDLValue lArg,
                                           Object rArg,
                                           QDLValue defaultValue,
                                           State state,
                                           Dyad dyad)

applyToStem

protected QDLStem applyToStem(QDLStem lArg,
                              QDLStem rArg,
                              QDLValue defaultValue,
                              State state,
                              Dyad dyad)

doSingleApply

protected Object doSingleApply(QDLValue lArg,
                               DyadicFunctionReferenceNode fNode,
                               QDLValue defaultValue,
                               State state,
                               Dyad dyad)

doSingleApply

protected Object doSingleApply(QDLValue lArg,
                               FunctionReferenceNode fNode,
                               QDLValue defaultValue,
                               State state,
                               Dyad dyad)

apply the argument to a single function. Note that the dyad here is passed along to make error messages only.

Parameters:: fNode -; dyad -
Returns:

doSingleApply

protected QDLValue doSingleApply(QDLValue lArg,
                                 FunctionReferenceNode fNode,
                                 State actualState)

doContainsKey

protected void doContainsKey(Dyad dyad,
                             State state,
                             boolean containsKey)

doIsDefinedDyad

protected void doIsDefinedDyad(Dyad dyad,
                               State state,
                               boolean isDefined)

doRegexMatch
```
protected void doRegexMatch(Dyad dyad,
                            State state)
```
Contract is expression regex ≈ expression returns true if it matches expression as a string.

Parameters:

dyad -

state -

doTilde

protected void doTilde(Dyad dyad,
                       State state)

doDyadIntegerDivide

protected void doDyadIntegerDivide(Dyad dyad,
                                   State state)

doDyadComparisonOperator

protected void doDyadComparisonOperator(Dyad dyad,
                                        State state)

doDyadEqualsOperator

protected void doDyadEqualsOperator(Dyad dyad,
                                    State state)

doSetUnionOrInteresection

protected void doSetUnionOrInteresection(Dyad dyad,
                                         State state)

doDyadLogicalOperator

protected void doDyadLogicalOperator(Dyad dyad,
                                     State state)

doDyadMinus

protected void doDyadMinus(Dyad dyad,
                           State state)

doDyadTimesOrDivide

protected void doDyadTimesOrDivide(Dyad dyad,
                                   State state,
                                   boolean doTimes)

doDyadPlus

protected void doDyadPlus(Dyad dyad,
                          State state)

For dyadic plus.

Parameters:: dyad -; state -

evaluate

public void evaluate(Monad monad,
                     State state)

evaluate2

public void evaluate2(Monad monad,
                      State state)

doMonadicTilde

protected void doMonadicTilde(Monad monad,
                              State state,
                              boolean isStile)

doMonadIncOrDec

protected void doMonadIncOrDec(Monad monad,
                               State state,
                               boolean isPlusPlus)

NOTE that at this point this only works for single variables -- you can't apply this to a stem.

Parameters:: monad -; state -; isPlusPlus -

doMonadNot

protected void doMonadNot(Monad monad,
                          State state)

doUnaryPlusMinus
```
protected void doUnaryPlusMinus(Monad monad,
                                State state,
                                Long sign)
```
This will evaluate the expression and take its opposite. This is because the parser does not differentiate between -3^4 and (-3)^4, turing the first of each into a single monad. It works right if there are parentheses, but this is possible a thronier issue to fix than we want now. Best to ket it do this since algebraic operations work as expected.

Parameters:

monad -

state -

sign -

doMonadPlus

protected void doMonadPlus(Monad monad,
                           State state)

doMonadMinus

protected void doMonadMinus(Monad monad,
                            State state)

evaluate

public void evaluate(Nilad nilad,
                     State state)

evaluate
```
public boolean evaluate(Polyad polyad,
                        State state)
```
Description copied from class: AbstractEvaluator

Decides if a Polyad is evaluated by this evaluator and if not, returns false, if so, it evaluates it and returns true. This function actually just dispatches it to AbstractEvaluator.dispatch(Polyad, State) where the work is done and manages putting better trace information in if there is a failure.

Overrides:

evaluate in class AbstractEvaluator

Returns:

dispatch
```
public boolean dispatch(Polyad polyad,
                        State state)
```
Description copied from class: AbstractEvaluator

Does the actual evaluation of the Polyad.

Specified by:

dispatch in class AbstractEvaluator

Returns:

Class OpEvaluator

Nested Class Summary

Nested classes/interfaces inherited from class org.qdl_lang.evaluate.AbstractEvaluator

Field Summary

Fields inherited from class org.qdl_lang.evaluate.AbstractEvaluator

Fields inherited from interface org.qdl_lang.evaluate.EvaluatorInterface

Constructor Summary

Method Summary

Methods inherited from class org.qdl_lang.evaluate.AbstractEvaluator

Methods inherited from class java.lang.Object

Field Detail

AND

AND2

ASSIGNMENT

CEILING

DIVIDE

DIVIDE2

EQUALS

EQUALS2

EXCISE

FLOOR

INTEGER_DIVIDE

SYMMETRIC_DIFFERENCE

LESS_THAN

LESS_THAN_EQUAL

LESS_THAN_EQUAL2

LESS_THAN_EQUAL3

MINUS

MINUS2

MINUS_MINUS

MORE_THAN

MORE_THAN_EQUAL

MORE_THAN_EQUAL2

MORE_THAN_EQUAL3

NOT

NOT2

NOT_EQUAL

NOT_EQUAL2

OR

OR2

PLUS

PLUS2

PLUS_PLUS

POWER

NROOT

UNION

UNION_2

INTERSECTION

INTERSECTION_2

TILDE

TILDE_STILE

TILDE_STILE2

TIMES

TIMES2

DOT

REGEX_MATCH

REGEX_MATCH2

TO_SET

TO_SET2

EPSILON

EPSILON_NOT

IS_A

IS_DEFINED

IS_NOT_DEFINED

CONTAINS_KEY

NOT_CONTAINS_KEY

FOR_ALL_KEY

MASK_OP_KEY

TRANSPOSE_OP_KEY

REDUCE_OP_KEY

EXPAND_OP_KEY

APPLY_OP_KEY

ASSIGNMENT_VALUE

PLUS_VALUE

MINUS_VALUE

PLUS_PLUS_VALUE

MINUS_MINUS_VALUE

AND_VALUE

OR_VALUE

EQUALS_VALUE