Apache
/
commons-math
mirror of https://github.com/apache/commons-math.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

[MATH-842] Added support for different pivot selection rules to SimplexSolver. 

git-svn-id: https://svn.apache.org/repos/asf/commons/proper/math/trunk@1550975 13f79535-47bb-0310-9956-ffa450edef68
This commit is contained in:
Thomas Neidhart 2013-12-14 21:50:33 +00:00
parent 7ebbaea90e
commit f3a785108f
4 changed files with 147 additions and 33 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

5
src/changes/changes.xml
View File

@ -51,6 +51,11 @@ If the output is not quite correct, check for invisible trailing spaces!
</properties>
<body>
<release version="3.3" date="TBD" description="TBD">
<action dev="tn" type="fix" issue="MATH-842">
Added support for different pivot selection rules to the "SimplexSolver" by introducing
the new "OptimizationData" class "PivotSelectionRule". Currently supported rules are:
Dantzig (default) and Bland (avoids cycles).
</action>
<action dev="tn" type="fix" issue="MATH-1070" due-to="Oleksandr Muliarevych">
Fix "Precision#round(float, int, int)" when using rounding mode "BigDecimal.ROUND_UP"
and the discarded fraction is zero.

39
src/main/java/org/apache/commons/math3/optim/linear/PivotSelectionRule.java Normal file
View File

@ -0,0 +1,39 @@
/*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You under the Apache License, Version 2.0
* (the "License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.apache.commons.math3.optim.linear;
import org.apache.commons.math3.optim.OptimizationData;
/**
* Pivot selection rule to the use for a Simplex solver.
*
* @version $Id$
* @since 3.3
*/
public enum PivotSelectionRule implements OptimizationData {
/**
* The classical rule, the variable with the most negative coefficient
* in the objective function row will be chosen as entering variable.
*/
Dantzig,
/**
* The first variable with a negative coefficient in the objective function
* row will be chosen as entering variable. This rule guarantees to prevent
* cycles, but may take longer to find an optimal solution.
*/
Bland
}

71
src/main/java/org/apache/commons/math3/optim/linear/SimplexSolver.java
View File

