    001    /*
    002     * Licensed to the Apache Software Foundation (ASF) under one or more
    003     * contributor license agreements.  See the NOTICE file distributed with
    004     * this work for additional information regarding copyright ownership.
    005     * The ASF licenses this file to You under the Apache License, Version 2.0
    006     * (the "License"); you may not use this file except in compliance with
    007     * the License.  You may obtain a copy of the License at
    008     *
    009     *      http://www.apache.org/licenses/LICENSE-2.0
    010     *
    011     * Unless required by applicable law or agreed to in writing, software
    012     * distributed under the License is distributed on an "AS IS" BASIS,
    013     * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
    014     * See the License for the specific language governing permissions and
    015     * limitations under the License.
    016     */
    017    package org.apache.commons.math.optimization.general;
    018
    019    import java.util.Arrays;
    020
    021    import org.apache.commons.math.FunctionEvaluationException;
    022    import org.apache.commons.math.exception.util.LocalizedFormats;
    023    import org.apache.commons.math.optimization.OptimizationException;
    024    import org.apache.commons.math.optimization.VectorialPointValuePair;
    025    import org.apache.commons.math.util.FastMath;
    026    import org.apache.commons.math.util.MathUtils;
    027
    028
    029    /**
    030     * This class solves a least squares problem using the Levenberg-Marquardt algorithm.
    031     *
    032     * <p>This implementation <em>should</em> work even for over-determined systems
    033     * (i.e. systems having more point than equations). Over-determined systems
    034     * are solved by ignoring the point which have the smallest impact according
    035     * to their jacobian column norm. Only the rank of the matrix and some loop bounds
    036     * are changed to implement this.</p>
    037     *
    038     * <p>The resolution engine is a simple translation of the MINPACK <a
    039     * href="http://www.netlib.org/minpack/lmder.f">lmder</a> routine with minor
    040     * changes. The changes include the over-determined resolution, the use of
    041     * inherited convergence checker and the Q.R. decomposition which has been
    042     * rewritten following the algorithm described in the
    043     * P. Lascaux and R. Theodor book <i>Analyse num&eacute;rique matricielle
    044     * appliqu&eacute;e &agrave; l'art de l'ing&eacute;nieur</i>, Masson 1986.</p>
    045     * <p>The authors of the original fortran version are:
    046     * <ul>
    047     * <li>Argonne National Laboratory. MINPACK project. March 1980</li>
    048     * <li>Burton S. Garbow</li>
    049     * <li>Kenneth E. Hillstrom</li>
    050     * <li>Jorge J. More</li>
    051     * </ul>
    052     * The redistribution policy for MINPACK is available <a
    053     * href="http://www.netlib.org/minpack/disclaimer">here</a>, for convenience, it
    054     * is reproduced below.</p>
    055     *
    056     * <table border="0" width="80%" cellpadding="10" align="center" bgcolor="#E0E0E0">
    057     * <tr><td>
    058     *    Minpack Copyright Notice (1999) University of Chicago.
    059     *    All rights reserved
    060     * </td></tr>
    061     * <tr><td>
    062     * Redistribution and use in source and binary forms, with or without
    063     * modification, are permitted provided that the following conditions
    064     * are met:
    065     * <ol>
    066     *  <li>Redistributions of source code must retain the above copyright
    067     *      notice, this list of conditions and the following disclaimer.</li>
    068     * <li>Redistributions in binary form must reproduce the above
    069     *     copyright notice, this list of conditions and the following
    070     *     disclaimer in the documentation and/or other materials provided
    071     *     with the distribution.</li>
    072     * <li>The end-user documentation included with the redistribution, if any,
    073     *     must include the following acknowledgment:
    074     *     <code>This product includes software developed by the University of
    075     *           Chicago, as Operator of Argonne National Laboratory.</code>
    076     *     Alternately, this acknowledgment may appear in the software itself,
    077     *     if and wherever such third-party acknowledgments normally appear.</li>
    078     * <li><strong>WARRANTY DISCLAIMER. THE SOFTWARE IS SUPPLIED "AS IS"
    079     *     WITHOUT WARRANTY OF ANY KIND. THE COPYRIGHT HOLDER, THE
    080     *     UNITED STATES, THE UNITED STATES DEPARTMENT OF ENERGY, AND
    081     *     THEIR EMPLOYEES: (1) DISCLAIM ANY WARRANTIES, EXPRESS OR
    082     *     IMPLIED, INCLUDING BUT NOT LIMITED TO ANY IMPLIED WARRANTIES
    083     *     OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE, TITLE
    084     *     OR NON-INFRINGEMENT, (2) DO NOT ASSUME ANY LEGAL LIABILITY
    085     *     OR RESPONSIBILITY FOR THE ACCURACY, COMPLETENESS, OR
    086     *     USEFULNESS OF THE SOFTWARE, (3) DO NOT REPRESENT THAT USE OF
    087     *     THE SOFTWARE WOULD NOT INFRINGE PRIVATELY OWNED RIGHTS, (4)
    088     *     DO NOT WARRANT THAT THE SOFTWARE WILL FUNCTION
    089     *     UNINTERRUPTED, THAT IT IS ERROR-FREE OR THAT ANY ERRORS WILL
    090     *     BE CORRECTED.</strong></li>
    091     * <li><strong>LIMITATION OF LIABILITY. IN NO EVENT WILL THE COPYRIGHT
    092     *     HOLDER, THE UNITED STATES, THE UNITED STATES DEPARTMENT OF
    093     *     ENERGY, OR THEIR EMPLOYEES: BE LIABLE FOR ANY INDIRECT,
    094     *     INCIDENTAL, CONSEQUENTIAL, SPECIAL OR PUNITIVE DAMAGES OF
    095     *     ANY KIND OR NATURE, INCLUDING BUT NOT LIMITED TO LOSS OF
    096     *     PROFITS OR LOSS OF DATA, FOR ANY REASON WHATSOEVER, WHETHER
    097     *     SUCH LIABILITY IS ASSERTED ON THE BASIS OF CONTRACT, TORT
    098     *     (INCLUDING NEGLIGENCE OR STRICT LIABILITY), OR OTHERWISE,
    099     *     EVEN IF ANY OF SAID PARTIES HAS BEEN WARNED OF THE
    100     *     POSSIBILITY OF SUCH LOSS OR DAMAGES.</strong></li>
    101     * <ol></td></tr>
    102     * </table>
    103     * @version $Revision: 1073272 $ $Date: 2011-02-22 10:22:25 +0100 (mar. 22 f??vr. 2011) $
    104     * @since 2.0
    105     *
    106     */
    107    public class LevenbergMarquardtOptimizer extends AbstractLeastSquaresOptimizer {
    108
    109        /** Number of solved point. */
    110        private int solvedCols;
    111
    112        /** Diagonal elements of the R matrix in the Q.R. decomposition. */
    113        private double[] diagR;
    114
    115        /** Norms of the columns of the jacobian matrix. */
    116        private double[] jacNorm;
    117
    118        /** Coefficients of the Householder transforms vectors. */
    119        private double[] beta;
    120
    121        /** Columns permutation array. */
    122        private int[] permutation;
    123
    124        /** Rank of the jacobian matrix. */
    125        private int rank;
    126
    127        /** Levenberg-Marquardt parameter. */
    128        private double lmPar;
    129
    130        /** Parameters evolution direction associated with lmPar. */
    131        private double[] lmDir;
    132
    133        /** Positive input variable used in determining the initial step bound. */
    134        private double initialStepBoundFactor;
    135
    136        /** Desired relative error in the sum of squares. */
    137        private double costRelativeTolerance;
    138
    139        /**  Desired relative error in the approximate solution parameters. */
    140        private double parRelativeTolerance;
    141
    142        /** Desired max cosine on the orthogonality between the function vector
    143         * and the columns of the jacobian. */
    144        private double orthoTolerance;
    145
    146        /** Threshold for QR ranking. */
    147        private double qrRankingThreshold;
    148
    149        /**
    150         * Build an optimizer for least squares problems.
    151         * <p>The default values for the algorithm settings are:
    152         *   <ul>
    153         *    <li>{@link #setConvergenceChecker(VectorialConvergenceChecker) vectorial convergence checker}: null</li>
    154         *    <li>{@link #setInitialStepBoundFactor(double) initial step bound factor}: 100.0</li>
    155         *    <li>{@link #setMaxIterations(int) maximal iterations}: 1000</li>
    156         *    <li>{@link #setCostRelativeTolerance(double) cost relative tolerance}: 1.0e-10</li>
    157         *    <li>{@link #setParRelativeTolerance(double) parameters relative tolerance}: 1.0e-10</li>
    158         *    <li>{@link #setOrthoTolerance(double) orthogonality tolerance}: 1.0e-10</li>
    159         *    <li>{@link #setQRRankingThreshold(double) QR ranking threshold}: {@link MathUtils#SAFE_MIN}</li>
    160         *   </ul>
    161         * </p>
    162         * <p>These default values may be overridden after construction. If the {@link
    163         * #setConvergenceChecker vectorial convergence checker} is set to a non-null value, it
    164         * will be used instead of the {@link #setCostRelativeTolerance cost relative tolerance}
    165         * and {@link #setParRelativeTolerance parameters relative tolerance} settings.
    166         */
    167        public LevenbergMarquardtOptimizer() {
    168
    169            // set up the superclass with a default  max cost evaluations setting
    170            setMaxIterations(1000);
    171
    172            // default values for the tuning parameters
    173            setConvergenceChecker(null);
    174            setInitialStepBoundFactor(100.0);
    175            setCostRelativeTolerance(1.0e-10);
    176            setParRelativeTolerance(1.0e-10);
    177            setOrthoTolerance(1.0e-10);
    178            setQRRankingThreshold(MathUtils.SAFE_MIN);
    179
    180        }
    181
    182        /**
    183         * Set the positive input variable used in determining the initial step bound.
    184         * This bound is set to the product of initialStepBoundFactor and the euclidean
    185         * norm of diag*x if nonzero, or else to initialStepBoundFactor itself. In most
    186         * cases factor should lie in the interval (0.1, 100.0). 100.0 is a generally
    187         * recommended value.
    188         *
    189         * @param initialStepBoundFactor initial step bound factor
    190         */
    191        public void setInitialStepBoundFactor(double initialStepBoundFactor) {
    192            this.initialStepBoundFactor = initialStepBoundFactor;
    193        }
    194
    195        /**
    196         * Set the desired relative error in the sum of squares.
    197         * <p>This setting is used only if the {@link #setConvergenceChecker vectorial
    198         * convergence checker} is set to null.</p>
    199         * @param costRelativeTolerance desired relative error in the sum of squares
    200         */
    201        public void setCostRelativeTolerance(double costRelativeTolerance) {
    202            this.costRelativeTolerance = costRelativeTolerance;
    203        }
    204
    205        /**
    206         * Set the desired relative error in the approximate solution parameters.
    207         * <p>This setting is used only if the {@link #setConvergenceChecker vectorial
    208         * convergence checker} is set to null.</p>
    209         * @param parRelativeTolerance desired relative error
    210         * in the approximate solution parameters
    211         */
    212        public void setParRelativeTolerance(double parRelativeTolerance) {
    213            this.parRelativeTolerance = parRelativeTolerance;
    214        }
    215
    216        /**
    217         * Set the desired max cosine on the orthogonality.
    218         * <p>This setting is always used, regardless of the {@link #setConvergenceChecker
    219         * vectorial convergence checker} being null or non-null.</p>
    220         * @param orthoTolerance desired max cosine on the orthogonality
    221         * between the function vector and the columns of the jacobian
    222         */
    223        public void setOrthoTolerance(double orthoTolerance) {
    224            this.orthoTolerance = orthoTolerance;
    225        }
    226
    227        /**
    228         * Set the desired threshold for QR ranking.
    229         * <p>
    230         * If the squared norm of a column vector is smaller or equal to this threshold
    231         * during QR decomposition, it is considered to be a zero vector and hence the
    232         * rank of the matrix is reduced.
    233         * </p>
    234         * @param threshold threshold for QR ranking
    235         * @since 2.2
    236         */
    237        public void setQRRankingThreshold(final double threshold) {
    238            this.qrRankingThreshold = threshold;
    239        }
    240
    241        /** {@inheritDoc} */
    242        @Override
    243        protected VectorialPointValuePair doOptimize()
    244            throws FunctionEvaluationException, OptimizationException, IllegalArgumentException {
    245
    246            // arrays shared with the other private methods
    247            solvedCols  = Math.min(rows, cols);
    248            diagR       = new double[cols];
    249            jacNorm     = new double[cols];
    250            beta        = new double[cols];
    251            permutation = new int[cols];
    252            lmDir       = new double[cols];
    253
    254            // local point
    255            double   delta   = 0;
    256            double   xNorm   = 0;
    257            double[] diag    = new double[cols];
    258            double[] oldX    = new double[cols];
    259            double[] oldRes  = new double[rows];
    260            double[] oldObj  = new double[rows];
    261            double[] qtf     = new double[rows];
    262            double[] work1   = new double[cols];
    263            double[] work2   = new double[cols];
    264            double[] work3   = new double[cols];
    265
    266            // evaluate the function at the starting point and calculate its norm
    267            updateResidualsAndCost();
    268
    269            // outer loop
    270            lmPar = 0;
    271            boolean firstIteration = true;
    272            VectorialPointValuePair current = new VectorialPointValuePair(point, objective);
    273            while (true) {
    274                for (int i=0;i<rows;i++) {
    275                    qtf[i]=wresiduals[i];
    276                }
    277                incrementIterationsCounter();
    278
    279                // compute the Q.R. decomposition of the jacobian matrix
    280                VectorialPointValuePair previous = current;
    281                updateJacobian();
    282                qrDecomposition();
    283
    284                // compute Qt.res
    285                qTy(qtf);
    286                // now we don't need Q anymore,
    287                // so let jacobian contain the R matrix with its diagonal elements
    288                for (int k = 0; k < solvedCols; ++k) {
    289                    int pk = permutation[k];
    290                    wjacobian[k][pk] = diagR[pk];
    291                }
    292
    293                if (firstIteration) {
    294
    295                    // scale the point according to the norms of the columns
    296                    // of the initial jacobian
    297                    xNorm = 0;
    298                    for (int k = 0; k < cols; ++k) {
    299                        double dk = jacNorm[k];
    300                        if (dk == 0) {
    301                            dk = 1.0;
    302                        }
    303                        double xk = dk * point[k];
    304                        xNorm  += xk * xk;
    305                        diag[k] = dk;
    306                    }
    307                    xNorm = FastMath.sqrt(xNorm);
    308
    309                    // initialize the step bound delta
    310                    delta = (xNorm == 0) ? initialStepBoundFactor : (initialStepBoundFactor * xNorm);
    311
    312                }
    313
    314                // check orthogonality between function vector and jacobian columns
    315                double maxCosine = 0;
    316                if (cost != 0) {
    317                    for (int j = 0; j < solvedCols; ++j) {
    318                        int    pj = permutation[j];
    319                        double s  = jacNorm[pj];
    320                        if (s != 0) {
    321                            double sum = 0;
    322                            for (int i = 0; i <= j; ++i) {
    323                                sum += wjacobian[i][pj] * qtf[i];
    324                            }
    325                            maxCosine = FastMath.max(maxCosine, FastMath.abs(sum) / (s * cost));
    326                        }
    327                    }
    328                }
    329                if (maxCosine <= orthoTolerance) {
    330                    // convergence has been reached
    331                    updateResidualsAndCost();
    332                    current = new VectorialPointValuePair(point, objective);
    333                    return current;
    334                }
    335
    336                // rescale if necessary
    337                for (int j = 0; j < cols; ++j) {
    338                    diag[j] = FastMath.max(diag[j], jacNorm[j]);
    339                }
    340
    341                // inner loop
    342                for (double ratio = 0; ratio < 1.0e-4;) {
    343
    344                    // save the state
    345                    for (int j = 0; j < solvedCols; ++j) {
    346                        int pj = permutation[j];
    347                        oldX[pj] = point[pj];
    348                    }
    349                    double previousCost = cost;
    350                    double[] tmpVec = residuals;
    351                    residuals = oldRes;
    352                    oldRes    = tmpVec;
    353                    tmpVec    = objective;
    354                    objective = oldObj;
    355                    oldObj    = tmpVec;
    356
    357                    // determine the Levenberg-Marquardt parameter
    358                    determineLMParameter(qtf, delta, diag, work1, work2, work3);
    359
    360                    // compute the new point and the norm of the evolution direction
    361                    double lmNorm = 0;
    362                    for (int j = 0; j < solvedCols; ++j) {
    363                        int pj = permutation[j];
    364                        lmDir[pj] = -lmDir[pj];
    365                        point[pj] = oldX[pj] + lmDir[pj];
    366                        double s = diag[pj] * lmDir[pj];
    367                        lmNorm  += s * s;
    368                    }
    369                    lmNorm = FastMath.sqrt(lmNorm);
    370                    // on the first iteration, adjust the initial step bound.
    371                    if (firstIteration) {
    372                        delta = FastMath.min(delta, lmNorm);
    373                    }
    374
    375                    // evaluate the function at x + p and calculate its norm
    376                    updateResidualsAndCost();
    377
    378                    // compute the scaled actual reduction
    379                    double actRed = -1.0;
    380                    if (0.1 * cost < previousCost) {
    381                        double r = cost / previousCost;
    382                        actRed = 1.0 - r * r;
    383                    }
    384
    385                    // compute the scaled predicted reduction
    386                    // and the scaled directional derivative
    387                    for (int j = 0; j < solvedCols; ++j) {
    388                        int pj = permutation[j];
    389                        double dirJ = lmDir[pj];
    390                        work1[j] = 0;
    391                        for (int i = 0; i <= j; ++i) {
    392                            work1[i] += wjacobian[i][pj] * dirJ;
    393                        }
    394                    }
    395                    double coeff1 = 0;
    396                    for (int j = 0; j < solvedCols; ++j) {
    397                        coeff1 += work1[j] * work1[j];
    398                    }
    399                    double pc2 = previousCost * previousCost;
    400                    coeff1 = coeff1 / pc2;
    401                    double coeff2 = lmPar * lmNorm * lmNorm / pc2;
    402                    double preRed = coeff1 + 2 * coeff2;
    403                    double dirDer = -(coeff1 + coeff2);
    404
    405                    // ratio of the actual to the predicted reduction
    406                    ratio = (preRed == 0) ? 0 : (actRed / preRed);
    407
    408                    // update the step bound
    409                    if (ratio <= 0.25) {
    410                        double tmp =
    411                            (actRed < 0) ? (0.5 * dirDer / (dirDer + 0.5 * actRed)) : 0.5;
    412                            if ((0.1 * cost >= previousCost) || (tmp < 0.1)) {
    413                                tmp = 0.1;
    414                            }
    415                            delta = tmp * FastMath.min(delta, 10.0 * lmNorm);
    416                            lmPar /= tmp;
    417                    } else if ((lmPar == 0) || (ratio >= 0.75)) {
    418                        delta = 2 * lmNorm;
    419                        lmPar *= 0.5;
    420                    }
    421
    422                    // test for successful iteration.
    423                    if (ratio >= 1.0e-4) {
    424                        // successful iteration, update the norm
    425                        firstIteration = false;
    426                        xNorm = 0;
    427                        for (int k = 0; k < cols; ++k) {
    428                            double xK = diag[k] * point[k];
    429                            xNorm    += xK * xK;
    430                        }
    431                        xNorm = FastMath.sqrt(xNorm);
    432                        current = new VectorialPointValuePair(point, objective);
    433
    434                        // tests for convergence.
    435                        if (checker != null) {
    436                        // we use the vectorial convergence checker
    437                            if (checker.converged(getIterations(), previous, current)) {
    438                                return current;
    439                            }
    440                        }
    441                    } else {
    442                        // failed iteration, reset the previous values
    443                        cost = previousCost;
    444                        for (int j = 0; j < solvedCols; ++j) {
    445                            int pj = permutation[j];
    446                            point[pj] = oldX[pj];
    447                        }
    448                        tmpVec    = residuals;
    449                        residuals = oldRes;
    450                        oldRes    = tmpVec;
    451                        tmpVec    = objective;
    452                        objective = oldObj;
    453                        oldObj    = tmpVec;
    454                    }
    455                    if (checker==null) {
    456                        if (((FastMath.abs(actRed) <= costRelativeTolerance) &&
    457                            (preRed <= costRelativeTolerance) &&
    458                            (ratio <= 2.0)) ||
    459                           (delta <= parRelativeTolerance * xNorm)) {
    460                           return current;
    461                       }
    462                    }
    463                    // tests for termination and stringent tolerances
    464                    // (2.2204e-16 is the machine epsilon for IEEE754)
    465                    if ((FastMath.abs(actRed) <= 2.2204e-16) && (preRed <= 2.2204e-16) && (ratio <= 2.0)) {
    466                        throw new OptimizationException(LocalizedFormats.TOO_SMALL_COST_RELATIVE_TOLERANCE,
    467                                costRelativeTolerance);
    468                    } else if (delta <= 2.2204e-16 * xNorm) {
    469                        throw new OptimizationException(LocalizedFormats.TOO_SMALL_PARAMETERS_RELATIVE_TOLERANCE,
    470                                parRelativeTolerance);
    471                    } else if (maxCosine <= 2.2204e-16)  {
    472                        throw new OptimizationException(LocalizedFormats.TOO_SMALL_ORTHOGONALITY_TOLERANCE,
    473                                orthoTolerance);
    474                    }
    475
    476                }
    477
    478            }
    479
    480        }
    481
    482        /**
    483         * Determine the Levenberg-Marquardt parameter.
    484         * <p>This implementation is a translation in Java of the MINPACK
    485         * <a href="http://www.netlib.org/minpack/lmpar.f">lmpar</a>
    486         * routine.</p>
    487         * <p>This method sets the lmPar and lmDir attributes.</p>
    488         * <p>The authors of the original fortran function are:</p>
    489         * <ul>
    490         *   <li>Argonne National Laboratory. MINPACK project. March 1980</li>
    491         *   <li>Burton  S. Garbow</li>
    492         *   <li>Kenneth E. Hillstrom</li>
    493         *   <li>Jorge   J. More</li>
    494         * </ul>
    495         * <p>Luc Maisonobe did the Java translation.</p>
    496         *
    497         * @param qy array containing qTy
    498         * @param delta upper bound on the euclidean norm of diagR * lmDir
    499         * @param diag diagonal matrix
    500         * @param work1 work array
    501         * @param work2 work array
    502         * @param work3 work array
    503         */
    504        private void determineLMParameter(double[] qy, double delta, double[] diag,
    505                double[] work1, double[] work2, double[] work3) {
    506
    507            // compute and store in x the gauss-newton direction, if the
    508            // jacobian is rank-deficient, obtain a least squares solution
    509            for (int j = 0; j < rank; ++j) {
    510                lmDir[permutation[j]] = qy[j];
    511            }
    512            for (int j = rank; j < cols; ++j) {
    513                lmDir[permutation[j]] = 0;
    514            }
    515            for (int k = rank - 1; k >= 0; --k) {
    516                int pk = permutation[k];
    517                double ypk = lmDir[pk] / diagR[pk];
    518                for (int i = 0; i < k; ++i) {
    519                    lmDir[permutation[i]] -= ypk * wjacobian[i][pk];
    520                }
    521                lmDir[pk] = ypk;
    522            }
    523
    524            // evaluate the function at the origin, and test
    525            // for acceptance of the Gauss-Newton direction
    526            double dxNorm = 0;
    527            for (int j = 0; j < solvedCols; ++j) {
    528                int pj = permutation[j];
    529                double s = diag[pj] * lmDir[pj];
    530                work1[pj] = s;
    531                dxNorm += s * s;
    532            }
    533            dxNorm = FastMath.sqrt(dxNorm);
    534            double fp = dxNorm - delta;
    535            if (fp <= 0.1 * delta) {
    536                lmPar = 0;
    537                return;
    538            }
    539
    540            // if the jacobian is not rank deficient, the Newton step provides
    541            // a lower bound, parl, for the zero of the function,
    542            // otherwise set this bound to zero
    543            double sum2;
    544            double parl = 0;
    545            if (rank == solvedCols) {
    546                for (int j = 0; j < solvedCols; ++j) {
    547                    int pj = permutation[j];
    548                    work1[pj] *= diag[pj] / dxNorm;
    549                }
    550                sum2 = 0;
    551                for (int j = 0; j < solvedCols; ++j) {
    552                    int pj = permutation[j];
    553                    double sum = 0;
    554                    for (int i = 0; i < j; ++i) {
    555                        sum += wjacobian[i][pj] * work1[permutation[i]];
    556                    }
    557                    double s = (work1[pj] - sum) / diagR[pj];
    558                    work1[pj] = s;
    559                    sum2 += s * s;
    560                }
    561                parl = fp / (delta * sum2);
    562            }
    563
    564            // calculate an upper bound, paru, for the zero of the function
    565            sum2 = 0;
    566            for (int j = 0; j < solvedCols; ++j) {
    567                int pj = permutation[j];
    568                double sum = 0;
    569                for (int i = 0; i <= j; ++i) {
    570                    sum += wjacobian[i][pj] * qy[i];
    571                }
    572                sum /= diag[pj];
    573                sum2 += sum * sum;
    574            }
    575            double gNorm = FastMath.sqrt(sum2);
    576            double paru = gNorm / delta;
    577            if (paru == 0) {
    578                // 2.2251e-308 is the smallest positive real for IEE754
    579                paru = 2.2251e-308 / FastMath.min(delta, 0.1);
    580            }
    581
    582            // if the input par lies outside of the interval (parl,paru),
    583            // set par to the closer endpoint
    584            lmPar = FastMath.min(paru, FastMath.max(lmPar, parl));
    585            if (lmPar == 0) {
    586                lmPar = gNorm / dxNorm;
    587            }
    588
    589            for (int countdown = 10; countdown >= 0; --countdown) {
    590
    591                // evaluate the function at the current value of lmPar
    592                if (lmPar == 0) {
    593                    lmPar = FastMath.max(2.2251e-308, 0.001 * paru);
    594                }
    595                double sPar = FastMath.sqrt(lmPar);
    596                for (int j = 0; j < solvedCols; ++j) {
    597                    int pj = permutation[j];
    598                    work1[pj] = sPar * diag[pj];
    599                }
    600                determineLMDirection(qy, work1, work2, work3);
    601
    602                dxNorm = 0;
    603                for (int j = 0; j < solvedCols; ++j) {
    604                    int pj = permutation[j];
    605                    double s = diag[pj] * lmDir[pj];
    606                    work3[pj] = s;
    607                    dxNorm += s * s;
    608                }
    609                dxNorm = FastMath.sqrt(dxNorm);
    610                double previousFP = fp;
    611                fp = dxNorm - delta;
    612
    613                // if the function is small enough, accept the current value
    614                // of lmPar, also test for the exceptional cases where parl is zero
    615                if ((FastMath.abs(fp) <= 0.1 * delta) ||
    616                        ((parl == 0) && (fp <= previousFP) && (previousFP < 0))) {
    617                    return;
    618                }
    619
    620                // compute the Newton correction
    621                for (int j = 0; j < solvedCols; ++j) {
    622                    int pj = permutation[j];
    623                    work1[pj] = work3[pj] * diag[pj] / dxNorm;
    624                }
    625                for (int j = 0; j < solvedCols; ++j) {
    626                    int pj = permutation[j];
    627                    work1[pj] /= work2[j];
    628                    double tmp = work1[pj];
    629                    for (int i = j + 1; i < solvedCols; ++i) {
    630                        work1[permutation[i]] -= wjacobian[i][pj] * tmp;
    631                    }
    632                }
    633                sum2 = 0;
    634                for (int j = 0; j < solvedCols; ++j) {
    635                    double s = work1[permutation[j]];
    636                    sum2 += s * s;
    637                }
    638                double correction = fp / (delta * sum2);
    639
    640                // depending on the sign of the function, update parl or paru.
    641                if (fp > 0) {
    642                    parl = FastMath.max(parl, lmPar);
    643                } else if (fp < 0) {
    644                    paru = FastMath.min(paru, lmPar);
    645                }
    646
    647                // compute an improved estimate for lmPar
    648                lmPar = FastMath.max(parl, lmPar + correction);
    649
    650            }
    651        }
    652
    653        /**
    654         * Solve a*x = b and d*x = 0 in the least squares sense.
    655         * <p>This implementation is a translation in Java of the MINPACK
    656         * <a href="http://www.netlib.org/minpack/qrsolv.f">qrsolv</a>
    657         * routine.</p>
    658         * <p>This method sets the lmDir and lmDiag attributes.</p>
    659         * <p>The authors of the original fortran function are:</p>
    660         * <ul>
    661         *   <li>Argonne National Laboratory. MINPACK project. March 1980</li>
    662         *   <li>Burton  S. Garbow</li>
    663         *   <li>Kenneth E. Hillstrom</li>
    664         *   <li>Jorge   J. More</li>
    665         * </ul>
    666         * <p>Luc Maisonobe did the Java translation.</p>
    667         *
    668         * @param qy array containing qTy
    669         * @param diag diagonal matrix
    670         * @param lmDiag diagonal elements associated with lmDir
    671         * @param work work array
    672         */
    673        private void determineLMDirection(double[] qy, double[] diag,
    674                double[] lmDiag, double[] work) {
    675
    676            // copy R and Qty to preserve input and initialize s
    677            //  in particular, save the diagonal elements of R in lmDir
    678            for (int j = 0; j < solvedCols; ++j) {
    679                int pj = permutation[j];
    680                for (int i = j + 1; i < solvedCols; ++i) {
    681                    wjacobian[i][pj] = wjacobian[j][permutation[i]];
    682                }
    683                lmDir[j] = diagR[pj];
    684                work[j]  = qy[j];
    685            }
    686
    687            // eliminate the diagonal matrix d using a Givens rotation
    688            for (int j = 0; j < solvedCols; ++j) {
    689
    690                // prepare the row of d to be eliminated, locating the
    691                // diagonal element using p from the Q.R. factorization
    692                int pj = permutation[j];
    693                double dpj = diag[pj];
    694                if (dpj != 0) {
    695                    Arrays.fill(lmDiag, j + 1, lmDiag.length, 0);
    696                }
    697                lmDiag[j] = dpj;
    698
    699                //  the transformations to eliminate the row of d
    700                // modify only a single element of Qty
    701                // beyond the first n, which is initially zero.
    702                double qtbpj = 0;
    703                for (int k = j; k < solvedCols; ++k) {
    704                    int pk = permutation[k];
    705
    706                    // determine a Givens rotation which eliminates the
    707                    // appropriate element in the current row of d
    708                    if (lmDiag[k] != 0) {
    709
    710                        final double sin;
    711                        final double cos;
    712                        double rkk = wjacobian[k][pk];
    713                        if (FastMath.abs(rkk) < FastMath.abs(lmDiag[k])) {
    714                            final double cotan = rkk / lmDiag[k];
    715                            sin   = 1.0 / FastMath.sqrt(1.0 + cotan * cotan);
    716                            cos   = sin * cotan;
    717                        } else {
    718                            final double tan = lmDiag[k] / rkk;
    719                            cos = 1.0 / FastMath.sqrt(1.0 + tan * tan);
    720                            sin = cos * tan;
    721                        }
    722
    723                        // compute the modified diagonal element of R and
    724                        // the modified element of (Qty,0)
    725                        wjacobian[k][pk] = cos * rkk + sin * lmDiag[k];
    726                        final double temp = cos * work[k] + sin * qtbpj;
    727                        qtbpj = -sin * work[k] + cos * qtbpj;
    728                        work[k] = temp;
    729
    730                        // accumulate the tranformation in the row of s
    731                        for (int i = k + 1; i < solvedCols; ++i) {
    732                            double rik = wjacobian[i][pk];
    733                            final double temp2 = cos * rik + sin * lmDiag[i];
    734                            lmDiag[i] = -sin * rik + cos * lmDiag[i];
    735                            wjacobian[i][pk] = temp2;
    736                        }
    737
    738                    }
    739                }
    740
    741                // store the diagonal element of s and restore
    742                // the corresponding diagonal element of R
    743                lmDiag[j] = wjacobian[j][permutation[j]];
    744                wjacobian[j][permutation[j]] = lmDir[j];
    745
    746            }
    747
    748            // solve the triangular system for z, if the system is
    749            // singular, then obtain a least squares solution
    750            int nSing = solvedCols;
    751            for (int j = 0; j < solvedCols; ++j) {
    752                if ((lmDiag[j] == 0) && (nSing == solvedCols)) {
    753                    nSing = j;
    754                }
    755                if (nSing < solvedCols) {
    756                    work[j] = 0;
    757                }
    758            }
    759            if (nSing > 0) {
    760                for (int j = nSing - 1; j >= 0; --j) {
    761                    int pj = permutation[j];
    762                    double sum = 0;
    763                    for (int i = j + 1; i < nSing; ++i) {
    764                        sum += wjacobian[i][pj] * work[i];
    765                    }
    766                    work[j] = (work[j] - sum) / lmDiag[j];
    767                }
    768            }
    769
    770            // permute the components of z back to components of lmDir
    771            for (int j = 0; j < lmDir.length; ++j) {
    772                lmDir[permutation[j]] = work[j];
    773            }
    774
    775        }
    776
    777        /**
    778         * Decompose a matrix A as A.P = Q.R using Householder transforms.
    779         * <p>As suggested in the P. Lascaux and R. Theodor book
    780         * <i>Analyse num&eacute;rique matricielle appliqu&eacute;e &agrave;
    781         * l'art de l'ing&eacute;nieur</i> (Masson, 1986), instead of representing
    782         * the Householder transforms with u<sub>k</sub> unit vectors such that:
    783         * <pre>
    784         * H<sub>k</sub> = I - 2u<sub>k</sub>.u<sub>k</sub><sup>t</sup>
    785         * </pre>
    786         * we use <sub>k</sub> non-unit vectors such that:
    787         * <pre>
    788         * H<sub>k</sub> = I - beta<sub>k</sub>v<sub>k</sub>.v<sub>k</sub><sup>t</sup>
    789         * </pre>
    790         * where v<sub>k</sub> = a<sub>k</sub> - alpha<sub>k</sub> e<sub>k</sub>.
    791         * The beta<sub>k</sub> coefficients are provided upon exit as recomputing
    792         * them from the v<sub>k</sub> vectors would be costly.</p>
    793         * <p>This decomposition handles rank deficient cases since the tranformations
    794         * are performed in non-increasing columns norms order thanks to columns
    795         * pivoting. The diagonal elements of the R matrix are therefore also in
    796         * non-increasing absolute values order.</p>
    797         * @exception OptimizationException if the decomposition cannot be performed
    798         */
    799        private void qrDecomposition() throws OptimizationException {
    800
    801            // initializations
    802            for (int k = 0; k < cols; ++k) {
    803                permutation[k] = k;
    804                double norm2 = 0;
    805                for (int i = 0; i < wjacobian.length; ++i) {
    806                    double akk = wjacobian[i][k];
    807                    norm2 += akk * akk;
    808                }
    809                jacNorm[k] = FastMath.sqrt(norm2);
    810            }
    811
    812            // transform the matrix column after column
    813            for (int k = 0; k < cols; ++k) {
    814
    815                // select the column with the greatest norm on active components
    816                int nextColumn = -1;
    817                double ak2 = Double.NEGATIVE_INFINITY;
    818                for (int i = k; i < cols; ++i) {
    819                    double norm2 = 0;
    820                    for (int j = k; j < wjacobian.length; ++j) {
    821                        double aki = wjacobian[j][permutation[i]];
    822                        norm2 += aki * aki;
    823                    }
    824                    if (Double.isInfinite(norm2) || Double.isNaN(norm2)) {
    825                        throw new OptimizationException(LocalizedFormats.UNABLE_TO_PERFORM_QR_DECOMPOSITION_ON_JACOBIAN,
    826                                rows, cols);
    827                    }
    828                    if (norm2 > ak2) {
    829                        nextColumn = i;
    830                        ak2        = norm2;
    831                    }
    832                }
    833                if (ak2 <= qrRankingThreshold) {
    834                    rank = k;
    835                    return;
    836                }
    837                int pk                  = permutation[nextColumn];
    838                permutation[nextColumn] = permutation[k];
    839                permutation[k]          = pk;
    840
    841                // choose alpha such that Hk.u = alpha ek
    842                double akk   = wjacobian[k][pk];
    843                double alpha = (akk > 0) ? -FastMath.sqrt(ak2) : FastMath.sqrt(ak2);
    844                double betak = 1.0 / (ak2 - akk * alpha);
    845                beta[pk]     = betak;
    846
    847                // transform the current column
    848                diagR[pk]        = alpha;
    849                wjacobian[k][pk] -= alpha;
    850
    851                // transform the remaining columns
    852                for (int dk = cols - 1 - k; dk > 0; --dk) {
    853                    double gamma = 0;
    854                    for (int j = k; j < wjacobian.length; ++j) {
    855                        gamma += wjacobian[j][pk] * wjacobian[j][permutation[k + dk]];
    856                    }
    857                    gamma *= betak;
    858                    for (int j = k; j < wjacobian.length; ++j) {
    859                        wjacobian[j][permutation[k + dk]] -= gamma * wjacobian[j][pk];
    860                    }
    861                }
    862
    863            }
    864
    865            rank = solvedCols;
    866
    867        }
    868
    869        /**
    870         * Compute the product Qt.y for some Q.R. decomposition.
    871         *
    872         * @param y vector to multiply (will be overwritten with the result)
    873         */
    874        private void qTy(double[] y) {
    875            for (int k = 0; k < cols; ++k) {
    876                int pk = permutation[k];
    877                double gamma = 0;
    878                for (int i = k; i < rows; ++i) {
    879                    gamma += wjacobian[i][pk] * y[i];
    880                }
    881                gamma *= beta[pk];
    882                for (int i = k; i < rows; ++i) {
    883                    y[i] -= gamma * wjacobian[i][pk];
    884                }
    885            }
    886        }
    887
    888    }