Uses of Interface
org.nfunk.jep.Node

Packages that use Node

Package	Description
org.lsmp.djep.djep
org.lsmp.djep.djep.diffRules
org.lsmp.djep.groupJep
org.lsmp.djep.matrixJep
org.lsmp.djep.matrixJep.function
org.lsmp.djep.matrixJep.nodeTypes
org.lsmp.djep.mrpe
org.lsmp.djep.rewrite
org.lsmp.djep.rpe
org.lsmp.djep.sjep
org.lsmp.djep.vectorJep
org.lsmp.djep.vectorJep.function
org.lsmp.djep.xjep
org.lsmp.djep.xjep.function
org.lsmp.djepExamples
org.nfunk.jep
org.nfunk.jep.evaluation
org.nfunk.jep.function

Uses of Node in org.lsmp.djep.djep

Methods in org.lsmp.djep.djep that return Node

Modifier and Type	Method and Description
Node	DiffRulesI.differentiate(ASTFunNode node, String var, Node[] children, Node[] dchildren, DJep djep) Returns the top node of of the derivative of this function wrt to variable var.
Node	DJep.differentiate(Node node, String name) Differentiate an equation with respect to a variable.
Node	DifferentiationVisitor.differentiate(Node node, String var, DJep djep) Differentiates an expression tree wrt a variable var.
Node	Diff.process(Node node, Node[] children, XJep xjep) Process the differentiation specified by node.

Methods in org.lsmp.djep.djep with parameters of type Node

Modifier and Type	Method and Description
PartialDerivative	DVariableFactory.createDerivative(DVariable var, String[] dnames, Node eqn) Creates a partial derivative of a given variable.
protected PartialDerivative	DVariable.createDerivative(String[] derivnames, Node eqn)
Node	DiffRulesI.differentiate(ASTFunNode node, String var, Node[] children, Node[] dchildren, DJep djep) Returns the top node of of the derivative of this function wrt to variable var.
Node	DiffRulesI.differentiate(ASTFunNode node, String var, Node[] children, Node[] dchildren, DJep djep) Returns the top node of of the derivative of this function wrt to variable var.
Node	DJep.differentiate(Node node, String name) Differentiate an equation with respect to a variable.
Node	DifferentiationVisitor.differentiate(Node node, String var, DJep djep) Differentiates an expression tree wrt a variable var.
Node	Diff.process(Node node, Node[] children, XJep xjep) Process the differentiation specified by node.
Node	Diff.process(Node node, Node[] children, XJep xjep) Process the differentiation specified by node.
void	DVariable.setEquation(Node eqn) sets the equation

Constructors in org.lsmp.djep.djep with parameters of type Node

Constructor and Description
PartialDerivative(DVariable var, String[] derivnames, Node deriv)

Uses of Node in org.lsmp.djep.djep.diffRules

Fields in org.lsmp.djep.djep.diffRules declared as Node

Modifier and Type	Field and Description
protected Node[]	ChainRuleDiffRules.rules

Methods in org.lsmp.djep.djep.diffRules that return Node

Modifier and Type	Method and Description
Node	SubtractDiffRule.differentiate(ASTFunNode node, String var, Node[] children, Node[] dchildren, DJep djep)
Node	PowerDiffRule.differentiate(ASTFunNode node, String var, Node[] children, Node[] dchildren, DJep djep)
Node	PassThroughDiffRule.differentiate(ASTFunNode node, String var, Node[] children, Node[] dchildren, DJep djep)
Node	MultiplyDiffRule.differentiate(ASTFunNode node, String var, Node[] children, Node[] dchildren, DJep djep)
Node	DivideDiffRule.differentiate(ASTFunNode node, String var, Node[] children, Node[] dchildren, DJep djep)
Node	ChainRuleDiffRules.differentiate(ASTFunNode node, String var, Node[] children, Node[] dchildren, DJep djep) Use the chain rule to differentiate.
Node	AdditionDiffRule.differentiate(ASTFunNode node, String var, Node[] children, Node[] dchildren, DJep djep)
Node	ChainRuleDiffRules.getRule(int i) returns the i-th rule as an expression tree.

Methods in org.lsmp.djep.djep.diffRules with parameters of type Node