@ -27,6 +27,19 @@ import org.apache.commons.math3.util.Precision;
/**
* Solves a linear problem using the "Two-Phase Simplex" method.
* <p>
* The {@link SimplexSolver} supports the following {@link OptimizationData} data provided
* as arguments to {@link #optimize(OptimizationData...)}:
* <ul>
* <li>objective function: {@link LinearObjectiveFunction} - mandatory</li>
* <li>linear constraints {@link LinearConstraintSet} - mandatory</li>
* <li>type of optimization: {@link org.apache.commons.math3.optim.nonlinear.scalar.GoalType GoalType}
* - optional, default: {@link org.apache.commons.math3.optim.nonlinear.scalar.GoalType#MINIMIZE MINIMIZE}</li>
* <li>whether to allow negative values as solution: {@link NonNegativeConstraint} - optional, default: true</li>
* <li>pivot selection rule: {@link PivotSelectionRule} - optional, default {@link PivotSelectionRule#Dantzig}</li>
* <li>callback for the best solution: {@link SolutionCallback} - optional</li>
* <li>maximum number of iterations: {@link MaxIter} - optional, default: {@link Integer#MAX_VALUE}</li>
* </ul>
* <p>
* <b>Note:</b> Depending on the problem definition, the default convergence criteria
* may be too strict, resulting in {@link NoFeasibleSolutionException} or
* {@link TooManyIterationsException}. In such a case it is advised to adjust these
@ -42,15 +55,8 @@ import org.apache.commons.math3.util.Precision;
* The cut-off value has been introduced to zero out very small numbers in the Simplex tableau,
* as these may lead to numerical instabilities due to the nature of the Simplex algorithm
* (the pivot element is used as a denominator). If the problem definition is very tight, the
* default cut-off value may be too small, thus it is advised to increase it to a larger value,
* in accordance with the chosen epsilon.
* <p>
* It may also be counter-productive to provide a too large value for {@link
* org.apache.commons.math3.optim.MaxIter MaxIter} as parameter in the call of {@link
* #optimize(org.apache.commons.math3.optim.OptimizationData...) optimize(OptimizationData...)},
* as the {@link SimplexSolver} will use different strategies depending on the current iteration
* count. After half of the allowed max iterations has already been reached, the strategy to select
* pivot rows will change in order to break possible cycles due to degenerate problems.
* default cut-off value may be too small for certain problems, thus it is advised to increase it
* to a larger value, in accordance with the chosen epsilon.
*
* @version $Id$
* @since 2.0
@ -77,6 +83,9 @@ public class SimplexSolver extends LinearOptimizer {
*/
private final double cutOff;
/** The pivot selection method to use. */
private PivotSelectionRule pivotSelection;
/**
* The solution callback to access the best solution found so far in case
* the optimizer fails to find an optimal solution within the iteration limits.
@ -120,6 +129,7 @@ public class SimplexSolver extends LinearOptimizer {
this.epsilon = epsilon;
this.maxUlps = maxUlps;
this.cutOff = cutOff;
this.pivotSelection = PivotSelectionRule.Dantzig;
}
/**
@ -130,6 +140,7 @@ public class SimplexSolver extends LinearOptimizer {
* LinearOptimizer}, this method will register the following data:
* <ul>
* <li>{@link SolutionCallback}</li>
* <li>{@link PivotSelectionRule}</li>
* </ul>
*
* @return {@inheritDoc}
@ -151,6 +162,7 @@ public class SimplexSolver extends LinearOptimizer {
* LinearOptimizer}, this method will register the following data:
* <ul>
* <li>{@link SolutionCallback}</li>
* <li>{@link PivotSelectionRule}</li>
* </ul>
*/
@Override
@ -166,6 +178,10 @@ public class SimplexSolver extends LinearOptimizer {
solutionCallback = (SolutionCallback) data;
continue;
}
if (data instanceof PivotSelectionRule) {
pivotSelection = (PivotSelectionRule) data;
continue;
}
}
}
@ -185,15 +201,43 @@ public class SimplexSolver extends LinearOptimizer {
if (entry < minValue) {
minValue = entry;
minPos = i;
// Bland's rule: chose the entering column with the lowest index
if (pivotSelection == PivotSelectionRule.Bland && isValidPivotColumn(tableau, i)) {
break;
}
}
}
return minPos;
}
/**
* Checks whether the given column is valid pivot column, i.e. will result
* in a valid pivot row.
* <p>
* When applying Bland's rule to select the pivot column, it may happen that
* there is no corresponding pivot row. This method will check if the selected
* pivot column will return a valid pivot row.
*
* @param tableau simplex tableau for the problem
* @param col the column to test
* @return {@code true} if the pivot column is valid, {@code false} otherwise
*/
private boolean isValidPivotColumn(SimplexTableau tableau, int col) {
for (int i = tableau.getNumObjectiveFunctions(); i < tableau.getHeight(); i++) {
final double entry = tableau.getEntry(i, col);
if (Precision.compareTo(entry, 0d, maxUlps) > 0) {
return true;
}
}
return false;
}
/**
* Returns the row with the minimum ratio as given by the minimum ratio test (MRT).
*
* @param tableau Simple tableau for the problem.
* @param tableau Simplex tableau for the problem.
* @param col Column to test the ratio of (see {@link #getPivotColumn(SimplexTableau)}).
* @return the row with the minimum ratio.
*/
@ -243,11 +287,7 @@ public class SimplexSolver extends LinearOptimizer {
//
// see http://www.stanford.edu/class/msande310/blandrule.pdf
// see http://en.wikipedia.org/wiki/Bland%27s_rule (not equivalent to the above paper)
//
// Additional heuristic: if we did not get a solution after half of maxIterations
// revert to the simple case of just returning the top-most row
// This heuristic is based on empirical data gathered while investigating MATH-828.
if (getEvaluations() < getMaxEvaluations() / 2) {
Integer minRow = null;
int minIndex = tableau.getWidth();
final int varStart = tableau.getNumObjectiveFunctions();
@ -263,7 +303,6 @@ public class SimplexSolver extends LinearOptimizer {
}
return minRow;
}
}
return minRatioPositions.get(0);
}

