com.singularsys.extensions.polynomials

Class PolynomialCreator

• java.lang.Object
• com.singularsys.extensions.polynomials.PolynomialCreator
• All Implemented Interfaces:
JepComponent, ParserVisitor, java.io.Serializable

```public class PolynomialCreator
extends java.lang.Object
implements ParserVisitor, JepComponent```
A system for symbolic simplification, expansion and comparision based on conversion to a canonical polynomial representation. A tree structure is built from Polynomials, Monomials, PVariable etc. An equation like
`1+2 x^2+3 x y+4 x sin(y)`
is represented as
```Polynomial([
Monomial(2.0,[PVariable(x)],[2])]),
Monomial(3.0,[x,y],[1,1]),
Monomial(4.0,[x,Function(sin,arg)],[1,1])
])
```

A total ordering of all expressions is used. As the representation is constructed the total ordering of terms is maintained. This helps ensure that polynomials are always in their simplest form and also allows comparison of equations.

The following sequence illustrates current ordering. The ordering follows this sequence

• -1 // numbers sorted by values
• 0
• 1 // numbers before monomials
• a^-2 // powers in increasing order, parsed as a^(-2)
• a^-1
• -2 a // monomials with lower coefficient first
• -a
• a
• 2 a
• a^2
• a^3
• a^x // numeric powers before symbolic powers
• b // variables sorted alphabetically
• b c // first term in a monomial tested first
• c
• x-1 // polynomials terms tested in order with higher degree ones first
• x
• x+1
• x+2
• 2 x+1
• x^2+x+1 // polynomials with lower degree come first
• x^2+x+2
• x^2+2 x+1
• x^2 y
• cos(a) // polynomials before functions
• sin(a) //function names sorted alphabetically
• sin(b) // function arguments compared
Serialized Form
• Field Summary

Fields
Modifier and Type Field and Description
`protected FieldI` `field`
`protected FunctionTable` `ft`
`PConstant` `infConstant`
`protected Jep` `jep`
`PConstant` `minusOneConstant`
`PConstant` `nanConstant`
`protected NodeFactory` `nf`
`protected NumberFactory` `numf`
`PConstant` `oneConstant`
`protected OperatorTableI` `ot`
`protected TreeUtils` `tu`
`PConstant` `twoConstant`
`protected VariableTable` `vt`
`PConstant` `zeroConstant`
• Constructor Summary

Constructors
Modifier Constructor and Description
` ` `PolynomialCreator()`
Constructor when used as a JepComponent.
` ` `PolynomialCreator(FieldI field)`
Constructor used as a component with a specified field.
`protected ` ```PolynomialCreator(FieldI f, TreeUtils tu)```
` ` `PolynomialCreator(Jep j)`
Constructor when used as a stand alone class, with default DoubleField.
` ` ```PolynomialCreator(Jep j, FieldI f)```
Constructor when used as a stand alone class with specified field
• Method Summary

All Methods
Modifier and Type Method and Description
`int` ```compare(Node node1, Node node2)```
Compares two nodes.
`PNodeI` `createPoly(Node node)`
Converts an expression into the polynomial representation.
`boolean` ```equals(Node node1, Node node2)```
Compares two nodes.
`Node` `expand(Node node)`
Expands an expression.
`PNodeI` `expand(PNodeI poly)`
Expand a PNodeI multiplying out all brackets
`int` ```expandCompare(Node node1, Node node2)```
Expands and compares two expressions.
`boolean` ```expandEquals(Node node1, Node node2)```
Compares two nodes.
`JepComponent` `getLightWeightInstance()`
Gets a light-weight instance suitable for using in multiple threads.
`NodeFactory` `getNodeFactory()`
`OperatorTableI` `getOperatorTable()`
`void` `init(Jep j)`
Initialize the component.
`Node` `simplify(Node node)`
Simplifies an expression.
`PNodeI[]` ```toCoefficientArray(PNodeI poly, java.lang.String var)```
Finds the coefficients of each power of the variable, these can be polynomials.
`double[]` ```toDoubleArray(PNodeI poly, java.lang.String var)```
Extract the numerical coefficients of a polynomial.
`double[][]` ```toDoubleArray(PNodeI poly, java.lang.String var1, java.lang.String var2)```
Extract the numerical coefficients of a polynomial in two variables.
`double[][][]` ```toDoubleArray(PNodeI poly, java.lang.String var1, java.lang.String var2, java.lang.String var3)```
Extract the numerical coefficients of a polynomial in three variables.
`Node` `toNode(PNodeI poly)`
Convert from a polynomial representation back to standard Jep format.
`java.lang.Object` ```toPNodeArray(PNodeI poly, java.lang.String... vars)```
Coefficients of a polynomial as a multi-dimensional array of PNodeI elements.
`java.lang.Object` ```visit(ASTConstant node, java.lang.Object data)```
`java.lang.Object` ```visit(ASTFunNode node, java.lang.Object data)```
`java.lang.Object` ```visit(ASTOpNode node, java.lang.Object data)```
`java.lang.Object` ```visit(ASTVarNode node, java.lang.Object data)```
• Methods inherited from class java.lang.Object

`clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait`
• Field Detail

• zeroConstant

`public PConstant zeroConstant`
• oneConstant

`public PConstant oneConstant`
• minusOneConstant

`public PConstant minusOneConstant`
• twoConstant

`public PConstant twoConstant`
• infConstant

`public PConstant infConstant`
• nanConstant

`public PConstant nanConstant`
• jep

`protected Jep jep`
• numf

`protected NumberFactory numf`
• tu

`protected TreeUtils tu`
• nf

`protected NodeFactory nf`
• vt

`protected VariableTable vt`
• ft

`protected FunctionTable ft`
• ot

`protected OperatorTableI ot`
• field

`protected FieldI field`
• Constructor Detail

• PolynomialCreator

`public PolynomialCreator()`
Constructor when used as a JepComponent. The `init(Jep)` method must be called.
• PolynomialCreator

`public PolynomialCreator(FieldI field)`
Constructor used as a component with a specified field.
Parameters:
`field` - field for operations on constants The `init(Jep)` method must be called.
• PolynomialCreator

`public PolynomialCreator(Jep j)`
Constructor when used as a stand alone class, with default DoubleField.
Parameters:
`j` - Jep instance
• PolynomialCreator

```public PolynomialCreator(Jep j,
FieldI f)```
Constructor when used as a stand alone class with specified field
Parameters:
`j` - Jep instance
`f` - field for operations on constants
• PolynomialCreator

```protected PolynomialCreator(FieldI f,
TreeUtils tu)```
• Method Detail

• 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`
Parameters:
`j` - the current Jep instance
• 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`
Returns:
either an new instance, or 'this'.
• createPoly

```public PNodeI createPoly(Node node)
throws ParseException```
Converts an expression into the polynomial representation.
Parameters:
`node` - top node of expression
Returns:
top node of polynomial form of expression
Throws:
`ParseException` - if expression cannot be converted. This can happen if the underlying field cannot represent Infinity or NaN and a constant exprssion with these values is encountered.
• toNode

```public Node toNode(PNodeI poly)
throws ParseException```
Convert from a polynomial representation back to standard Jep format.
Parameters:
`poly` -
Returns:
a Jep expression
Throws:
`ParseException` - if expression cannot be converted.
• simplify

```public Node simplify(Node node)
throws ParseException```
Simplifies an expression.
Parameters:
`node` - top node to expression to be simplified.
Returns:
a simplified expression
Throws:
`ParseException` - if expression cannot be converted.
• expand

```public Node expand(Node node)
throws ParseException```
Expands an expression. Will always expand brackets for multiplication and simple powers. For instance `(1+x)^3 -> 1+3x+3x^2+x^3`
Parameters:
`node` - top node to expression to be simplified.
Returns:
a simplified expression
Throws:
`ParseException` - if expression cannot be converted.
• expand

```public PNodeI expand(PNodeI poly)
throws ParseException```
Expand a PNodeI multiplying out all brackets
Parameters:
`poly` - input polynomial
Returns:
the expanded polynomial
Throws:
`ParseException` - if expression cannot be converted.
• compare

```public int compare(Node node1,
Node node2)
throws ParseException```
Compares two nodes. Uses a total ordering of expressions. Does not expands equations before comparison. The ordering follows this sequence
• -1 // numbers sorted by values
• 0
• 1 // numbers before monomials
• a^-2 // powers in increasing order, parsed as a^(-2)
• a^-1
• -2 a // monomials with lower coefficient first
• -a
• a
• 2 a
• a^2
• a^3
• a^x // numeric powers before symbolic powers
• b // variables sorted alphabetically
• b c // first term in a monomial tested first
• c
• x-1 // polynomials terms tested in order with higher degree ones first
• x
• x+1
• x+2
• 2 x+1
• x^2+x+1 // polynomials with lower degree come first
• x^2+x+2
• x^2+2 x+1
• x^2 y
• cos(a) // polynomials before functions
• sin(a) //function names sorted alphabetically
• sin(b) // function arguments compared
Parameters:
`node1` - lhs node
`node2` - rhs node
Returns:
-1 if node1<node2, 0 if node1==node2, +1 if node1>node2
Throws:
`ParseException`
• expandCompare

