import org.apache.commons.math3.exception.TooManyIterationsException; //导入依赖的package包/类
/**
 * Computes \( 1 + 2 \sum_{i=1}^\infty (-1)^i e^{-2 i^2 t^2} \) stopping when successive partial
 * sums are within {@code tolerance} of one another, or when {@code maxIterations} partial sums
 * have been computed. If the sum does not converge before {@code maxIterations} iterations a
 * {@link TooManyIterationsException} is thrown.
 *
 * @param t argument
 * @param tolerance Cauchy criterion for partial sums
 * @param maxIterations maximum number of partial sums to compute
 * @return Kolmogorov sum evaluated at t
 * @throws TooManyIterationsException if the series does not converge
 */
public double ksSum(double t, double tolerance, int maxIterations) {
    if (t == 0.0) {
        return 0.0;
    }

    // TODO: for small t (say less than 1), the alternative expansion in part 3 of [1]
    // from class javadoc should be used.

    final double x = -2 * t * t;
    int sign = -1;
    long i = 1;
    double partialSum = 0.5d;
    double delta = 1;
    while (delta > tolerance && i < maxIterations) {
        delta = FastMath.exp(x * i * i);
        partialSum += sign * delta;
        sign *= -1;
        i++;
    }
    if (i == maxIterations) {
        throw new TooManyIterationsException(maxIterations);
    }
    return partialSum * 2;
}
 

import org.apache.commons.math3.exception.TooManyIterationsException; //导入依赖的package包/类
/**
 * Solves Phase 1 of the Simplex method.
 *
 * @param tableau Simple tableau for the problem.
 * @throws TooManyIterationsException if the allowed number of iterations has been exhausted.
 * @throws UnboundedSolutionException if the model is found not to have a bounded solution.
 * @throws NoFeasibleSolutionException if there is no feasible solution?
 */
protected void solvePhase1(final SimplexTableau tableau)
    throws TooManyIterationsException,
           UnboundedSolutionException,
           NoFeasibleSolutionException {

    // make sure we're in Phase 1
    if (tableau.getNumArtificialVariables() == 0) {
        return;
    }

    while (!tableau.isOptimal()) {
        doIteration(tableau);
    }

    // if W is not zero then we have no feasible solution
    if (!Precision.equals(tableau.getEntry(0, tableau.getRhsOffset()), 0d, epsilon)) {
        throw new NoFeasibleSolutionException();
    }
}
 

import org.apache.commons.math3.exception.TooManyIterationsException; //导入依赖的package包/类
/**
 * Computes \( 1 + 2 \sum_{i=1}^\infty (-1)^i e^{-2 i^2 t^2} \) stopping when successive partial
 * sums are within {@code tolerance} of one another, or when {@code maxIterations} partial sums
 * have been computed. If the sum does not converge before {@code maxIterations} iterations a
 * {@link TooManyIterationsException} is thrown.
 *
 * @param t argument
 * @param tolerance Cauchy criterion for partial sums
 * @param maxIterations maximum number of partial sums to compute
 * @return Kolmogorov sum evaluated at t
 * @throws TooManyIterationsException if the series does not converge
 */
public double ksSum(double t, double tolerance, int maxIterations) {
    // TODO: for small t (say less than 1), the alternative expansion in part 3 of [1]
    // from class javadoc should be used.
    final double x = -2 * t * t;
    int sign = -1;
    long i = 1;
    double partialSum = 0.5d;
    double delta = 1;
    while (delta > tolerance && i < maxIterations) {
        delta = FastMath.exp(x * i * i);
        partialSum += sign * delta;
        sign *= -1;
        i++;
    }
    if (i == maxIterations) {
        throw new TooManyIterationsException(maxIterations);
    }
    return partialSum * 2;
}
 

import org.apache.commons.math3.exception.TooManyIterationsException; //导入依赖的package包/类
/**
 * Runs one iteration of the Simplex method on the given model.
 *
 * @param tableau Simple tableau for the problem.
 * @throws TooManyIterationsException if the allowed number of iterations has been exhausted.
 * @throws UnboundedSolutionException if the model is found not to have a bounded solution.
 */
protected void doIteration(final SimplexTableau tableau)
    throws TooManyIterationsException,
           UnboundedSolutionException {

    incrementIterationCount();

    Integer pivotCol = getPivotColumn(tableau);
    Integer pivotRow = getPivotRow(tableau, pivotCol);
    if (pivotRow == null) {
        throw new UnboundedSolutionException();
    }

    // set the pivot element to 1
    double pivotVal = tableau.getEntry(pivotRow, pivotCol);
    tableau.divideRow(pivotRow, pivotVal);

    // set the rest of the pivot column to 0
    for (int i = 0; i < tableau.getHeight(); i++) {
        if (i != pivotRow) {
            final double multiplier = tableau.getEntry(i, pivotCol);
            tableau.subtractRow(i, pivotRow, multiplier);
        }
    }
}
 

import org.apache.commons.math3.exception.TooManyIterationsException; //导入依赖的package包/类
/** {@inheritDoc} */
@Override
public PointValuePair doOptimize()
    throws TooManyIterationsException,
           UnboundedSolutionException,
           NoFeasibleSolutionException {
    final SimplexTableau tableau =
        new SimplexTableau(getFunction(),
                           getConstraints(),
                           getGoalType(),
                           isRestrictedToNonNegative(),
                           epsilon,
                           maxUlps,
                           cutOff);

    solvePhase1(tableau);
    tableau.dropPhase1Objective();

    while (!tableau.isOptimal()) {
        doIteration(tableau);
    }
    return tableau.getSolution();
}
 

