import org.apache.commons.math3.optim.univariate.UnivariateOptimizer; //导入依赖的package包/类
private UnivariatePointValuePair findMin(UnivariatePointValuePair current, UnivariateOptimizer o,
		UnivariateFunction f, double qValue, double factor)
{
	try
	{
		BracketFinder bracket = new BracketFinder();
		bracket.search(f, GoalType.MINIMIZE, qValue * factor, qValue / factor);
		UnivariatePointValuePair next = o.optimize(GoalType.MINIMIZE, new MaxEval(3000),
				new SearchInterval(bracket.getLo(), bracket.getHi(), bracket.getMid()),
				new UnivariateObjectiveFunction(f));
		if (next == null)
			return current;
		//System.out.printf("LineMin [%.1f]  %f = %f\n", factor, next.getPoint(), next.getValue());
		if (current != null)
			return (next.getValue() < current.getValue()) ? next : current;
		return next;
	}
	catch (Exception e)
	{
		return current;
	}
}
 

import org.apache.commons.math3.optim.univariate.UnivariateOptimizer; //导入依赖的package包/类
/**
 * Calculates the 'canonical' start point. This version uses 
 * (a) a coarse search for a global maximum of fp() and subsequently 
 * (b) a numerical optimization using Brent's method
 * (implemented with Apache Commons Math).
 * 
 * @param Mp number of Fourier coefficient pairs
 * @return start point phase
 */
public double getStartPointPhase(int Mp) {
	Mp = Math.min(Mp, (G.length-1)/2);
	UnivariateFunction fp =  new TargetFunction(Mp);
	// search for the global maximum in coarse steps
	double cmax = Double.NEGATIVE_INFINITY;
	int kmax = -1;
	int K = 25;	// number of steps over 180 degrees
	for (int k = 0; k < K; k++) {
		final double phi = Math.PI * k / K; 	// phase to evaluate
		final double c = fp.value(phi);
		if (c > cmax) {
			cmax = c;
			kmax = k;
		}
	}
	// optimize using previous and next point as the bracket.
	double minPhi = Math.PI * (kmax - 1) / K;
	double maxPhi = Math.PI * (kmax + 1) / K;	

	UnivariateOptimizer optimizer = new BrentOptimizer(1E-4, 1E-6);
	int maxIter = 20;
	UnivariatePointValuePair result = optimizer.optimize(
			new MaxEval(maxIter),
			new UnivariateObjectiveFunction(fp),
			GoalType.MAXIMIZE,
			new SearchInterval(minPhi, maxPhi)
			);
	double phi0 = result.getPoint();
	return phi0;	// the canonical start point phase
}
 

import org.apache.commons.math3.optim.univariate.UnivariateOptimizer; //导入依赖的package包/类
/**
  * Perform a line search minimization. This function accepts as input:
  *   (a) a starting point (a vector),
  *   (b) a direction in which to travel (a vector),
  *   (c) limits on the total distance to travel along (b).
  *   
  * With these inputs the function attempts to find the minimum of a
  * scalar-valued multivariate function along the line starting at 
  * (a) and pointing in the direction of (b).
  * 
  * @param function
  *        A scalar-valued multivariate function to minimize,
  * @param startingPoint
  *        A vector starting point from which to begin the minimization (P),
  * @param vectorDirection
  *        A vector direction along which to travel from P, (V)
  * @param maximumDistanceToTravel
  *        The maximum distance to travel in the direction of V,
  * @param maximumEvaluations
  *        The maximum number of function evaluations to identify the minimum,
  * @param relativeErrorGoal
  *        The relative error target of the minimization,
  * @param absoluteErrorGoal
  *        The absolute error target of the minimization.
  * @return
  *        A lightweight immutable struct containing the vector solution and
  *        the evaluation of the function at this point.
  */
static public LineSearchResult doLineSearch(
   final MultivariateFunction function,
   final double[] startingPoint,
   final double[] vectorDirection,
   final double maximumDistanceToTravel,
   final int maximumEvaluations,
   final double relativeErrorGoal,
   final double absoluteErrorGoal
   ) {
   Preconditions.checkArgument(maximumEvaluations > 0);
   Preconditions.checkArgument(relativeErrorGoal > 0. || absoluteErrorGoal > 0.);
   Preconditions.checkArgument(maximumDistanceToTravel > 0.);
   final LineSearchObjectiveFunction lineSearcher =
      new LineSearchObjectiveFunction(function, startingPoint, vectorDirection);
   final UnivariateOptimizer optimizer =
      new BrentOptimizer(relativeErrorGoal, absoluteErrorGoal);
   UnivariatePointValuePair result = optimizer.optimize(
      new MaxEval(maximumEvaluations),
      new UnivariateObjectiveFunction(lineSearcher),
      GoalType.MINIMIZE,
      new SearchInterval(0, maximumDistanceToTravel, 0)
      );
   final double[] vectorSolution = new double[startingPoint.length];
   for(int i = 0; i< vectorDirection.length; ++i)
      vectorSolution[i] = lineSearcher.startingPoint[i] + 
         lineSearcher.normalizedDirection[i] * result.getPoint();
   final LineSearchResult solution = 
      new LineSearchResult(vectorSolution, result.getValue());
   return solution;
}