parsefunction.java

java 作图的程序

             if(x == null) throw new Exception("X Array error");

             double array[] = new double[n];

             for(int i=0; i<n; i++) {
                 this.x = x[i];
                 array[i] = evaluate(root);
             }
             return array;
        }

  /**
   * Return an array of solutions given an array of x values and y values
   * @param n number of values to process in the input array
   * @param x Array containing the x values.
   * @param y Array containing the y values.
   * @return Array containing the solutions.
   * @exception Exception
   *       Generic exception if the array index n<=0, or x is null, or y is null.
   */
        public double[] getResults(int n, double x[], double y[]) 
                                    throws Exception {

             if(n <= 0) throw new Exception("Array index error");
             if(x == null) throw new Exception("X Array error");
             if(y == null) throw new Exception("Y Array error");

             double array[] = new double[n];

             for(int i=0; i<n; i++) {
                 this.x = x[i];
                 this.y = y[i];
                 array[i] = evaluate(root);
             }
             return array;
        }

  /**
   * Return an array of solutions given an array of x values, y values
   * and z values.
   * @param n number of values to process in the input array
   * @param x Array containing the x values.
   * @param y Array containing the y values.
   * @return Array containing the solutions.
   * @exception Exception
   *      Generic exception if the array index n<=0, or x is null, 
   *    or y is null, or z is null.
   */
        public double[] getResults(int n, double x[], double y[], double z[]) 
                                    throws Exception {

             if(n <= 0) throw new Exception("Array index error");
             if(x == null) throw new Exception("X Array error");
             if(y == null) throw new Exception("Y Array error");
             if(z == null) throw new Exception("Z Array error");

             double array[] = new double[n];

             for(int i=0; i<n; i++) {
                 this.x = x[i];
                 this.y = y[i];
                 this.z = z[i];
                 array[i] = evaluate(root);
             }
             return array;
        }
  /**
   * Return a boolean array with index 0 true if the independent
   * variable x was found in the function, index 1 true if
   * y was found, and index 2  true if z was found.
   */

        public boolean[] getVariables()  {
        	boolean b[] =  new boolean[3];
        	
        	b[0] = independent_x;
        	b[1] = independent_y;
        	b[2] = independent_z;

            return b;
        }

  /**
   * Set the value of the independent variable X.
   */
        public void setX( double x ) { this.x = x; } 

  /**
   * Set the value of the independent variable Y.
   */
        public void setY( double y ) { this.y = y; } 

  /**
   * Set the value of the independent variable Z.
   */
        public void setZ( double z ) { this.z = z; }
 

