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.
An abstract base class for fields where comparison methods are implemented using a single
cmp(a,b) method.Abstract base class for rpe-base evaluation routines.
Base class which provides access to Jep components
Base class for pre and post increment operators.
An abstract base class for implementations of MatrixFieldI.
Default methods, when more specific methods do not work.
Basic implementation for a RewriteRule.
Base class for rules which operate on vectors and matrices.
A base class for polynomial rewriters.
Accumulate values in a sequence returning a sequence of intermediate values.
Addition function.
A rule which expands addition of vectors and matrices.
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
AlternateFunctionsHandle <annotation-xml> and <annotation> elements.
Tests a predicate against sequence.
Concatenates two lists, or append a single element.
Apply a lambda function to a single argument.
Abstract class for builders which need to construct <apply> elements.
Handles the <apply> container element.
The 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
Base class for methods which expand Lists, arrays and other collections in their argument list.
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.
One dimension Bernstein polynomial for implicit plotter app.
Pair of bernstein polynomials.
An always negative Bernstein polynomial.
An always positive Bernstein polynomial.
An always zero Bernstein polynomial.
Two dimension Bernstein polynomial for implicit plotter app.
sign bits for derivatives
An always negative polynomial
An always positive polynomial
Four Bernstein polynomials
Derivatives of a polynomial
An always zero polynomial
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.
Tests for matrix operations using the
BigDecimalField.A console using
BigDecimal for calculations.Tests for the
BigDecimalConsoleImplementation of field methods using BigDecimals
Tests for the
BigDecimalField.Function table for function which work with BigDecimal numbers.
Classes 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.
A field using Java's unlimited precision BigInteger class.
A number factory to create BigInteger numbers
Converts BigIntegers, Long, Integer and Short to Rationals on input.
A field to work with modulus values of any value, used BigInteger.
Convenient base class for binary functions.
FunctionalInterface for the
BinaryFunction.instanceOf(Class, BiFunctionWithException) method.Consolidate nested
NaryBinaryFunction functions to a single function with multiple arguments.Binomial coefficients: binom(n,i).
The binomial cumulative distribution function.
The binomial distribution function.
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.
Parse a statement block
{ sequence }.Facilitates standard Boolean logical operations.
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
Converts a
BinaryFunction so it can be used in a chain or directly as binary function.Converts a
BinaryFunction so it can be used in a chain or directly as binary function.Adds chainable list processing functions.
Converts a
NaryFunction so it can be used in a chain or directly as Nary function.Converts a
UnaryFunction so it can be used in a chain or directly as unary function.Converts a
BinaryFunction so it can be used in a chain.Converts a
BinaryFunction so it can be used in a chain.A console application illustrating the chained function features
in the
com.singularsys.extensions.chained package.Tests for the
ChainedConsole application.An extension to the
Define function that allows
chained functions to be created.Test generated from chained.html
Specifies functions than can be used in a chain.
Adds chained list processing functions.
Tests for the Chained package.
Converts a general
PostfixMathCommandI so it can be used in a chain.Converts a
NaryFunction so it can be used in a chain.Creates VariableBinding objects by translating the variable name into a chain of object references.
An OperatorTable for chained and chainable syntax.
Keys to identify the lambda operators.
Converts a
UnaryFunction so that it can be used in a chain.An PFMC which allows a method chaining syntax.
Abstract base class for function which are differentiated using the chain rule.
This interface describes a character stream that maintains line and
column number positions of the characters.
Jep functions which adds a
clean(eqn) preprocessing operator to tidy expressions.Test generated from cleaner.html
Tests for the
ExpressionCleanerClears the map.
Jep function to extract array of coefficients from a polynomial.
Collect powers together so that
x*x -> x^2 and x^n*x -> x^(n+1).Executes commands like diff and eval embedded in expression trees.
Interface defining the special actions performed during the preprocessing
stage.
Tokens representing comments.
Matches various styles of comments.
Common classes for overload function tests.
Implements the comparative operations <, >, <=, >=, !
Tests for
ComparativeThe
compare(x,y) command.Represents a complex number with double precision real and imaginary
components.
An immutable version of the Complex class.
Canvas used by the
ComplexPlotter applet.A Field which operates on Complex objects.
Tests for the
ComplexField.A Field which operates on Complex objects.
A Field which operates on Complex objects which imposes
a total order on the complex numbers,
by first comparing the real part and then the imaginary part.
Function table for function which work with
Complex numbers.Implementation for vector whose elements are
Complex numbers.Field for
ComplexMatrix and ComplexVector types.Tests for matrix operations using the
ComplexMatrixField.Parse all numeric strings as
Complex.Converts a pair of real numbers to a complex number Complex(x,y)=x+i y.
Applet for plotting images of complex functions.
Rewrites polynomials with powers of i, the square root of -1, to a form without i.
Test for
Complex.Implementation for vector whose elements are
Complex numbers.Collects all the components which make up the Jep system.
Represent an incomplete set of components.
Concatenates string arguments.
A Reader implementation that concatenates two readers.
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.
Handles <cn> elements.
Parses complex numbers like
<cn type="complex-cartesian">1.23<sep/>4.56</cn>Parses complex numbers like
<cn type="complex-polar">1.23<sep/>4.56</cn>Methods for individual <cn type="type"> handlers
Parses numbers in e-notation like
<cn type="e-notation">123<sep/>-2</cn>Parses integer numbers like
<cn type="integer">123</cn>Parses constants like
<cn type="constant">π</cn>Parses complex numbers like
<cn type="rational">123<sep/>456</cn>Parses real numbers like
<cn type="real">1.23</cn>Tests if the map contains a given key.
Canvas used by the
ContourPlotter applet.Plots contours of functions defined by implicit functions
f(x,y)=h.A node representing a control statement such as
break or continue.Parses
break and continue statementsThe cosec function
The cos function
The hyperbolic cosine function
The cotangent function.
Counts its arguments
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 rule which expands the cross product of two 3D vectors.
A
DimensionVisitor which can work with PartialDerivative variablesTests for the
DDimensionVisitor.Handles the <declare> element.
A VariableTable that can optionally decorate another variable table.
A Visitor which returns an exact copy of the tree.
Defines a lambda function as a regular function.
Extract equations for symbolic variables.
Type of variable to replace by their equations
Test various features until failure.
An extension of
ExpressionCleaner which can simplify
partial derivatives.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_VALUESThe diff(f,x) operator.
A class for performing differentiation of an expression.
Simple example of using differentiation
Defines a set of rules describing how to differentiate a function.
A class to represent a set of dimensions giving the size of a vector or matrix.
Tests for the
Dimensions class.Annotates nodes with the dimension of the vector or matrix.
Class to check conditions on a node
Checks nodes to see if the variable matches
one in the supplied list
Tests for the
DimensionVisitor.Marker interface for functions which should never be cleaned.
Version of
Random which implements DirtyFunction
so the ExpressionCleaner does not remove the function.Version of
ThreadSafeRandom which implements DirtyFunction
so the ExpressionCleaner does not remove the function.Limit the list returning only the first n elements.
Division of two arguments.
Differentiates a division with respect to a variable.
Adds differentiation facilities to Jep.
The set of components used by a standard DJep instance.
Console with support for differentiation.
Tests for the
DJepConsole application.Tests for the
DJepA Visitor which visits each node of an expression tree and does nothing.
The dot product of two vectors.
A rule which expands the dot product of two vectors.
Tests for matrix operations using the
ComplexField
in combintion with a DoubleField.A double field where all input must be double and all output is double.
A matrix where the elements are doubles
A JepComponent encapsulating a DoubleMatrixFactory and DoubleMatrixField.
A factory for creating
DoubleMatrix and DoubleVector.A field operating on
DoubleMatrix and DoubleVector.Tests cleaning for matrix operations using the
DoubleMatrixField.Tests for matrix operations using the
DoubleMatrixField.Default class for creating number objects.
A vector where the elements are doubles
An extension of
PolynomialCreator which can simplify
partial derivatives.An extension of PrintVisitor which will print the equations of a variable if required.
Holds all info about a variable.
A VariableFactory which can work with PartialDerivatives.
A VariableTable which works with partial derivatives of variables.
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.
Finds the min/max of the elements of a vector or matrix.
Flag indicating if the mix or max is calculated
Tests if the first argument is in a set of values given in subsequent arguments.
Calculates the product of the elements of a vector or matrix.
Sums the elements of a Vector (or matrix).
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.Extract equations for symbolic variables.
Evaluate an expression in the pre-processing stage.
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.
An integer field where results are always integers and Exceptions are thrown
on error.
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.
The
expand(x) command.A rule which expands brackets (a+b)*(c+d) -> a*c+a*d+b*c+b*d
An
var[index] function whose ExpandingEle.set(Evaluator, Node, Object) method
modifies and expands the Vector<Object> value of the variable.Test for
ExpandingEle.Expands powers (a+b)^2 -> a^2+2*a*b+b^2
Cleans up expressions, removing redundant parts.
Consolidates nested addition and multiplication to produce nary operators.
This class is designed for testing the validity of Jep evaluations.
Parses an expression.
Test for all the examples given in the documents.
A customised parser
A simple implementation of a string field
A simple implementation of a string field with a single cmp method
A implementation of a string field using a GenericField
Tests using a field operator table with a bitwise table.
An example of an OperatorSet which adds
suffix operators: n!
Keys for the new operators.
Tests for modification to the configurable parser.
Tests for the
ExtensionsConsole application.Console illustrating most of the features of jep extensions.
Turns a unary function taking scalar arguments into
a function that takes a list and returns a list with function
applied to each element.
Turns a unary function taking scalar arguments into
a function that takes a list and returns a list with function
applied to each element.
Base class for MatrixFactories where external matrix libraries are used for the matrix implementation.
Base class for MatrixField implementations with external matrix libraries.
Tests for matrix operations using the
ExternalMatrixField.A function that sorts a list using a provided comparator.
This class is designed for testing the validity of Jep evaluations.
Class to handle externalized messages for the extensions package.
Extracts the equation of a symbolic variable
Compares the speed of evaluation between standard evaluator and real
evaluator and occasionally java.
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.
Test generated from fastmatrix.html
Calculate the absolute value of a number using a Field with a working
ge method.Binomial coefficients: binom(n,i), which can be calculated over any field.
Cleaner tests using a field
Groups a set of fields together.
A comparator which works using a field.
A console application which can work with a number of different fields.
Decorator to convert all input numbers to complex numbers.
Function to convert a number to a double.
Decorator to convert rational and big decimal numbers.
NumberFactory which creates rational numbers if possible otherwise doubles.
Function to convert a number to a rational.
Decorator to convert rational numbers to big decimals for input to a field which only supports big decimals.
Describes the type of Field used.
Tests for the
FieldConsole application.Abstract base class for Decorators used to convert the inputs and outputs of a field operation.
Provides a set of components for using
dictionaries compatible with the
com.singularsys.extensions.field package.Tests for
FieldDictComponents using MAP_MISSING_VALUES.Using differentiation and fields.
Calculate factorials using a field.
Function plotter using field calculation.
Defines the methods which each field should implement - add, sub, mul, div, mod, pow, eq, ne, gt, ge, lt, le, and, or, not.
An MatrixField where elements are of type Object and the
operation on elements are defined by a field.
Exposes a fields
mod method.Tests for matrix operations using the
FieldMatrixField.An operator table where the standard operators are evaluated using a set of
fields.
Java style
x-- operator, implemented for a field.Java style
x++ operator, implemented for a field.Exposes a fields
pow method.Java style
--x operator, implemented for a field.Java style
++x operator, implemented for a field.A Field aware version of the
LambdaRange function
which returns an increasing sequence of all the items between the end points inclusive.Calculate the sign of a value using a Field with a working
ge, lt methods.Calculate the square root of a number using any field.
Tests for the
FieldSqrt algorithm.A function which returns an increasing sequence using a
FieldI.Test for fields without matrix support.
The TreeUtility functions adapted to work with a Field.
A
VariableBinding which binds variables to a particular field of an object.Filter a list using a lambda function returning only those elements which meet a criteria.
Finds the first element in a list
first([1..100])Finds the first element that matches a predicate
or return a default value.
Finds the first element in a list, or returns the default value if the list is empty.
Implementation of field methods using BigDecimals
Functions, operators and components that support fixed precision operations.
Flatten a list of lists to produce a single list of all elements
A PostfixMathCommandI which find the largest integer above the number
floor(pi) give 3
floor(-i) give -4
Handles the <fn> tag.
Fold or reduce a list using a lambda function to reduce the list down to a single argument.
Fold or reduce a list using a lambda function to reduce the list down to a single argument.
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.
Builds xml-fragments for jep functions.
Class to build a CSymbol element, with the name of the jep-function.
Default builder for unknown function, throws a jep exception.
Class to build a Fn element, with the name of the jep-function.
This class plots a graph using the Jep API.
Object returned by
StandardFunctionHandler.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.
Tests to see if appropriate exceptions are throw when adding a matrix to a vector etc.
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.
Abstract-generic base class where the type-variable specifies the arguments and return type.
A MatrixField where the elements of the matrices and vectors are of type E
and the evaluation is carried out using a
GenericPowerField of type E.Generic implementation of a matrix when all elements are of the base type E.
An abstract matrix factory for vectors and matrices over a specific type
such as Object or Complex.
A Generic matrix field providing default implementations
for all operations.
Provides a standard
E powI(E l, Integer r) method for integer powers.Generic implementation of a matrix when all elements are of the base type E.
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
Indicates rules for parsing structured code.
Graded Reverse Lexical Order comparator.
Tests for
GrevlexComparator.Graded Lexical Order comparator.
Tests for
GrlexComparator.Matches hexadecimal numbers, in the format 0xff.
Remove a specific hook from any node which has it on a tree
Test for
HookRemover.Converts <cn> elements into jep variable nodes with the same name.
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.
Differentiates functions like
if(cond,trueExpr,falseExpr) where
the first argument should not be differentiated, but subsequent ones should
be.A node representing an if statement.
Represents an illegal parameter
Finds the imaginary part of a complex number.
An Immutable version of the Complex numbers.
Canvas used by the
ImplicitPlotter.Implicit function plotter.
Imports an expression from one Jep instance into another.
Where possible numbers are converted to Integer otherwise Double.
Defines fields which can convert numbers to or from integers.
An integer field where overflows are ignored.
Tests for the
IntegerField.Function table for function which work with Integer numbers.
Where possible numbers are converted to Integer otherwise Double.
A FieldDecorator which converters Integer/Long/Short to BigIntegers on input,
and optionally BigIntegers to Integers on output when there is no loss of precision.
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.
Generate a sequence using iteration
iterate(first_value, iteration_lambda_function, limit_lambda_function)
For example the following generate the even number from 4 to 20.Parses a java-style for loop
for(i=0;i<10;++i) x+=i;.Parse a java style if statement:
if(expr) statement [ else statement ]An operator table which supports most of the operators which appear in Java.
Keys to identify the Java operators.
Parse a Java-style while loop
while(x<10) x=x+1;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.A console application illustrating the use of lambda functions
in the
com.singularsys.extensions.lambda package.Tests for the
LambdaConsole application.Count the number of elements in a list
Test generated from lambda.html
PostfixMathCommand representing a lambda functions.
Adds list processing and higher order functions.
Jep Function that generates a
LambdaFunction.Tests for lambda package.
Apply a lambda function to a list of arguments returning a list
An OperatorTable that defines
the lambda definition operator
x => x^2,
the optional range operator [1..5],
the optinal send to operator x^2 -> y,
and optional ternary operator code ? x : y.Keys to identify the lambda operators.
A function which returns an increasing sequence of all the items between the end points inclusive.
Test generated from lambda.html
Test generated from lambda.html
Finds the last element in a list.
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
Lexical Order comparator.
Tests for
LexComparator.Builder to handle the lg() function.
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.Limit the list returning only the first n elements.
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.
Handler for the List operator.
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].Defines some utility methods use by higher order functions for processing lists
of data, where the actual types used by Jep may differ.
Base class for functions which return lists or vectors.
Log base 10.
Tess for
LogarithmLog base 2.
Handles:
<apply><log/>arg</apply>
<apply><log/><logbase><cn>2</cn></logbase>arg</apply>
Logical operators
AND and OR.Logarithm function where the base is specified in the second argument.
Where possible numbers are converted to Long otherwise Double.
A field where all operations are implemented using Long.
An iterator which stores the next two tokens.
A subclass of a Lookahead2Iterator which allows any number of character of lookahead.
A node represents a looping construct such as a
for or while loop.Special values to indicate break and continue statements
Used by
ControlRule and ControlNode.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.
Rules are specified by an expression string or a trees of nodes.
A function specified by a string.
For functions defined by expressions this rule automatically calculates the
derivative.
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 Swing application to
show conversion of a mathematical expression to semantic and presentation MathML.
Simple console application where jep equations are input on the command line and the resulting xml is printed.
Tests for the
MathMLConsole application.Defines some useful constants for MathML namespaces etc.
Main class for the Content MathML builder.
Main class for the Content-MathML parser.
Behaviour for unknown tags when parsing with
MathMLContentParser.parseAll(Reader, Behaviour).Interface defining methods of the main builder class which can be used
by individual
MathMLFragmentBuilder fragment builders.Central class for parsing MathML.
Classes which build subtrees for specific jep nodes should implement this interface.
General testing suite for mathml parser builder.
Handles the <math> element.
Adds two elements using a MatrixField.
Cleaner tests using a matrix field.
Compare two elements using a MatrixField.
Creates matrix specific components.
The set of components used by a Jep instance with Vector-Matrix support.
Console with support for matrix operations.
Tests for the
MatrixConsole application.Calculates the cross-product of two 3D vectors using a matrix field.
Calculate the determinant of a matrix using a MatrixField.
Provides a set of components for using
dictionaries compatible with the
com.singularsys.extensions.matrix package.Configuration type, one of MAP_NULL_VALUES, MAP_NO_NULL, MATRIX_NO_NULL.
Implementation of ContainKey compatible with the matrix package.
Implementation of Entries compatible with the matrix package.
Matrix compatible versions of the
EntriesIterable function.Implementation of Get compatible with the matrix package.
Implementation of GetOr compatible with the matrix package.
Implementation of Keys compatible with the matrix package.
Matrix compatible versions of the
KeysIterable function.Tests for
MatrixDictComponents using MATRIX_NO_NULL.Implementation of MakeMap compatible with the matrix package.
Tests for
MatrixDictComponents using MAP_NULL_VALUES.Implementation of Put compatible with the matrix package.
Removes entries with matching key from the map.
Implementation of Size compatible with the matrix package.
Implementation of Values compatible with the matrix package.
Matrix compatible versions of the
ValuesIterable function.A DifferentiationVisitor which knows about vectors and matrices.
Divides two objects using a MatrixField.
Test generated from matrix.html
Calculates the dot-product of two vectors using a MatrixField.
Gets and sets the elements of a matrix or vector using a MatrixFactory.
Defines basic methods for constructing matrices.
Base class to check implementation of a matrix field/factory.
A collection of fields including one matrix.
Defines all the basic operations which can be carried out on matrices and vectors.
Signals functions for which the dimensions of the results can be calculated
A function table with some matrix functions.
Convert <matrix>, <matrixrow>, <vector>, <list> and <set>.
Defines the basic interface implemented by all types of matrix.
Generates identity matrices. id(2) will generate a 2 by 2 identity. id(3,2)
will generate a 3 by 2 matrix with 1's down the principal diagonal.
A versions of the
If function which implements the MatrixFunctionI interface.Tests for the
MatrixIf class.Calculate the inverse of a square matrix using a MatrixField.
Lambda function tests using a matrix field.
PostfixMathCommand which takes a number of objects on the stack
and creates either a matrix or a vector.
A list processor which accepts and produces
VectorI arguments.An Iterable over the columns of a
MatrixI.An Iterable over the rows of a
MatrixI.Tests for the
MatrixList class.Tests for the
MatrixList
class foring use of run method..Calculates the modulus of two elements using a MatrixField.
Multiplies two objects using a MatrixField.
Negates an object using a MatrixField.
An operator table with operators which work on vectors and matrices.
Raise one element to a power using a MatrixField.
Returns the size of a Scalar, Vector or Matrix.
Solved the equation A * X = B Default implementation is to use Gauss-Jordan
Speed test for various matrix implementations.
Subject two objects using a MatrixField.
A versions of the
Switch function which implements the
MatrixFunctionI interface.Tests for the
MatrixSwitch class.Tests for matrix operations using the
SimpleMatrixField.Calculate the trace of a matrix using a MatrixField.
Calculate the transpose of a matrix using a MatrixField.
Construct a matrix of zeros using a matrix field.
Construct a matrix of zeros using a matrix field.
An extension of the DJep class with Matrix support.
The set of components used by a standard DJep instance.
Tests for differentation using a matrix field.
Calculate the mean of its arguments
Calculate the median of its arguments.
A medium weight set of components reusing components from an existing Jep instance.
Joins two sequences together, element by element.
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.
Needed to distinguish between Unary and binary minus.
Calculate the mode of its arguments
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 field to work with small modulus values < 46341.
Tests for the
ModulusField
where all values are calculated mod n.An implementation of the
ChainingOpPfmc
that records calls to ChainedFunctionI.apply(Evaluator, Node, Object)
to the MonitoringEvaluator.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.
Represents an immutable monomial a x^i * y^j * ... * z^k, a constant.
A list of commands evaluated in sequence by the evaluator.
Data type for the command string
Test generated from fastmatrix.html
Tests for matrix operations using the
fastmatrix package.Tests the fastmatrix evaluator.
JUnit test for full Matrix Rp evaluator
A fast evaluation algorithm for equations using Vectors and Matrix over the Doubles.
Console using the ReEval class rather than the RpEvaluator wrapper.
Tests for the
MrpEvalConsole application.The values returned by the evaluator and the base type for internal types.
Tests for serialization the
fastmatrix package.A reference to a variable used by the fast matrix evaluation package
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.
Differentiates a product with respect to a variable. diff(y*z,x) ->
diff(y,x)*z+y*diff(z,x)
A rule which expands multiplication of vectors and matrices.
A simple Mutable Double class.
A mutable monomial representing a * x^i * y^j * ... * z^k.
A mutable polynomial representing a + b + c.
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.
Converts
NaryBinaryFunction functions with multiple
arguments to nested binary 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.
The normal distribution function.
Type of distribution to calculate PDF/CDF
Inverse Normal distribution.
Implementation of the not function.
Convenient base class for zero-argument nullary functions, like
random().FunctionalInterface for the
BinaryFunction.instanceOf(Class, BiFunctionWithException) method.Just returns null.
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
Treat Numbers as boolean values in And &&, Or || and Not !
Converts numeric-constants to CN nodes.
How to format Double objects with integral values.
This interface can be implemented to create numbers of any object type.
Convert all Number types to Complex, and optionally convert result to Doubles if possible.
Tests for the
ComplexField
using the
NumberToComplexDecorator
to convert to from complex numbers.Decorator which converts all Number types to Double.
Represent numbers.
Matches numbers.
Handler for MathML elements which correspond to numeric constants,
Double.NAN
and Double.POSITIVE_INFINITYA Matrix where all elements are simply Objects.
An implementation of vectors and matrices where elements are Objects.
A Vector where all elements are simply Objects.
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.
Builds mathml elements corresponding to operators.
Handles elements corresponding to Jep operators.
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.An Iterable backed by a
VectorI.An Iterator over a
VectorIA 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.
Contains information about a PartialDerivative of a variable.
Rules like Sum where diff(sum(a,b,c),x) -> sum(da/dx,db/dx,dc/dx) are instance of this class.
Represents a constant.
Calculate the percentile values of its arguments.
Type of Rank to percentile to calculate.
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.
Represents a function.
Base canvas class where individual pixels can be plotted.
An element in a polynomial representation of an expression.
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.
Test generated from polynomials.html
Represents a polynomial.
A system for symbolic simplification, expansion and comparison based
on conversion to a canonical polynomial representation.
Tests for the polynomial package.
Represents an operator.
Parse an expression followed by an optional separator.
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.
Differentiates a power
y^z with respect to a variable.Fast static routines for calculating powers.
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.
Runs the preprocessors on an expression during evaluation.
Speed test for various methods of calculating primes.
A console which prints the equation before evaluating it.
Tests for the
PrintConsoleTest generated from printing.html
Prints a list of elements using '[' and ']' as delimiters
and ',' as a separators.
Prints 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
Represents a variable.
Encapsulates the Math.random() function.
A function which returns an increasing sequence of all the items between the end points inclusive.
Represents a 2D rectangular range.
Operators like
[ x ..Test the range operator
RangeOperator and function Range
and the associated parser ConfigurableParserWithRange.PostfixMathCommand to return the rank of a single number in a list.
Type of Rank to calculate.
PostfixMathCommand to return the rank of all the elements in a list.
Type of Rank to calculate.
A rational number represented as the quotient of two BigIntegers.
A special rule for printing divisions involving rational numbers.
A field which works with unlimited precision rational numbers, represented as
the quotient of two BigIntegers.
Tests for the
RationalField.Function table for function which work with
Rational numbers.Tests for matrix operations using the
RationalField.Tests for matrix operations using the
RationalField.A MatrixFactory where the matrices have elements of type Rational.
A matrix with rational elements
A vector with rational elements
Tests for matrix operations using the
RationalField.Creates
Rational numbers.Rounds rational numbers according to the rounding mode specified.
Tests for the
Rational number type.A rational number represented as the quotient of two BigIntegers.
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.Reduce a list, using an identity value and a lambda function defining the reduction operation.
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.
The
rewrite(x) command.Defines a rule for symbolic rewriting of an expression
Tests for the
rewrite package.A visitor which allows rewrite rules to be added and applied.
Define a rule which may modify a constant node.
Define a rule which may modify a variable node.
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
RIntHandles:
<apply><root/>arg</apply>
<apply><root/><degree><cn>3</cn></degree>arg</apply>
A 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.
Data type for the command string
A list of commands
Constants used by the evaluator.
Test generated from fastreal.html
A fast evaluation algorithm for equations over Doubles, does not work with vectors or matrices.
Console using the ReEval class rather than the RpEvaluator wrapper.
Tests for the
RpEvalConsole application.An evaluator using the RpEval system.
Tests for serialization the
fastreal package.Tests the fastreal evaluator.
ArcSin implementation counting number of calls
Rpe Thread speed test application.
A thread which evaluates an expression multiple times using RpEval.
Bitwise right shift with sign extension, like the java a >> b operator.
A rule which expands division of
vectors and matrices by scalers.
A rule which expands multiplication of
vectors and matrices by scalers.
The secant function,
sec(x)=1/cos(x).Needed to distinguish between Unary and binary minus.
Handler for
<semantics> elements.An assignment operator so we can do
3+4 -> x
This function implements the CallbackEvaluationI interface
so that it handles setting the value of a variable.A Matrix where elements are stored as a one dimensional array of
double values.A MatrixFactory which is used to create a
SequenceMatrix (stored internally as a 1D array of double values)
or DoubleVector.A MatrixField which operates on
SequenceMatrix or
or DoubleVector.Tests for matrix operations using the
SequenceMatrixField.A node representing a sequence of expressions.
Parses a sequence of statements
Parses a sequence of statements separated by a separator
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 integer field where overflows are ignored.
An operator precedence parser based on the shunting yard algorithm.
Return result of following methods.
Factory creating new ShuntingYard instances.
Represents the signature of a lambda function
Either a single variable
x, a list of variables [x,y,z]
a pattern (u,v) or a list containing variables and patterns [(x1,x2),y].Inner elements
A Signature representing a list of signatures
Outer, top-level elements
A Signature representing a pattern
{u,v} .A signature representing a single variable inside a list or pattern,
e.g.
A signature representing a single variable.
The signum function returns -1 if x<0, 1 if x>0, 0 if x==0.
Returns an array of non-null children, flattening nested arrays and Lists.
A simple example that demonstrates the use of Jep for evaluation of a single
expression.
A simple handler which converts all elements to a tree structure.
A class used to represent the tree.
An implementation using the default Jep methods for evaluation of elements of a matrix.
The base class for all AST node classes.
A simplified base number factory class.
A simple field for lists of type
Vector<Object>.Tests for the
SimpleVectorField.The
simplify(x) command.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.
Remove the first n elements from a list.
A rule where numbers very close to zero are replaces by zero.
Sort a list using a lambda function.
PostfixMathCommand to sort elements in a list.
Base class for functions and operators which have special arguments.
Represents the results returned by the
SpecialNodeHandler.Handles special elements like <logbase>, <degree> and <sep/>.
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.
Representation of an element, contains the name, attributes and children of the element.
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
A Field implementation using the default Jep methods for evaluation.
Handles standard functions like <sin> returns
FunctionElement.The standard function table.
Default implementation of a ListProcessor.
The old standard operator table used by Jep.
Provides the standard implementations of operators used by Jep.
The standard parser for Jep.
A structured parser with a java like grammar.
A VariableTable which defines some constant values.
Interface for handlers which need to be informed of starting tags.
Parse a single statement from a list of possibilities.
Tests for the
statistical package.Converts an object into its string representation.
Accumulate values in a sequence returning a sequence of intermediate values.
Tests a predicate against sequence.
Concatenates two streams into a single stream.
Apply a lambda function, converting stream arguments to lists and passing them as a single argument.
An assignment operator that converts rhs streams values to
Vector<Object>
using the List.Extract the first element from a stream.
Extract a stream with the first element removed.
Create a new stream with the same elements as the original stream.
Collects the elements of a stream into a list using a provided
Collector.A console application illustrating the use of evaluation using
Streams
in the com.singularsys.extensions.stream package.A unbounded supplier of prime numbers, implemented as an Iterable.
Tests for the
StreamConsole application.Counts the number of elements in a stream and returns it as a Number.
Provides a set of components for using
dictionaries compatible with the
com.singularsys.extensions.stream package.Tests for
StreamDictComponents using MAP_MISSING_VALUES.Return only distinct elements of a stream.
Test generated from stream.html
Function providing an infinite stream of primes as BigInteger
Function providing an infinite stream of primes as BigIntegers.
Function prividing an infinite stream of primes
Returns the entries of a dictionary as a stream of
Vector<Object>.An evaluator that works with stream converting the
final result of
StreamEvaluator.evaluate(Node) to a list.Filters elements of a stream based on a externally defined predicate.
Applies an externally defined mapping function to each element of a stream.
Sorts elements of a stream based on a comparator.
Provides a set of components for using
dictionaries compatible with the
com.singularsys.extensions.stream package
and using a FieldI.Filter a list using a lambda function returning only those elements which meet a criteria.
Returns the first element from a stream.
Finds the first element that matches a predicate
or return a default value.
Returns the first element from a stream or a default value if the stream is empty.
Fold a list using a lambda function to reduce the list down to a single argument.
Fold or reduce a list using a lambda function
and an defualt value returned when the stream is empty.
Adds stream processing functions.
Generate an infinite sequence using iteration using an
initial value and a lambda function to calculate the next value and
optionally a lambda function to determine when to end the stream.
Returns the keys of a dictionary as a stream of
Object.Returns the last element from a stream.
Return only the first n elements of a stream.
A ListProcessor implementation that can process lists, vectors and streams.
Takes a stream and returns a stream that loops over the same elements indefinitely.
Apply a lambda function to a list of arguments returning a list.
Provides a set of components for using
dictionaries compatible with the
com.singularsys.extensions.stream package
and converting to and from VectorI vectors and MatrixI matrices.Configuration type, one of MAP_NULL_VALUES, MAP_NO_NULL, MATRIX_NO_NULL.
Returns the entries of a dictionary as a stream of
Vector<Object>.Returns the keys of a dictionary as a stream of
Object.Returns the keys of a dictionary as a stream of
Object.Joins two sequences together, element by element.
Returns the minimum or maximum element from a stream.
An OperatorTable for stream package.
A function which returns an increasing sequence of double values
all the items between the end points inclusive.
Reduce a list to a single value using a lambda function and an initial identity value.
An assignment operator so we can do
3+4 -> x
This function implements the CallbackEvaluationI interface
so that it handles setting the value of a variable.An assignment operator allowing unclosed steams to be saved to a variable.
Skip the first n elements of a stream.
Use a lambda functions to sort items in a stream.
A PostfixMathCommandI which returns a stream specified in the constructor.
A terminal function that takes a Stream as its single argument, takes all elements from the stream
and passes them as arguments to the inner functions.
Terminal function that reduces a stream to a single value using
an
NaryBinaryFunction.Tests for the Stream package.
Convert the Stream to a list using the ListProcessor.
Returns the keys of a dictionary as a stream of
Object.Filter a stream so only the elements from the
start of the stream that match a criteria are returned.
A stricter version of
DoubleNumberFactory
that always creates Doubles.Tests for
StrictDoubleNumberFactoryA strict version of Natural logarithm.
String concatenation, and comparison
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.
A console application illustrating the structured programming features
in the
com.singularsys.extensions.structure package.Tests for the
StructuredConsole application.An evaluator which works with structured programming.
A grammar parser which works with structured programming.
Test generated from structure.html
Base class for defining a parser for structured code.
Simple example of using structured programming constructs.
Base class for all structure nodes, defines an
eval method.Tests for the
structure package
using two different assignment operators.Jep functions which adds a
substitute(eqn,sub) preprocessing operator to perform
symbolic substitution.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.A rule which expands subtraction of vectors and matrices.
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.
The
symequals(x,y) command.Functions which can appear on the left-hand side of a symbolic assignment.
A simple type of token which represents a fixed string of characters.
Matches a fixed set of symbols, each represented by a SymbolToken.
Interface for handlers which transform individual elements.
The tan function.
Hyperbolic tan.
A terminal function constructed from an
PostfixMathCommand.A terminal function constructed from an
NaryBinaryFunction.Parse an expression followed by a separator.
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.Test generated from threads.html
Test generated from threads.html
Test generated from threads.html
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.
A set of Utility functions for working with Jep expression trees.
Tests for serialization the
TreeUtils class.Trims leading and trailing whitespace
The unary minus function
-x.Convenient base class for unary functions.
FunctionalInterface for the
BinaryFunction.instanceOf(Class, BiFunctionWithException) method.A rule which transforms a chain of functions into a nested function calls.
Tests for the
UncheckedEvaluator.An evaluator which does fewer checks on values with a 5% faster speed.
For unsupported tags, handle always throws a SAXParseException.
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.
Builder for jep variables, most variables are represented as <ci>x</ci>.
A factory class which is used to create variables.
Unit tests for the
VariableFactoryTests for hooks on Variables.
Replaces a variable "x" by "x + d" where d is a double value.
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.
PostfixMathCommand for variance and standard deviation.
Type of variance or standard deviation to calculate.
A console which illustrates a different syntax for vectors using mathematical (1,2,3) notation.
the tokenizer
Test for the
VectorConsoleDefines the basic interface implemented by all matrix types.
Summation function which expands the arguments.
Filter a list returning elements while a condition is true and skipping the rest.
A token filter that removes whitespace and comments.
Tokens representing sequence of white space characters.
Matches whitespace.
An assignment operator which implements the CommandVisitorI interface.
Standard set of components for use with XJep.
Evaluator which uses equations of variables.
Add the following functions to the standard function table:
clean(expr) - clean an expression.An extended version of Jep adds various routines for working with trees.
A Console application show the symbolic capabilities of the
XJep,
PolynomialCreator, and ExpressionCleaner including
functions for simplification, expansion comparison and conversion to arrays
of coefficients.Tests for the
XJepConsole application.Test generated from xjep.html
Tests for the
XJepTests for the
xjep package
using two different assignment operators.Tests for the light weight components of different field function tables.
Evaluator which uses equations of variables.
An operator table to use in the XJep.
Variables which have their equations stored.
A VariableFactory which creates XVariables (which have equations).
An extension of the VariableTable with a few new features.
Rules like
diff(x > y,x) -> 0 where the derivative should be zero.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.