Modifier and Type	Method and Description
Node	SubtractDiffRule.differentiate(ASTFunNode node, String var, Node[] children, Node[] dchildren, DJep djep)
Node	SubtractDiffRule.differentiate(ASTFunNode node, String var, Node[] children, Node[] dchildren, DJep djep)
Node	PowerDiffRule.differentiate(ASTFunNode node, String var, Node[] children, Node[] dchildren, DJep djep)
Node	PowerDiffRule.differentiate(ASTFunNode node, String var, Node[] children, Node[] dchildren, DJep djep)
Node	PassThroughDiffRule.differentiate(ASTFunNode node, String var, Node[] children, Node[] dchildren, DJep djep)
Node	PassThroughDiffRule.differentiate(ASTFunNode node, String var, Node[] children, Node[] dchildren, DJep djep)
Node	MultiplyDiffRule.differentiate(ASTFunNode node, String var, Node[] children, Node[] dchildren, DJep djep)
Node	MultiplyDiffRule.differentiate(ASTFunNode node, String var, Node[] children, Node[] dchildren, DJep djep)
Node	DivideDiffRule.differentiate(ASTFunNode node, String var, Node[] children, Node[] dchildren, DJep djep)
Node	DivideDiffRule.differentiate(ASTFunNode node, String var, Node[] children, Node[] dchildren, DJep djep)
Node	ChainRuleDiffRules.differentiate(ASTFunNode node, String var, Node[] children, Node[] dchildren, DJep djep) Use the chain rule to differentiate.
Node	ChainRuleDiffRules.differentiate(ASTFunNode node, String var, Node[] children, Node[] dchildren, DJep djep) Use the chain rule to differentiate.
Node	AdditionDiffRule.differentiate(ASTFunNode node, String var, Node[] children, Node[] dchildren, DJep djep)
Node	AdditionDiffRule.differentiate(ASTFunNode node, String var, Node[] children, Node[] dchildren, DJep djep)

Constructors in org.lsmp.djep.djep.diffRules with parameters of type Node

Constructor and Description
MacroDiffRules(DJep djep, String inName, Node node) Create a differention rule for function with 1 argument

Uses of Node in org.lsmp.djep.groupJep

Methods in org.lsmp.djep.groupJep with parameters of type Node

Modifier and Type	Method and Description
Polynomial	PolynomialVisitor.calcPolynomial(Node node, FreeGroup fg) calculates a polynomial representing the node.

Uses of Node in org.lsmp.djep.matrixJep

Methods in org.lsmp.djep.matrixJep that return Node

Modifier and Type	Method and Description
Node	MatrixVariableI.getEquation() The equation represented by this variable.
Node	MatrixJep.preprocess(Node node) Pre-processes an equation to allow the diff and eval operators to be used.

Methods in org.lsmp.djep.matrixJep with parameters of type Node

Modifier and Type	Method and Description
ASTFunNode	MatrixNodeFactory.buildFunctionNode(ASTFunNode node, Node[] children) Builds a function with n arguments
ASTFunNode	MatrixNodeFactory.buildFunctionNode(ASTFunNode node, Node[] arguments, Dimensions dim) create a function node with a known dimension
ASTFunNode	MatrixNodeFactory.buildFunctionNode(String name, PostfixMathCommandI pfmc, Node[] arguments) Builds a function with n arguments
ASTFunNode	MatrixNodeFactory.buildOperatorNode(Operator op, Node[] arguments) Builds a operator node with n arguments
ASTFunNode	MatrixNodeFactory.buildOperatorNode(Operator op, Node[] arguments, Dimensions dim) create a function node with a known dimension
Dimensions	MatrixNodeFactory.calcDim(Operator op, Node[] arguments) Calculates the dimension of node using the dimensions of the children.
Dimensions	MatrixNodeFactory.calcDim(String name, PostfixMathCommandI pfmc, Node[] arguments) Calculates the dimension of node using the dimensions of the children.
PartialDerivative	MatrixVariableFactory.createDerivative(DVariable var, String[] dnames, Node eqn) create a derivative
protected PartialDerivative	MatrixVariable.createDerivative(String[] derivnames, Node eqn)
Object	MatrixEvaluator.eval(Node node)
Object	MatrixJep.evaluate(Node node) Evaluate a node.
Object	MatrixJep.evaluateRaw(Node node) Evaluate a node.
Node	MatrixJep.preprocess(Node node) Pre-processes an equation to allow the diff and eval operators to be used.
MatrixNodeI	MatrixPreprocessor.preprocess(Node node, MatrixJep mdjep) Main entry point: pre-process a node.
MatrixNodeI[]	MatrixPreprocessor.visitChildrenAsArray(Node node, Object data) Returns an array of matrix nodes which are the results of visiting each child.

