io.jenetics.prog.op

Class MathExpr

java.lang.Object

io.jenetics.prog.op.MathExpr

All Implemented Interfaces:

Serializable, Function<Double[],Double>

public final class MathExpr
extends Object
implements Function<Double[],Double>, Serializable

This class allows you to create a math operation tree from an expression string. The expression string may only contain functions/operations defined in MathOp.

final MathExpr expr = MathExpr.parse("5 + 6*x + sin(x)^34 + (1 + sin(x*5)/4)/6"); final double result = expr.eval(4.32); assert result == 31.170600453465315; assert 12.0 == MathExpr.eval("3*4"); assert 24.0 == MathExpr.eval("3*4*x", 2); assert 28.0 == MathExpr.eval("3*4*x + y", 2, 4);

Since:

4.1

Version:

4.1

Author:

Franz Wilhelmstötter

See Also:

MathOp, Serialized Form

Constructor Summary

Constructors

Constructor and Description
MathExpr(Tree<? extends Op<Double>,?> tree) Create a new MathExpr object from the given operation tree.

Method Summary

Modifier and Type	Method and Description
Double	apply(Double[] args)
boolean	equals(Object obj)
double	eval(double... args) Convenient method, which lets you apply the program function without explicitly create a wrapper array.
static double	eval(String expression, double... args) Evaluates the given expression with the given arguments.
int	hashCode()
static MathExpr	parse(String expression) Parses the given expression into a AST tree.
static Tree<? extends Op<Double>,?>	parseTree(String expression) Parses the given mathematical expression string and returns the mathematical expression tree.
static void	prune(TreeNode<Op<Double>> tree) Tries to simplify the given math tree in place.
MathExpr	simplify() Tries to simplify this math expression.
static Tree<? extends Op<Double>,?>	simplify(Tree<? extends Op<Double>,?> tree) Tries to simplify the given math tree.
String	toString() Return the string representation of this MathExpr object.
static String	toString(Tree<? extends Op<Double>,?> tree) Return the string representation of the given tree object.
Tree<? extends Op<Double>,?>	toTree() Return the math expression as operation tree.
ISeq<Var<Double>>	vars() Return the variable list of this math expression.

Methods inherited from class java.lang.Object

clone, finalize, getClass, notify, notifyAll, wait, wait, wait

Methods inherited from interface java.util.function.Function

andThen, compose, identity

Constructor Detail

MathExpr

public MathExpr(Tree<? extends Op<Double>,?> tree)

Create a new MathExpr object from the given operation tree.

Parameters:

tree - the underlying operation tree

Throws:

NullPointerException - if the given program is null

IllegalArgumentException - if the given operation tree is invalid, which means there is at least one node where the operation arity and the node child count differ.

Method Detail

vars

public ISeq<Var<Double>> vars()

Return the variable list of this math expression.

Returns:

the variable list of this math expression

toTree

public Tree<? extends Op<Double>,?> toTree()

Return the math expression as operation tree.

Returns:

a new expression tree

apply

public Double apply(Double[] args)

Specified by:

apply in interface Function<Double[],Double>

See Also:

eval(double...), eval(String, double...)

eval

public double eval(double... args)

Convenient method, which lets you apply the program function without explicitly create a wrapper array.

final double result = MathExpr.parse("2*z + 3*x - y").eval(3, 2, 1); assert result == 9.0;

Parameters:

args - the function arguments

Returns:

the evaluated value

Throws:

NullPointerException - if the given variable array is null

IllegalArgumentException - if the length of the arguments array is smaller than the program arity

See Also:

apply(Double[]), eval(String, double...)

hashCode

public int hashCode()

Overrides:

hashCode in class Object

equals

public boolean equals(Object obj)

Overrides:

equals in class Object

toString

public String toString()

Return the string representation of this MathExpr object. The string returned by this method can be parsed again and will result in the same expression object.

