org.mathIT.util

Class TermParser

java.lang.Object

org.mathIT.util.TermParser

All Implemented Interfaces:

Serializable

public class TermParser
extends Object
implements Serializable

This class provides methods to parse and evaluate strings representing computable terms. 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. 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 < TermParser.operator.length; i++) {
        System.out.println(text[i] + ":");
        for (int j = 0; j < TermParser.operator[i].length; j++) {
           System.out.print(TermParser.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
TermParser(String formula) Creates a term parser from a single formula in usual notation, infix for binary operators and prefix for functions and ternary operators.

Method Summary

Modifier and Type	Method and Description
static boolean	checkSyntax(String formula) Analyses and parses the function being input as a string.
static BigDecimal	evaluate(String formula, MathContext mc) Evaluates the function (in postfix notation) at the value x.
String	getFormula(boolean postfix) Returns a string of the formula, 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 = {
      {// 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",
         "brown"
         
      },
      {// 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

TermParser

public TermParser(String formula)

Creates a term parser from a single formula in usual notation, infix for binary operators and prefix for functions and ternary operators. The usual mathematical functions are also interpreted. 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 < TermParser.operator.length; i++) {
        System.out.println(text[i] + ":");
        for (int j = 0; j < TermParser.operator[i].length; j++) {
           System.out.print(TermParser.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:

formula - a string of the function in usual notation

Method Detail

checkSyntax

public static boolean checkSyntax(String formula)

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:

formula - a string representing a function

Returns:

true if and only if the function could be parsed successfully

getFormula

public String getFormula(boolean postfix)

Returns a string of the formula, 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:

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 static BigDecimal evaluate(String formula,
                                  MathContext mc)

Evaluates the function (in postfix notation) at the value x.

Parameters:

formula - the formula in postfix notation, each array element being a postfix component

mc - the mathcontext determining the precision

Returns:

the function value at x