Constructors in org.lsmp.djep.matrixJep with parameters of type Node

Constructor and Description
MatrixPartialDerivative(MatrixVariable var, String[] derivnames, Node deriv) Protected constructor, should only be constructed through the findDerivative method in MatrixVariable.

Uses of Node in org.lsmp.djep.matrixJep.function

Methods in org.lsmp.djep.matrixJep.function with parameters of type Node

Modifier and Type	Method and Description
void	MList.append(Node node, PrintVisitor pv) Used to print the TensorNode with all its children.
void	MArrayAccess.append(Node node, PrintVisitor pv)

Uses of Node in org.lsmp.djep.matrixJep.nodeTypes

Subinterfaces of Node in org.lsmp.djep.matrixJep.nodeTypes

Modifier and Type	Interface and Description
interface	MatrixNodeI

Classes in org.lsmp.djep.matrixJep.nodeTypes that implement Node

Modifier and Type	Class and Description
class	ASTMConstant Holds a single constant number.
class	ASTMFunNode
class	ASTMVarNode

Uses of Node in org.lsmp.djep.mrpe

Methods in org.lsmp.djep.mrpe with parameters of type Node

Modifier and Type	Method and Description
MRpCommandList	MRpEval.compile(MatrixVariableI var, Node node) compile an expression of the type var = node.
MRpCommandList	MRpEval.compile(Node node) Compile the expressions to produce a set of commands in reverse Polish notation.

Uses of Node in org.lsmp.djep.rewrite

Methods in org.lsmp.djep.rewrite that return Node

Modifier and Type	Method and Description
Node	RewriteRuleI.apply(ASTFunNode node, Node[] children) Rewrites the node
Node	ExpandPower.apply(ASTFunNode node, Node[] children)
Node	ExpandBrackets.apply(ASTFunNode node, Node[] children)
Node	CollectPowers.apply(ASTFunNode node, Node[] children)
Node	RewriteVisitor.rewrite(Node node, XJep xjep, RewriteRuleI[] inrules, boolean simplify) must be implemented for subclasses.

Methods in org.lsmp.djep.rewrite with parameters of type Node

Modifier and Type	Method and Description
Node	RewriteRuleI.apply(ASTFunNode node, Node[] children) Rewrites the node
Node	ExpandPower.apply(ASTFunNode node, Node[] children)
Node	ExpandBrackets.apply(ASTFunNode node, Node[] children)
Node	CollectPowers.apply(ASTFunNode node, Node[] children)
Node	RewriteVisitor.rewrite(Node node, XJep xjep, RewriteRuleI[] inrules, boolean simplify) must be implemented for subclasses.
boolean	RewriteRuleI.test(ASTFunNode node, Node[] children) Returns true if node needs to be rewritten, according to this rule.
boolean	ExpandPower.test(ASTFunNode node, Node[] children)
boolean	ExpandBrackets.test(ASTFunNode node, Node[] children)
boolean	CollectPowers.test(ASTFunNode node, Node[] children)

Uses of Node in org.lsmp.djep.rpe

Methods in org.lsmp.djep.rpe with parameters of type Node

Modifier and Type	Method and Description
RpCommandList	RpEval.compile(Node node) Compile the expressions to produce a set of commands in reverse Polish notation.

Uses of Node in org.lsmp.djep.sjep

Methods in org.lsmp.djep.sjep that return Node

Modifier and Type	Method and Description
Node	PolynomialCreator.expand(Node node) Expands an expression.
Node	PolynomialCreator.simplify(Node node) Simplifies an expression.
Node	PVariable.toNode()
Node	POperator.toNode()
Node	Polynomial.toNode()
Node	PNodeI.toNode() Converts the node to standard JEP format.
Node	PFunction.toNode()
Node	PConstant.toNode()
Node	Monomial.toNode()

Methods in org.lsmp.djep.sjep with parameters of type Node

Modifier and Type	Method and Description
int	PolynomialCreator.compare(Node node1, Node node2) Compares two nodes.
PNodeI	PolynomialCreator.createPoly(Node node) Converts an expression into the polynomial representation.
boolean	PolynomialCreator.equals(Node node1, Node node2) Compares two nodes.
Node	PolynomialCreator.expand(Node node) Expands an expression.
Node	PolynomialCreator.simplify(Node node) Simplifies an expression.

