com.singularsys.extensions.xjep

Class ExpressionCleaner

java.lang.Object

com.singularsys.jep.walkers.DoNothingVisitor

com.singularsys.extensions.xjep.ExpressionCleaner

All Implemented Interfaces:

JepComponent, ParserVisitor, java.io.Serializable

Direct Known Subclasses:

DExpressionCleaner

public class ExpressionCleaner
extends DoNothingVisitor

Cleans up expressions, removing redundant parts. To use

 Jep j = new Jep();
 TreeUtils tu = new TreeUtils(jep.getNumberFactory());
 SimplificationVisitor sv = new SimplificationVisitor(jep, tu);
 
 Node in = jep.parse("1*x^1+0");
 Node out = sv.clean(in);
 

Note this visitor works in-place.

See Also:

Serialized Form

Field Summary

Fields inherited from class com.singularsys.jep.walkers.DoNothingVisitor

ft, jep, nf, ot, vt

Constructor Summary

Constructors

Constructor and Description
ExpressionCleaner() Constructor to use when used with Jep.setComponent(JepComponent component).
ExpressionCleaner(Jep j, TreeUtils tu) Constructor with explicit Jep and TreeUtils instances.

Method Summary

Modifier and Type	Method and Description
Node	clean(Node node) Main entry point.
Node	cleanAdd(Node lhs, Node rhs) Cleans an addition.
Node	cleanBuildOperatorNode(Operator op, Node node)
Node	cleanBuildOperatorNode(Operator op, Node lhs, Node rhs) First create a new node and then clean it.
Node	cleanDivide(Node child1, Node child2) Cleans a division.
Node	cleanMultiply(Node child1, Node child2) Cleans a multiplication.
Node	cleanOp(Node node, Node... children) simplifies operators, does not descend into children
Node	cleanOp(Operator op, Node... children) Attempt to clean an operator.
Node	cleanPower(Node child1, Node child2) Simplify a power.
Node	cleanSubtract(Node lhs, Node rhs) Cleans a subtraction.
Node	cleanTripple(Operator op, Node lhs, Node rhs) Cleans expressions like 2+(3+x) or (2+x)+3
Node	cleanUMinus(Node node)
JepComponent	getLightWeightInstance() Gets a light-weight instance suitable for using in multiple threads.
void	init(Jep j) Initialize the component.
java.lang.Object	visit(ASTFunNode node, java.lang.Object data) Visit a function node.
java.lang.Object	visit(ASTOpNode node, java.lang.Object data) Visit a operator node.

Methods inherited from class com.singularsys.jep.walkers.DoNothingVisitor

childrenHaveChanged, copyChildrenIfNeeded, getFunctionTable, getNodeFactory, getOperatorTable, getVariableTable, visit, visit, visit, visitChildren, visitNode

Methods inherited from class java.lang.Object

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

Constructor Detail

ExpressionCleaner

public ExpressionCleaner()

Constructor to use when used with Jep.setComponent(JepComponent component). The reference to the jep instance and TreeUtils are found in init(Jep).

ExpressionCleaner

public ExpressionCleaner(Jep j,
                         TreeUtils tu)

Constructor with explicit Jep and TreeUtils instances. Can be used in a stand alone context.

Parameters:

j -

tu - TreeUtils class to use

Method Detail

getLightWeightInstance

public JepComponent getLightWeightInstance()

Description copied from interface: JepComponent

Gets a light-weight instance suitable for using in multiple threads.

Specified by:

getLightWeightInstance in interface JepComponent

Overrides:

getLightWeightInstance in class DoNothingVisitor

Returns:

this

init

public void init(Jep j)

Description copied from interface: JepComponent

Initialize the component. This methods is called whenever a component is added to Jep. Hence it allows components to keep track of the other components they may rely on.

Specified by:

init in interface JepComponent

Overrides:

init in class DoNothingVisitor

Parameters:

j - the current Jep instance

clean

public Node clean(Node node)
           throws ParseException

Main entry point. Cleans the node in place.

Parameters:

node - the base of the tree which will be modified.

Returns:

simplified version of the expression tree, no necessarily the same object as the input.

Throws:

ParseException

cleanBuildOperatorNode

public Node cleanBuildOperatorNode(Operator op,
                                   Node lhs,
                                   Node rhs)
                            throws ParseException

First create a new node and then clean it.

Throws:

ParseException

