FunctionParser

java.lang.Object
- org.mathIT.util.FunctionParser

All Implemented Interfaces:

Serializable
```
public class FunctionParser
extends Object
implements Serializable
```
This class provides methods to parse and evaluate strings representing functions. The letters x, y, and z are reserved as variables, the infix operators +, -, *, /, %, ^, and mod are understood, as well as logical operators such as ==, <=, >=, "and", "or", "xor", &&, |, but not || (note that &, | are interpreted as logical operators, not as binary ones, and that = is equivalent to ==). The usual mathematical functions are also interpreted, besides the Riemann-Siegel Z-function. A complete list of possible operators are determined in the array operator and can be displayed by implementing the following snippet:
```
     String[] text = {
      "Variables","Functions", "Binary Infix Operators","Ternary Operators"
     };
     for (int i = 0; i < FunctionParser.operator.length; i++) {
        System.out.println(text[i] + ":");
        for (int j = 0; j < FunctionParser.operator[i].length; j++) {
           System.out.print(FunctionParser.operator[i][j] + ", ");
        }
        System.out.println("\n");
     }
  
```
Fractional numbers (i.e., double values) have to be inputted with a decimal point (not a comma).
Version:

1.3

Author:

Andreas de Vries

See Also:

Serialized Form

Field Summary

Fields
Modifier and Type	Field and Description
`static String[]`	`constantName` Names of predefined constants.
`static double[]`	`constantValue` Values of the predefined constants.
`static int`	`maxOpLength` Maximum number of letters an operator can have.
`static String[][]`	`operator` Table of predefined operators.

Constructor Summary

Constructors
Constructor and Description
`FunctionParser(ArrayList<String[]> functions)` Creates a function parser from the list of functions in postfix notation.
`FunctionParser(String function)` Creates a function parser from a single function in usual notation, infix for binary operators and prefix for functions and ternary operators.
`FunctionParser(String[] functionList)` Creates a function parser from a list of functions in usual (infix or prefix) notation.

Method Summary

All Methods Static Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`static boolean`	`checkSyntax(String function)` Analyses and parses the function being input as a string.
`double`	`evaluate(int i, double x)` Evaluates the i-th function of the current object at the value x.
`double`	`evaluate(int i, double x, double y)` Evaluates the i-th function f(x, y) of the this object at the values x and y.
`double`	`evaluateInt(int x, int z)` Evaluates the 0-th function f(x, z) of this object at the values x and z.
`static double`	`evaluatePostFix(String[] function, double x)` Evaluates the function (in postfix notation) at the value x.
`String[]`	`getFunction(int i)` Returns an array of the parts of the i-th function in postfix notation.
`String`	`getFunction(int i, boolean postfix)` Returns a string of the i-th function, either in postfix or in usual notation.

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

- Field Detail
  - constantName
```
public static final String[] constantName
```
    Names of predefined constants.
  - constantValue
```
public static final double[] constantValue
```
    Values of the predefined constants.
  - operator
```
public static final String[][] operator
```
    Table of predefined operators. In the i-throw row there are i-nary operators, variables are counted as nullary operators. Currently, the array is implemented as follows:
```
   public static final String[][] operator = {
      {// variables:
         "x", "y", "z"
      },
      {// unary operators:
         "ln", "ld",
         "exp", "log",
         "sqrt", "w",
         "sin", "cos", "tan", "cot", "sec", "csc",
         "asin", "acos", "atan", "acot",
         "sinh", "cosh", "tanh", "coth",
         "arsinh", "arcosh", "artanh", "arcoth",
         "Z"
      },
      {// binary operators:
         "+", "-", "*", "/", "%", "^", "mod",
         "=", "<", ">", "==", "<=", ">=",
         "&&", "|", "&", "and", "or", "xor",
         ";", ","
      },
      {// ternary operators:
         "if", "modPow"
      },
   };
 
```
  - maxOpLength
```
public static int maxOpLength
```
    Maximum number of letters an operator can have.
- Constructor Detail
  - FunctionParser