/*
*******************
**
** Private Methods
**
******************/

  /*
  ** Parse the string and build the node link list.
  ** This builds up a simple Left-Right binary node tree.
  **
  ** A GROUP token (start of parenthesis) forces a new group node
  ** that starts an independent branch of the tree with the contents
  ** of the group linked to the left node of the group node.
  ** Intrinsic functions behave like a GROUP token they start an independent
  ** branch of the tree with the contents of the group linked to the
  ** left node of the intrinsic function.
  ** Intrinsic functions that have to be passed 2 parameters have the
  ** second parameter linked to there right node.
  **  (This has to be modified for functions containing more than 2 parameters
  **  currently the code cannot deal with more than 2 parameters)
  */
        private int parseString(Node node) {
        Node left;
        Node right;
        int token;
        int t;

        // Get the next token in the string
        token = nextWord();

        // Do some preliminary branching.
        if(token == ERROR) {
             System.out.println("Error parsing \""+sval+"\"");
             return ERROR;
        } else 
        if( token != EOS && debug ) {
             System.out.println("Parse: "+sval+"\t Token: "+token);
        } else 
        if( token == EOS && debug ) {
             System.out.println("Parse: EOS");
        }
        
        // Main token switch

        switch(token) {
        	
	  /*
	  ** Number token or constant tokens.
          ** Place the value in the node and recurse on this
          ** terminal node. It will be used by an operator.
          */
        case NUMBER:
       	       node.type  = Node.VALUE;
       	       node.value = nval;
               return parseString(node);
       	       
        case PI:
      	       node.type = Node.VALUE;
      	       node.value = Math.PI;
               return parseString(node);
      	       
        case E:
      	       node.type = Node.VALUE;
      	       node.value = Math.E;
      	       return parseString(node);
        case BOLTZMAN:
      	       node.type = Node.VALUE;
      	       node.value =             SpecialFunction.BOLTZMAN;
      	       return parseString(node);
        case ECHARGE:
      	       node.type = Node.VALUE;
      	       node.value =             SpecialFunction.ECHARGE;
      	       return parseString(node);
        case EMASS:
      	       node.type = Node.VALUE;
      	       node.value =             SpecialFunction.EMASS;
      	       return parseString(node);
        case PMASS:
      	       node.type = Node.VALUE;
      	       node.value =             SpecialFunction.PMASS;
      	       return parseString(node);
        case GRAV:
      	       node.type = Node.VALUE;
      	       node.value =             SpecialFunction.GRAV;
      	       return parseString(node);
        case PLANCK:
      	       node.type = Node.VALUE;
      	       node.value =             SpecialFunction.PLANCK;
      	       return parseString(node);
        case LIGHTSPEED:
      	       node.type = Node.VALUE;
      	       node.value =             SpecialFunction.LIGHTSPEED;
      	       return parseString(node);
        case STEFANBOLTZ:
      	       node.type = Node.VALUE;
      	       node.value =             SpecialFunction.STEFANBOLTZ;
      	       return parseString(node);
        case AVOGADRO:
      	       node.type = Node.VALUE;
      	       node.value =             SpecialFunction.AVOGADRO;
      	       return parseString(node);
        case GASCONSTANT:
      	       node.type = Node.VALUE;
      	       node.value =             SpecialFunction.GASCONSTANT;
      	       return parseString(node);
        case GRAVACC:
      	       node.type = Node.VALUE;
      	       node.value =             SpecialFunction.GRAVACC;
      	       return parseString(node);
      	case RAD:
      	       node.type = Node.VALUE;
      	       node.value = Math.PI/180.0;
      	       return parseString(node);

	case RANDOM:
      	       node.type = Node.VALUE;
      	       node.value = Math.random();
      	       return parseString(node);

	 /*
	 ** Independent variables behave like constant nodes except
         ** they are flagged as INDEPENDENT nodes. Then we recurse using this
         **  this node as it has to be used by an operator
         */
        case X: case Y: case Z:
      	       node.op   = token;
      	       node.type = Node.INDEPENDENT;

      	       
      	       if(token == X) independent_x = true;
      	       else
      	       if(token == Y) independent_y = true;
      	       else
      	       if(token == Z) independent_z = true;
      	       
      	       return parseString(node);
      	       
	/*
	** Terminal tokens
        */
	case ENDGROUP: case EOS: case COMMA:
               break;

       /*
       ** beginning of a group '('. Parse the string until the
       ** corresponding endgroup is encountered ')'. The created
       ** node list is attached to the group nodes left
       ** node. Then continue the process by continuing to parse
       ** the string after the endgroup.
       */
        case GROUP:
               left = new Node();
               if(parseString(left) == ENDGROUP) {
                    node.left = left;
                    node.type = Node.GROUP;
                    node.precedence = Node.P5;
                    token = parseString(node);
                } else {
                    System.out.println("Parse Failed: missing parentheses");
                    token = ERROR;
                }
                break;

	/*
	** Binary and Unary Operators.
        ** The existing node goes to the left and everything
        ** on the right gets attached to the right node.
        **
        ** A unary operator is recognised by the empty
        ** node parsed ie nothing exists on the left.
        */
	case ADD: case SUBTRACT: case MULTIPLY: case DIVIDE: case POWER:
               right = new Node();
               t = parseString(right);


               if(t != ERROR) {
 		   if( (token == SUBTRACT || token == ADD )
                                       && node.type == Node.NULL ) {

                      //System.out.println("...Unary Operator");
                      
                      node.right = right;
                      node.precedence = Node.P4;
                      node.op = token;
                      node.type = Node.OP;
		   } else {

                      //System.out.println("...Binary Operator");

                      left = new Node(node);
                      node.left = left;
                      node.right = right;
                      node.op = token;
                      node.type = Node.OP;
                      switch (token) {
		         case ADD: case SUBTRACT:
                            node.precedence = Node.P1;
                            break;
                         case MULTIPLY: case DIVIDE:
                            node.precedence = Node.P2;
                            break;
                         case POWER:
                            node.precedence = Node.P3;
                            break;
                       }
                   }
	       }
               token = t;
               
               break;
	/*
	** Single parameter intrinsic functions behave excacty like
        ** parenthesis.
        */       
        case SIN:   case COS:   case TAN: 
        case ASIN:  case ACOS:  case ATAN:
        case LOG:   case SQRT:  case LOG10:
        case EXP:   case REMAINDER: 
        case J0:    case J1: case Y0: case Y1:
        case SINH:  case COSH:  case TANH:
        case ASINH: case ACOSH: case ATANH:
        case FAC:   case GAMMA: case ERF: case ERFC:
        case NORMAL: 
                node.op = token;
                node.type = Node.INTRINSIC;
                node.precedence = Node.P0;

                token = nextWord();
                if(token != GROUP ) {
                     System.out.println(
                    "Parse Failed: intrinsic function is missing \"(\"");
                    token = ERROR;
                } else {
                   left = new Node();
                   if(parseString(left) == ENDGROUP) {
                       node.left = left;
                       token = parseString(node);
                   } else {
                       System.out.println(
                       "Parse Failed: intrinsic function is missing \")\"");
                       token = ERROR;
                   }
                }
                break;
	/*
	** 2 parameter intrinsic functions
        ** First parameter on attached to the left node, 
        **  second parameter attached to the right.
        */
	case ATAN2: case JN: case YN: case IGAM: case IGAMC:
        case CHISQ: case CHISQC: case POISSON: case POISSONC:
                node.op = token;
                node.type = Node.INTRINSIC;
                node.precedence = Node.P0;

                token = nextWord();
                if(debug) System.out.println("Parse: "+sval);
                if(token != GROUP ) {
                     System.out.println(
                    "Parse Failed: intrinsic function is missing \"(\"");
                    token = ERROR;
                } else {
                   Node param1 = new Node();
                   if(parseString(param1) == COMMA) {
                       Node param2 = new Node();
                       if(parseString(param2) == ENDGROUP) {
                          node.right = param2;
                          node.left  = param1;
                          token = parseString(node);
                       } else {
                          System.out.println(
                          "Parse Failed: intrinsic function is missing \")\"");
                          token = ERROR;
                       }
                   } else {
                          System.out.println(
                          "Parse Failed: intrinsic function is missing \",\"");
                          token = ERROR;
		   }                      
                }
                break;


         default:
                break;