import org.apache.commons.math3.exception.TooManyIterationsException; //导入依赖的package包/类
/** {@inheritDoc} */
@Override
public PointValuePair doOptimize()
    throws TooManyIterationsException,
           UnboundedSolutionException,
           NoFeasibleSolutionException {
    final SimplexTableau tableau =
        new SimplexTableau(getFunction(),
                           getConstraints(),
                           getGoalType(),
                           isRestrictedToNonNegative(),
                           epsilon,
                           maxUlps);

    solvePhase1(tableau);
    tableau.dropPhase1Objective();

    while (!tableau.isOptimal()) {
        doIteration(tableau);
    }
    return tableau.getSolution();
}
 

import org.apache.commons.math3.exception.TooManyIterationsException; //导入依赖的package包/类
/**
 * Performs the optimization.
 *
 * @return a point/value pair that satisfies the convergence criteria.
 * @throws TooManyEvaluationsException if the maximal number of
 * evaluations is exceeded.
 * @throws TooManyIterationsException if the maximal number of
 * iterations is exceeded.
 */
public PAIR optimize()
    throws TooManyEvaluationsException,
           TooManyIterationsException {
    // Reset counters.
    evaluations.resetCount();
    iterations.resetCount();
    // Perform optimization.
    return doOptimize();
}
 

import org.apache.commons.math3.exception.TooManyIterationsException; //导入依赖的package包/类
/**
 * Runs one iteration of the Simplex method on the given model.
 *
 * @param tableau Simple tableau for the problem.
 * @throws TooManyIterationsException if the allowed number of iterations has been exhausted.
 * @throws UnboundedSolutionException if the model is found not to have a bounded solution.
 */
protected void doIteration(final SimplexTableau tableau)
    throws TooManyIterationsException,
           UnboundedSolutionException {

    incrementIterationCount();

    Integer pivotCol = getPivotColumn(tableau);
    Integer pivotRow = getPivotRow(tableau, pivotCol);
    if (pivotRow == null) {
        throw new UnboundedSolutionException();
    }

    tableau.performRowOperations(pivotCol, pivotRow);
}
 

import org.apache.commons.math3.exception.TooManyIterationsException; //导入依赖的package包/类
@Test(expected=TooManyIterationsException.class)
public void testWithMaxIterations2() {
    final int maxIter = 1; // Too few iterations.
    final double[] init = { 3.5e6, 4.2, 0.1 };

    GaussianCurveFitter fitter = GaussianCurveFitter.create();
    fitter.withMaxIterations(maxIter)
          .withStartPoint(init)
          .fit(createDataset(DATASET1).toList());
}
 

import org.apache.commons.math3.exception.TooManyIterationsException; //导入依赖的package包/类
@Test
public void testSolutionCallback() {
    // re-use the problem from testcase for MATH-288
    // it normally requires 5 iterations
    
    LinearObjectiveFunction f = new LinearObjectiveFunction(new double[] { 7, 3, 0, 0 }, 0 );

    List<LinearConstraint> constraints = new ArrayList<LinearConstraint>();
    constraints.add(new LinearConstraint(new double[] { 3, 0, -5, 0 }, Relationship.LEQ, 0.0));
    constraints.add(new LinearConstraint(new double[] { 2, 0, 0, -5 }, Relationship.LEQ, 0.0));
    constraints.add(new LinearConstraint(new double[] { 0, 3, 0, -5 }, Relationship.LEQ, 0.0));
    constraints.add(new LinearConstraint(new double[] { 1, 0, 0, 0 }, Relationship.LEQ, 1.0));
    constraints.add(new LinearConstraint(new double[] { 0, 1, 0, 0 }, Relationship.LEQ, 1.0));

    final SimplexSolver solver = new SimplexSolver();
    final SolutionCallback callback = new SolutionCallback();
    
    Assert.assertNull(callback.getSolution());
    Assert.assertFalse(callback.isSolutionOptimal());

    try {
        solver.optimize(new MaxIter(3), f, new LinearConstraintSet(constraints),
                        GoalType.MAXIMIZE, new NonNegativeConstraint(true), callback);
        Assert.fail("expected TooManyIterationsException");
    } catch (TooManyIterationsException ex) {
        // expected
    }
    
    final PointValuePair solution = callback.getSolution();
    Assert.assertNotNull(solution);
    Assert.assertTrue(validSolution(solution, constraints, 1e-4));
    Assert.assertFalse(callback.isSolutionOptimal());
    // the solution is clearly not optimal: optimal = 10.0
    Assert.assertEquals(7.0, solution.getValue(), 1e-4);
}
 

import org.apache.commons.math3.exception.TooManyIterationsException; //导入依赖的package包/类
/**
 * Performs the optimization.
 *
 * @return a point/value pair that satifies the convergence criteria.
 * @throws TooManyEvaluationsException if the maximal number of
 * evaluations is exceeded.
 * @throws TooManyIterationsException if the maximal number of
 * iterations is exceeded.
 */
public PAIR optimize()
    throws TooManyEvaluationsException,
           TooManyIterationsException {
    // Reset counters.
    evaluations.resetCount();
    iterations.resetCount();
    // Perform optimization.
    return doOptimize();
}
 

import org.apache.commons.math3.exception.TooManyIterationsException; //导入依赖的package包/类
@Test(expected=TooManyIterationsException.class)
public void testWithMaxIterations2() {
    final int maxIter = 1; // Too few iterations.
    final double[] init = { 3.5e6, 4.2, 0.1 };

    GaussianCurveFitter fitter = GaussianCurveFitter.create();
    double[] parameters = fitter
        .withMaxIterations(maxIter)
        .withStartPoint(init)
        .fit(createDataset(DATASET1).toList());
}