```
public FunctionParser(String function)
```
    Creates a function parser from a single function in usual notation, infix for binary operators and prefix for functions and ternary operators. The letters x, y, and z are reserved as variables, the infix operators +, -, *, /, %, ^, and mod are possible, as well as logical operators such as ==, <=, >=, "and", "or", "xor", &&, |, but not || (note that &, | are interpreted as logical operators, not as binary ones, and that = is equivalent to ==). The usual mathematical functions are also interpreted, besides the Riemann-Siegel Z-function. A complete list of possible operators are determined in the array operator and can be displayed by implementing the following snippet:
```
     String[] text = {
      "Variables","Functions", "Binary Infix Operators","Ternary Operators"
     };
     for (int i = 0; i < FunctionParser.operator.length; i++) {
        System.out.println(text[i] + ":");
        for (int j = 0; j < FunctionParser.operator[i].length; j++) {
           System.out.print(FunctionParser.operator[i][j] + ", ");
        }
        System.out.println("\n");
     }
  
```
    Fractional numbers (i.e., double values) have to be inputted with a decimal point (not a comma).
    Parameters:
    
    function - a string of the function in usual notation
  - FunctionParser
```
public FunctionParser(String[] functionList)
```
    Creates a function parser from a list of functions in usual (infix or prefix) notation. See FunctionParser(String) for detailed description of the requirements of the input strings.
    
    Parameters:
    
    functionList - an array of strings of functions in usual notation
  - FunctionParser
```
public FunctionParser(ArrayList<String[]> functions)
```
    Creates a function parser from the list of functions in postfix notation. Each member of the list is a string array in which each entry represents an operator, a variable (x, y, z) or a constant number, with the last operator being executed last.
    
    Parameters:
    
    functions - a list of functions in parsed postfix notation
- Method Detail
  - checkSyntax
```
public static boolean checkSyntax(String function)
```
    Analyses and parses the function being input as a string. First the string is divided in its operators and operands, then its syntax is checked. Only operators, integers or real numbers are admissible.
    
    Parameters:
    
    function - a string representing a function
    
    Returns:
    
    true if and only if the function could be parsed successfully
  - getFunction
```
public String[] getFunction(int i)
```
    Returns an array of the parts of the i-th function in postfix notation.
    
    Parameters:
    
    i - specifies the index of the function
    
    Returns:
    
    a string array containing the parts of the i-th function in postfix notation
  - getFunction
```
public String getFunction(int i,
                          boolean postfix)
```
    Returns a string of the i-th function, either in postfix or in usual notation. "Usual notation" here means, that the string contains infix notation for binary operators, such as ((2*x) + 2), and prefix notation for functions and ternary operators, e.g., sin(x) or if(-1 < x && x < 1; 1; 0).
    
    Parameters:
    
    i - the index of the function to be returned
    
    postfix - specifies whether the returned string is in postfix notation
    
    Returns:
    
    a string representing the function, either in usual (infix/prefix) or in postfix notation
  - evaluate
```
public double evaluate(int i,
                       double x)
```
    Evaluates the i-th function of the current object at the value x.
    
    Parameters:
    
    i - index of the function (starting at 0)
    
    x - the double value to be inserted
    
    Returns:
    
    the i-th function value at x
  - evaluate
```
public double evaluate(int i,
                       double x,
                       double y)
```
    Evaluates the i-th function f(x, y) of the this object at the values x and y.
    
    Parameters:
    
    i - index of the function (starting at 0)
    
    x - the first parameter value to be inserted
    
    y - the second parameter value to be inserted
    
    Returns:
    
    the i-th function value at (x, y)
  - evaluateInt
```
public double evaluateInt(int x,
                          int z)
```
    Evaluates the 0-th function f(x, z) of this object at the values x and z.
    
    Parameters:
    
    x - the x-value to be inserted
    
    z - the z-value to be inserted
    
    Returns:
    
    the function value at (x, z)
  - evaluatePostFix
```
public static double evaluatePostFix(String[] function,
                                     double x)
```
    Evaluates the function (in postfix notation) at the value x.
    
    Parameters:
    
    function - the function in postfix notation, each array element being a postfix component
    
    x - the double value to be inserted in the function
    
    Returns:
    
    the function value at x

Class FunctionParser

Field Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Field Detail

constantName

constantValue

operator

maxOpLength

Constructor Detail

FunctionParser

FunctionParser

FunctionParser

Method Detail

checkSyntax

getFunction

getFunction

evaluate

evaluate

evaluateInt

evaluatePostFix