package graph;import java.awt.*;import java.util.*;import java.lang.*;/*******************************************************************************    Class  ParseFunction            ******************************************************************************    Copyright (C) 1996 Leigh Brookshaw****    This program is free software; you can redistribute it and/or modify**    it under the terms of the GNU General Public License as published by**    the Free Software Foundation; either version 2 of the License, or**    (at your option) any later version.****    This program is distributed in the hope that it will be useful,**    but WITHOUT ANY WARRANTY; without even the implied warranty of**    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the**    GNU General Public License for more details.****    You should have received a copy of the GNU General Public License**    along with this program; if not, write to the Free Software**    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.**************************************************************************//** * This class will parse a function definition and solve it returning the * value. The function may have upto 3 independent variables in it * (x,y,z).  * <p> * <b>Known Bugs</B> This class is not fool proof. If the answer is wrong * then use the parenthesis to force the order of evaluation. The most * likely place this will be needed is in the use of the power command. * The exponent is not evaluated correctly if it begins with a * unary operator. * * <h3>List of recognised commands</h3> * <ul> *   <li> ( ) parenthesis , comma *   <li> +, -, unary -, unary + *   <li> *, / *   <li> ^ (raise to a power) *   <li> pi, e, All the constants in class SpecialFunction *   <li> log *   <li> sin, cos, tan *   <li> asin, acos, atan *   <li> sqrt *   <li> rand *   <li> exp *   <li> remainder *   <li> atan2 *   <li> All the functions in class SpecialFunction *   <li> Independent variables x,y,z *   <li> Scientific notation using "e", "E", "d", "D". * </ul> * * @version $Revision: 1.8 $, $Date: 1996/08/12 23:37:08 $ * @author Leigh Brookshaw */public class ParseFunction extends ScanString {/*************************  Constants*********************//***   Specifiy the integer values associated with keywords. Every integer **   in this list is associated with keyword used in the string*/       static final int GROUP        =  1;       static final int ENDGROUP     =  2;       static final int ADD          =  3;       static final int SUBTRACT     =  4;       static final int DIVIDE       =  5;       static final int MULTIPLY     =  6;       static final int LOG          =  7;       static final int POWER        =  8;       static final int PI           =  9;       static final int E            = 10;       static final int SIN          = 11;       static final int COS          = 12;       static final int TAN          = 13;       static final int X            = 14;       static final int Y            = 15;       static final int Z            = 16;       static final int ASIN         = 17;       static final int ACOS         = 18;       static final int ATAN         = 19;       static final int RAD          = 20;       static final int SQRT         = 21;       static final int RANDOM       = 22;       static final int LOG10        = 23;       static final int EXP          = 24;       static final int REMAINDER    = 25;       static final int COMMA        = 26;       static final int ATAN2        = 27;       static final int J0           = 28;       static final int J1           = 29;       static final int JN           = 30;       static final int SINH         = 31;       static final int COSH         = 32;       static final int TANH         = 33;       static final int ASINH        = 34;       static final int ACOSH        = 35;       static final int ATANH        = 36;       static final int Y0           = 37;       static final int Y1           = 38;       static final int YN           = 39;       static final int FAC          = 40;       static final int GAMMA        = 41;       static final int ERF          = 42;       static final int ERFC         = 43;       static final int NORMAL       = 44;       static final int POISSONC     = 45;       static final int POISSON      = 46;       static final int CHISQC       = 47;       static final int CHISQ        = 48;       static final int IGAM         = 49;       static final int IGAMC        = 50;  /*  **   Physical Constants in SI units  */       static final int BOLTZMAN     = 101;        static final int ECHARGE      = 102;       static final int EMASS        = 103;       static final int PMASS        = 104;       static final int GRAV         = 105;       static final int PLANCK       = 106;       static final int LIGHTSPEED   = 107;       static final int STEFANBOLTZ  = 108;       static final int AVOGADRO     = 109;       static final int GASCONSTANT  = 110;       static final int GRAVACC      = 111;/************************** Private Variables***********************/  /*  ** The root node after parsing the string  */       private Node root;  /*  ** Boolean flags set when any of the independent variable are encountered  */            private boolean independent_x;       private boolean independent_y;       private boolean independent_z;  /*  ** Internal values for the independent variables  */            private double x;       private double y;       private double z;  /**   * Debug variable. If set true debug output is printed.   */       public boolean debug;                     /***************************** Constructors************************/  /**   * Instantiate the class   */       public ParseFunction() {                   root = null;            independent_x = false;            independent_y = false;            independent_z = false;            debug = false;                        x = 0.0;            y = 0.0;            z = 0.0;                                                addKeyWord(",",          COMMA);            addKeyWord("(",          GROUP);            addKeyWord(")",          ENDGROUP);            addKeyWord("+",          ADD);            addKeyWord("-",          SUBTRACT);            addKeyWord("/",          DIVIDE);            addKeyWord("*",          MULTIPLY);            addKeyWord("log",        LOG);            addKeyWord("^",          POWER);            addKeyWord("pi",         PI);            addKeyWord("e",          E);            addKeyWord("sin",        SIN);            addKeyWord("cos",        COS);            addKeyWord("tan",        TAN);            addKeyWord("x",          X);            addKeyWord("y",          Y);            addKeyWord("z",          Z);            addKeyWord("asin",       ASIN);            addKeyWord("acos",       ACOS);            addKeyWord("atan",       ATAN);            addKeyWord("rad",        RAD);            addKeyWord("sqrt",       SQRT);            addKeyWord("rand",       RANDOM);            addKeyWord("log10",      LOG10);            addKeyWord("exp",        EXP);            addKeyWord("rem",        REMAINDER);            addKeyWord("atan2",      ATAN2);            addKeyWord("j0",         J0);            addKeyWord("j1",         J1);            addKeyWord("jn",         JN);            addKeyWord("sinh",       SINH);            addKeyWord("cosh",       COSH);            addKeyWord("tanh",       TANH);            addKeyWord("asinh",      ASINH);            addKeyWord("acosh",      ACOSH);            addKeyWord("atanh",      ATANH);            addKeyWord("y0",         Y0);            addKeyWord("y1",         Y1);            addKeyWord("yn",         YN);            addKeyWord("fac",        FAC);            addKeyWord("gamma",      GAMMA);            addKeyWord("erf",        ERF);            addKeyWord("erfc",       ERFC);            addKeyWord("normal",     NORMAL);            addKeyWord("poissonc",   POISSONC);            addKeyWord("poisson",    POISSON);            addKeyWord("chisq",      CHISQ);            addKeyWord("chisqc",     CHISQC);            addKeyWord("igam",       IGAM);            addKeyWord("igamc",      IGAMC);            addKeyWord("k",          BOLTZMAN);            addKeyWord("ec",         ECHARGE);            addKeyWord("me",         EMASS);            addKeyWord("mp",         PMASS);            addKeyWord("gc",         GRAV);            addKeyWord("h",          PLANCK);            addKeyWord("c",          LIGHTSPEED);            addKeyWord("sigma",      STEFANBOLTZ);            addKeyWord("na",         AVOGADRO);            addKeyWord("r",          GASCONSTANT);            addKeyWord("g",          GRAVACC);              }         /**   * Instantiate the class and define the string to parse.   * @param s The string to be parsed.   */       public ParseFunction(String s) {            this();            setString(s);       }       /*********************** Public Methods       *******************/  /**   * Parse the string.   * @param s The string to parse   * @return true if it was successful, false otherwise.   */       public boolean parse(String s) {            setString(s);            return parse();       }  /**   * Parse the previously set string   * @return true if it was successful, false otherwise.   */        public boolean parse() {             root = new Node();             if( parseString(root) != EOS) return false;             if(debug) {                System.out.println("Before Reordering:");                root.print(5);             }             reOrderNodes(root);             if(debug) {                System.out.println("After Reordering:");                root.print(5);             }             return true;        }  /**   * Return the solution of the function given the independent values   * @param x indpendent x value   * @param y indpendent y value   * @param z indpendent z value   * @return solution of the function   */        public double getResult(double x, double y, double z)                                                     throws Exception {        	        	this.x = x;        	this.y = y;        	this.z = z;        	return evaluate(root);        }  /**   * Return the solution of the function given the independent values   * @param x indpendent x value   * @param y indpendent y value   * @return solution of the function   */        public double getResult(double x, double y)                                                     throws Exception {        	        	this.x = x;        	this.y = y;        	return evaluate(root);        }  /**   * Return the solution of the function given the independent values   * @param x indpendent x value   * @return solution of the function   */        public double getResult(double x) throws Exception {        	        	this.x = x;        	return evaluate(root);        }  /**   * Return the solution of the function if it has no independent values   * or they have already been set using the set methods   * @return solution of the function   * @see ParseFunction.setX()   * @see ParseFunction.setY()   * @see ParseFunction.setZ()   */        public double getResult() throws Exception {        	        	return evaluate(root);        }  /**   * Return an array of solutions given an array of x values   * @param n number of values to process in the input array   * @param x Array containing the x values.   * @return Array containing the solutions.   * @exception Exception   *             Generic exception if the array index n<=0, or x is null.   */        public double[] getResults(int n, double x[]) throws Exception {             if(n <= 0) throw new Exception("Array index error");