43
src/test/java/org/apache/commons/math3/optim/linear/SimplexSolverTest.java
View File

@ -32,6 +32,34 @@ import org.junit.Assert;
public class SimplexSolverTest {
private static final MaxIter DEFAULT_MAX_ITER = new MaxIter(100);
@Test
public void testMath842Cycle() {
// from http://www.math.toronto.edu/mpugh/Teaching/APM236_04/bland
// maximize 10 x1 - 57 x2 - 9 x3 - 24 x4
// subject to
// 1/2 x1 - 11/2 x2 - 5/2 x3 + 9 x4 <= 0
// 1/2 x1 - 3/2 x2 - 1/2 x3 + x4 <= 0
// x1 <= 1
// x1,x2,x3,x4 >= 0
LinearObjectiveFunction f = new LinearObjectiveFunction(new double[] { 10, -57, -9, -24}, 0);
ArrayList<LinearConstraint> constraints = new ArrayList<LinearConstraint>();
constraints.add(new LinearConstraint(new double[] {0.5, -5.5, -2.5, 9}, Relationship.LEQ, 0));
constraints.add(new LinearConstraint(new double[] {0.5, -1.5, -0.5, 1}, Relationship.LEQ, 0));
constraints.add(new LinearConstraint(new double[] { 1, 0, 0, 0}, Relationship.LEQ, 1));
double epsilon = 1e-6;
SimplexSolver solver = new SimplexSolver();
PointValuePair solution = solver.optimize(f, new LinearConstraintSet(constraints),
GoalType.MAXIMIZE,
new NonNegativeConstraint(true),
PivotSelectionRule.Bland);
Assert.assertEquals(1.0d, solution.getValue(), epsilon);
Assert.assertTrue(validSolution(solution, constraints, epsilon));
}
@Test
public void testMath828() {
LinearObjectiveFunction f = new LinearObjectiveFunction(
@ -721,13 +749,14 @@ public class SimplexSolverTest {
@Test
public void testSolutionCallback() {
// re-use the problem from testcase for MATH-930
// it normally requires 186 iterations
// it normally requires 113 iterations
final List<LinearConstraint> constraints = createMath930Constraints();
//Collections.reverse(constraints);
double[] objFunctionCoeff = new double[33];
objFunctionCoeff[3] = 1;
LinearObjectiveFunction f = new LinearObjectiveFunction(objFunctionCoeff, 0);
SimplexSolver solver = new SimplexSolver(1e-4, 10, 1e-6);
SimplexSolver solver = new SimplexSolver(1e-2, 10, 1e-6);
final SolutionCallback callback = new SolutionCallback();
@ -735,7 +764,8 @@ public class SimplexSolverTest {
try {
// we need to use a DeterministicLinearConstraintSet to always get the same behavior
solver.optimize(new MaxIter(100), f, new DeterministicLinearConstraintSet(constraints),
GoalType.MINIMIZE, new NonNegativeConstraint(true), callback);
GoalType.MINIMIZE, new NonNegativeConstraint(true), callback,
PivotSelectionRule.Bland);
Assert.fail("expected TooManyIterationsException");
} catch (TooManyIterationsException ex) {
// expected
@ -747,9 +777,10 @@ public class SimplexSolverTest {
// 2. iteration limit allows to reach phase 2, but too low to find an optimal solution
try {
// we need to use a DeterministicLinearConstraintSet to always get the same behavior
solver.optimize(new MaxIter(180), f, new DeterministicLinearConstraintSet(constraints),
GoalType.MINIMIZE, new NonNegativeConstraint(true), callback);
Assert.fail("expected TooManyIterationsException");
solver.optimize(new MaxIter(111), f, new DeterministicLinearConstraintSet(constraints),
GoalType.MINIMIZE, new NonNegativeConstraint(true), callback,
PivotSelectionRule.Bland);
//Assert.fail("expected TooManyIterationsException");
} catch (TooManyIterationsException ex) {
// expected
}