Uses of Node in org.lsmp.djep.vectorJep

Methods in org.lsmp.djep.vectorJep with parameters of type Node

Modifier and Type	Method and Description
Object	VectorJep.evaluate(Node node) Evaluate a node.
Object	VectorJep.evaluateRaw(Node node) Evaluate a node.

Uses of Node in org.lsmp.djep.vectorJep.function

Methods in org.lsmp.djep.vectorJep.function with parameters of type Node

Modifier and Type	Method and Description
Object	VMap.evaluate(Node node, EvaluatorI pv)
Object	GenMat.evaluate(Node node, EvaluatorI pv)
static Variable[]	VMap.getVars(Node varsNode)
void	ArrayAccess.set(EvaluatorI pv, Node node, Object value) Sets the LValue.

Uses of Node in org.lsmp.djep.xjep

Methods in org.lsmp.djep.xjep that return Node

Modifier and Type	Method and Description
protected Node[]	DoNothingVisitor.acceptChildrenAsArray(Node node, Object data) Gets the result of visiting children of a array of nodes.
Node	XJep.continueParsing() Continue parsing without re-initilising the stream.
static Node	TreeUtils.copyChildrenIfNeeded(Node node, Node[] children) Sets the children of a node if they have changed for it current children.
Node	XJep.deepCopy(Node node) Returns a deep copy of an expression tree.
Node	DeepCopyVisitor.deepCopy(Node node, XJep xj) Creates a deepCopy of a Node
static Node[]	TreeUtils.getChildrenAsArray(Node node) returns the children of a node as an array of nodes.
Node	XVariable.getEquation() get the equation
Node	MacroFunction.getTopNode()
Node	XJep.preprocess(Node node) Pre-processes an equation to allow the diff and eval operators to be used.
Node	Eval.process(Node node, Node[] children, XJep xjep)
Node	CommandVisitorI.process(Node node, Node[] children, XJep xjep) Performs the specified action on an expression tree.
Node	CommandVisitor.process(Node node, XJep xj) Descends the tree processing all diff, eval and simplify options
Node	XJep.simplify(Node node) Returns a simplification of an expression tree.
Node	SimplificationVisitor.simplify(Node node, XJep xjep) must be implemented for subclasses.
Node	SimplificationVisitor.simplifyAdd(Node lhs, Node rhs) Simplifies an addition.
Node	SimplificationVisitor.simplifyBuiltOperatorNode(Operator op, Node lhs, Node rhs) First create a new node and then simplify it.
Node	SimplificationVisitor.simplifyDivide(Node child1, Node child2) Simplifies a division.
Node	SimplificationVisitor.simplifyMultiply(Node child1, Node child2) Simplifies a multiplication.
Node	SimplificationVisitor.simplifyOp(ASTFunNode node, Node[] children) simplifies operators, does not descend into children
Node	SimplificationVisitor.simplifyPower(Node child1, Node child2) Simplify a power.
Node	SimplificationVisitor.simplifySubtract(Node lhs, Node rhs) Simplifies a subtraction.
Node	SimplificationVisitor.simplifyTripple(XOperator op, Node lhs, Node rhs) Simplifies expressions like 2+(3+x) or (2+x)+3
Node	XJep.substitute(Node orig, String[] names, Node[] replacements) Substitute all occurrences of a set of named variable with a set of expression tree.
Node	SubstitutionVisitor.substitute(Node orig, String[] names, Node[] replacements, XJep xj) Substitutes all occurrences of a set of variable var with a set of replacements.
Node	XJep.substitute(Node orig, String name, Node replacement) Substitute all occurrences of a named variable with an expression tree.
Node	SubstitutionVisitor.substitute(Node orig, String name, Node replacement, XJep xj) Substitutes all occurrences of variable var with replacement.

Methods in org.lsmp.djep.xjep with parameters of type Node

