http://git-wip-us.apache.org/repos/asf/commons-math/blob/b4669aad/src/main/java/org/apache/commons/math4/optimization/general/LevenbergMarquardtOptimizer.java ---------------------------------------------------------------------- diff --git a/src/main/java/org/apache/commons/math4/optimization/general/LevenbergMarquardtOptimizer.java b/src/main/java/org/apache/commons/math4/optimization/general/LevenbergMarquardtOptimizer.java deleted file mode 100644 index 407f721..0000000 --- a/src/main/java/org/apache/commons/math4/optimization/general/LevenbergMarquardtOptimizer.java +++ /dev/null @@ -1,943 +0,0 @@ -/* - * 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.math4.optimization.general; - -import java.util.Arrays; - -import org.apache.commons.math4.exception.ConvergenceException; -import org.apache.commons.math4.exception.util.LocalizedFormats; -import org.apache.commons.math4.linear.RealMatrix; -import org.apache.commons.math4.optimization.ConvergenceChecker; -import org.apache.commons.math4.optimization.PointVectorValuePair; -import org.apache.commons.math4.util.FastMath; -import org.apache.commons.math4.util.Precision; - - -/** - * This class solves a least squares problem using the Levenberg-Marquardt algorithm. - * - * <p>This implementation <em>should</em> work even for over-determined systems - * (i.e. systems having more point than equations). Over-determined systems - * are solved by ignoring the point which have the smallest impact according - * to their jacobian column norm. Only the rank of the matrix and some loop bounds - * are changed to implement this.</p> - * - * <p>The resolution engine is a simple translation of the MINPACK <a - * href="http://www.netlib.org/minpack/lmder.f";>lmder</a> routine with minor - * changes. The changes include the over-determined resolution, the use of - * inherited convergence checker and the Q.R. decomposition which has been - * rewritten following the algorithm described in the - * P. Lascaux and R. Theodor book <i>Analyse numérique matricielle - * appliquée à l'art de l'ingénieur</i>, Masson 1986.</p> - * <p>The authors of the original fortran version are: - * <ul> - * <li>Argonne National Laboratory. MINPACK project. March 1980</li> - * <li>Burton S. Garbow</li> - * <li>Kenneth E. Hillstrom</li> - * <li>Jorge J. More</li> - * </ul> - * The redistribution policy for MINPACK is available <a - * href="http://www.netlib.org/minpack/disclaimer";>here</a>, for convenience, it - * is reproduced below.</p> - * - * <table border="0" width="80%" cellpadding="10" align="center" bgcolor="#E0E0E0"> - * <tr><td> - * Minpack Copyright Notice (1999) University of Chicago. - * All rights reserved - * </td></tr> - * <tr><td> - * Redistribution and use in source and binary forms, with or without - * modification, are permitted provided that the following conditions - * are met: - * <ol> - * <li>Redistributions of source code must retain the above copyright - * notice, this list of conditions and the following disclaimer.</li> - * <li>Redistributions in binary form must reproduce the above - * copyright notice, this list of conditions and the following - * disclaimer in the documentation and/or other materials provided - * with the distribution.</li> - * <li>The end-user documentation included with the redistribution, if any, - * must include the following acknowledgment: - * <code>This product includes software developed by the University of - * Chicago, as Operator of Argonne National Laboratory.</code> - * Alternately, this acknowledgment may appear in the software itself, - * if and wherever such third-party acknowledgments normally appear.</li> - * <li><strong>WARRANTY DISCLAIMER. THE SOFTWARE IS SUPPLIED "AS IS" - * WITHOUT WARRANTY OF ANY KIND. THE COPYRIGHT HOLDER, THE - * UNITED STATES, THE UNITED STATES DEPARTMENT OF ENERGY, AND - * THEIR EMPLOYEES: (1) DISCLAIM ANY WARRANTIES, EXPRESS OR - * IMPLIED, INCLUDING BUT NOT LIMITED TO ANY IMPLIED WARRANTIES - * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE, TITLE - * OR NON-INFRINGEMENT, (2) DO NOT ASSUME ANY LEGAL LIABILITY - * OR RESPONSIBILITY FOR THE ACCURACY, COMPLETENESS, OR - * USEFULNESS OF THE SOFTWARE, (3) DO NOT REPRESENT THAT USE OF - * THE SOFTWARE WOULD NOT INFRINGE PRIVATELY OWNED RIGHTS, (4) - * DO NOT WARRANT THAT THE SOFTWARE WILL FUNCTION - * UNINTERRUPTED, THAT IT IS ERROR-FREE OR THAT ANY ERRORS WILL - * BE CORRECTED.</strong></li> - * <li><strong>LIMITATION OF LIABILITY. IN NO EVENT WILL THE COPYRIGHT - * HOLDER, THE UNITED STATES, THE UNITED STATES DEPARTMENT OF - * ENERGY, OR THEIR EMPLOYEES: BE LIABLE FOR ANY INDIRECT, - * INCIDENTAL, CONSEQUENTIAL, SPECIAL OR PUNITIVE DAMAGES OF - * ANY KIND OR NATURE, INCLUDING BUT NOT LIMITED TO LOSS OF - * PROFITS OR LOSS OF DATA, FOR ANY REASON WHATSOEVER, WHETHER - * SUCH LIABILITY IS ASSERTED ON THE BASIS OF CONTRACT, TORT - * (INCLUDING NEGLIGENCE OR STRICT LIABILITY), OR OTHERWISE, - * EVEN IF ANY OF SAID PARTIES HAS BEEN WARNED OF THE - * POSSIBILITY OF SUCH LOSS OR DAMAGES.</strong></li> - * <ol></td></tr> - * </table> - * @deprecated As of 3.1 (to be removed in 4.0). - * @since 2.0 - * - */ -@Deprecated -public class LevenbergMarquardtOptimizer extends AbstractLeastSquaresOptimizer { - /** Number of solved point. */ - private int solvedCols; - /** Diagonal elements of the R matrix in the Q.R. decomposition. */ - private double[] diagR; - /** Norms of the columns of the jacobian matrix. */ - private double[] jacNorm; - /** Coefficients of the Householder transforms vectors. */ - private double[] beta; - /** Columns permutation array. */ - private int[] permutation; - /** Rank of the jacobian matrix. */ - private int rank; - /** Levenberg-Marquardt parameter. */ - private double lmPar; - /** Parameters evolution direction associated with lmPar. */ - private double[] lmDir; - /** Positive input variable used in determining the initial step bound. */ - private final double initialStepBoundFactor; - /** Desired relative error in the sum of squares. */ - private final double costRelativeTolerance; - /** Desired relative error in the approximate solution parameters. */ - private final double parRelativeTolerance; - /** Desired max cosine on the orthogonality between the function vector - * and the columns of the jacobian. */ - private final double orthoTolerance; - /** Threshold for QR ranking. */ - private final double qrRankingThreshold; - /** Weighted residuals. */ - private double[] weightedResidual; - /** Weighted Jacobian. */ - private double[][] weightedJacobian; - - /** - * Build an optimizer for least squares problems with default values - * for all the tuning parameters (see the {@link - * #LevenbergMarquardtOptimizer(double,double,double,double,double) - * other contructor}. - * The default values for the algorithm settings are: - * <ul> - * <li>Initial step bound factor: 100</li> - * <li>Cost relative tolerance: 1e-10</li> - * <li>Parameters relative tolerance: 1e-10</li> - * <li>Orthogonality tolerance: 1e-10</li> - * <li>QR ranking threshold: {@link Precision#SAFE_MIN}</li> - * </ul> - */ - public LevenbergMarquardtOptimizer() { - this(100, 1e-10, 1e-10, 1e-10, Precision.SAFE_MIN); - } - - /** - * Constructor that allows the specification of a custom convergence - * checker. - * Note that all the usual convergence checks will be <em>disabled</em>. - * The default values for the algorithm settings are: - * <ul> - * <li>Initial step bound factor: 100</li> - * <li>Cost relative tolerance: 1e-10</li> - * <li>Parameters relative tolerance: 1e-10</li> - * <li>Orthogonality tolerance: 1e-10</li> - * <li>QR ranking threshold: {@link Precision#SAFE_MIN}</li> - * </ul> - * - * @param checker Convergence checker. - */ - public LevenbergMarquardtOptimizer(ConvergenceChecker<PointVectorValuePair> checker) { - this(100, checker, 1e-10, 1e-10, 1e-10, Precision.SAFE_MIN); - } - - /** - * Constructor that allows the specification of a custom convergence - * checker, in addition to the standard ones. - * - * @param initialStepBoundFactor Positive input variable used in - * determining the initial step bound. This bound is set to the - * product of initialStepBoundFactor and the euclidean norm of - * {@code diag * x} if non-zero, or else to {@code initialStepBoundFactor} - * itself. In most cases factor should lie in the interval - * {@code (0.1, 100.0)}. {@code 100} is a generally recommended value. - * @param checker Convergence checker. - * @param costRelativeTolerance Desired relative error in the sum of - * squares. - * @param parRelativeTolerance Desired relative error in the approximate - * solution parameters. - * @param orthoTolerance Desired max cosine on the orthogonality between - * the function vector and the columns of the Jacobian. - * @param threshold Desired threshold for QR ranking. If the squared norm - * of a column vector is smaller or equal to this threshold during QR - * decomposition, it is considered to be a zero vector and hence the rank - * of the matrix is reduced. - */ - public LevenbergMarquardtOptimizer(double initialStepBoundFactor, - ConvergenceChecker<PointVectorValuePair> checker, - double costRelativeTolerance, - double parRelativeTolerance, - double orthoTolerance, - double threshold) { - super(checker); - this.initialStepBoundFactor = initialStepBoundFactor; - this.costRelativeTolerance = costRelativeTolerance; - this.parRelativeTolerance = parRelativeTolerance; - this.orthoTolerance = orthoTolerance; - this.qrRankingThreshold = threshold; - } - - /** - * Build an optimizer for least squares problems with default values - * for some of the tuning parameters (see the {@link - * #LevenbergMarquardtOptimizer(double,double,double,double,double) - * other contructor}. - * The default values for the algorithm settings are: - * <ul> - * <li>Initial step bound factor}: 100</li> - * <li>QR ranking threshold}: {@link Precision#SAFE_MIN}</li> - * </ul> - * - * @param costRelativeTolerance Desired relative error in the sum of - * squares. - * @param parRelativeTolerance Desired relative error in the approximate - * solution parameters. - * @param orthoTolerance Desired max cosine on the orthogonality between - * the function vector and the columns of the Jacobian. - */ - public LevenbergMarquardtOptimizer(double costRelativeTolerance, - double parRelativeTolerance, - double orthoTolerance) { - this(100, - costRelativeTolerance, parRelativeTolerance, orthoTolerance, - Precision.SAFE_MIN); - } - - /** - * The arguments control the behaviour of the default convergence checking - * procedure. - * Additional criteria can defined through the setting of a {@link - * ConvergenceChecker}. - * - * @param initialStepBoundFactor Positive input variable used in - * determining the initial step bound. This bound is set to the - * product of initialStepBoundFactor and the euclidean norm of - * {@code diag * x} if non-zero, or else to {@code initialStepBoundFactor} - * itself. In most cases factor should lie in the interval - * {@code (0.1, 100.0)}. {@code 100} is a generally recommended value. - * @param costRelativeTolerance Desired relative error in the sum of - * squares. - * @param parRelativeTolerance Desired relative error in the approximate - * solution parameters. - * @param orthoTolerance Desired max cosine on the orthogonality between - * the function vector and the columns of the Jacobian. - * @param threshold Desired threshold for QR ranking. If the squared norm - * of a column vector is smaller or equal to this threshold during QR - * decomposition, it is considered to be a zero vector and hence the rank - * of the matrix is reduced. - */ - public LevenbergMarquardtOptimizer(double initialStepBoundFactor, - double costRelativeTolerance, - double parRelativeTolerance, - double orthoTolerance, - double threshold) { - super(null); // No custom convergence criterion. - this.initialStepBoundFactor = initialStepBoundFactor; - this.costRelativeTolerance = costRelativeTolerance; - this.parRelativeTolerance = parRelativeTolerance; - this.orthoTolerance = orthoTolerance; - this.qrRankingThreshold = threshold; - } - - /** {@inheritDoc} */ - @Override - protected PointVectorValuePair doOptimize() { - final int nR = getTarget().length; // Number of observed data. - final double[] currentPoint = getStartPoint(); - final int nC = currentPoint.length; // Number of parameters. - - // arrays shared with the other private methods - solvedCols = FastMath.min(nR, nC); - diagR = new double[nC]; - jacNorm = new double[nC]; - beta = new double[nC]; - permutation = new int[nC]; - lmDir = new double[nC]; - - // local point - double delta = 0; - double xNorm = 0; - double[] diag = new double[nC]; - double[] oldX = new double[nC]; - double[] oldRes = new double[nR]; - double[] oldObj = new double[nR]; - double[] qtf = new double[nR]; - double[] work1 = new double[nC]; - double[] work2 = new double[nC]; - double[] work3 = new double[nC]; - - final RealMatrix weightMatrixSqrt = getWeightSquareRoot(); - - // Evaluate the function at the starting point and calculate its norm. - double[] currentObjective = computeObjectiveValue(currentPoint); - double[] currentResiduals = computeResiduals(currentObjective); - PointVectorValuePair current = new PointVectorValuePair(currentPoint, currentObjective); - double currentCost = computeCost(currentResiduals); - - // Outer loop. - lmPar = 0; - boolean firstIteration = true; - int iter = 0; - final ConvergenceChecker<PointVectorValuePair> checker = getConvergenceChecker(); - while (true) { - ++iter; - final PointVectorValuePair previous = current; - - // QR decomposition of the jacobian matrix - qrDecomposition(computeWeightedJacobian(currentPoint)); - - weightedResidual = weightMatrixSqrt.operate(currentResiduals); - for (int i = 0; i < nR; i++) { - qtf[i] = weightedResidual[i]; - } - - // compute Qt.res - qTy(qtf); - - // now we don't need Q anymore, - // so let jacobian contain the R matrix with its diagonal elements - for (int k = 0; k < solvedCols; ++k) { - int pk = permutation[k]; - weightedJacobian[k][pk] = diagR[pk]; - } - - if (firstIteration) { - // scale the point according to the norms of the columns - // of the initial jacobian - xNorm = 0; - for (int k = 0; k < nC; ++k) { - double dk = jacNorm[k]; - if (dk == 0) { - dk = 1.0; - } - double xk = dk * currentPoint[k]; - xNorm += xk * xk; - diag[k] = dk; - } - xNorm = FastMath.sqrt(xNorm); - - // initialize the step bound delta - delta = (xNorm == 0) ? initialStepBoundFactor : (initialStepBoundFactor * xNorm); - } - - // check orthogonality between function vector and jacobian columns - double maxCosine = 0; - if (currentCost != 0) { - for (int j = 0; j < solvedCols; ++j) { - int pj = permutation[j]; - double s = jacNorm[pj]; - if (s != 0) { - double sum = 0; - for (int i = 0; i <= j; ++i) { - sum += weightedJacobian[i][pj] * qtf[i]; - } - maxCosine = FastMath.max(maxCosine, FastMath.abs(sum) / (s * currentCost)); - } - } - } - if (maxCosine <= orthoTolerance) { - // Convergence has been reached. - setCost(currentCost); - // Update (deprecated) "point" field. - point = current.getPoint(); - return current; - } - - // rescale if necessary - for (int j = 0; j < nC; ++j) { - diag[j] = FastMath.max(diag[j], jacNorm[j]); - } - - // Inner loop. - for (double ratio = 0; ratio < 1.0e-4;) { - - // save the state - for (int j = 0; j < solvedCols; ++j) { - int pj = permutation[j]; - oldX[pj] = currentPoint[pj]; - } - final double previousCost = currentCost; - double[] tmpVec = weightedResidual; - weightedResidual = oldRes; - oldRes = tmpVec; - tmpVec = currentObjective; - currentObjective = oldObj; - oldObj = tmpVec; - - // determine the Levenberg-Marquardt parameter - determineLMParameter(qtf, delta, diag, work1, work2, work3); - - // compute the new point and the norm of the evolution direction - double lmNorm = 0; - for (int j = 0; j < solvedCols; ++j) { - int pj = permutation[j]; - lmDir[pj] = -lmDir[pj]; - currentPoint[pj] = oldX[pj] + lmDir[pj]; - double s = diag[pj] * lmDir[pj]; - lmNorm += s * s; - } - lmNorm = FastMath.sqrt(lmNorm); - // on the first iteration, adjust the initial step bound. - if (firstIteration) { - delta = FastMath.min(delta, lmNorm); - } - - // Evaluate the function at x + p and calculate its norm. - currentObjective = computeObjectiveValue(currentPoint); - currentResiduals = computeResiduals(currentObjective); - current = new PointVectorValuePair(currentPoint, currentObjective); - currentCost = computeCost(currentResiduals); - - // compute the scaled actual reduction - double actRed = -1.0; - if (0.1 * currentCost < previousCost) { - double r = currentCost / previousCost; - actRed = 1.0 - r * r; - } - - // compute the scaled predicted reduction - // and the scaled directional derivative - for (int j = 0; j < solvedCols; ++j) { - int pj = permutation[j]; - double dirJ = lmDir[pj]; - work1[j] = 0; - for (int i = 0; i <= j; ++i) { - work1[i] += weightedJacobian[i][pj] * dirJ; - } - } - double coeff1 = 0; - for (int j = 0; j < solvedCols; ++j) { - coeff1 += work1[j] * work1[j]; - } - double pc2 = previousCost * previousCost; - coeff1 /= pc2; - double coeff2 = lmPar * lmNorm * lmNorm / pc2; - double preRed = coeff1 + 2 * coeff2; - double dirDer = -(coeff1 + coeff2); - - // ratio of the actual to the predicted reduction - ratio = (preRed == 0) ? 0 : (actRed / preRed); - - // update the step bound - if (ratio <= 0.25) { - double tmp = - (actRed < 0) ? (0.5 * dirDer / (dirDer + 0.5 * actRed)) : 0.5; - if ((0.1 * currentCost >= previousCost) || (tmp < 0.1)) { - tmp = 0.1; - } - delta = tmp * FastMath.min(delta, 10.0 * lmNorm); - lmPar /= tmp; - } else if ((lmPar == 0) || (ratio >= 0.75)) { - delta = 2 * lmNorm; - lmPar *= 0.5; - } - - // test for successful iteration. - if (ratio >= 1.0e-4) { - // successful iteration, update the norm - firstIteration = false; - xNorm = 0; - for (int k = 0; k < nC; ++k) { - double xK = diag[k] * currentPoint[k]; - xNorm += xK * xK; - } - xNorm = FastMath.sqrt(xNorm); - - // tests for convergence. - if (checker != null && checker.converged(iter, previous, current)) { - setCost(currentCost); - // Update (deprecated) "point" field. - point = current.getPoint(); - return current; - } - } else { - // failed iteration, reset the previous values - currentCost = previousCost; - for (int j = 0; j < solvedCols; ++j) { - int pj = permutation[j]; - currentPoint[pj] = oldX[pj]; - } - tmpVec = weightedResidual; - weightedResidual = oldRes; - oldRes = tmpVec; - tmpVec = currentObjective; - currentObjective = oldObj; - oldObj = tmpVec; - // Reset "current" to previous values. - current = new PointVectorValuePair(currentPoint, currentObjective); - } - - // Default convergence criteria. - if ((FastMath.abs(actRed) <= costRelativeTolerance && - preRed <= costRelativeTolerance && - ratio <= 2.0) || - delta <= parRelativeTolerance * xNorm) { - setCost(currentCost); - // Update (deprecated) "point" field. - point = current.getPoint(); - return current; - } - - // tests for termination and stringent tolerances - // (2.2204e-16 is the machine epsilon for IEEE754) - if ((FastMath.abs(actRed) <= 2.2204e-16) && (preRed <= 2.2204e-16) && (ratio <= 2.0)) { - throw new ConvergenceException(LocalizedFormats.TOO_SMALL_COST_RELATIVE_TOLERANCE, - costRelativeTolerance); - } else if (delta <= 2.2204e-16 * xNorm) { - throw new ConvergenceException(LocalizedFormats.TOO_SMALL_PARAMETERS_RELATIVE_TOLERANCE, - parRelativeTolerance); - } else if (maxCosine <= 2.2204e-16) { - throw new ConvergenceException(LocalizedFormats.TOO_SMALL_ORTHOGONALITY_TOLERANCE, - orthoTolerance); - } - } - } - } - - /** - * Determine the Levenberg-Marquardt parameter. - * <p>This implementation is a translation in Java of the MINPACK - * <a href="http://www.netlib.org/minpack/lmpar.f";>lmpar</a> - * routine.</p> - * <p>This method sets the lmPar and lmDir attributes.</p> - * <p>The authors of the original fortran function are:</p> - * <ul> - * <li>Argonne National Laboratory. MINPACK project. March 1980</li> - * <li>Burton S. Garbow</li> - * <li>Kenneth E. Hillstrom</li> - * <li>Jorge J. More</li> - * </ul> - * <p>Luc Maisonobe did the Java translation.</p> - * - * @param qy array containing qTy - * @param delta upper bound on the euclidean norm of diagR * lmDir - * @param diag diagonal matrix - * @param work1 work array - * @param work2 work array - * @param work3 work array - */ - private void determineLMParameter(double[] qy, double delta, double[] diag, - double[] work1, double[] work2, double[] work3) { - final int nC = weightedJacobian[0].length; - - // compute and store in x the gauss-newton direction, if the - // jacobian is rank-deficient, obtain a least squares solution - for (int j = 0; j < rank; ++j) { - lmDir[permutation[j]] = qy[j]; - } - for (int j = rank; j < nC; ++j) { - lmDir[permutation[j]] = 0; - } - for (int k = rank - 1; k >= 0; --k) { - int pk = permutation[k]; - double ypk = lmDir[pk] / diagR[pk]; - for (int i = 0; i < k; ++i) { - lmDir[permutation[i]] -= ypk * weightedJacobian[i][pk]; - } - lmDir[pk] = ypk; - } - - // evaluate the function at the origin, and test - // for acceptance of the Gauss-Newton direction - double dxNorm = 0; - for (int j = 0; j < solvedCols; ++j) { - int pj = permutation[j]; - double s = diag[pj] * lmDir[pj]; - work1[pj] = s; - dxNorm += s * s; - } - dxNorm = FastMath.sqrt(dxNorm); - double fp = dxNorm - delta; - if (fp <= 0.1 * delta) { - lmPar = 0; - return; - } - - // if the jacobian is not rank deficient, the Newton step provides - // a lower bound, parl, for the zero of the function, - // otherwise set this bound to zero - double sum2; - double parl = 0; - if (rank == solvedCols) { - for (int j = 0; j < solvedCols; ++j) { - int pj = permutation[j]; - work1[pj] *= diag[pj] / dxNorm; - } - sum2 = 0; - for (int j = 0; j < solvedCols; ++j) { - int pj = permutation[j]; - double sum = 0; - for (int i = 0; i < j; ++i) { - sum += weightedJacobian[i][pj] * work1[permutation[i]]; - } - double s = (work1[pj] - sum) / diagR[pj]; - work1[pj] = s; - sum2 += s * s; - } - parl = fp / (delta * sum2); - } - - // calculate an upper bound, paru, for the zero of the function - sum2 = 0; - for (int j = 0; j < solvedCols; ++j) { - int pj = permutation[j]; - double sum = 0; - for (int i = 0; i <= j; ++i) { - sum += weightedJacobian[i][pj] * qy[i]; - } - sum /= diag[pj]; - sum2 += sum * sum; - } - double gNorm = FastMath.sqrt(sum2); - double paru = gNorm / delta; - if (paru == 0) { - // 2.2251e-308 is the smallest positive real for IEE754 - paru = 2.2251e-308 / FastMath.min(delta, 0.1); - } - - // if the input par lies outside of the interval (parl,paru), - // set par to the closer endpoint - lmPar = FastMath.min(paru, FastMath.max(lmPar, parl)); - if (lmPar == 0) { - lmPar = gNorm / dxNorm; - } - - for (int countdown = 10; countdown >= 0; --countdown) { - - // evaluate the function at the current value of lmPar - if (lmPar == 0) { - lmPar = FastMath.max(2.2251e-308, 0.001 * paru); - } - double sPar = FastMath.sqrt(lmPar); - for (int j = 0; j < solvedCols; ++j) { - int pj = permutation[j]; - work1[pj] = sPar * diag[pj]; - } - determineLMDirection(qy, work1, work2, work3); - - dxNorm = 0; - for (int j = 0; j < solvedCols; ++j) { - int pj = permutation[j]; - double s = diag[pj] * lmDir[pj]; - work3[pj] = s; - dxNorm += s * s; - } - dxNorm = FastMath.sqrt(dxNorm); - double previousFP = fp; - fp = dxNorm - delta; - - // if the function is small enough, accept the current value - // of lmPar, also test for the exceptional cases where parl is zero - if ((FastMath.abs(fp) <= 0.1 * delta) || - ((parl == 0) && (fp <= previousFP) && (previousFP < 0))) { - return; - } - - // compute the Newton correction - for (int j = 0; j < solvedCols; ++j) { - int pj = permutation[j]; - work1[pj] = work3[pj] * diag[pj] / dxNorm; - } - for (int j = 0; j < solvedCols; ++j) { - int pj = permutation[j]; - work1[pj] /= work2[j]; - double tmp = work1[pj]; - for (int i = j + 1; i < solvedCols; ++i) { - work1[permutation[i]] -= weightedJacobian[i][pj] * tmp; - } - } - sum2 = 0; - for (int j = 0; j < solvedCols; ++j) { - double s = work1[permutation[j]]; - sum2 += s * s; - } - double correction = fp / (delta * sum2); - - // depending on the sign of the function, update parl or paru. - if (fp > 0) { - parl = FastMath.max(parl, lmPar); - } else if (fp < 0) { - paru = FastMath.min(paru, lmPar); - } - - // compute an improved estimate for lmPar - lmPar = FastMath.max(parl, lmPar + correction); - - } - } - - /** - * Solve a*x = b and d*x = 0 in the least squares sense. - * <p>This implementation is a translation in Java of the MINPACK - * <a href="http://www.netlib.org/minpack/qrsolv.f";>qrsolv</a> - * routine.</p> - * <p>This method sets the lmDir and lmDiag attributes.</p> - * <p>The authors of the original fortran function are:</p> - * <ul> - * <li>Argonne National Laboratory. MINPACK project. March 1980</li> - * <li>Burton S. Garbow</li> - * <li>Kenneth E. Hillstrom</li> - * <li>Jorge J. More</li> - * </ul> - * <p>Luc Maisonobe did the Java translation.</p> - * - * @param qy array containing qTy - * @param diag diagonal matrix - * @param lmDiag diagonal elements associated with lmDir - * @param work work array - */ - private void determineLMDirection(double[] qy, double[] diag, - double[] lmDiag, double[] work) { - - // copy R and Qty to preserve input and initialize s - // in particular, save the diagonal elements of R in lmDir - for (int j = 0; j < solvedCols; ++j) { - int pj = permutation[j]; - for (int i = j + 1; i < solvedCols; ++i) { - weightedJacobian[i][pj] = weightedJacobian[j][permutation[i]]; - } - lmDir[j] = diagR[pj]; - work[j] = qy[j]; - } - - // eliminate the diagonal matrix d using a Givens rotation - for (int j = 0; j < solvedCols; ++j) { - - // prepare the row of d to be eliminated, locating the - // diagonal element using p from the Q.R. factorization - int pj = permutation[j]; - double dpj = diag[pj]; - if (dpj != 0) { - Arrays.fill(lmDiag, j + 1, lmDiag.length, 0); - } - lmDiag[j] = dpj; - - // the transformations to eliminate the row of d - // modify only a single element of Qty - // beyond the first n, which is initially zero. - double qtbpj = 0; - for (int k = j; k < solvedCols; ++k) { - int pk = permutation[k]; - - // determine a Givens rotation which eliminates the - // appropriate element in the current row of d - if (lmDiag[k] != 0) { - - final double sin; - final double cos; - double rkk = weightedJacobian[k][pk]; - if (FastMath.abs(rkk) < FastMath.abs(lmDiag[k])) { - final double cotan = rkk / lmDiag[k]; - sin = 1.0 / FastMath.sqrt(1.0 + cotan * cotan); - cos = sin * cotan; - } else { - final double tan = lmDiag[k] / rkk; - cos = 1.0 / FastMath.sqrt(1.0 + tan * tan); - sin = cos * tan; - } - - // compute the modified diagonal element of R and - // the modified element of (Qty,0) - weightedJacobian[k][pk] = cos * rkk + sin * lmDiag[k]; - final double temp = cos * work[k] + sin * qtbpj; - qtbpj = -sin * work[k] + cos * qtbpj; - work[k] = temp; - - // accumulate the tranformation in the row of s - for (int i = k + 1; i < solvedCols; ++i) { - double rik = weightedJacobian[i][pk]; - final double temp2 = cos * rik + sin * lmDiag[i]; - lmDiag[i] = -sin * rik + cos * lmDiag[i]; - weightedJacobian[i][pk] = temp2; - } - } - } - - // store the diagonal element of s and restore - // the corresponding diagonal element of R - lmDiag[j] = weightedJacobian[j][permutation[j]]; - weightedJacobian[j][permutation[j]] = lmDir[j]; - } - - // solve the triangular system for z, if the system is - // singular, then obtain a least squares solution - int nSing = solvedCols; - for (int j = 0; j < solvedCols; ++j) { - if ((lmDiag[j] == 0) && (nSing == solvedCols)) { - nSing = j; - } - if (nSing < solvedCols) { - work[j] = 0; - } - } - if (nSing > 0) { - for (int j = nSing - 1; j >= 0; --j) { - int pj = permutation[j]; - double sum = 0; - for (int i = j + 1; i < nSing; ++i) { - sum += weightedJacobian[i][pj] * work[i]; - } - work[j] = (work[j] - sum) / lmDiag[j]; - } - } - - // permute the components of z back to components of lmDir - for (int j = 0; j < lmDir.length; ++j) { - lmDir[permutation[j]] = work[j]; - } - } - - /** - * Decompose a matrix A as A.P = Q.R using Householder transforms. - * <p>As suggested in the P. Lascaux and R. Theodor book - * <i>Analyse numérique matricielle appliquée à - * l'art de l'ingénieur</i> (Masson, 1986), instead of representing - * the Householder transforms with u<sub>k</sub> unit vectors such that: - * <pre> - * H<sub>k</sub> = I - 2u<sub>k</sub>.u<sub>k</sub><sup>t</sup> - * </pre> - * we use <sub>k</sub> non-unit vectors such that: - * <pre> - * H<sub>k</sub> = I - beta<sub>k</sub>v<sub>k</sub>.v<sub>k</sub><sup>t</sup> - * </pre> - * where v<sub>k</sub> = a<sub>k</sub> - alpha<sub>k</sub> e<sub>k</sub>. - * The beta<sub>k</sub> coefficients are provided upon exit as recomputing - * them from the v<sub>k</sub> vectors would be costly.</p> - * <p>This decomposition handles rank deficient cases since the tranformations - * are performed in non-increasing columns norms order thanks to columns - * pivoting. The diagonal elements of the R matrix are therefore also in - * non-increasing absolute values order.</p> - * - * @param jacobian Weighted Jacobian matrix at the current point. - * @exception ConvergenceException if the decomposition cannot be performed - */ - private void qrDecomposition(RealMatrix jacobian) throws ConvergenceException { - // Code in this class assumes that the weighted Jacobian is -(W^(1/2) J), - // hence the multiplication by -1. - weightedJacobian = jacobian.scalarMultiply(-1).getData(); - - final int nR = weightedJacobian.length; - final int nC = weightedJacobian[0].length; - - // initializations - for (int k = 0; k < nC; ++k) { - permutation[k] = k; - double norm2 = 0; - for (int i = 0; i < nR; ++i) { - double akk = weightedJacobian[i][k]; - norm2 += akk * akk; - } - jacNorm[k] = FastMath.sqrt(norm2); - } - - // transform the matrix column after column - for (int k = 0; k < nC; ++k) { - - // select the column with the greatest norm on active components - int nextColumn = -1; - double ak2 = Double.NEGATIVE_INFINITY; - for (int i = k; i < nC; ++i) { - double norm2 = 0; - for (int j = k; j < nR; ++j) { - double aki = weightedJacobian[j][permutation[i]]; - norm2 += aki * aki; - } - if (Double.isInfinite(norm2) || Double.isNaN(norm2)) { - throw new ConvergenceException(LocalizedFormats.UNABLE_TO_PERFORM_QR_DECOMPOSITION_ON_JACOBIAN, - nR, nC); - } - if (norm2 > ak2) { - nextColumn = i; - ak2 = norm2; - } - } - if (ak2 <= qrRankingThreshold) { - rank = k; - return; - } - int pk = permutation[nextColumn]; - permutation[nextColumn] = permutation[k]; - permutation[k] = pk; - - // choose alpha such that Hk.u = alpha ek - double akk = weightedJacobian[k][pk]; - double alpha = (akk > 0) ? -FastMath.sqrt(ak2) : FastMath.sqrt(ak2); - double betak = 1.0 / (ak2 - akk * alpha); - beta[pk] = betak; - - // transform the current column - diagR[pk] = alpha; - weightedJacobian[k][pk] -= alpha; - - // transform the remaining columns - for (int dk = nC - 1 - k; dk > 0; --dk) { - double gamma = 0; - for (int j = k; j < nR; ++j) { - gamma += weightedJacobian[j][pk] * weightedJacobian[j][permutation[k + dk]]; - } - gamma *= betak; - for (int j = k; j < nR; ++j) { - weightedJacobian[j][permutation[k + dk]] -= gamma * weightedJacobian[j][pk]; - } - } - } - rank = solvedCols; - } - - /** - * Compute the product Qt.y for some Q.R. decomposition. - * - * @param y vector to multiply (will be overwritten with the result) - */ - private void qTy(double[] y) { - final int nR = weightedJacobian.length; - final int nC = weightedJacobian[0].length; - - for (int k = 0; k < nC; ++k) { - int pk = permutation[k]; - double gamma = 0; - for (int i = k; i < nR; ++i) { - gamma += weightedJacobian[i][pk] * y[i]; - } - gamma *= beta[pk]; - for (int i = k; i < nR; ++i) { - y[i] -= gamma * weightedJacobian[i][pk]; - } - } - } -}
http://git-wip-us.apache.org/repos/asf/commons-math/blob/b4669aad/src/main/java/org/apache/commons/math4/optimization/general/NonLinearConjugateGradientOptimizer.java ---------------------------------------------------------------------- diff --git a/src/main/java/org/apache/commons/math4/optimization/general/NonLinearConjugateGradientOptimizer.java b/src/main/java/org/apache/commons/math4/optimization/general/NonLinearConjugateGradientOptimizer.java deleted file mode 100644 index 499fd07..0000000 --- a/src/main/java/org/apache/commons/math4/optimization/general/NonLinearConjugateGradientOptimizer.java +++ /dev/null @@ -1,311 +0,0 @@ -/* - * 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.math4.optimization.general; - -import org.apache.commons.math4.analysis.UnivariateFunction; -import org.apache.commons.math4.analysis.solvers.BrentSolver; -import org.apache.commons.math4.analysis.solvers.UnivariateSolver; -import org.apache.commons.math4.exception.MathIllegalStateException; -import org.apache.commons.math4.exception.util.LocalizedFormats; -import org.apache.commons.math4.optimization.ConvergenceChecker; -import org.apache.commons.math4.optimization.GoalType; -import org.apache.commons.math4.optimization.PointValuePair; -import org.apache.commons.math4.optimization.SimpleValueChecker; -import org.apache.commons.math4.util.FastMath; - -/** - * Non-linear conjugate gradient optimizer. - * <p> - * This class supports both the Fletcher-Reeves and the Polak-Ribière - * update formulas for the conjugate search directions. It also supports - * optional preconditioning. - * </p> - * - * @deprecated As of 3.1 (to be removed in 4.0). - * @since 2.0 - * - */ -@Deprecated -public class NonLinearConjugateGradientOptimizer - extends AbstractScalarDifferentiableOptimizer { - /** Update formula for the beta parameter. */ - private final ConjugateGradientFormula updateFormula; - /** Preconditioner (may be null). */ - private final Preconditioner preconditioner; - /** solver to use in the line search (may be null). */ - private final UnivariateSolver solver; - /** Initial step used to bracket the optimum in line search. */ - private double initialStep; - /** Current point. */ - private double[] point; - - /** - * Constructor with default {@link SimpleValueChecker checker}, - * {@link BrentSolver line search solver} and - * {@link IdentityPreconditioner preconditioner}. - * - * @param updateFormula formula to use for updating the β parameter, - * must be one of {@link ConjugateGradientFormula#FLETCHER_REEVES} or {@link - * ConjugateGradientFormula#POLAK_RIBIERE}. - * @deprecated See {@link SimpleValueChecker#SimpleValueChecker()} - */ - @Deprecated - public NonLinearConjugateGradientOptimizer(final ConjugateGradientFormula updateFormula) { - this(updateFormula, - new SimpleValueChecker()); - } - - /** - * Constructor with default {@link BrentSolver line search solver} and - * {@link IdentityPreconditioner preconditioner}. - * - * @param updateFormula formula to use for updating the β parameter, - * must be one of {@link ConjugateGradientFormula#FLETCHER_REEVES} or {@link - * ConjugateGradientFormula#POLAK_RIBIERE}. - * @param checker Convergence checker. - */ - public NonLinearConjugateGradientOptimizer(final ConjugateGradientFormula updateFormula, - ConvergenceChecker<PointValuePair> checker) { - this(updateFormula, - checker, - new BrentSolver(), - new IdentityPreconditioner()); - } - - - /** - * Constructor with default {@link IdentityPreconditioner preconditioner}. - * - * @param updateFormula formula to use for updating the β parameter, - * must be one of {@link ConjugateGradientFormula#FLETCHER_REEVES} or {@link - * ConjugateGradientFormula#POLAK_RIBIERE}. - * @param checker Convergence checker. - * @param lineSearchSolver Solver to use during line search. - */ - public NonLinearConjugateGradientOptimizer(final ConjugateGradientFormula updateFormula, - ConvergenceChecker<PointValuePair> checker, - final UnivariateSolver lineSearchSolver) { - this(updateFormula, - checker, - lineSearchSolver, - new IdentityPreconditioner()); - } - - /** - * @param updateFormula formula to use for updating the β parameter, - * must be one of {@link ConjugateGradientFormula#FLETCHER_REEVES} or {@link - * ConjugateGradientFormula#POLAK_RIBIERE}. - * @param checker Convergence checker. - * @param lineSearchSolver Solver to use during line search. - * @param preconditioner Preconditioner. - */ - public NonLinearConjugateGradientOptimizer(final ConjugateGradientFormula updateFormula, - ConvergenceChecker<PointValuePair> checker, - final UnivariateSolver lineSearchSolver, - final Preconditioner preconditioner) { - super(checker); - - this.updateFormula = updateFormula; - solver = lineSearchSolver; - this.preconditioner = preconditioner; - initialStep = 1.0; - } - - /** - * Set the initial step used to bracket the optimum in line search. - * <p> - * The initial step is a factor with respect to the search direction, - * which itself is roughly related to the gradient of the function - * </p> - * @param initialStep initial step used to bracket the optimum in line search, - * if a non-positive value is used, the initial step is reset to its - * default value of 1.0 - */ - public void setInitialStep(final double initialStep) { - if (initialStep <= 0) { - this.initialStep = 1.0; - } else { - this.initialStep = initialStep; - } - } - - /** {@inheritDoc} */ - @Override - protected PointValuePair doOptimize() { - final ConvergenceChecker<PointValuePair> checker = getConvergenceChecker(); - point = getStartPoint(); - final GoalType goal = getGoalType(); - final int n = point.length; - double[] r = computeObjectiveGradient(point); - if (goal == GoalType.MINIMIZE) { - for (int i = 0; i < n; ++i) { - r[i] = -r[i]; - } - } - - // Initial search direction. - double[] steepestDescent = preconditioner.precondition(point, r); - double[] searchDirection = steepestDescent.clone(); - - double delta = 0; - for (int i = 0; i < n; ++i) { - delta += r[i] * searchDirection[i]; - } - - PointValuePair current = null; - int iter = 0; - int maxEval = getMaxEvaluations(); - while (true) { - ++iter; - - final double objective = computeObjectiveValue(point); - PointValuePair previous = current; - current = new PointValuePair(point, objective); - if (previous != null && checker.converged(iter, previous, current)) { - // We have found an optimum. - return current; - } - - // Find the optimal step in the search direction. - final UnivariateFunction lsf = new LineSearchFunction(searchDirection); - final double uB = findUpperBound(lsf, 0, initialStep); - // XXX Last parameters is set to a value close to zero in order to - // work around the divergence problem in the "testCircleFitting" - // unit test (see MATH-439). - final double step = solver.solve(maxEval, lsf, 0, uB, 1e-15); - maxEval -= solver.getEvaluations(); // Subtract used up evaluations. - - // Validate new point. - for (int i = 0; i < point.length; ++i) { - point[i] += step * searchDirection[i]; - } - - r = computeObjectiveGradient(point); - if (goal == GoalType.MINIMIZE) { - for (int i = 0; i < n; ++i) { - r[i] = -r[i]; - } - } - - // Compute beta. - final double deltaOld = delta; - final double[] newSteepestDescent = preconditioner.precondition(point, r); - delta = 0; - for (int i = 0; i < n; ++i) { - delta += r[i] * newSteepestDescent[i]; - } - - final double beta; - if (updateFormula == ConjugateGradientFormula.FLETCHER_REEVES) { - beta = delta / deltaOld; - } else { - double deltaMid = 0; - for (int i = 0; i < r.length; ++i) { - deltaMid += r[i] * steepestDescent[i]; - } - beta = (delta - deltaMid) / deltaOld; - } - steepestDescent = newSteepestDescent; - - // Compute conjugate search direction. - if (iter % n == 0 || - beta < 0) { - // Break conjugation: reset search direction. - searchDirection = steepestDescent.clone(); - } else { - // Compute new conjugate search direction. - for (int i = 0; i < n; ++i) { - searchDirection[i] = steepestDescent[i] + beta * searchDirection[i]; - } - } - } - } - - /** - * Find the upper bound b ensuring bracketing of a root between a and b. - * - * @param f function whose root must be bracketed. - * @param a lower bound of the interval. - * @param h initial step to try. - * @return b such that f(a) and f(b) have opposite signs. - * @throws MathIllegalStateException if no bracket can be found. - */ - private double findUpperBound(final UnivariateFunction f, - final double a, final double h) { - final double yA = f.value(a); - double yB = yA; - for (double step = h; step < Double.MAX_VALUE; step *= FastMath.max(2, yA / yB)) { - final double b = a + step; - yB = f.value(b); - if (yA * yB <= 0) { - return b; - } - } - throw new MathIllegalStateException(LocalizedFormats.UNABLE_TO_BRACKET_OPTIMUM_IN_LINE_SEARCH); - } - - /** Default identity preconditioner. */ - public static class IdentityPreconditioner implements Preconditioner { - - /** {@inheritDoc} */ - public double[] precondition(double[] variables, double[] r) { - return r.clone(); - } - } - - /** Internal class for line search. - * <p> - * The function represented by this class is the dot product of - * the objective function gradient and the search direction. Its - * value is zero when the gradient is orthogonal to the search - * direction, i.e. when the objective function value is a local - * extremum along the search direction. - * </p> - */ - private class LineSearchFunction implements UnivariateFunction { - /** Search direction. */ - private final double[] searchDirection; - - /** Simple constructor. - * @param searchDirection search direction - */ - public LineSearchFunction(final double[] searchDirection) { - this.searchDirection = searchDirection; - } - - /** {@inheritDoc} */ - public double value(double x) { - // current point in the search direction - final double[] shiftedPoint = point.clone(); - for (int i = 0; i < shiftedPoint.length; ++i) { - shiftedPoint[i] += x * searchDirection[i]; - } - - // gradient of the objective function - final double[] gradient = computeObjectiveGradient(shiftedPoint); - - // dot product with the search direction - double dotProduct = 0; - for (int i = 0; i < gradient.length; ++i) { - dotProduct += gradient[i] * searchDirection[i]; - } - - return dotProduct; - } - } -} http://git-wip-us.apache.org/repos/asf/commons-math/blob/b4669aad/src/main/java/org/apache/commons/math4/optimization/general/Preconditioner.java ---------------------------------------------------------------------- diff --git a/src/main/java/org/apache/commons/math4/optimization/general/Preconditioner.java b/src/main/java/org/apache/commons/math4/optimization/general/Preconditioner.java deleted file mode 100644 index 882b789..0000000 --- a/src/main/java/org/apache/commons/math4/optimization/general/Preconditioner.java +++ /dev/null @@ -1,46 +0,0 @@ -/* - * 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.math4.optimization.general; - -/** - * This interface represents a preconditioner for differentiable scalar - * objective function optimizers. - * @deprecated As of 3.1 (to be removed in 4.0). - * @since 2.0 - */ -@Deprecated -public interface Preconditioner { - /** - * Precondition a search direction. - * <p> - * The returned preconditioned search direction must be computed fast or - * the algorithm performances will drop drastically. A classical approach - * is to compute only the diagonal elements of the hessian and to divide - * the raw search direction by these elements if they are all positive. - * If at least one of them is negative, it is safer to return a clone of - * the raw search direction as if the hessian was the identity matrix. The - * rationale for this simplified choice is that a negative diagonal element - * means the current point is far from the optimum and preconditioning will - * not be efficient anyway in this case. - * </p> - * @param point current point at which the search direction was computed - * @param r raw search direction (i.e. opposite of the gradient) - * @return approximation of H<sup>-1</sup>r where H is the objective function hessian - */ - double[] precondition(double[] point, double[] r); -} http://git-wip-us.apache.org/repos/asf/commons-math/blob/b4669aad/src/main/java/org/apache/commons/math4/optimization/general/package-info.java ---------------------------------------------------------------------- diff --git a/src/main/java/org/apache/commons/math4/optimization/general/package-info.java b/src/main/java/org/apache/commons/math4/optimization/general/package-info.java deleted file mode 100644 index ac50fd4..0000000 --- a/src/main/java/org/apache/commons/math4/optimization/general/package-info.java +++ /dev/null @@ -1,22 +0,0 @@ -/* - * 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. - */ -/** - * - * This package provides optimization algorithms that require derivatives. - * - */ -package org.apache.commons.math4.optimization.general; http://git-wip-us.apache.org/repos/asf/commons-math/blob/b4669aad/src/main/java/org/apache/commons/math4/optimization/linear/AbstractLinearOptimizer.java ---------------------------------------------------------------------- diff --git a/src/main/java/org/apache/commons/math4/optimization/linear/AbstractLinearOptimizer.java b/src/main/java/org/apache/commons/math4/optimization/linear/AbstractLinearOptimizer.java deleted file mode 100644 index 7a58f0d..0000000 --- a/src/main/java/org/apache/commons/math4/optimization/linear/AbstractLinearOptimizer.java +++ /dev/null @@ -1,162 +0,0 @@ -/* - * 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.math4.optimization.linear; - -import java.util.Collection; -import java.util.Collections; - -import org.apache.commons.math4.exception.MathIllegalStateException; -import org.apache.commons.math4.exception.MaxCountExceededException; -import org.apache.commons.math4.optimization.GoalType; -import org.apache.commons.math4.optimization.PointValuePair; - -/** - * Base class for implementing linear optimizers. - * <p> - * This base class handles the boilerplate methods associated to thresholds - * settings and iterations counters. - * - * @deprecated As of 3.1 (to be removed in 4.0). - * @since 2.0 - */ -@Deprecated -public abstract class AbstractLinearOptimizer implements LinearOptimizer { - - /** Default maximal number of iterations allowed. */ - public static final int DEFAULT_MAX_ITERATIONS = 100; - - /** - * Linear objective function. - * @since 2.1 - */ - private LinearObjectiveFunction function; - - /** - * Linear constraints. - * @since 2.1 - */ - private Collection<LinearConstraint> linearConstraints; - - /** - * Type of optimization goal: either {@link GoalType#MAXIMIZE} or {@link GoalType#MINIMIZE}. - * @since 2.1 - */ - private GoalType goal; - - /** - * Whether to restrict the variables to non-negative values. - * @since 2.1 - */ - private boolean nonNegative; - - /** Maximal number of iterations allowed. */ - private int maxIterations; - - /** Number of iterations already performed. */ - private int iterations; - - /** - * Simple constructor with default settings. - * <p>The maximal number of evaluation is set to its default value.</p> - */ - protected AbstractLinearOptimizer() { - setMaxIterations(DEFAULT_MAX_ITERATIONS); - } - - /** - * @return {@code true} if the variables are restricted to non-negative values. - */ - protected boolean restrictToNonNegative() { - return nonNegative; - } - - /** - * @return the optimization type. - */ - protected GoalType getGoalType() { - return goal; - } - - /** - * @return the optimization type. - */ - protected LinearObjectiveFunction getFunction() { - return function; - } - - /** - * @return the optimization type. - */ - protected Collection<LinearConstraint> getConstraints() { - return Collections.unmodifiableCollection(linearConstraints); - } - - /** {@inheritDoc} */ - public void setMaxIterations(int maxIterations) { - this.maxIterations = maxIterations; - } - - /** {@inheritDoc} */ - public int getMaxIterations() { - return maxIterations; - } - - /** {@inheritDoc} */ - public int getIterations() { - return iterations; - } - - /** - * Increment the iterations counter by 1. - * @exception MaxCountExceededException if the maximal number of iterations is exceeded - */ - protected void incrementIterationsCounter() - throws MaxCountExceededException { - if (++iterations > maxIterations) { - throw new MaxCountExceededException(maxIterations); - } - } - - /** {@inheritDoc} */ - public PointValuePair optimize(final LinearObjectiveFunction f, - final Collection<LinearConstraint> constraints, - final GoalType goalType, final boolean restrictToNonNegative) - throws MathIllegalStateException { - - // store linear problem characteristics - this.function = f; - this.linearConstraints = constraints; - this.goal = goalType; - this.nonNegative = restrictToNonNegative; - - iterations = 0; - - // solve the problem - return doOptimize(); - - } - - /** - * Perform the bulk of optimization algorithm. - * @return the point/value pair giving the optimal value for objective function - * @exception MathIllegalStateException if no solution fulfilling the constraints - * can be found in the allowed number of iterations - */ - protected abstract PointValuePair doOptimize() throws MathIllegalStateException; - -} http://git-wip-us.apache.org/repos/asf/commons-math/blob/b4669aad/src/main/java/org/apache/commons/math4/optimization/linear/LinearConstraint.java ---------------------------------------------------------------------- diff --git a/src/main/java/org/apache/commons/math4/optimization/linear/LinearConstraint.java b/src/main/java/org/apache/commons/math4/optimization/linear/LinearConstraint.java deleted file mode 100644 index 85c3b2f..0000000 --- a/src/main/java/org/apache/commons/math4/optimization/linear/LinearConstraint.java +++ /dev/null @@ -1,234 +0,0 @@ -/* - * 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.math4.optimization.linear; - -import java.io.IOException; -import java.io.ObjectInputStream; -import java.io.ObjectOutputStream; -import java.io.Serializable; - -import org.apache.commons.math4.linear.ArrayRealVector; -import org.apache.commons.math4.linear.MatrixUtils; -import org.apache.commons.math4.linear.RealVector; - - -/** - * A linear constraint for a linear optimization problem. - * <p> - * A linear constraint has one of the forms: - * <ul> - * <li>c<sub>1</sub>x<sub>1</sub> + ... c<sub>n</sub>x<sub>n</sub> = v</li> - * <li>c<sub>1</sub>x<sub>1</sub> + ... c<sub>n</sub>x<sub>n</sub> <= v</li> - * <li>c<sub>1</sub>x<sub>1</sub> + ... c<sub>n</sub>x<sub>n</sub> >= v</li> - * <li>l<sub>1</sub>x<sub>1</sub> + ... l<sub>n</sub>x<sub>n</sub> + l<sub>cst</sub> = - * r<sub>1</sub>x<sub>1</sub> + ... r<sub>n</sub>x<sub>n</sub> + r<sub>cst</sub></li> - * <li>l<sub>1</sub>x<sub>1</sub> + ... l<sub>n</sub>x<sub>n</sub> + l<sub>cst</sub> <= - * r<sub>1</sub>x<sub>1</sub> + ... r<sub>n</sub>x<sub>n</sub> + r<sub>cst</sub></li> - * <li>l<sub>1</sub>x<sub>1</sub> + ... l<sub>n</sub>x<sub>n</sub> + l<sub>cst</sub> >= - * r<sub>1</sub>x<sub>1</sub> + ... r<sub>n</sub>x<sub>n</sub> + r<sub>cst</sub></li> - * </ul> - * The c<sub>i</sub>, l<sub>i</sub> or r<sub>i</sub> are the coefficients of the constraints, the x<sub>i</sub> - * are the coordinates of the current point and v is the value of the constraint. - * </p> - * @deprecated As of 3.1 (to be removed in 4.0). - * @since 2.0 - */ -@Deprecated -public class LinearConstraint implements Serializable { - - /** Serializable version identifier. */ - private static final long serialVersionUID = -764632794033034092L; - - /** Coefficients of the constraint (left hand side). */ - private final transient RealVector coefficients; - - /** Relationship between left and right hand sides (=, <=, >=). */ - private final Relationship relationship; - - /** Value of the constraint (right hand side). */ - private final double value; - - /** - * Build a constraint involving a single linear equation. - * <p> - * A linear constraint with a single linear equation has one of the forms: - * <ul> - * <li>c<sub>1</sub>x<sub>1</sub> + ... c<sub>n</sub>x<sub>n</sub> = v</li> - * <li>c<sub>1</sub>x<sub>1</sub> + ... c<sub>n</sub>x<sub>n</sub> <= v</li> - * <li>c<sub>1</sub>x<sub>1</sub> + ... c<sub>n</sub>x<sub>n</sub> >= v</li> - * </ul> - * </p> - * @param coefficients The coefficients of the constraint (left hand side) - * @param relationship The type of (in)equality used in the constraint - * @param value The value of the constraint (right hand side) - */ - public LinearConstraint(final double[] coefficients, final Relationship relationship, - final double value) { - this(new ArrayRealVector(coefficients), relationship, value); - } - - /** - * Build a constraint involving a single linear equation. - * <p> - * A linear constraint with a single linear equation has one of the forms: - * <ul> - * <li>c<sub>1</sub>x<sub>1</sub> + ... c<sub>n</sub>x<sub>n</sub> = v</li> - * <li>c<sub>1</sub>x<sub>1</sub> + ... c<sub>n</sub>x<sub>n</sub> <= v</li> - * <li>c<sub>1</sub>x<sub>1</sub> + ... c<sub>n</sub>x<sub>n</sub> >= v</li> - * </ul> - * </p> - * @param coefficients The coefficients of the constraint (left hand side) - * @param relationship The type of (in)equality used in the constraint - * @param value The value of the constraint (right hand side) - */ - public LinearConstraint(final RealVector coefficients, final Relationship relationship, - final double value) { - this.coefficients = coefficients; - this.relationship = relationship; - this.value = value; - } - - /** - * Build a constraint involving two linear equations. - * <p> - * A linear constraint with two linear equation has one of the forms: - * <ul> - * <li>l<sub>1</sub>x<sub>1</sub> + ... l<sub>n</sub>x<sub>n</sub> + l<sub>cst</sub> = - * r<sub>1</sub>x<sub>1</sub> + ... r<sub>n</sub>x<sub>n</sub> + r<sub>cst</sub></li> - * <li>l<sub>1</sub>x<sub>1</sub> + ... l<sub>n</sub>x<sub>n</sub> + l<sub>cst</sub> <= - * r<sub>1</sub>x<sub>1</sub> + ... r<sub>n</sub>x<sub>n</sub> + r<sub>cst</sub></li> - * <li>l<sub>1</sub>x<sub>1</sub> + ... l<sub>n</sub>x<sub>n</sub> + l<sub>cst</sub> >= - * r<sub>1</sub>x<sub>1</sub> + ... r<sub>n</sub>x<sub>n</sub> + r<sub>cst</sub></li> - * </ul> - * </p> - * @param lhsCoefficients The coefficients of the linear expression on the left hand side of the constraint - * @param lhsConstant The constant term of the linear expression on the left hand side of the constraint - * @param relationship The type of (in)equality used in the constraint - * @param rhsCoefficients The coefficients of the linear expression on the right hand side of the constraint - * @param rhsConstant The constant term of the linear expression on the right hand side of the constraint - */ - public LinearConstraint(final double[] lhsCoefficients, final double lhsConstant, - final Relationship relationship, - final double[] rhsCoefficients, final double rhsConstant) { - double[] sub = new double[lhsCoefficients.length]; - for (int i = 0; i < sub.length; ++i) { - sub[i] = lhsCoefficients[i] - rhsCoefficients[i]; - } - this.coefficients = new ArrayRealVector(sub, false); - this.relationship = relationship; - this.value = rhsConstant - lhsConstant; - } - - /** - * Build a constraint involving two linear equations. - * <p> - * A linear constraint with two linear equation has one of the forms: - * <ul> - * <li>l<sub>1</sub>x<sub>1</sub> + ... l<sub>n</sub>x<sub>n</sub> + l<sub>cst</sub> = - * r<sub>1</sub>x<sub>1</sub> + ... r<sub>n</sub>x<sub>n</sub> + r<sub>cst</sub></li> - * <li>l<sub>1</sub>x<sub>1</sub> + ... l<sub>n</sub>x<sub>n</sub> + l<sub>cst</sub> <= - * r<sub>1</sub>x<sub>1</sub> + ... r<sub>n</sub>x<sub>n</sub> + r<sub>cst</sub></li> - * <li>l<sub>1</sub>x<sub>1</sub> + ... l<sub>n</sub>x<sub>n</sub> + l<sub>cst</sub> >= - * r<sub>1</sub>x<sub>1</sub> + ... r<sub>n</sub>x<sub>n</sub> + r<sub>cst</sub></li> - * </ul> - * </p> - * @param lhsCoefficients The coefficients of the linear expression on the left hand side of the constraint - * @param lhsConstant The constant term of the linear expression on the left hand side of the constraint - * @param relationship The type of (in)equality used in the constraint - * @param rhsCoefficients The coefficients of the linear expression on the right hand side of the constraint - * @param rhsConstant The constant term of the linear expression on the right hand side of the constraint - */ - public LinearConstraint(final RealVector lhsCoefficients, final double lhsConstant, - final Relationship relationship, - final RealVector rhsCoefficients, final double rhsConstant) { - this.coefficients = lhsCoefficients.subtract(rhsCoefficients); - this.relationship = relationship; - this.value = rhsConstant - lhsConstant; - } - - /** - * Get the coefficients of the constraint (left hand side). - * @return coefficients of the constraint (left hand side) - */ - public RealVector getCoefficients() { - return coefficients; - } - - /** - * Get the relationship between left and right hand sides. - * @return relationship between left and right hand sides - */ - public Relationship getRelationship() { - return relationship; - } - - /** - * Get the value of the constraint (right hand side). - * @return value of the constraint (right hand side) - */ - public double getValue() { - return value; - } - - @Override - public boolean equals(Object other) { - - if (this == other) { - return true; - } - - if (other instanceof LinearConstraint) { - LinearConstraint rhs = (LinearConstraint) other; - return (relationship == rhs.relationship) && - (value == rhs.value) && - coefficients.equals(rhs.coefficients); - } - return false; - } - - @Override - public int hashCode() { - return relationship.hashCode() ^ - Double.valueOf(value).hashCode() ^ - coefficients.hashCode(); - } - - /** - * Serialize the instance. - * @param oos stream where object should be written - * @throws IOException if object cannot be written to stream - */ - private void writeObject(ObjectOutputStream oos) - throws IOException { - oos.defaultWriteObject(); - MatrixUtils.serializeRealVector(coefficients, oos); - } - - /** - * Deserialize the instance. - * @param ois stream from which the object should be read - * @throws ClassNotFoundException if a class in the stream cannot be found - * @throws IOException if object cannot be read from the stream - */ - private void readObject(ObjectInputStream ois) - throws ClassNotFoundException, IOException { - ois.defaultReadObject(); - MatrixUtils.deserializeRealVector(this, "coefficients", ois); - } - -} http://git-wip-us.apache.org/repos/asf/commons-math/blob/b4669aad/src/main/java/org/apache/commons/math4/optimization/linear/LinearObjectiveFunction.java ---------------------------------------------------------------------- diff --git a/src/main/java/org/apache/commons/math4/optimization/linear/LinearObjectiveFunction.java b/src/main/java/org/apache/commons/math4/optimization/linear/LinearObjectiveFunction.java deleted file mode 100644 index be5ed6bd..0000000 --- a/src/main/java/org/apache/commons/math4/optimization/linear/LinearObjectiveFunction.java +++ /dev/null @@ -1,148 +0,0 @@ -/* - * 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.math4.optimization.linear; - -import java.io.IOException; -import java.io.ObjectInputStream; -import java.io.ObjectOutputStream; -import java.io.Serializable; - -import org.apache.commons.math4.linear.ArrayRealVector; -import org.apache.commons.math4.linear.MatrixUtils; -import org.apache.commons.math4.linear.RealVector; - -/** - * An objective function for a linear optimization problem. - * <p> - * A linear objective function has one the form: - * <pre> - * c<sub>1</sub>x<sub>1</sub> + ... c<sub>n</sub>x<sub>n</sub> + d - * </pre> - * The c<sub>i</sub> and d are the coefficients of the equation, - * the x<sub>i</sub> are the coordinates of the current point. - * </p> - * @deprecated As of 3.1 (to be removed in 4.0). - * @since 2.0 - */ -@Deprecated -public class LinearObjectiveFunction implements Serializable { - - /** Serializable version identifier. */ - private static final long serialVersionUID = -4531815507568396090L; - - /** Coefficients of the constraint (c<sub>i</sub>). */ - private final transient RealVector coefficients; - - /** Constant term of the linear equation. */ - private final double constantTerm; - - /** - * @param coefficients The coefficients for the linear equation being optimized - * @param constantTerm The constant term of the linear equation - */ - public LinearObjectiveFunction(double[] coefficients, double constantTerm) { - this(new ArrayRealVector(coefficients), constantTerm); - } - - /** - * @param coefficients The coefficients for the linear equation being optimized - * @param constantTerm The constant term of the linear equation - */ - public LinearObjectiveFunction(RealVector coefficients, double constantTerm) { - this.coefficients = coefficients; - this.constantTerm = constantTerm; - } - - /** - * Get the coefficients of the linear equation being optimized. - * @return coefficients of the linear equation being optimized - */ - public RealVector getCoefficients() { - return coefficients; - } - - /** - * Get the constant of the linear equation being optimized. - * @return constant of the linear equation being optimized - */ - public double getConstantTerm() { - return constantTerm; - } - - /** - * Compute the value of the linear equation at the current point - * @param point point at which linear equation must be evaluated - * @return value of the linear equation at the current point - */ - public double getValue(final double[] point) { - return coefficients.dotProduct(new ArrayRealVector(point, false)) + constantTerm; - } - - /** - * Compute the value of the linear equation at the current point - * @param point point at which linear equation must be evaluated - * @return value of the linear equation at the current point - */ - public double getValue(final RealVector point) { - return coefficients.dotProduct(point) + constantTerm; - } - - @Override - public boolean equals(Object other) { - - if (this == other) { - return true; - } - - if (other instanceof LinearObjectiveFunction) { - LinearObjectiveFunction rhs = (LinearObjectiveFunction) other; - return (constantTerm == rhs.constantTerm) && coefficients.equals(rhs.coefficients); - } - - return false; - } - - @Override - public int hashCode() { - return Double.valueOf(constantTerm).hashCode() ^ coefficients.hashCode(); - } - - /** - * Serialize the instance. - * @param oos stream where object should be written - * @throws IOException if object cannot be written to stream - */ - private void writeObject(ObjectOutputStream oos) - throws IOException { - oos.defaultWriteObject(); - MatrixUtils.serializeRealVector(coefficients, oos); - } - - /** - * Deserialize the instance. - * @param ois stream from which the object should be read - * @throws ClassNotFoundException if a class in the stream cannot be found - * @throws IOException if object cannot be read from the stream - */ - private void readObject(ObjectInputStream ois) - throws ClassNotFoundException, IOException { - ois.defaultReadObject(); - MatrixUtils.deserializeRealVector(this, "coefficients", ois); - } - -} http://git-wip-us.apache.org/repos/asf/commons-math/blob/b4669aad/src/main/java/org/apache/commons/math4/optimization/linear/LinearOptimizer.java ---------------------------------------------------------------------- diff --git a/src/main/java/org/apache/commons/math4/optimization/linear/LinearOptimizer.java b/src/main/java/org/apache/commons/math4/optimization/linear/LinearOptimizer.java deleted file mode 100644 index 07e5930..0000000 --- a/src/main/java/org/apache/commons/math4/optimization/linear/LinearOptimizer.java +++ /dev/null @@ -1,92 +0,0 @@ -/* - * 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.math4.optimization.linear; - -import java.util.Collection; - -import org.apache.commons.math4.exception.MathIllegalStateException; -import org.apache.commons.math4.optimization.GoalType; -import org.apache.commons.math4.optimization.PointValuePair; - -/** - * This interface represents an optimization algorithm for linear problems. - * <p>Optimization algorithms find the input point set that either {@link GoalType - * maximize or minimize} an objective function. In the linear case the form of - * the function is restricted to - * <pre> - * c<sub>1</sub>x<sub>1</sub> + ... c<sub>n</sub>x<sub>n</sub> = v - * </pre> - * and there may be linear constraints too, of one of the forms: - * <ul> - * <li>c<sub>1</sub>x<sub>1</sub> + ... c<sub>n</sub>x<sub>n</sub> = v</li> - * <li>c<sub>1</sub>x<sub>1</sub> + ... c<sub>n</sub>x<sub>n</sub> <= v</li> - * <li>c<sub>1</sub>x<sub>1</sub> + ... c<sub>n</sub>x<sub>n</sub> >= v</li> - * <li>l<sub>1</sub>x<sub>1</sub> + ... l<sub>n</sub>x<sub>n</sub> + l<sub>cst</sub> = - * r<sub>1</sub>x<sub>1</sub> + ... r<sub>n</sub>x<sub>n</sub> + r<sub>cst</sub></li> - * <li>l<sub>1</sub>x<sub>1</sub> + ... l<sub>n</sub>x<sub>n</sub> + l<sub>cst</sub> <= - * r<sub>1</sub>x<sub>1</sub> + ... r<sub>n</sub>x<sub>n</sub> + r<sub>cst</sub></li> - * <li>l<sub>1</sub>x<sub>1</sub> + ... l<sub>n</sub>x<sub>n</sub> + l<sub>cst</sub> >= - * r<sub>1</sub>x<sub>1</sub> + ... r<sub>n</sub>x<sub>n</sub> + r<sub>cst</sub></li> - * </ul> - * where the c<sub>i</sub>, l<sub>i</sub> or r<sub>i</sub> are the coefficients of - * the constraints, the x<sub>i</sub> are the coordinates of the current point and - * v is the value of the constraint. - * </p> - * @deprecated As of 3.1 (to be removed in 4.0). - * @since 2.0 - */ -@Deprecated -public interface LinearOptimizer { - - /** - * Set the maximal number of iterations of the algorithm. - * @param maxIterations maximal number of function calls - */ - void setMaxIterations(int maxIterations); - - /** - * Get the maximal number of iterations of the algorithm. - * @return maximal number of iterations - */ - int getMaxIterations(); - - /** - * Get the number of iterations realized by the algorithm. - * <p> - * The number of evaluations corresponds to the last call to the - * {@link #optimize(LinearObjectiveFunction, Collection, GoalType, boolean) optimize} - * method. It is 0 if the method has not been called yet. - * </p> - * @return number of iterations - */ - int getIterations(); - - /** - * Optimizes an objective function. - * @param f linear objective function - * @param constraints linear constraints - * @param goalType type of optimization goal: either {@link GoalType#MAXIMIZE} or {@link GoalType#MINIMIZE} - * @param restrictToNonNegative whether to restrict the variables to non-negative values - * @return point/value pair giving the optimal value for objective function - * @exception MathIllegalStateException if no solution fulfilling the constraints - * can be found in the allowed number of iterations - */ - PointValuePair optimize(LinearObjectiveFunction f, Collection<LinearConstraint> constraints, - GoalType goalType, boolean restrictToNonNegative) throws MathIllegalStateException; - -} http://git-wip-us.apache.org/repos/asf/commons-math/blob/b4669aad/src/main/java/org/apache/commons/math4/optimization/linear/NoFeasibleSolutionException.java ---------------------------------------------------------------------- diff --git a/src/main/java/org/apache/commons/math4/optimization/linear/NoFeasibleSolutionException.java b/src/main/java/org/apache/commons/math4/optimization/linear/NoFeasibleSolutionException.java deleted file mode 100644 index ca3b438..0000000 --- a/src/main/java/org/apache/commons/math4/optimization/linear/NoFeasibleSolutionException.java +++ /dev/null @@ -1,42 +0,0 @@ -/* - * 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.math4.optimization.linear; - -import org.apache.commons.math4.exception.MathIllegalStateException; -import org.apache.commons.math4.exception.util.LocalizedFormats; - -/** - * This class represents exceptions thrown by optimizers when no solution fulfills the constraints. - * - * @deprecated As of 3.1 (to be removed in 4.0). - * @since 2.0 - */ -@Deprecated -public class NoFeasibleSolutionException extends MathIllegalStateException { - - /** Serializable version identifier. */ - private static final long serialVersionUID = -3044253632189082760L; - - /** - * Simple constructor using a default message. - */ - public NoFeasibleSolutionException() { - super(LocalizedFormats.NO_FEASIBLE_SOLUTION); - } - -}
