Java PointValuePair.getPoint方法代码示例

import org.apache.commons.math3.optimization.PointValuePair; //导入方法依赖的package包/类
@Test
public void testMath283() {
    // fails because MultiDirectional.iterateSimplex is looping forever
    // the while(true) should be replaced with a convergence check
    SimplexOptimizer optimizer = new SimplexOptimizer(1e-14, 1e-14);
    optimizer.setSimplex(new MultiDirectionalSimplex(2));
    final Gaussian2D function = new Gaussian2D(0, 0, 1);
    PointValuePair estimate = optimizer.optimize(1000, function,
                                                     GoalType.MAXIMIZE, function.getMaximumPosition());
    final double EPSILON = 1e-5;
    final double expectedMaximum = function.getMaximum();
    final double actualMaximum = estimate.getValue();
    Assert.assertEquals(expectedMaximum, actualMaximum, EPSILON);

    final double[] expectedPosition = function.getMaximumPosition();
    final double[] actualPosition = estimate.getPoint();
    Assert.assertEquals(expectedPosition[0], actualPosition[0], EPSILON );
    Assert.assertEquals(expectedPosition[1], actualPosition[1], EPSILON );
}
 

import org.apache.commons.math3.optimization.PointValuePair; //导入方法依赖的package包/类
/**
 * @param func Function to optimize.
 * @param optimum Expected optimum.
 * @param init Starting point.
 * @param goal Minimization or maximization.
 * @param fTol Tolerance (relative error on the objective function) for
 * "Powell" algorithm.
 * @param pointTol Tolerance for checking that the optimum is correct.
 */
private void doTest(MultivariateFunction func,
                    double[] optimum,
                    double[] init,
                    GoalType goal,
                    double fTol,
                    double pointTol) {
    final MultivariateOptimizer optim = new PowellOptimizer(fTol, Math.ulp(1d));

    final PointValuePair result = optim.optimize(1000, func, goal, init);
    final double[] point = result.getPoint();

    for (int i = 0, dim = optimum.length; i < dim; i++) {
        Assert.assertEquals("found[" + i + "]=" + point[i] + " value=" + result.getValue(),
                            optimum[i], point[i], pointTol);
    }
}
 

import org.apache.commons.math3.optimization.PointValuePair; //导入方法依赖的package包/类
@Test
public void testMath293() {
  LinearObjectiveFunction f = new LinearObjectiveFunction(new double[] { 0.8, 0.2, 0.7, 0.3, 0.4, 0.6}, 0 );
  Collection<LinearConstraint> constraints = new ArrayList<LinearConstraint>();
  constraints.add(new LinearConstraint(new double[] { 1, 0, 1, 0, 1, 0 }, Relationship.EQ, 30.0));
  constraints.add(new LinearConstraint(new double[] { 0, 1, 0, 1, 0, 1 }, Relationship.EQ, 30.0));
  constraints.add(new LinearConstraint(new double[] { 0.8, 0.2, 0.0, 0.0, 0.0, 0.0 }, Relationship.GEQ, 10.0));
  constraints.add(new LinearConstraint(new double[] { 0.0, 0.0, 0.7, 0.3, 0.0, 0.0 }, Relationship.GEQ, 10.0));
  constraints.add(new LinearConstraint(new double[] { 0.0, 0.0, 0.0, 0.0, 0.4, 0.6 }, Relationship.GEQ, 10.0));

  SimplexSolver solver = new SimplexSolver();
  PointValuePair solution1 = solver.optimize(f, constraints, GoalType.MAXIMIZE, true);

  Assert.assertEquals(15.7143, solution1.getPoint()[0], .0001);
  Assert.assertEquals(0.0, solution1.getPoint()[1], .0001);
  Assert.assertEquals(14.2857, solution1.getPoint()[2], .0001);
  Assert.assertEquals(0.0, solution1.getPoint()[3], .0001);
  Assert.assertEquals(0.0, solution1.getPoint()[4], .0001);
  Assert.assertEquals(30.0, solution1.getPoint()[5], .0001);
  Assert.assertEquals(40.57143, solution1.getValue(), .0001);

  double valA = 0.8 * solution1.getPoint()[0] + 0.2 * solution1.getPoint()[1];
  double valB = 0.7 * solution1.getPoint()[2] + 0.3 * solution1.getPoint()[3];
  double valC = 0.4 * solution1.getPoint()[4] + 0.6 * solution1.getPoint()[5];

  f = new LinearObjectiveFunction(new double[] { 0.8, 0.2, 0.7, 0.3, 0.4, 0.6}, 0 );
  constraints = new ArrayList<LinearConstraint>();
  constraints.add(new LinearConstraint(new double[] { 1, 0, 1, 0, 1, 0 }, Relationship.EQ, 30.0));
  constraints.add(new LinearConstraint(new double[] { 0, 1, 0, 1, 0, 1 }, Relationship.EQ, 30.0));
  constraints.add(new LinearConstraint(new double[] { 0.8, 0.2, 0.0, 0.0, 0.0, 0.0 }, Relationship.GEQ, valA));
  constraints.add(new LinearConstraint(new double[] { 0.0, 0.0, 0.7, 0.3, 0.0, 0.0 }, Relationship.GEQ, valB));
  constraints.add(new LinearConstraint(new double[] { 0.0, 0.0, 0.0, 0.0, 0.4, 0.6 }, Relationship.GEQ, valC));

  PointValuePair solution2 = solver.optimize(f, constraints, GoalType.MAXIMIZE, true);
  Assert.assertEquals(40.57143, solution2.getValue(), .0001);
}
 

