All Classes and Interfaces
Class
Description
Absolute value function.
Base class for pre and post increment operators.
Addition function.
The acos function.
Implements the arcCosH function.
Implements the arcSinH 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.
How to respond to a zero length array as argument
An assignment operator so we can do
x=3+4.A Constant Node.
Function Node
Function Node
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.
A set of components for working with big decimal numbers.
A function table for BigDecimals.
Tests the BigDecComponents through a set of test expressions that are evaluated.
A set of operators for using BigDecimal numbers
Implements the relational operations <, >, <=, >=, != and ==.
Rounding functions for BigDecimals.
Rounding functions to round to a specific number of significant figures.
The signum function for BigDecimals.
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.
Convenient base class for binary functions.
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.
Bitwise Xor, like the java a ^ b operator.
A GrammarMatcher which matches lists of items with the syntax
or a simple list
[1,2,3,4].Minimal implementation of the
java.io.BufferedReader.This class is intended to contain all tests related to reported bugs.
A function which can incorrectly read the stack.
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.
A Variable table which ignores case.
A PostfixMathCommandI which find the smallest integer above the number
ceil(pi) give 4
ceil(-i) give -3
Tokens representing comments.
Matches various styles of comments.
Implements the comparative operations <, >, <=, >=, != and ==.
Represents 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.
Collects all the components which make up the Jep system.
Represent an incomplete set of components.
Concatenates string arguments.
A configurable parser.
The complex conjugate of a number conj(c)
This class implements a simple command line utility for evaluating
mathematical expressions.
Values returned by @link{testSpecialCommands(String command)}.
Functions which always return a constant value.
The cotangent function.
Tests for the configurable parser.
Tests for the configurable parser.
The cross product of two 3D vectors.
Simple implementation, just prints the value, does not attempt to round to values.
Simple implementation, with just Infinity and NaN.
A Visitor which returns an exact copy of the tree.
Test various features until failure.
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.
GWT compatible version of the example messages class
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.
A base class for operator tables, this class has no pre-defined operators.
All operators enums must implement this interface.
Exceptions thrown during evaluation.
Defines a method which can be used to evaluate a part of a node-tree.
Class to examine the results types of the various operators
and function.
The exp function.
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 two
suffix operators: n! (factorial) and n% (percentage).
Tests for modification to the configurable parser.
Simple implementation of factorial, good up to 20!
Do nothing implementation.
A PostfixMathCommandI which find the largest integer above the number
floor(pi) give 3
floor(-i) give -4
PostfixMathCommand which converts a string to a number in a given base.
A GrammarMatcher which matches functions in the form 'atan2(y,x)'.
A GrammarMatcher which matches functions in the form
atan2(seq) where
seq is a sequence of terms.Holds a set of functions.
A table holding details of the functions known to Jep.
A token representing a function name.
Signals grammatical errors.
Interface defining matchers for custom grammatical elements.
Interface used by
GrammarMatcherAbstract Factory defining how to create a GrammarParser
GWT enabled Console application.
Class handling most of the I/O interaction of of Console apps so that they can use an HTML TextArea
for I/O.
Interface to represent the properties in the message file.
GWT entry point exposing parts of the Jep system to JavaScript using the JSNI system.
GWT entry point exposing parts of the Jep system to JavaScript using the JsInterop system.
Wrapper type for a
Node that can be passed back to JavaScriptWrapper type for a
Variable that can be passed back to JavaScriptEntry point classes allowing the all examples to be accessed from the same library.
Interface to represent the properties in the message file.
A Simple GWT application.
Matches hexadecimal numbers, in the format 0xff.
Remove a specific hook from any node which has it on a tree
Token representing variables or function.
Matches identifiers: variables or function names.
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.
An operator table which supports most of the operators which appear in Java.
Token literal values and constants.
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.
GWT Version of the Message access class
A RuntimeException which wraps a JepException for use in cases where
throwing a JepException is not possible.
Tests various functions on the Jep class.
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.
A NodeFactory which adds line numbering information to nodes.
Version of the shunting yard algorithm which sets lines numbers in the parse tree.
The list function.
A GrammarMatcher which matches lists of items.
A GrammarMatcher which matches overloaded lists of items or brackets.
Log base 10.
Log 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.
A function specified by a string.
A very restricted re-implementation of the Matcher class.
A medium weight set of components reusing components from an existing Jep instance.
A simplified replacement for java.text.MessageFormat
uses code from stackoverflow
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.
Calculates the modulus x % y of the arguments.
Matches tokens which span multiple lines of the input.
A token representing a token which spans multiple lines.
Convenient base class for n-ary functions backed by a binary operation.
Convenient base class for nary functions.
Natural logarithm.
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.
Implementation of the not function.
Convenient base class for zero-argument nullary functions, like
random().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.
This interface can be implemented to create numbers of any object type.
very simple NumberFormat implementation, just appends the value to the buffer
with no attempt to set the number of digits.
Represent numbers.
Matches numbers.
An Operator with additional information about its commutativity etc.
A GrammarMatcher which matches functions in the form '
+(x,y)' where + is an operator.
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.
Exception thrown at parse time.
This exception is thrown when parse errors are encountered.
Defines the methods a parser must implement.
Classes which wish to use the visitor pattern should use this interface.
Tests the speed of parsing.
A very restricted re-implementation of the Pattern class.
Converts an [r,theta] pair to a complex number r * e^(i theta).
Java style x-- operator.
Evaluation component that avoids excessive use of the stack for large
expressions.
Function classes extend this class.
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.
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.
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.
Encapsulates the Math.random() function.
Finds the real part of a complex number.
A set of components for real (non-complex) evaluation.
Performs 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.
A 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.
Extract the right most n characters from a string: right("abcdefg",2) -> "fg".
A PostfixMathCommandI which rounds a number to the closest integer.
rint(2.4) finds the closest integer to the argument (2).
rint(2.1234, 3) rounds the argument to 3 decimal places (2.123).
rint(2.4) finds the closest integer to the argument (2).
rint(2.1234, 3) rounds the argument to 3 decimal places (2.123).
A PostfixMathCommandI which rounds a number.
round(a) adds 0.5 to the argument and returns the closest integer.round(a,3) rounds the argument to 3 decimal places.Rounding functions using
BigDecimal.setScale(int, RoundingMode)
this should handle tricky cases like round(265.335,2) correctly.A GrammarMatcher which matches bracketed expressions.
Rounds to a specific number of significant figures.
Bitwise right shift with sign extension, like the java a >> b operator.
Do nothing implementation.
The secant function.
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.
Hyperbolic sin.
A matcher for functions like "sin 30" without brackets and a single simple argument.
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 FastEvaluator)
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
Compares the speed of evaluation between different evaluation schemes.
Basic class to set the evaluation context
Standard Jep configuration (with FastEvaluator)
Standard Jep configuration (with FastEvaluator)
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
Square root function.
An Evaluator which checks the stack size after every function call.
The standard set of components.
Performs the regular JepTests using the StandardEvaluator
The old standard operator table used by Jep.
Provides the standard implementations of operators used by Jep.
Empty placeholder class
A VariableTable which defines some constant values.
Converts an object into its string representation.
A 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.
Extract substring of first argument: substring("abcdefg",2,4) -> "cd".
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 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 ? x : y behaviour
Since 4.0 this now operates in a lazy fashion so only the needed branch is evaluated.A class representing a ternary operator, for example x?y:z.
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.
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.
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
Convenient base class for unary functions.
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.
Some common utility methods
Information about a variable.
A factory class which is used to create variables.
A table of variables.
A console which illustrates a different syntax for vectors using mathematical (1,2,3) notation.
Summation function which expands the arguments.
Tokens representing sequence of white space characters.
Matches whitespace.