How to use

evaluateNode

method

in

org.matheclipse.parser.client.eval.DoubleEvaluator

/**
 * Reevaluate the <code>expression</code> (possibly after a new Variable
 * assignment).
 * 
 * @return the double
 * @throws SyntaxError the syntax error
 */
public double evaluate() {
  if ( fNode == null ) {
    throw new SyntaxError( 0, 0, 0, " ", "No parser input defined", 1 );
  }
  return evaluateNode( fNode );
}

/**
 * Reevaluate the <code>expression</code> (possibly after a new Variable assignment)
 * 
 * @param Expression
 * @return
 * @throws SyntaxError
 */
public double evaluate() {
  if (fNode == null) {
    throw new SyntaxError(0, 0, 0, " ", "No parser input defined", 1);
  }
  return evaluateNode(fNode);
}

/**
 * Reevaluate the <code>expression</code> (possibly after a new Variable
 * assignment)
 * 
 * @param expression
 * @return
 * @throws SyntaxError
 */
public double evaluate() {
 if (fNode == null) {
  throw new SyntaxError(0, 0, 0, " ", "No parser input defined", 1);
 }
 return evaluateNode(fNode);
}

  @Override
  public double evaluate(DoubleEvaluator engine, FunctionNode function) {
    double result = Double.NaN;
    double temp;
    int end = function.size();
    if (end > 1) {
      result = engine.evaluateNode(function.getNode(1));
      for (int i = 2; i < end; i++) {
        temp = Math.max(result, engine.evaluateNode(function.getNode(i)));
        if (temp > result) {
          result = temp;
        }
      }
    }
    return result;
  }
}

 public double evaluate(DoubleEvaluator engine, FunctionNode function) {
  double result = Double.MIN_VALUE;
  double temp;
  int end = function.size();
  for (int i = 1; i < end; i++) {
   temp = Math.max(result, engine.evaluateNode(function
     .getNode(i)));
   if (temp > result) {
    result = temp;
   }
  }
  return result;
 }
}

  @Override
  public double evaluate(DoubleEvaluator engine, FunctionNode function) {
    double result = Double.NaN;
    double temp;
    int end = function.size();
    if (end > 1) {
      result = engine.evaluateNode(function.getNode(1));
      for (int i = 2; i < end; i++) {
        temp = Math.min(result, engine.evaluateNode(function.getNode(i)));
        if (temp < result) {
          result = temp;
        }
      }
    }
    return result;
  }
}

 public double evaluate(DoubleEvaluator engine, FunctionNode function) {
  double result = Double.MAX_VALUE;
  double temp;
  int end = function.size();
  for (int i = 1; i < end; i++) {
   temp = Math.min(result, engine.evaluateNode(function
     .getNode(i)));
   if (temp < result) {
    result = temp;
   }
  }
  return result;
 }
}

 public double evaluate(DoubleEvaluator engine, FunctionNode function) {
  double result = Double.NaN;
  int end = function.size();
  for (int i = 1; i < end; i++) {
   result = engine.evaluateNode(function.getNode(i));
   if (DEBUG) {
    System.out.println(result);
   }
  }
  return result;
 }
}

  @Override
  public double evaluate(DoubleEvaluator engine, FunctionNode function) {
    double result = Double.NaN;
    int end = function.size();
    for (int i = 1; i < end; i++) {
      result = engine.evaluateNode(function.getNode(i));
      if (DEBUG) {
        System.out.println(result);
      }
    }
    return result;
  }
}

 public double evaluate(DoubleEvaluator engine, FunctionNode function) {
  double result = 0.0;
  for (int i = 1; i < function.size(); i++) {
   result += engine.evaluateNode(function.getNode(i));
  }
  return result;
 }
}

 public double evaluate(DoubleEvaluator engine, FunctionNode function) {
  double result = 1.0;
  for (int i = 1; i < function.size(); i++) {
   result *= engine.evaluateNode(function.getNode(i));
  }
  return result;
 }
}

  @Override
  public double evaluate(DoubleEvaluator engine, FunctionNode function) {
    double result = 0.0;
    for (int i = 1; i < function.size(); i++) {
      result += engine.evaluateNode(function.getNode(i));
    }
    return result;
  }
}

  @Override
  public double evaluate(DoubleEvaluator engine, FunctionNode function) {
    double result = 1.0;
    for (int i = 1; i < function.size(); i++) {
      result *= engine.evaluateNode(function.getNode(i));
    }
    return result;
  }
}

  /**
   * Evaluate.
   *
   * @param engine the engine
   * @param function the function
   * @return the double
   */
  @Override
  public double evaluate( DoubleEvaluator engine, FunctionNode function ) {
    double result = Double.MAX_VALUE;
    double temp;
    int end = function.size();
    for ( int i = 1; i < end; i++ ) {
      temp = Math.min( result, engine.evaluateNode( function.getNode( i ) ) );
      if ( temp < result ) {
        result = temp;
      }
    }
    return result;
  }
}

  /**
   * Evaluate.
   *
   * @param engine the engine
   * @param function the function
   * @return the double
   */
  @Override
  public double evaluate( DoubleEvaluator engine, FunctionNode function ) {
    double result = 0.0;
    for ( int i = 1; i < function.size(); i++ ) {
      result += engine.evaluateNode( function.getNode( i ) );
    }
    return result;
  }
}

  /**
   * Evaluate.
   *
   * @param engine the engine
   * @param function the function
   * @return the double
   */
  @Override
  public double evaluate( DoubleEvaluator engine, FunctionNode function ) {
    double result = 1.0;
    for ( int i = 1; i < function.size(); i++ ) {
      result *= engine.evaluateNode( function.getNode( i ) );
    }
    return result;
  }
}

  /**
   * Evaluate.
   *
   * @param engine the engine
   * @param function the function
   * @return the double
   */
  @Override
  public double evaluate( DoubleEvaluator engine, FunctionNode function ) {
    double result = Double.NaN;
    int end = function.size();
    for ( int i = 1; i < end; i++ ) {
      result = engine.evaluateNode( function.getNode( i ) );
      if ( DEBUG ) {
        System.out.println( result );
      }
    }
    return result;
  }
}

/**
 * Parse the given <code>expression String</code> and evaluate it to a
 * double value.
 * 
 * @param expression the expression
 * @return the double
 * @throws SyntaxError the syntax error
 */
public double evaluate( String expression ) {
  Parser p = new Parser();
  fNode = p.parse( expression );
  if ( fNode instanceof FunctionNode ) {
    fNode = optimizeFunction( (FunctionNode) fNode );
  }
  return evaluateNode( fNode );
}

/**
 * Parse the given <code>expression String</code> and evaluate it to a double
 * value
 * 
 * @param expression
 * @return
 * @throws SyntaxError
 */
public double evaluate(String expression) {
 Parser p = new Parser();
 fNode = p.parse(expression);
 if (fNode instanceof FunctionNode) {
  fNode = optimizeFunction((FunctionNode) fNode);
 }
 return evaluateNode(fNode);
}

/**
 * Parse the given <code>expression String</code> and evaluate it to a double value
 * 
 * @param expression
 * @return
 * @throws SyntaxError
 */
public double evaluate(String expression) {
  Parser p;
  if (fRelaxedSyntax) {
    p = new Parser(ASTNodeFactory.RELAXED_STYLE_FACTORY, true);
  } else {
    p = new Parser(ASTNodeFactory.MMA_STYLE_FACTORY, false);
  }
  fNode = p.parse(expression);
  if (fNode instanceof FunctionNode) {
    fNode = optimizeFunction((FunctionNode) fNode);
  }
  return evaluateNode(fNode);
}