All Classes and Interfaces
Class
Description
Absolute value function.
Unit tests for the
Abs function.An abstract base class providing scaling and double buffering support for
Canvas components.
Base class for pre and post increment operators.
Addition function.
A FunctionGrammarMatcher that works with
AlternateFunctions
and OverloadedFunctionByStructure selecting the function
at parse time.Tests for
AlternateFunctionGrammerMatcherAllows function to be overloaded with multiple candidate functions chosen by the number of arguments.
Tests for
AlternateFunctionsThe acos function.
The inverse hyperbolic cos function
acosh(x).The inverse sin function
arcsin(x).Implements the arcSinH function.
The arctan function
atan2(y, x) Returns the angle whose tangent is y/x.
Implements the arcTanH function.
Argument of a complex number
Matches syntax for array element access a[3].
Base class for functions that operate on arrays such as Average, MinMax,
and VSum.
An assignment operator so we can do
x=3+4.A list than can be assigned to
[x,y,z] = [1,2,3].Tesf for
AssignableList function.A Constant Node.
Function Node
Represents an operator like
+.Start Node
Variable Node
Average function class, calculates the average of all its arguments.
Absolute value function for BigDecimals, Double and other Number types.
Function class for the addition operator.
Tests for
BigDecAdd.A set of components for working with big decimal numbers.
Division function for BigDecimals, Double and other Number types.
A function table for BigDecimals.
A console using
BigDecimal for calculations.Tests for the
BigDecimalConsoleClasses relating to "Arrays in Jep Java" Q on forum 2022/08/22
asking about operations on
List<BigDecimal> JepTests using BigDecimals
Tests the BigDecComponents through a set of test expressions that are evaluated.
Modulus function for BigDecimals, Double and other Number types.
Multiplication function for BigDecimals, Double and other Number types.
Tests for
BigDecAdd.Unary minus negation function for BigDecimals.
A NumberFactory producing BigDecimal objects.
A set of operators for using BigDecimal numbers
Power function for BigDecimals, Double and other Number types.
Implements the relational operations <, >, <=, >=, !
Tests for
BigDecRelationalRounding functions for BigDecimals.
Rounding functions to round to a specific number of significant figures.
Tests for
BigDecRoundThe signum function for BigDecimals.
Subtraction function for BigDecimals, Double and other Number types.
A version of the comparative operator which breaks ties between two
BigDecimal numbers representing the same value with different precisions,
here for the LT operation 2.0 < 2.00 and for the GT operation
2.00 > 2.0.
Sum function, expanding its arguments together.
Convenient base class for binary functions.
FunctionalInterface for the
BinaryFunction.instanceOf(Class, BiFunctionWithException) method.Binomial coefficients: binom(n,i).
Bitwise And, like the java
a & b operator.Unary bitwise complement, like the java ~a operator.
Bitwise Or, like the java a | b operator.
An operator table with a selection of bitwise operators.
Keys to identify the bitwise operators.
Bitwise Xor, like the java a ^ b operator.
A variable bound to an object outside Jep.
A variable factory for creating bound variables.
Tests using the
BoundVariableFactory.Object bound to variables in this test.
A GrammarMatcher which matches lists of items with the syntax
or a simple list
[1,2,3,4].This class is intended to contain all tests related to reported bugs.
A matcher for mumbers with commas in them,
1,000,000Class to hold a number with a unit.
TokenMatcher used to match a number with a unit.
Functions which require greater control over their evaluation should implement this interface.
A case statement.
Action to take if first argument is null.
A version of a function table which is case-insensitive.
An IdentifierTokenMatcher that converts all identifier tokens to lowercase.
A Variable table which ignores case.
A case statement.
Action to take if first argument is null.
Unit tests for
Case, Switch, SwitchDefault,
and non lazy versions CaseNonLazy, SwitchNonLazy, SwitchDefaultNonLazy.A PostfixMathCommandI which find the smallest integer above the number
ceil(pi) give 4
ceil(-i) give -3
Creates VariableBinding objects by translating the variable name into a chain of object references.
This interface describes a character stream that maintains line and
column number positions of the characters.
Clears the map.
Tokens representing comments.
Matches various styles of comments.
Common classes for overload function tests.
Implements the comparative operations <, >, <=, >=, !
Tests for
ComparativeRepresents a complex number with double precision real and imaginary
components.
An immutable version of the Complex class.
Converts a pair of real numbers to a complex number Complex(x,y)=x+i y.
Test for
Complex.Collects all the components which make up the Jep system.
Represent an incomplete set of components.
Concatenates string arguments.
A variable table backed by a ConcurrentHashMap that is safe for concurrent
access.
Tests for the
ConcurrentVariableTableA configurable parser.
Unit tests for the
StandardConfigurableParserA modified version of the
StandardConfigurableParser
which includes a grammar matcher for matching lists [1,2,3] and ranges [1..10].The complex conjugate of a number conj(c)
This class implements a simple command line utility for evaluating
mathematical expressions.
Values returned by
Console.testSpecialCommands(String command).Test for the
ConsoleFunctions which always return a constant value.
Tests if the map contains a given key.
The cosec function
The cos function
The hyperbolic cosine function
The cotangent function.
Count the number of elements in a list.
A console that uses the
StandardConfigurableParser.Tests for the
CPConsoleTests for the configurable parser.
Tests for the configurable parser.
The cross product of two 3D vectors.
A VariableTable that can optionally decorate another variable table.
A Visitor which returns an exact copy of the tree.
Test various features until failure.
A set of components for parsing and operating on associative arrays.
Keys for the two operators used to build maps.
Type of configuration.
A GrammarMatcher for JSON like map syntax.
Type of matcher.
Abstract base class for test for the
com.singularsys.jep.misc.dictionary package.Represents a key value pair
Abstract base class for test for the
com.singularsys.jep.misc.dictionary package
with options allowing null values.Test for the
com.singularsys.jep.misc.dictionary package with LIST_REQUIRE_VALUESTest for the
com.singularsys.jep.misc.dictionary package with LIST_MISSING_VALUESTest for the
com.singularsys.jep.misc.dictionary package with MAP_MISSING_VALUESDivision of two arguments.
A Visitor which visits each node of an expression tree and does nothing.
The dot product of two vectors.
Default class for creating number objects.
Class to handle externalized messages for the jep examples package.
Function which allows array access using the a[3] notation on left and
right-hand side.
Tests if the first argument is in a set of values given in subsequent arguments.
Tests for
EleA base class for operator tables, this class has no pre-defined operators.
All operators enums must implement this interface.
Test for the
EmptyOperatorTable.Return the entries of a map a nested list
of key-value pairs.
Return an
Iterable<Vector<Object>> for the entries of a map.Evaluates an expression
nIterations times.Exceptions thrown during evaluation.
Defines a method which can be used to evaluate a part of a node-tree.
This application is a simple graphical example for how Jep can be used to evaluate
expressions.
Class to examine the results types of the various operators
and function.
Used to examine the memory used to initialise a Jep instance.
The exp function.
An
var[index] function whose ExpandingEle.set(Evaluator, Node, Object) method
modifies and expands the Vector<Object> value of the variable.Test for
ExpandingEle.Consolidates nested addition and multiplication to produce nary operators.
This class is designed for testing the validity of Jep evaluations.
An example of an OperatorSet which adds
suffix operators: n!
Keys for the new operators.
Tests for modification to the configurable parser.
Simple implementation of factorial, good up to 20!
A fast evaluator for Jep expressions.
The versions of the FastEvaluator in Jep 3.4.
The versions of the FastEvaluator in Jep 3.5.
A
VariableBinding which binds variables to a particular field of an object.Functions, operators and components that support fixed precision operations.
A PostfixMathCommandI which find the largest integer above the number
floor(pi) give 3
floor(-i) give -4
Application which calculates fractals using a multithreaded system.
This class performs the drawing of the fractal, using a number of
threads/runnables to compute the image in chunks.
PostfixMathCommand which converts a string to a number in a given base.
This class plots a graph using the Jep API.
Tests for functions created by
BinaryFunction.instanceOf(com.singularsys.jep.functions.BinaryFunction.BiFunctionWithException)
etc.A GrammarMatcher which matches functions in the form 'atan2(y,x)'.
This application is a demonstration of the possible use of the Jep
mathematical expression parser.
A GrammarMatcher which matches functions in the form
atan2(seq) where
seq is a sequence of terms.Holds a set of functions.
Tests affect of overloading functions
Tests the standard functions to ensure they all work with custom types extending Number.
A table holding details of the functions known to Jep.
A token representing a function name.
A Visitor which returns an exact copy of the tree,
creating new nodes for each type.
A Visitor which visits each node, typically return the
original node.
A generic version of the
ParserVisitor
allowing the return type, data parsed and exception type to be specified.Gets the value associated with a key.
Gets the value associated with a key, or a default value.
Signals grammatical errors.
Interface defining matchers for custom grammatical elements.
Interface used by
GrammarMatcherAbstract Factory defining how to create a GrammarParser
Matches hexadecimal numbers, in the format 0xff.
Remove a specific hook from any node which has it on a tree
Test for
HookRemover.Token representing variables or function.
Matches identifiers: variables or function names.
Test the various types of identifier matchers
A Unary operator which does nothing, used for unary plus +x.
The if(condExpr, posExpr, negExpr) function.
Represents an illegal parameter
Finds the imaginary part of a complex number.
An Immutable version of the Complex numbers.
Imports an expression from one Jep instance into another.
Tests if a double value is infinite.
Tests if a double value is NaN.
Tests if a null value is encountered.
Tests if a value is an instance of a specified type.
An operator table which supports most of the operators which appear in Java.
Keys to identify the Java operators.
Matches syntax for array element access
v[3],
the node tree produced by this matcher matches those
produced by the standard Jep JccParser.Token literal values and constants.
Token Manager.
The Jep class is the main interface with which the user should
interact.
Base interface for all Jep components (parsers, evaluators etc).
Super class of all Jep specific exceptions.
Customised version of the JavaCharStream.
Class to handle externalisation of error messages.
A RuntimeException which wraps a JepException for use in cases where
throwing a JepException is not possible.
Tests various functions on the Jep class.
NaryFunction to add fractions
Function to add fractions using a stack
Function for diference of two variables.
A binary function
An Nary function
An NaryBinary function
A nullary functions
A unary function
Real nullay function
Product of values
Square of value
JepTests using a ccustom number type.
A custom number type, simple wrapps a double.
Unit tests for the main
Jep class.Return the keys of a map a nested list
of key-value pairs.
Return an
Iterable<Object> for the keys of a map.Tests printing is psudo latex syntax.
Prints a function with optional brackets.
A version of the logical operators which use lazy evaluation.
Extract the left most n characters from a string: left("abcdefg",2) -> "ab"
If n is greater than the length of the string return the full string.
If n is less than zero an EvaluationException is thrown.
If the first argument is not a string an EvaluationException is thrown.
If the second argument is not a number representing an integer an EvaluationException is thrown.
Returns the length of a string: len("hello") -> 5
A lightweight set of components reusing components from an existing Jep instance.
Tests for the
LightWeightComponentSet
See https://ar.trac.cloudforge.com/jep/ticket/175A variant off the
ImportationVisitor
that uses either the same pfmc for a node
or its getLightWeightInstance() if the function implements
JepComponent.A NodeFactory which adds line numbering information to nodes.
Keys for storing line and column numbers in nodes
Version of the shunting yard algorithm which sets lines numbers in the parse tree.
Factory for creating
LineNumberingShuntingYard instances.Test for the
LineNumberingNodeFactoryTest for the
LineNumberingNodeFactory.The list function.
A GrammarMatcher which matches lists of items.
A GrammarMatcher which matches overloaded lists of items or brackets.
A GrammarMatcher which matches lists of items with the syntax
[a..b],
or a simple list [1,2,3,4].Log base 10.
Tess for
LogarithmLog base 2.
Logical operators
AND and OR.Logarithm function where the base is specified in the second argument.
An iterator which stores the next two tokens.
A subclass of a Lookahead2Iterator which allows any number of character of lookahead.
Convert a string to lowercase
Bitwise Left shift, like the java a << b operator.
An interface for functions which can be used on the left-hand side of an assignment.
A function specified by a string.
Tests for
MacroFunctionCreate a map of a given type, either
creates an empty map or uses a list or map of data.
Configuration type.
PostfixMathCommand for creating a
Map.Value returned for an individual map entry.
PostfixMathCommand for individual entries
A medium weight set of components reusing components from an existing Jep instance.
This class should print out all messages produced by Jep.
Extract substring of first argument:
mid("abcdefg",2,3) -> "cde"
Syntax: mid(str,start,len)
Second argument is starting index, with the first character being at index 0.Minimum and Maximum functions.
Type of MinMax function, used to make construct clearer.
Tests for various custom grammars.
Simple test class of a function which returns an array.
A subclass of the ShuntingYard which can parse various forms of list element access.
Factory to create SuffixArrayAccessShuntingYard
A rule to correctly print suffix array access expressions
Calculates the modulus x % y of the arguments.
A subclass of FastEvaluator that monitors the number of times
each function, operator, variable, and constant is called during evaluation.
Functional interface for functions to be measured.
The type of monitoring to perform.
Matches tokens which span multiple lines of the input.
A token representing a token which spans multiple lines.
A parser which can be used to parse multiple expressions in sequence.
A Jep which uses a
ParallelConfigurableParser
providing implementations of the
Jep.initMultiParse(java.io.Reader) and MultipleEquationParsingJep.continueParsing() methods.The multiplication function.
A simple Mutable Double class.
Convenient base class for n-ary functions backed by a binary operation.
Tests for
Add using the multiple arguments.Convenient base class for nary functions.
Natural logarithm.
Tests for
NaturalLogarithm.Interface defining a node in the parse-tree.
Nodes can optional have hooks which add meta-data to the node.
This class is used to create nodes of specified types.
Unit tests for the
NodeFactory.Tests for adding hooks to nodes.
Implementation of the not function.
Convenient base class for zero-argument nullary functions, like
random().FunctionalInterface for the
BinaryFunction.instanceOf(Class, BiFunctionWithException) method.A Parser which cannot actually parse expressions.
The Null Safe equals function.
Null wrapped version of the AbstractInc functions.
Null wrapped version of a binary function.
A factory to create the appropriate type of wrapped function.
Indicate that the function handles nulls.
A function table which wraps all the functions in an existing table.
NullWrapped version of the if function.
Null wrapped versions of the LazyLogical functions.
Wrap an NaryFunction with a new function so that if any argument is null, then null is returned.
Wrap a NaryBinaryFunction so that if any argument is null then null is returned.
An operator table where the operators generally return null if either argument is null.
Key for the one operator NullSafeEquals added by the table.
Functions/operators which are not wrapped in the NullWrappedFunctionTable.
Wrap a general PostfixMathCommand so that if any argument is null the function will return null.
Null wrapped version of a unary function.
Tests using the
nullwapper package.A binary function
An nary function
An nary binary function
A simple multi arg function.
A unary function
This interface can be implemented to create numbers of any object type.
Represent numbers.
Matches numbers.
Components are are initialised only once.
Function implementing compound assignment operators such as
+=, *= etc.An Operator with additional information about its commutativity etc.
A GrammarMatcher which matches functions in the form '
+(x,y)' where + is an operator.
Test standard operators using
List.Base class for the older style Operator table.
The basic set of operators provided as standard by Jep.
The basic arithmetic comparative and logical operators
Operators which do not correspond to
Special purpose operators
Interface for all OperatorTables.
A token representing an operator.
TokenMatcher for matching operators from the operator set.
Allows function to be overloaded with two candidate functions
and a predicate that tests the values of the arguments
to see which function should be applied.
Tests for
OverloadedBinaryFunctionAllows function to be overloaded with two candidate functions
and a predicate that tests the structure of the parse tree
to see which function should be applied.
Tests for
OverloadedFunctionByStructureAllows function to be overloaded with two candidate functions
and a predicate that tests the values of the arguments
to see which function should be applied.
Tests for
OverloadedNaryFunctionAn operator representing two alternative operators that can be used in alternative contexts
based on the structure of the node.
Allows function to be overloaded with two candidate functions
and a predicate that tests the values of the arguments
to see which function should be applied.
Tests for
OverloadedUnaryFunction.System tests for overloading functions and operators.
Resolves
OverloadedOperator, OverloadedFunctionByStructure
and AlternateFunctions setting the
operator or PostfixMathCommand of the node based on a test of the node.Tests for the
OverloadResolver.A version of the ConfigurableParser that can parse expressions
in multiple threads.
A set of tests checking different methods of parallel parsing
from the
com.singularsys.jep.misc.parallelparsing package.This class plots parametrised curves specified by two Jep expressions.
A plotter which plots parameterised curves given by two equations.
Exception thrown at parse time.
This exception is thrown when parse errors are encountered.
Parses an expression
nIterations times.Defines the methods a parser must implement.
Classes which wish to use the visitor pattern should use this interface.
Tests the speed of parsing.
Stores a single performance test result and contains logic to write this to
a DB.
Runs a set of performance tests and stores the results in a database.
Base class for a single performance test.
Converts an [r,theta] pair to a complex number r * e^(i theta).
This applet is a demonstration of the possible applications of the Jep
mathematical expression parser.
Java style x-- operator.
Tests for the
PostfixEvaluationConsoleTest for the
PostfixEvaluatorA console using the
PostfixEvaluator to evaluate expressions.Evaluation component that avoids excessive use of the stack for large
expressions.
Abstract base classes for most function classes.
All function classes must implement this interface to ensure that the run()
method is implemented.
Base class for routines which use a non-recursive tree walker strategy.
Java style x++ operator.
Computes the power of a number.
Java style --x operator.
A console application which dumps the tree representing an equation and statistics about the tree.
Tests for the
PrefixDumperConsole.Dumps the contents of a tree to a specified stream, or to standard output.
Base class for routines which use a non-recursive tree walker strategy.
Java style ++x operator.
A console which prints the equation before evaluating it.
Tests for the
PrintConsolePrints an expression with configuration options.
A do-nothing version of a PrintVisitor for reducing memory usage.
This interface specifies the method needed to implement a special print rule.
Prints a list access in form a[3] or for multidimensional access use the list syntax.
Prints a list of elements using '[' and ']' as delimiters and ',' as a separators.
Tests for the
PrintVisitor.A Variable that can publish messages when its value is changed.
A factory for creating
PublishingVariables.A VariableTable which publishes changes to its content.
Tests for the
PublishingVariable.Updates a variable table when another table changes
Puts a key-value pair into a map.
Configuration type
Encapsulates the Math.random() function.
A function which returns an increasing sequence of all the items between the end points inclusive.
Operators like
[ x ..Test the range operator
RangeOperator and function Range
and the associated parser ConfigurableParserWithRange.Finds the real part of a complex number.
Specifies binary function that efficient
double evaluate(double l, double r) method.A set of components for real (non-complex) evaluation.
Test for the
RealEvaluatorPerforms fast evaluation of expressions by using primitive types double and
boolean instead of objects.
Function table where evaluation is carried out using reals and never complex numbers.
Specifies n-ary functions
that have an efficient
double evaluate(double[] parameters) method.Specifies no arguments function returning doubles.
Unary functions that have an efficient
double evaluate(double val) function
for use with the RealEvaluatorA VariableTable which defines
pi, e, true, false but not the complex number i.An abstract TokenMatcher which uses RegExp patterns to match patterns.
Calculates the remainder and quotient the arguments.
The type of rounding to perform.
Removes entries with matching key from the map.
A JButton that fires repeatedly when the mouse is held down.
Extract the right most n characters from a string: right("abcdefg",2) -> "fg".
A PostfixMathCommandI which rounds a number to the closest integer.
Test rounding using
RIntA PostfixMathCommandI which rounds a number.
Rounding functions using BigDecimals rounding method.
A GrammarMatcher which matches bracketed expressions.
Rounds to a specific number of significant figures.
Test rounding using various functions.
Bitwise right shift with sign extension, like the java a >> b operator.
The secant function,
sec(x)=1/cos(x).A serializable representation of an expression.
An element representing a constant value.
interface used in internal representation of expression
An element representing a function.
An element representing an operator.
An element representing a variable.
Tests for serialization of expressions and Jep instances.
An operator precedence parser based on the shunting yard algorithm.
Return result of following methods.
Factory creating new ShuntingYard instances.
The signum function returns -1 if x<0, 1 if x>0, 0 if x==0.
A simple example that demonstrates the use of Jep for evaluation of a single
expression.
The base class for all AST node classes.
The sin(x) function
Hyperbolic sin.
A matcher for functions like "sin 30" without brackets and a single simple argument.
The number of entries of the map.
Compares the speed of evaluation between different evaluation schemes.
Configuration using the BDConfig
Basic class to set the evaluation context
Standard Jep configuration (with FastEvaluator)
Standard Jep configuration (with Jep 3.4's FastEvaluator)
Standard Jep configuration (with Jep 3.5's FastEvaluator)
Standard Jep configuration (with Jep 3.5's FastEvaluator and no checks)
Standard Jep configuration (with FastEvaluator)
Configuration using the StandardEvaluator
Different output methods
Configuration using the RealEvaluator
Print detailed ratios for each run.
Configuration using the RealEvaluator
Print output tab separated.
Configuration using the RealEvaluator
Configuration using the
UncheckedEvaluatorCompares the speed of evaluation between different evaluation schemes.
Basic class to set the evaluation context
Standard Jep configuration (with FastEvaluator)
Standard Jep configuration (with Jep 3.4's FastEvaluator)
Standard Jep configuration (with Jep 3.5's FastEvaluator)
Standard Jep configuration (with Jep 3.5's FastEvaluator) with all checks turned off.
Standard Jep configuration (with FastEvaluator)
Configuration using the StandardEvaluator
Different output methods
Configuration using the RealEvaluator
Print detailed ratios for each run.
Configuration using the RealEvaluator
Print output tab separated.
Configuration using the RealEvaluator
Configuration using the UncheckedEvaluator
Square root function.
An Evaluator which checks the stack size after every function call.
The standard set of components.
Tests for
StandardComponentsThe standard configurable parser with a standard set of options.
The older standard evaluator.
Performs the regular JepTests using the StandardEvaluator
The standard function table.
The old standard operator table used by Jep.
Provides the standard implementations of operators used by Jep.
The standard parser for Jep.
A VariableTable which defines some constant values.
Converts an object into its string representation.
A stricter version of
DoubleNumberFactory
that always creates Doubles.Tests for
StrictDoubleNumberFactoryA strict version of Natural logarithm.
Adds string functions left, right, lower, upper, substring, len, mid, trim.
Single or double-quoted strings.
Base class for matching quoted strings.
Base class for matching quoted strings.
Allows substitution of variable with values or expressions.
Tests for the
SubstitutionVisitor.Extract substring of first argument: substring("abcdefg",2,4) -> "cd".
The different between two arguments
a-b.Adds it arguments
sum(1,2,3,4,5) will be 15.A switch statement.
Action to take if first argument is null.
A switch statement, with a default value.
Action to take if first argument is null.
A switch statement, with a default value.
Action to take if first argument is null.
A switch statement.
Action to take if first argument is null.
A simple type of token which represents a fixed string of characters.
Matches a fixed set of symbols, each represented by a SymbolToken.
The tan function.
Hyperbolic tan.
A token representing the end of the equation.
A token matcher which matches the end of an expression
Implements the
condition ?A class representing a ternary operator, for example x?
A visitor than can test all nodes in a tree against a set of predicates.
Tests for the
TestingVisitor.An assignment operator so we can do
x=3+4.
Thread safe version of the element operation.
An evaluator which can safely evaluate an expression in multiple threads.
Random number generator using the
java.util.concurrent.ThreadLocalRandom
nextDouble(double) method.A diagnostic application using the
ThreadSafeEvaluator
and a variable number of threads.A thread which evaluates an expression multiple times.
Tests evaluation using multiple threads.
A thread which evaluates an expression multiple times.
Tests for evaluation in multiple theads
Convert a number to a string in a given base.
Base class for tokens.
Describes the input token stream.
Sub-interface of TokenMatcher which allows tokens to be created without matching
input text.
Classes which filter the list of tokens.
Breaks the input into a set of tokens.
Factory creating new instances of the tokenizer.
AbstractFactory for creating new Tokenizer instances.
Tests for the tokenizer.
Interface defining classes which match tokens
Token Manager Error.
Analyze an expression, counting the number of nodes of each type, and recording which variables,
functions and operators occurred in the expression.
Trims leading and trailing whitespace
The unary minus function
-x.Convenient base class for unary functions.
FunctionalInterface for the
BinaryFunction.instanceOf(Class, BiFunctionWithException) method.Tests for the
UncheckedEvaluator.An evaluator which does fewer checks on values with a 5% faster speed.
Convert a string to uppercase
A case-insensitive operator token matcher.
Bitwise right shift with zero extension, like the java a <<< b operator.
Utilities for constructing tests on functions.
Some common utility methods
Return the values of a map a nested list
of key-value pairs.
Return an
Iterable<Object> for the values of a dictionary.Information about a variable.
Bound variables will call these methods to interact with objects outside Jep.
Defines a method which translates a variable name into a variable binding.
A factory class which is used to create variables.
Unit tests for the
VariableFactoryTests for hooks on Variables.
A table of variables.
Contains details of an action on a variable table or a change in a variable.
The type of action
Convenience class for implementing a Subscriber of VariableTableActions.
Unit test for the
VariableTableA VariableTableSubscriber that updates
variables in the table when messages are received.
A console which illustrates a different syntax for vectors using mathematical (1,2,3) notation.
the tokenizer
Test for the
VectorConsoleSummation function which expands the arguments.
A token filter that removes whitespace and comments.
Tokens representing sequence of white space characters.
Matches whitespace.
Interface for functions which can be configured to respond
to zero length array arguments with either an exception, NaN or a value.
Interface for classes which implement
ZeroLengthBehaviourI by delegating to a helper class.How to respond to a zero length array as argument
Helper class which implements the zero length behaviour.