Modifier and Type	Method and Description
Object	ErrorCatchingVisitor.acceptCatchingErrors(Node node, Object data) calls jjtAccept inside a try catch block, adding the error if necessary
protected Node[]	DoNothingVisitor.acceptChildrenAsArray(Node node, Object data) Gets the result of visiting children of a array of nodes.
void	PrintVisitor.PrintRulesI.append(Node node, PrintVisitor pv) The method called to append data for the rule.
ASTConstant	NodeFactory.buildConstantNode(Operator op, Node child1) Creates a ASTConstant whose value of applying a unary operator to its arguments.
ASTConstant	NodeFactory.buildConstantNode(Operator op, Node[] children) Creates a ASTConstant whose value of applying the operator to its arguments.
ASTConstant	NodeFactory.buildConstantNode(Operator op, Node child1, Node child2) Creates a ASTConstant whose value of applying binary operator to its arguments.
ASTConstant	NodeFactory.buildConstantNode(PostfixMathCommandI pfmc, Node[] children) Creates a ASTConstant whose value of applying the operator to its arguments.
ASTFunNode	NodeFactory.buildFunctionNode(ASTFunNode node, Node[] arguments) Builds a function with n arguments and same fun as specified in arguments.
ASTFunNode	NodeFactory.buildFunctionNode(String name, PostfixMathCommandI pfmc, Node[] arguments) Builds a function with n arguments This method should be sub-classed
ASTFunNode	NodeFactory.buildOperatorNode(Operator op, Node child) creates a unary function.
ASTFunNode	NodeFactory.buildOperatorNode(Operator op, Node[] arguments) Builds a operator node with n arguments This method should be sub-classed
ASTFunNode	NodeFactory.buildOperatorNode(Operator op, Node lhs, Node rhs) creates a binary function.
Complex	TreeUtils.complexValue(Node node) Returns the Complex value represented by node
void	NodeFactory.copyChildren(Node node, Node[] children) Sets the children of node to be those specified in array.
void	NodeFactory.copyChildren(Node node, Node[] children) Sets the children of node to be those specified in array.
static Node	TreeUtils.copyChildrenIfNeeded(Node node, Node[] children) Sets the children of a node if they have changed for it current children.
static Node	TreeUtils.copyChildrenIfNeeded(Node node, Node[] children) Sets the children of a node if they have changed for it current children.
Node	XJep.deepCopy(Node node) Returns a deep copy of an expression tree.
Node	DeepCopyVisitor.deepCopy(Node node, XJep xj) Creates a deepCopy of a Node
double	TreeUtils.doubleValue(Node node) Returns the double value represented by node
Object	XJep.evaluate(PostfixMathCommandI pfmc, Node node)
static Node[]	TreeUtils.getChildrenAsArray(Node node) returns the children of a node as an array of nodes.
String	TreeUtils.getName(Node node) Returns the value represented by node
Operator	TreeUtils.getOperator(Node node) returns the operator for a node or null if it is not an operator node.
Object	TreeUtils.getValue(Node node) Returns the value represented by node
Vector	XJep.getVarsInEquation(Node n, Vector v) Finds all the variables in an equation.
int	TreeUtils.intValue(Node node) Returns the int value represented by node
boolean	TreeUtils.isBinaryOperator(Node node)
boolean	TreeUtils.isComplex(Node node) returns true if node is an ASTConstant of type Complex
boolean	TreeUtils.isConstant(Node node) returns true if node is a ASTConstant
boolean	TreeUtils.isFunction(Node node) returns true if node is an ASTFunNode
boolean	TreeUtils.isInfinity(Node node) returns true if node is a ASTConstant with a Infinite component TODO do proper treatment of signed infinity
boolean	TreeUtils.isInteger(Node node) returns true if node is a ASTConstant with Double value representing an integer.
boolean	TreeUtils.isMinusOne(Node node) returns true if node is a ASTConstant with value Double(-1) or Complex(-1,0)
boolean	TreeUtils.isNaN(Node node) returns true if node is a ASTConstant with a NaN component
boolean	TreeUtils.isNegative(Node node) returns true if node is an ASTConstant with a negative Double value
boolean	TreeUtils.isOne(Node node) returns true if node is a ASTConstant with value Double(1) or Complex(1,0)
boolean	TreeUtils.isOperator(Node node) returns true if node is an ASTOpNode
boolean	TreeUtils.isPositive(Node node) returns true if node is an ASTConstant with a positive Double value
boolean	TreeUtils.isReal(Node node) returns true if node is a ASTConstant with Double value
boolean	TreeUtils.isUnaryOperator(Node node)
boolean	TreeUtils.isVariable(Node node) returns true if node is an ASTVarNode
boolean	TreeUtils.isZero(Node node) returns true if node is a ASTConstant with value Double(0) or Complex(0,0)
boolean	TreeUtils.isZero(Node node, double tol) returns true if node is a ASTConstant with value Double(0) or Complex(0,0)
long	TreeUtils.longValue(Node node) Returns the long value represented by node
Node	XJep.preprocess(Node node) Pre-processes an equation to allow the diff and eval operators to be used.
void	XJep.print(Node node) Prints the expression tree on standard output.
void	PrintVisitor.print(Node node) Prints on System.out.
void	XJep.print(Node node, PrintStream out) Prints the expression tree on given stream.
void	PrintVisitor.print(Node node, PrintStream out) Prints the tree descending from node with lots of brackets or specified stream.
void	XJep.println(Node node) Prints the expression tree on standard output with newline at end.
void	PrintVisitor.println(Node node) Prints on System.out.
void	XJep.println(Node node, PrintStream out) Prints the expression tree on given stream with newline at end.
void	PrintVisitor.println(Node node, PrintStream out) Prints the tree descending from node with a newline at end.
Node	Eval.process(Node node, Node[] children, XJep xjep)
Node	Eval.process(Node node, Node[] children, XJep xjep)
Node	CommandVisitorI.process(Node node, Node[] children, XJep xjep) Performs the specified action on an expression tree.
Node	CommandVisitorI.process(Node node, Node[] children, XJep xjep) Performs the specified action on an expression tree.
Node	CommandVisitor.process(Node node, XJep xj) Descends the tree processing all diff, eval and simplify options
Vector	XJep.recursiveGetVarsInEquation(Node n, Vector v) Finds all the variables in an equation and if any of those variables are defined by equations find the variables in those equations as well.
void	XVariable.setEquation(Node eqn) sets the equation
Node	XJep.simplify(Node node) Returns a simplification of an expression tree.
Node	SimplificationVisitor.simplify(Node node, XJep xjep) must be implemented for subclasses.
Node	SimplificationVisitor.simplifyAdd(Node lhs, Node rhs) Simplifies an addition.
Node	SimplificationVisitor.simplifyBuiltOperatorNode(Operator op, Node lhs, Node rhs) First create a new node and then simplify it.
Node	SimplificationVisitor.simplifyDivide(Node child1, Node child2) Simplifies a division.
Node	SimplificationVisitor.simplifyMultiply(Node child1, Node child2) Simplifies a multiplication.
Node	SimplificationVisitor.simplifyOp(ASTFunNode node, Node[] children) simplifies operators, does not descend into children
Node	SimplificationVisitor.simplifyPower(Node child1, Node child2) Simplify a power.
Node	SimplificationVisitor.simplifySubtract(Node lhs, Node rhs) Simplifies a subtraction.
Node	SimplificationVisitor.simplifyTripple(XOperator op, Node lhs, Node rhs) Simplifies expressions like 2+(3+x) or (2+x)+3
Node	XJep.substitute(Node orig, String[] names, Node[] replacements) Substitute all occurrences of a set of named variable with a set of expression tree.
Node	XJep.substitute(Node orig, String[] names, Node[] replacements) Substitute all occurrences of a set of named variable with a set of expression tree.
Node	SubstitutionVisitor.substitute(Node orig, String[] names, Node[] replacements, XJep xj) Substitutes all occurrences of a set of variable var with a set of replacements.
Node	SubstitutionVisitor.substitute(Node orig, String[] names, Node[] replacements, XJep xj) Substitutes all occurrences of a set of variable var with a set of replacements.
Node	XJep.substitute(Node orig, String name, Node replacement) Substitute all occurrences of a named variable with an expression tree.
Node	SubstitutionVisitor.substitute(Node orig, String name, Node replacement, XJep xj) Substitutes all occurrences of variable var with replacement.
String	XJep.toString(Node node) Returns a string representation of a expression tree.
String	PrintVisitor.toString(Node node) returns a String representation of the equation.

