optim_private_nlsq.c

ASUFIT－Matlab－全局拟合程序

        } else {
            mxArray * a_ = mclInitialize(
                             mlfLt(
                               mlfMtimes(mlfCtranspose(GradF), SD), tolFun));
            if (mlfTobool(a_)
                && mlfTobool(
                     mlfAnd(
                       a_,
                       mlfLt(
                         mlfMax(NULL, mlfAbs(GradF), NULL, NULL),
                         mlfMtimes(
                           mlfScalar(10.0), mlfPlus(tolFun, tolX)))))) {
                mxDestroyArray(a_);
                /*
                 * max(abs(GradF)) < 10*(tolFun+tolX)
                 * if verbosity > 0
                 */
                if (mlfTobool(mlfGt(verbosity, mlfScalar(0.0)))) {
                    /*
                     * disp('Optimization terminated successfully:') 
                     */
                    mlfDisp(
                      mxCreateString("Optimization terminated successfully:"));
                    /*
                     * disp(' Gradient in the search direction less than tolFun') 
                     */
                    mlfDisp(
                      mxCreateString(
                        " Gradient in the search direction less than tolFun"));
                    /*
                     * disp(' Gradient less than 10*(tolFun+tolX)')  
                     */
                    mlfDisp(
                      mxCreateString(" Gradient less than 10*(tolFun+tolX)"));
                /*
                 * end
                 */
                }
                /*
                 * status=1; EXITFLAG=1;
                 */
                mlfAssign(&status, mlfScalar(1.0));
                mlfAssign(EXITFLAG, mlfScalar(1.0));
            /*
             * 
             * elseif numFunEvals > maxFunEvals
             */
            } else {
                mxDestroyArray(a_);
                if (mlfTobool(mlfGt(numFunEvals, maxFunEvals))) {
                    /*
                     * if verbosity>0
                     */
                    if (mlfTobool(mlfGt(verbosity, mlfScalar(0.0)))) {
                        /*
                         * disp('maximum number of function evaluations has been exceeded');
                         */
                        mlfDisp(
                          mxCreateString(
                            "maximum number of function eva"
                            "luations has been exceeded"));
                        /*
                         * disp('Increase OPTIONS.maxFunEvals')
                         */
                        mlfDisp(mxCreateString("Increase OPTIONS.maxFunEvals"));
                    /*
                     * end
                     */
                    }
                    /*
                     * status=1;
                     */
                    mlfAssign(&status, mlfScalar(1.0));
                    /*
                     * EXITFLAG = 0;
                     */
                    mlfAssign(EXITFLAG, mlfScalar(0.0));
                /*
                 * elseif iter > maxIter
                 */
                } else if (mlfTobool(mlfGt(iter, maxIter))) {
                    /*
                     * if verbosity>0
                     */
                    if (mlfTobool(mlfGt(verbosity, mlfScalar(0.0)))) {
                        /*
                         * disp('maximum number of iterations has been exceeded');
                         */
                        mlfDisp(
                          mxCreateString(
                            "maximum number of iterations has been exceeded"));
                        /*
                         * disp('Increase OPTIONS.iterations')
                         */
                        mlfDisp(mxCreateString("Increase OPTIONS.iterations"));
                    /*
                     * end
                     */
                    }
                    /*
                     * status=1;
                     */
                    mlfAssign(&status, mlfScalar(1.0));
                    /*
                     * EXITFLAG = 0;
                     */
                    mlfAssign(EXITFLAG, mlfScalar(0.0));
                /*
                 * else
                 */
                } else {
                    /*
                     * % Line search using mixed polynomial interpolation and extrapolation.
                     * if PCNT~=0
                     */
                    if (mlfTobool(mlfNe(PCNT, mlfScalar(0.0)))) {
                        /*
                         * % initialize OX and OLDF 
                         * OX = XOUT; OLDF = CostFunction;
                         */
                        mlfAssign(&OX, XOUT);
                        mlfAssign(&OLDF, *CostFunction);
                        /*
                         * while PCNT > 0 & OPT_STOP == 0 & numFunEvals <= maxFunEvals
                         */
                        for (;;) {
                            mxArray * a_ = mclInitialize(
                                             mlfGt(PCNT, mlfScalar(0.0)));
                            if (mlfTobool(a_)) {
                                mlfAssign(
                                  &a_,
                                  mlfAnd(a_, mlfEq(OPT_STOP, mlfScalar(0.0))));
                            } else {
                                mlfAssign(&a_, mlfScalar(0));
                            }
                            if (mlfTobool(a_)
                                && mlfTobool(
                                     mlfAnd(
                                       a_, mlfLe(numFunEvals, maxFunEvals)))) {
                                mxDestroyArray(a_);
                            } else {
                                mxDestroyArray(a_);
                                break;
                            }
                            /*
                             * x(:) = XOUT; 
                             */
                            mlfIndexAssign(
                              &x, "(?)", mlfCreateColonIndex(), XOUT);
                            /*
                             * CostFunction = feval(funfcn{3},x,varargin{:});
                             */
                            mlfAssign(
                              CostFunction,
                              mlfFeval(
                                mclValueVarargout(),
                                mclFevalLookup(
                                  mlfIndexRef(funfcn, "{?}", mlfScalar(3.0)),
                                  1,
                                  local_function_table_),
                                x,
                                mlfIndexRef(
                                  varargin, "{?}", mlfCreateColonIndex()),
                                NULL));
                            /*
                             * if ~isempty(YDATA)
                             */
                            if (mlfTobool(mlfNot(mlfIsempty(YDATA)))) {
                                /*
                                 * CostFunction = CostFunction - YDATA;
                                 */
                                mlfAssign(
                                  CostFunction, mlfMinus(*CostFunction, YDATA));
                            /*
                             * end
                             */
                            }
                            /*
                             * CostFunction = CostFunction(:);
                             */
                            mlfAssign(
                              CostFunction,
                              mlfIndexRef(
                                *CostFunction, "(?)", mlfCreateColonIndex()));
                            /*
                             * numFunEvals=numFunEvals+1;
                             */
                            mlfAssign(
                              &numFunEvals,
                              mlfPlus(numFunEvals, mlfScalar(1.0)));
                            /*
                             * NewF = CostFunction'*CostFunction;
                             */
                            mlfAssign(
                              &NewF,
                              mlfMtimes(
                                mlfCtranspose(*CostFunction), *CostFunction));
                            /*
                             * % <= used in case when no improvement found.
                             * if NewF <= OLDF'*OLDF, 
                             */
                            if (mlfTobool(
                                  mlfLe(
                                    NewF,
                                    mlfMtimes(mlfCtranspose(OLDF), OLDF)))) {
                                /*
                                 * OX = XOUT; 
                                 */
                                mlfAssign(&OX, XOUT);
                                /*
                                 * OLDF=CostFunction; 
                                 */
                                mlfAssign(&OLDF, *CostFunction);
                            /*
                             * end
                             */
                            }
                            /*
                             * [PCNT,MATL,MATX,steplen,NewF,how]=searchq(PCNT,NewF,OLDX,MATL,MATX,SD,GDOLD,currstepsize,how);
                             */
                            mlfAssign(
                              &PCNT,
                              mlfSearchq(
                                &MATL,
                                &MATX,
                                &steplen,
                                &NewF,
                                &how,
                                PCNT,
                                NewF,
                                OLDX,
                                MATL,
                                MATX,
                                SD,
                                GDOLD,
                                currstepsize,
                                how));
                            /*
                             * currstepsize=steplen;
                             */
                            mlfAssign(&currstepsize, steplen);
                            /*
                             * XOUT=OLDX+steplen*SD;
                             */
                            mlfAssign(
                              &XOUT, mlfPlus(OLDX, mlfMtimes(steplen, SD)));
                            /*
                             * if NewF==FIRSTF,  
                             */
                            if (mlfTobool(mlfEq(NewF, FIRSTF))) {
                                /*
                                 * PCNT=0; 
                                 */
                                mlfAssign(&PCNT, mlfScalar(0.0));
                            /*
                             * end
                             */
                            }
                        /*
                         * end % end while
                         */
                        }
                        /*
                         * XOUT = OX;
                         */
                        mlfAssign(&XOUT, OX);
                        /*
                         * CostFunction=OLDF;
                         */
                        mlfAssign(CostFunction, OLDF);
                        /*
                         * if numFunEvals>maxFunEvals 
                         */
                        if (mlfTobool(mlfGt(numFunEvals, maxFunEvals))) {
                            /*
                             * if verbosity > 0
                             */
                            if (mlfTobool(mlfGt(verbosity, mlfScalar(0.0)))) {
                                /*
                                 * disp('Maximum number of function evaluations exceeded;')
                                 */
                                mlfDisp(
                                  mxCreateString(
                                    "Maximum number of function"
                                    " evaluations exceeded;"));
                                /*
                                 * disp('   increase maxFunEvals.')
                                 */
                                mlfDisp(
                                  mxCreateString("   increase maxFunEvals."));
                            /*
                             * end              
                             */
                            }
                            /*
                             * status=1; 
                             */
                            mlfAssign(&status, mlfScalar(1.0));
                            /*
                             * EXITFLAG = 0;
                             */
                            mlfAssign(EXITFLAG, mlfScalar(0.0));
                        /*
                         * end
                         */
                        }
                    /*
                     * end % if PCNT~=0
                     */
                    }
                }
            }
        /*
         * end % if max
         */
        }
        /*
         * OPT_STEP = 1; % Call the next iteration a major step for plotting etc.
         */
        mlfAssign(&OPT_STEP, mlfScalar(1.0));
        /*
         * 
         * x(:)=XOUT; 
         */
        mlfIndexAssign(&x, "(?)", mlfCreateColonIndex(), XOUT);
        /*
         * switch funfcn{1}
         */
        {
            mxArray * t_ = mclUnassigned();
            mlfAssign(&t_, mlfIndexRef(funfcn, "{?}", mlfScalar(1.0)));
            /*
             * case 'fun'
             */
            if (mclSwitchCompare(t_, mxCreateString("fun"))) {
                /*
                 * CostFunction =