import org.apache.commons.math3.optim.nonlinear.scalar.MultivariateOptimizer; //导入依赖的package包/类
private PointValuePair optimize(final MultivariateOptimizer optimizer, final double[] initialValues,
		final OptimizationData... data) {
	final OptimizationData[] d = new OptimizationData[5 + data.length];
	d[0] = new MaxIter(convergence.maxIt + 1);
	d[1] = new MaxEval(convergence.maxIt * 2);
	d[2] = new ObjectiveFunction(this);
	d[3] = GoalType.MAXIMIZE;
	d[4] = new InitialGuess(fixBounds(initialValues));
	for (int i = 0; i < data.length; ++i) {
		d[5 + i] = data[i];
	}
	return optimizer.optimize(d);
}
 

import org.apache.commons.math3.optim.nonlinear.scalar.MultivariateOptimizer; //导入依赖的package包/类
@Override
public synchronized void solve(Objenome o, List<SetNumericValue> variables) {
    
    this.variables = variables;
    this.objenome = o;
    
    if (numStarts==-1)
        numStarts = variables.size() * 2;
    
    double[] lower = new double[variables.size()];
    double[] upper = new double[variables.size()];
    double[] mid = new double[variables.size()];
    int j = 0;
    for (SetNumericValue n : variables) {
        lower[j] = n.getMin().doubleValue();
        upper[j] = n.getMax().doubleValue();
        mid[j] = (lower[j] + upper[j]) * 0.5f;
        j++;
    }
    
    //TODO add MultiStart
    
    MultivariateOptimizer optimize = 
            new BOBYQAOptimizer(variables.size()*2);
            //new PowellOptimizer(0.01, 0.05);
    
    RandomGenerator rng = getRandomGenerator();
    
    MultiStartMultivariateOptimizer multiOptimize = new MultiStartMultivariateOptimizer(optimize, numStarts, new UncorrelatedRandomVectorGenerator(variables.size(), new UniformRandomGenerator(rng)));
    
    PointValuePair result = multiOptimize.optimize(
            new MaxEval(evaluations),
            new SimpleBounds(lower, upper),
            goal,
            new InitialGuess(mid),
            new ObjectiveFunction(this)
            );        
    
    apply(result.getPointRef());
            
    this.bestValue = result.getValue();
}
 

import org.apache.commons.math3.optim.nonlinear.scalar.MultivariateOptimizer; //导入依赖的package包/类
public Pair<Double, SubstitutionModel> optimiseModel(final Tree tree, final SubstitutionModel model) {
    double[] startingValues = Mapper.getOptimisable(model.getParameters());
    PointValuePair optima;

    setRunnerTree(tree);

    SubstitutionModelFunction function = new SubstitutionModelFunction(model, this);

    ConvergenceChecker<PointValuePair> convergenceChecker = new SimpleValueChecker(-1, Constants.CONVERGENCE_TOL);

    //int n = initialGuess.length;
    //MultivariateOptimizer optimiser = new BOBYQAOptimizer(2 * n + 1);
    MultivariateOptimizer optimiser = new NativeLBFGSBMultivariateOptimizer(convergenceChecker);

    //MultivariateOptimizer optimiser = new SimplexOptimizer(convergenceChecker);

    try {
        optima = optimiser.optimize(new ObjectiveFunction(function),
                GoalType.MAXIMIZE,
                new InitialGuess(startingValues),//,
                new NelderMeadSimplex(startingValues.length),
                new MaxEval(Constants.MAX_EVALUATIONS)
        );
    } catch (Exception e) {
        e.printStackTrace();
        throw new RuntimeException(e);
    }

    System.out.println(" " + optimiser.getEvaluations() + " evaluations");

    if (optima == null)
        throw new RuntimeException("ERROR: Runner.optimiseMutationParameters was unsuccessful (optima == null).");

    double[] d = optima.getPoint();

    Mapper.setOptimisable(model.getParameters(), d);
    model.build();

    //CoreUtils.msg("Runner.optimiseMutationParameters optima: %s -> %s\n", Doubles.join(",", optima.getPoint()), optima.getValue());

    return Pair.of(optima.getValue(), model);
}
 

import org.apache.commons.math3.optim.nonlinear.scalar.MultivariateOptimizer; //导入依赖的package包/类
public Pair<Double, SwMut> optimiseMutationParameters(final Tree tree, final SwMut mutation, final FitnessStore fitnesses, final Penalty penalty) {
    double[] startingValues = Mapper.getOptimisable(mutation.getParameters());
    PointValuePair optima;

    // To improve performance (esp. the distributed runner), we set the tree
    // and fitnesses for the runner so they do not need to be sent over the
    // wire each iteration
    setRunnerTree(tree);
    setRunnerFitnesses(fitnesses);
    setRunnerPenalty(penalty);

    CoreUtils.msg("Optimising mutation parameters: ");

    SwMutFunction function = new SwMutFunction(mutation, this);

    ConvergenceChecker<PointValuePair> convergenceChecker = new SimpleValueChecker(-1, Constants.CONVERGENCE_TOL);

    //int n = initialGuess.length;
    //MultivariateOptimizer optimiser = new BOBYQAOptimizer(2 * n + 1);
    //MultivariateOptimizer optimiser = new NativeLBFGSBMultivariateOptimizer(convergenceChecker);

    MultivariateOptimizer optimiser = new SimplexOptimizer(convergenceChecker);

    try {
        optima = optimiser.optimize(new ObjectiveFunction(function),
                GoalType.MAXIMIZE,
                new InitialGuess(startingValues),//,
                new NelderMeadSimplex(startingValues.length),
                new MaxEval(Constants.MAX_EVALUATIONS)
        );
    } catch (Exception e) {
        e.printStackTrace();
        throw new RuntimeException(e);
    }

    System.out.println(" " + optimiser.getEvaluations() + " evaluations");

    if (optima == null)
        throw new RuntimeException("ERROR: Runner.optimiseMutationParameters was unsuccessful (optima == null).");

    double[] d = optima.getPoint();

    Mapper.setOptimisable(mutation.getParameters(), d);
    mutation.build();

    //CoreUtils.msg("Runner.optimiseMutationParameters optima: %s -> %s\n", Doubles.join(",", optima.getPoint()), optima.getValue());

    return Pair.of(optima.getValue(), mutation);
}