com.graphbuilder.math

Class ExpressionTree

java.lang.Object

com.graphbuilder.math.ExpressionTree

public class ExpressionTree
extends java.lang.Object

Expression string parser. The parser returns an Expression object which can be evaluated.

The elements of an expression fall into two categories, operators and terms. Terms include variables, functions and values. Although values do not subclass TermNode, they are processed in a similar way during the parsing.

The operators are exponent (^), times (*), divide (/), plus (+) and minus (-). The exponent has the highest precedence, then times and divide (which have an equal level of precedence) and then plus and minus (which have an equal level of precedence). For those operators that have an equal level of precedence, the operator that comes first (reading from left to right) gets the higher level of precedence. For example, a-b+c becomes ((a-b)+c)

During the parsing, the string is scanned from left to right. Either a term or an operator will come next. If it is a term, then it may be preceded by an optional + or - sign. For example, For example +a/-b/+c is valid, and becomes ((a/(-b))/c). If a term is not explicitly signed, then by default it is positive.

If the first character of a term is a decimal (.) or a digit (0-9) then the term marks the beginning of a value. The first character that is found that is not a digit or a decimal marks the end of the value, except if the character is an 'e' or an 'E'. In this case, the first digit immediately following can be a plus sign, minus sign or digit. E.g. 1.23E+4. At this point, the first character that is not a digit marks the end of the value.

If the first character of a term is not a decimal, digit, open bracket '(', a close bracket ')', a comma ',', a whitespace character ' ', '\t', '\n', or an operator, then the character marks the beginning of a variable or function name. The first character found that is an operator, whitespace, open bracket, close bracket or comma marks the end of the name. If the first non-whitespace character after a name is an open bracket, then it marks the beginning of the function parameters, otherwise the term is marked as a variable.

Functions that accept more than one parameter will have the parameters separated by commas. E.g. f(x,y). Since the parameters of a function are also expressions, when a comma is detected that has exactly one unbalanced open bracket to the left, a recursive call is made passing in the substring. E.g. f(g(x,y),z), a recursive call will occur passing in the substring "g(x,y)".

Miscellaneous Notes

• Names cannot begin with a decimal or a digit since those characters mark the beginning of a value.
• In general, whitespace is ignored or marks the end of a name or value.
• Evaluation of values is done using the Double.parseDouble(...) method.
• Constants can be represented as functions that take no parameters. E.g. pi() or e()
• Round brackets '(' and ')' are the only brackets that have special meaning.
• The brackets in the expression must balance otherwise an ExpressionParseException is thrown.
• An ExpressionParseException is thrown in all cases where the expression string is invalid.
• All terms must be separated by an operator. E.g. 2x is not valid, but 2*x is.
• In cases where simplification is possible, simplification is not done. E.g. 2^4 is not simplified to 16.
• Computerized scientific notation is supported for values. E.g. 3.125e-4
• Scoped negations are not permitted. E.g. -(a) is not valid, but -1*(a) is.

See Also:

Expression

Constructor Summary

Constructors

Modifier	Constructor and Description
private	ExpressionTree()

Method Summary

Modifier and Type	Method and Description
private static Expression	build(Stack s1, Stack s2)
private static Expression	build(java.lang.String s, int indexErrorOffset)
static Expression	parse(java.lang.String s) Returns an expression-tree that represents the expression string.

Methods inherited from class java.lang.Object

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

Constructor Detail

ExpressionTree

private ExpressionTree()

Method Detail

parse

public static Expression parse(java.lang.String s)

Returns an expression-tree that represents the expression string. Returns null if the string is empty.

Throws:

ExpressionParseException - If the string is invalid.

build

private static Expression build(java.lang.String s,
                                int indexErrorOffset)

build

private static Expression build(Stack s1,
                                Stack s2)