```public int expandCompare(Node node1,
Node node2)
throws ParseException```
Expands and compares two expressions.
Parameters:
`node1` - lhs
`node2` - rhs
Returns:
-1 if node1<node2, 0 if node1==node2, +1 if node1>node2 using the total order
Throws:
`ParseException`
• equals

```public boolean equals(Node node1,
Node node2)
throws ParseException```
Compares two nodes. Uses a total ordering of expressions. May give some false negatives is simplification cannot reduce two equal expressions to the same canonical form. Does not expands equations before comparison.
Parameters:
`node1` -
`node2` -
Returns:
true if two nodes represents same expression.
Throws:
`ParseException`
• expandEquals

```public boolean expandEquals(Node node1,
Node node2)
throws ParseException```
Compares two nodes. Uses a total ordering of expressions. May give some false negatives is simplification cannot reduce two equal expressions to the same canonical form. Expands equations before comparison.
Parameters:
`node1` -
`node2` -
Returns:
true if two nodes represents same expression.
Throws:
`ParseException`
• toCoefficientArray

```public PNodeI[] toCoefficientArray(PNodeI poly,
java.lang.String var)
throws ParseException```
Finds the coefficients of each power of the variable, these can be polynomials.
Parameters:
`poly` - The input polynomial
`var` - the name of the variable
Returns:
an array with coefficients, [constant,var,var^2, ...]
Throws:
`ParseException`
• toPNodeArray

```public java.lang.Object toPNodeArray(PNodeI poly,
java.lang.String... vars)
throws ParseException```
Coefficients of a polynomial as a multi-dimensional array of PNodeI elements. With one variable the coefficients can be found using ``` PNodeI[] coeffs = (PNodeI[]) pc.toPNodeArray("a x^2+b x+c","x"); ``` For two variables use ``` PNodeI[][] coeffs = (PNodeI[][]) pc.toPNodeArray("a x^2+b x y","x","y"); ``` Note the returned array is not guaranteed to have the same number of elements in each row or column.
Parameters:
`poly` - expression to find coefficients of
`vars` - names of variables to find coefficients of
Returns:
multi-dimensional array either PNodeI[] or PNodeI[][] etc depending on number of variables
Throws:
`ParseException` - if poly does not represent a polynomial
• toDoubleArray

```public double[] toDoubleArray(PNodeI poly,
java.lang.String var)
throws ParseException```
Extract the numerical coefficients of a polynomial.
Parameters:
`poly` - input polynomial. A polynomial in a single variables.
`var` - polynomial variable
Returns:
array of coefficients with constant term first
Throws:
`ParseException`
• toDoubleArray

```public double[][] toDoubleArray(PNodeI poly,
java.lang.String var1,
java.lang.String var2)
throws ParseException```
Extract the numerical coefficients of a polynomial in two variables.
Parameters:
`poly` - input polynomial. A polynomial in two variables.
`var1` - name of first variable
`var2` - name of second variable
Returns:
two dimensional array of coefficients, element [i][j] is coefficient of x^i y^j.
Throws:
`ParseException`
• toDoubleArray

```public double[][][] toDoubleArray(PNodeI poly,
java.lang.String var1,
java.lang.String var2,
java.lang.String var3)
throws ParseException```
Extract the numerical coefficients of a polynomial in three variables.
Parameters:
`poly` - input polynomial. A polynomial in three variables.
`var1` - name of first variable
`var2` - name of second variable
`var3` - name of third variable
Returns:
three dimensional array of coefficients, element [i][j][k] is coefficient of x^i y^j z^k.
Throws:
`ParseException`
• visit

```public java.lang.Object visit(ASTConstant node,
java.lang.Object data)
throws ParseException```
Specified by:
`visit` in interface `ParserVisitor`
Throws:
`ParseException`
• visit

```public java.lang.Object visit(ASTVarNode node,
java.lang.Object data)
throws ParseException```
Specified by:
`visit` in interface `ParserVisitor`
Throws:
`ParseException`
• visit

```public java.lang.Object visit(ASTFunNode node,
java.lang.Object data)
throws JepException```
Specified by:
`visit` in interface `ParserVisitor`
Throws:
`JepException`
• visit

```public java.lang.Object visit(ASTOpNode node,
java.lang.Object data)
throws JepException```
Specified by:
`visit` in interface `ParserVisitor`
Throws:
`JepException`
• getNodeFactory

`public NodeFactory getNodeFactory()`
• getOperatorTable

`public OperatorTableI getOperatorTable()`