MathExpr (Jenetics 5.1.0)

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:

5.0

Author:

Franz Wilhelmstötter

See Also:

MathOp, Serialized Form

Field Summary

Fields
Modifier and Type	Field and Description
`static TreeRewriter<Op<Double>>`	`ARITHMETIC_REWRITER` This rewriter implements some common arithmetic identities, in exactly this order.
`static TreeRewriter<Op<Double>>`	`CONST_REWRITER` This tree-rewriter rewrites constant expressions to its single value.
`static TreeRewriter<Op<Double>>`	`REWRITER` Combination of the `ARITHMETIC_REWRITER` and the `CONST_REWRITER`, in this specific order.

Constructor Summary

Constructors
Constructor and Description

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

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

Method Summary

All Methods Static Methods Instance Methods Concrete Methods
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.
`static double`	`eval(Tree<? extends Op<Double>,?> expression, double... args)` Evaluates the given `expression` with the given arguments.
`static String`	`format(Tree<? extends Op<Double>,?> tree)` Return the string representation of the given `tree` object.
`int`	`hashCode()`
`static MathExpr`	`parse(String expression)` Parses the given `expression` into a AST tree.
`static TreeNode<Op<Double>>`	`parseTree(String expression)` Parses the given mathematical expression string and returns the mathematical expression tree.
`static int`	`rewrite(TreeNode<Op<Double>> tree)` Applies the `REWRITER` to the given (mutable) `tree`.
`static int`	`rewrite(TreeNode<Op<Double>> tree, int limit)` Applies the `REWRITER` to the given (mutable) `tree`.
`MathExpr`	`simplify()` Simplifies `this` expression by applying the default `REWRITER`.
`MathExpr`	`simplify(TreeRewriter<Op<Double>> rewriter)` Simplifying `this` expression by applying the given `rewriter`.
`MathExpr`	`simplify(TreeRewriter<Op<Double>> rewriter, int limit)` Simplifying `this` expression by applying the given `rewriter` and the given rewrite `limit`.
`String`	`toString()` Return the string representation of this `MathExpr` object.
`TreeNode<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

- Field Detail
  - CONST_REWRITER
```
public static final TreeRewriter<Op<Double>> CONST_REWRITER
```
    This tree-rewriter rewrites constant expressions to its single value.
    final TreeNode<Op<Double>> tree = MathExpr.parseTree("1 + 2*(6 + 7)"); MathExpr.CONST_REWRITER.rewrite(tree); assertEquals(tree.getValue(), Const.of(27.0));
    
    Since:
    
    5.0
  - ARITHMETIC_REWRITER
```
public static final TreeRewriter<Op<Double>> ARITHMETIC_REWRITER
```
    This rewriter implements some common arithmetic identities, in exactly this order.
```
 
     sub($x,$x) ->  0
     sub($x,0)  ->  $x
     add($x,0)  ->  $x
     add(0,$x)  ->  $x
     add($x,$x) ->  mul(2,$x)
     div($x,$x) ->  1
     div(0,$x)  ->  0
     mul($x,0)  ->  0
     mul(0,$x)  ->  0
     mul($x,1)  ->  $x
     mul(1,$x)  ->  $x
     mul($x,$x) ->  pow($x,2)
     pow($x,0)  ->  1
     pow(0,$x)  ->  0
     pow($x,1)  ->  $x
     pow(1,$x)  ->  1
 
```
    Since:
    
    5.0
  - REWRITER
```
public static final TreeRewriter<Op<Double>> REWRITER
```
    Combination of the ARITHMETIC_REWRITER and the CONST_REWRITER, in this specific order.
    
    Since:
    
    5.0
- 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 TreeNode<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(TreeRewriter<Op<Double>> rewriter,
                         int limit)
```
    Simplifying this expression by applying the given rewriter and the given rewrite limit.
    
    Parameters:
    
    rewriter - the rewriter used for simplifying this expression
    
    limit - the rewrite limit
    
    Returns:
    
    a newly created math expression object
    
    Throws:
    
    NullPointerException - if the rewriter is null
    
    IllegalArgumentException - if the limit is smaller than zero
  - simplify
```
public MathExpr simplify(TreeRewriter<Op<Double>> rewriter)
```
    Simplifying this expression by applying the given rewriter.
    
    Parameters:
    
    rewriter - the rewriter used for simplifying this expression
    
    Returns:
    
    a newly created math expression object
    
    Throws:
    
    NullPointerException - if the rewriter is null
  - simplify
```
public MathExpr simplify()
```
    Simplifies this expression by applying the default REWRITER.
    
    Returns:
    
    a newly created math expression object
  - format
```
public static String format(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.format(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
    
    Since:
    
    4.3
  - 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
    
    Throws:
    
    NullPointerException - if the given expression is null
    
    IllegalArgumentException - if the given expression is invalid or can't be parsed.
  - parseTree
```
public static TreeNode<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 Tree<? extends 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 expression 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...)
  - eval
```
public static double eval(Tree<? extends Op<Double>,?> expression,
                          double... args)
```
    Evaluates the given expression with the given arguments.
    
    Parameters:
    
    expression - the expression to evaluate
    
    args - the expression arguments, in alphabetical order
    
    Returns:
    
    the evaluation result
    
    Throws:
    
    NullPointerException - if the given expression is null
    
    Since:
    
    4.4
    
    See Also:
    
    apply(Double[]), eval(double...), eval(String, double...)
  - rewrite
```
public static int rewrite(TreeNode<Op<Double>> tree,
                          int limit)
```
    Applies the REWRITER to the given (mutable) tree. The tree rewrite is done in place.
    
    Parameters:
    
    tree - the tree to be rewritten
    
    limit - the maximal number this rewrite rule is applied to the given tree. This guarantees the termination of the rewrite method.
    
    Returns:
    
    the number of rewrites applied to the input tree
    
    Throws:
    
    NullPointerException - if the given tree is null
    
    IllegalArgumentException - if the limit is smaller than one
    
    Since:
    
    5.0
    
    See Also:
    
    TreeRewriter.rewrite(TreeNode, int)
  - rewrite
```
public static int rewrite(TreeNode<Op<Double>> tree)
```
    Applies the REWRITER to the given (mutable) tree. The tree rewrite is done in place. The limit of the applied rewrites is set unlimited (Integer.MAX_VALUE).
    
    Parameters:
    
    tree - the tree to be rewritten
    
    Returns:
    
    true if the tree has been changed (rewritten) by this method, false if the tree hasn't been changed
    
    Throws:
    
    NullPointerException - if the given tree is null
    
    Since:
    
    5.0
    
    See Also:
    
    rewrite(TreeNode, int), TreeRewriter.rewrite(TreeNode)

Class MathExpr

Field Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Methods inherited from interface java.util.function.Function

Field Detail

CONST_REWRITER

ARITHMETIC_REWRITER

REWRITER

Constructor Detail

MathExpr

Method Detail

vars

toTree

apply

eval

hashCode

equals

toString

simplify

simplify

simplify

format

parse

parseTree

eval

eval

rewrite

rewrite