Uses of Node in org.lsmp.djep.xjep.function

Methods in org.lsmp.djep.xjep.function that return Node

Modifier and Type	Method and Description
Node	XAssign.process(Node node, Node[] children, XJep xjep) In the pre-process stage, set the equation of the lhs variable to the rhs equation.
Node	Define.process(Node node, Node[] children, XJep xjep)

Methods in org.lsmp.djep.xjep.function with parameters of type Node

Modifier and Type	Method and Description
Object	SumType.evaluate(Node node, EvaluatorI pv) Evaluates the operator in given context.
Object	Trapezium.evaluate(Node node, Variable var, double min, double max, double inc, EvaluatorI pv)
Object	SumType.evaluate(Node node, Variable var, double min, double max, double inc, EvaluatorI pv) Evaluates the node by repeatibly setting the value of the variable from min to max, and calculating the value of the first argument.
Object	MinArg.evaluate(Node node, Variable var, double min, double max, double inc, EvaluatorI pv)
Object	MaxArg.evaluate(Node node, Variable var, double min, double max, double inc, EvaluatorI pv)
Node	XAssign.process(Node node, Node[] children, XJep xjep) In the pre-process stage, set the equation of the lhs variable to the rhs equation.
Node	XAssign.process(Node node, Node[] children, XJep xjep) In the pre-process stage, set the equation of the lhs variable to the rhs equation.
Node	Define.process(Node node, Node[] children, XJep xjep)
Node	Define.process(Node node, Node[] children, XJep xjep)