final String expr = "5.0 + 6.0*x + sin(x)^34.0 + (1.0 + sin(x*5.0)/4.0) + 6.5"; final MathExpr tree = MathExpr.parse(expr); assert tree.toString().equals(expr);

Overrides:

toString in class Object

Returns:

the expression string

simplify

public MathExpr simplify()

Tries to simplify this math expression.

final MathExpr expr = MathExpr.parse("4.0 + 4.0 + x*(5.0 + 13.0)"); final MathExpr simplified = expr.simplify() System.out.println(simplified);

The simplified expression will be look like this: 8.0 + (x*18.0).

Returns:

a new simplified math expression

See Also:

prune(TreeNode), simplify(Tree)

toString

public static String toString(Tree<? extends Op<Double>,?> tree)

Return the string representation of the given tree object. The string returned by this method can be parsed again and will result in the same expression object.

final String expr = "5.0 + 6.0*x + sin(x)^34.0 + (1.0 + sin(x*5.0)/4.0) + 6.5"; final MathExpr tree = MathExpr.parse(expr); assert MathExpr.toString(tree.tree()).equals(expr);

Parameters:

tree - the tree object to convert to a string

Returns:

a new expression string

Throws:

NullPointerException - if the given tree is null

parse

public static MathExpr parse(String expression)

Parses the given expression into a AST tree.

Parameters:

expression - the expression string

Returns:

the tree representation of the given expression

parseTree

public static Tree<? extends Op<Double>,?> parseTree(String expression)

Parses the given mathematical expression string and returns the mathematical expression tree. The expression may contain all functions defined in MathOp.

final TreeNode<Op<Double>> tree = MathExpr .parseTree("5 + 6*x + sin(x)^34 + (1 + sin(x*5)/4)/6");

The example above will lead to the following tree:

 
  add
  ├── add
  │   ├── add
  │   │   ├── 5.0
  │   │   └── mul
  │   │       ├── 6.0
  │   │       └── x
  │   └── pow
  │       ├── sin
  │       │   └── x
  │       └── 34.0
  └── div
      ├── add
      │   ├── 1.0
      │   └── div
      │       ├── sin
      │       │   └── mul
      │       │       ├── x
      │       │       └── 5.0
      │       └── 4.0
      └── 6.0
 

Parameters:

expression - the expression string

Returns:

the parsed expression tree

Throws:

NullPointerException - if the given expression is null

IllegalArgumentException - if the given expression is invalid or can't be parsed.

eval

public static double eval(String expression,
                          double... args)

Evaluates the given expression with the given arguments.

final double result = MathExpr.eval("2*z + 3*x - y", 3, 2, 1); assert result == 9.0;

Parameters:

expression - the expression to evaluate

args - the expression arguments, in alphabetical order

Returns:

the evaluation result

Throws:

NullPointerException - if the given program is null

IllegalArgumentException - if the given operation tree is invalid, which means there is at least one node where the operation arity and the node child count differ.

See Also:

apply(Double[]), eval(double...)

simplify

public static Tree<? extends Op<Double>,?> simplify(Tree<? extends Op<Double>,?> tree)

Tries to simplify the given math tree.

final Tree<? extends Op<Double>, ?> tree = MathExpr.parseTree("4.0 + 4.0 + x*(5.0 + 13.0)"); final Tree<? extends Op<Double>, ?> simplified = MathExpr.simplify(tree) System.out.println(simplified);

The simplified tree will be look like this:

 
  add
  ├── 8.0
  └── mul
      ├── x
      └── 18.0
 

Parameters:

tree - the math tree to simplify

Returns:

the new simplified tree

Throws:

NullPointerException - if the given tree is null

See Also:

prune(TreeNode), simplify()

prune

public static void prune(TreeNode<Op<Double>> tree)

Tries to simplify the given math tree in place.

Parameters:

tree - the math tree to simplify

Throws:

NullPointerException - if the given tree is null

See Also:

simplify(Tree), simplify()