cleanBuildOperatorNode

public Node cleanBuildOperatorNode(Operator op,
                                   Node node)
                            throws ParseException

Throws:

ParseException

cleanOp

public Node cleanOp(Node node,
                    Node... children)
             throws ParseException

simplifies operators, does not descend into children

Throws:

ParseException

cleanOp

public Node cleanOp(Operator op,
                    Node... children)
             throws ParseException

Attempt to clean an operator.

Parameters:

op -

children -

Returns:

a simplified expression or null if it could be simplified.

Throws:

ParseException

cleanTripple

public Node cleanTripple(Operator op,
                         Node lhs,
                         Node rhs)
                  throws ParseException

Cleans expressions like 2+(3+x) or (2+x)+3

Parameters:

op - the root operator

lhs - the left hand side node

rhs - the right hand side node

Returns:

null if no rewrite happens or top node or top node of new tree.

Throws:

ParseException

cleanAdd

public Node cleanAdd(Node lhs,
                     Node rhs)
              throws ParseException

Cleans an addition. Performs the following rules

 0+x -> x
 x+0 -> x
 m+n -> (m+n) where m,n are numbers
 x - (-2) -> x + 2 for any negative number -2
 x + (-2) -> x - 2 for any negative number -2
 2 +/- ( 3 +/- x ) ->  (2 +/- 3 ) +/- x and similar
 

Throws:

ParseException

cleanSubtract

public Node cleanSubtract(Node lhs,
                          Node rhs)
                   throws ParseException

Cleans a subtraction. Performs the following rules

 +Infinity-x -> +Infinity 
 -Infinity-x -> -Infinity 
 x - +Infinity -> -Infinity 
 x - -Infinity -> +Infinity 
 0-x -> 0-x
 x-0 -> x
 m-n -> (m-n) where m,n are numbers
 x - (-2) -> x + 2 for any negative number -2
 x + (-2) -> x - 2 for any negative number -2
 2 +/- ( 3 +/- x ) ->  (2 +/- 3 ) +/- x and similar
 

Parameters:

lhs - the left hand side

rhs - the right hand side

Throws:

ParseException

cleanMultiply

public Node cleanMultiply(Node child1,
                          Node child2)
                   throws ParseException

Cleans a multiplication.

 0 * Inf -> NaN
 0 * x -> 0
 x * 0 -> 0
 1 * x -> x
 x * 1 -> x
 Inf * x -> Inf
 x * Inf -> Inf
 2 * ( 3 * x) -> (2*3) * x
 2 * (-x) -> -2 * x
 and similar.
 

Throws:

ParseException

cleanDivide

public Node cleanDivide(Node child1,
                        Node child2)
                 throws ParseException

Cleans a division.

 0/0 -> NaN
 0/Inf -> Inf
 0/x -> Inf
 x/0 -> Inf
 x/1 -> x
 Inf / x -> Inf
 x / Inf -> 0
 2 / ( 3 * x) -> (2/3) / x
 2 / ( x * 3) -> (2/3) / x
 2 / ( 3 / x) -> (2/3) * x
 2 / ( x / 3) -> (2*3) / x
 (2 * x) / 3 -> (2/3) * x
 (x * 2) / 3 -> x * (2/3)
 (2 / x) / 3 -> (2/3) / x
 (x / 2) / 3 -> x / (2*3)
 

Throws:

ParseException

cleanPower

public Node cleanPower(Node child1,
                       Node child2)
                throws ParseException

Simplify a power.

 x^0 -> 1
 x^1 -> x
 0^0 -> NaN
 0^x -> 0
 1^x -> 1
 

Throws:

ParseException

cleanUMinus

public Node cleanUMinus(Node node)
                 throws ParseException

Throws:

ParseException

visit

public java.lang.Object visit(ASTOpNode node,
                              java.lang.Object data)
                       throws ParseException

Description copied from class: DoNothingVisitor

Visit a operator node. Can be overridden by sub-classes.

Specified by:

visit in interface ParserVisitor

Overrides:

visit in class DoNothingVisitor

Throws:

ParseException

visit

public java.lang.Object visit(ASTFunNode node,
                              java.lang.Object data)
                       throws ParseException

Description copied from class: DoNothingVisitor

Visit a function node. Can be overridden by sub-classes.

Specified by:

visit in interface ParserVisitor

Overrides:

visit in class DoNothingVisitor

Throws:

ParseException