Uses of Node in org.lsmp.djepExamples

Methods in org.lsmp.djepExamples with parameters of type Node

Modifier and Type	Method and Description
void	XJepConsole.processEquation(Node node)
void	SJepConsole.processEquation(Node node)
void	MatrixConsole.processEquation(Node node)
void	GroupConsole.processEquation(Node node)
void	DJepConsole.processEquation(Node node)
void	Console.processEquation(Node node) Performs the required operation on a node.
void	BlockStatments.processEquation(Node node) Evaluates a node, but only if the state corresponds to the conditionValue.

Uses of Node in org.nfunk.jep

Classes in org.nfunk.jep that implement Node

Modifier and Type	Class and Description
class	ASTConstant Constant Node
class	ASTFunNode Function Node
class	ASTStart Start Node
class	ASTVarNode Variable Node
class	SimpleNode

Fields in org.nfunk.jep declared as Node

Modifier and Type	Field and Description
protected Node[]	SimpleNode.children
protected Node	SimpleNode.parent

Methods in org.nfunk.jep that return Node

Modifier and Type	Method and Description
Node	Parser.continueParse() Continue parsing without re-initilising stream.
Node	JEP.getTopNode() Returns the top node of the expression tree.
Node	SimpleNode.jjtGetChild(int i)
Node	Node.jjtGetChild(int i) This method returns a child node.
Node	SimpleNode.jjtGetParent()
Node	Node.jjtGetParent()
Node	JEP.parse(String expression) Parses an expression.
Node	JEP.parseExpression(String expression_in) Parses the expression.
Node	Parser.parseStream(Reader stream, JEP jep_in)

Methods in org.nfunk.jep with parameters of type Node

Modifier and Type	Method and Description
Object	EvaluatorVisitor.eval(Node node) Evaluates a given node, in the current context.
Object	EvaluatorI.eval(Node node) Evaluates a node and returns and object with the value of the node.
Object	EvaluatorVisitor.eval(PostfixMathCommandI pfmc, Node[] children) Evaluates a PostfixMathCommandI with given arguments.
Object	JEP.evaluate(Node node) Evaluate an expression.
Object	EvaluatorVisitor.getValue(Node topNode, SymbolTable symTab_in) Returns the value of the expression as an object.
void	SimpleNode.jjtAddChild(Node n, int i)
void	Node.jjtAddChild(Node n, int i) This method tells the node to add its argument to the node's list of children.
void	SimpleNode.jjtSetParent(Node n)
void	Node.jjtSetParent(Node n) This pair of methods are used to inform the node of its parent.

Uses of Node in org.nfunk.jep.evaluation

Methods in org.nfunk.jep.evaluation with parameters of type Node

Modifier and Type	Method and Description
CommandElement[]	ExpressionCompiler.compile(Node node)

Uses of Node in org.nfunk.jep.function

Methods in org.nfunk.jep.function with parameters of type Node

Modifier and Type	Method and Description
Object	If.evaluate(Node node, EvaluatorI pv)
Object	CallbackEvaluationI.evaluate(Node node, EvaluatorI pv) Performs some special evaluation on the node.
Object	Assign.evaluate(Node node, EvaluatorI pv) For assignment set the value of the variable on the lhs to value returned by evaluating the righthand side.
Object	SpecialEvaluationI.evaluate(Node node, Object data, ParserVisitor pv, Stack stack, SymbolTable symTab) Deprecated. Performs some special evaluation on the node.
void	LValueI.set(EvaluatorI pv, Node node, Object value) Performs appropriate action to set an LValue.
void	Ele.set(EvaluatorI pv, Node node, Object value)