import org.apache.commons.math3.optimization.PointValuePair; //导入方法依赖的package包/类
private static boolean validSolution(PointValuePair solution, List<LinearConstraint> constraints, double epsilon) {
    double[] vals = solution.getPoint();
    for (LinearConstraint c : constraints) {
        double[] coeffs = c.getCoefficients().toArray();
        double result = 0.0d;
        for (int i = 0; i < vals.length; i++) {
            result += vals[i] * coeffs[i];
        }
        
        switch (c.getRelationship()) {
        case EQ:
            if (!Precision.equals(result, c.getValue(), epsilon)) {
                return false;
            }
            break;
            
        case GEQ:
            if (Precision.compareTo(result, c.getValue(), epsilon) < 0) {
                return false;
            }
            break;
            
        case LEQ:
            if (Precision.compareTo(result, c.getValue(), epsilon) > 0) {
                return false;
            }
            break;
        }
    }
    
    return true;
}
 

import org.apache.commons.math3.optimization.PointValuePair; //导入方法依赖的package包/类
/**
 * Cf. MATH-867
 */
@Test
public void testFitAccuracyDependsOnBoundary() {
    final CMAESOptimizer optimizer = new CMAESOptimizer();
    final MultivariateFunction fitnessFunction = new MultivariateFunction() {
            public double value(double[] parameters) {
                final double target = 11.1;
                final double error = target - parameters[0];
                return error * error;
            }
        };

    final double[] start = { 1 };
 
    // No bounds.
    PointValuePair result = optimizer.optimize(100000, fitnessFunction, GoalType.MINIMIZE,
                                               start);
    final double resNoBound = result.getPoint()[0];

    // Optimum is near the lower bound.
    final double[] lower = { -20 };
    final double[] upper = { 5e16 };
    result = optimizer.optimize(100000, fitnessFunction, GoalType.MINIMIZE,
                                start, lower, upper);
    final double resNearLo = result.getPoint()[0];

    // Optimum is near the upper bound.
    lower[0] = -5e16;
    upper[0] = 20;
    result = optimizer.optimize(100000, fitnessFunction, GoalType.MINIMIZE,
                                start, lower, upper);
    final double resNearHi = result.getPoint()[0];

    // System.out.println("resNoBound=" + resNoBound +
    //                    " resNearLo=" + resNearLo +
    //                    " resNearHi=" + resNearHi);

    // The two values currently differ by a substantial amount, indicating that
    // the bounds definition can prevent reaching the optimum.
    Assert.assertEquals(resNoBound, resNearLo, 1e-3);
    Assert.assertEquals(resNoBound, resNearHi, 1e-3);
}