optim_private_snls.c

ASUFIT－Matlab－全局拟合程序

    /*
     * 
     * %   Main loop: Generate feas. seq. x(it) s.t. ||F(x(it)|| is decreasing.
     * while ~ex 
     */
    while (mlfTobool(mlfNot(ex))) {
        /*
         * if any(~isfinite(fvec)) 
         */
        if (mlfTobool(mlfAny(mlfNot(mlfIsfinite(*fvec)), NULL))) {
            /*
             * errmsg= sprintf('%s%s%s',caller,' cannot continue: ',...
             */
            mlfAssign(
              &errmsg,
              mlfSprintf(
                NULL,
                mxCreateString("%s%s%s"),
                caller,
                mxCreateString(" cannot continue: "),
                mxCreateString("user function is returning Inf or NaN values."),
                NULL));
            /*
             * 'user function is returning Inf or NaN values.');
             * error(errmsg)
             */
            mlfError(errmsg);
        /*
         * end
         */
        }
        /*
         * 
         * %  Stop (Interactive)?
         * figtr=findobj('type','figure','Name','Progress Information');
         */
        mlfAssign(
          &figtr,
          mlfFindobj(
            mxCreateString("type"),
            mxCreateString("figure"),
            mxCreateString("Name"),
            mxCreateString("Progress Information"),
            NULL));
        /*
         * if ~isempty(figtr)
         */
        if (mlfTobool(mlfNot(mlfIsempty(figtr)))) {
            /*
             * lsotframe = findobj(figtr,'type','uicontrol',...
             */
            mlfAssign(
              &lsotframe,
              mlfFindobj(
                figtr,
                mxCreateString("type"),
                mxCreateString("uicontrol"),
                mxCreateString("Userdata"),
                mxCreateString("LSOT frame"),
                NULL));
            /*
             * 'Userdata','LSOT frame') ;
             * if get(lsotframe,'Value'), 
             */
            if (mlfTobool(mlfGet(lsotframe, mxCreateString("Value"), NULL))) {
                /*
                 * ex = 10 % New exiting condition 
                 */
                mlfAssign(&ex, mlfScalar(10.0));
                mclPrintArray(ex, "ex");
                /*
                 * EXITFLAG = -1;
                 */
                mlfAssign(EXITFLAG, mlfScalar(-1.0));
                /*
                 * if verb > 0
                 */
                if (mlfTobool(mlfGt(verb, mlfScalar(0.0)))) {
                    /*
                     * display('Exiting per request.')
                     */
                    mlfDisp(mxCreateString("Exiting per request."));
                /*
                 * end       
                 */
                }
            /*
             * end 
             */
            }
        /*
         * end 
         */
        }
        /*
         * 
         * % Update 
         * [v,dv] = definev(g,x,l,u); 
         */
        mlfAssign(&v, mlfOptim_private_definev(&dv, g, x, l, u));
        /*
         * gopt = v.*g;
         */
        mlfAssign(&gopt, mlfTimes(v, g));
        /*
         * optnrm = norm(gopt,inf);
         */
        mlfAssign(&optnrm, mlfNorm(gopt, mlfInf()));
        /*
         * voptnrm(it,1) = optnrm; 
         */
        mlfIndexAssign(&voptnrm, "(?,?)", it, mlfScalar(1.0), optnrm);
        /*
         * r = abs(min(u-x,x-l));
         */
        mlfAssign(
          &r, mlfAbs(mlfMin(NULL, mlfMinus(u, x), mlfMinus(x, l), NULL)));
        /*
         * degen = min(r + abs(g));
         */
        mlfAssign(&degen, mlfMin(NULL, mlfPlus(r, mlfAbs(g)), NULL, NULL));
        /*
         * vdeg(it,1) = min(degen,1);
         */
        mlfIndexAssign(
          &vdeg,
          "(?,?)",
          it,
          mlfScalar(1.0),
          mlfMin(NULL, degen, mlfScalar(1.0), NULL));
        /*
         * if ~nbnds 
         */
        if (mlfTobool(mlfNot(nbnds))) {
            /*
             * degen = -1; 
             */
            mlfAssign(&degen, mlfScalar(-1.0));
        /*
         * end
         */
        }
        /*
         * bndfeas = min(min(x-l,u-x));
         */
        mlfAssign(
          &bndfeas,
          mlfMin(
            NULL,
            mlfMin(NULL, mlfMinus(x, l), mlfMinus(u, x), NULL),
            NULL,
            NULL));
        /*
         * % Display
         * if showstat > 1
         */
        if (mlfTobool(mlfGt(showstat, mlfScalar(1.0)))) {
            /*
             * display1('progress',it,optnrm,val,pcgit,...
             */
            mclAssignAns(
              &ans,
              mlfOptim_private_display1(
                mclAnsVarargout(),
                mxCreateString("progress"),
                it,
                optnrm,
                val,
                pcgit,
                npcg,
                degen,
                bndfeas,
                showstat,
                nbnds,
                x,
                g,
                l,
                u,
                figtr,
                NULL));
        /*
         * npcg,degen,bndfeas,showstat,nbnds,x,g,l,u,figtr);
         * end
         */
        }
        /*
         * if verb > 1
         */
        if (mlfTobool(mlfGt(verb, mlfScalar(1.0)))) {
            /*
             * currOutput = sprintf(formatstr,it,numFunEvals,val,nrmsx,optnrm,pcgit);
             */
            mlfAssign(
              &currOutput,
              mlfSprintf(
                NULL,
                formatstr,
                it,
                numFunEvals,
                val,
                nrmsx,
                optnrm,
                pcgit,
                NULL));
            /*
             * disp(currOutput);
             */
            mlfDisp(currOutput);
        /*
         * end
         */
        }
        /*
         * 
         * %     Test for convergence
         * diff = abs(oval-val); 
         */
        mlfAssign(&diff, mlfAbs(mlfMinus(oval, val)));
        /*
         * prev_diff = diff; 
         */
        mlfAssign(&prev_diff, diff);
        /*
         * oval = val; 
         */
        mlfAssign(&oval, val);
        /*
         * vflops(it,1) = flops; 
         */
        mlfIndexAssign(&vflops, "(?,?)", it, mlfScalar(1.0), mlfFlops(NULL));
        /*
         * if (nrmsx < .9*delta)&(ratio > .25)&(diff < tol1*(1+abs(oval)))
         */
        {
            mxArray * a_ = mclInitialize(
                             mlfLt(nrmsx, mlfMtimes(mlfScalar(.9), delta)));
            if (mlfTobool(a_)) {
                mlfAssign(&a_, mlfAnd(a_, mlfGt(ratio, mlfScalar(.25))));
            } else {
                mlfAssign(&a_, mlfScalar(0));
            }
            if (mlfTobool(a_)
                && mlfTobool(
                     mlfAnd(
                       a_,
                       mlfLt(
                         diff,
                         mlfMtimes(
                           tol1, mlfPlus(mlfScalar(1.0), mlfAbs(oval))))))) {
                mxDestroyArray(a_);
                /*
                 * ex = 1;
                 */
                mlfAssign(&ex, mlfScalar(1.0));
                /*
                 * if verb > 0
                 */
                if (mlfTobool(mlfGt(verb, mlfScalar(0.0)))) {
                    /*
                     * disp('Optimization terminated successfully:')
                     */
                    mlfDisp(
                      mxCreateString("Optimization terminated successfully:"));
                    /*
                     * disp(' Relative function value changing by less than OPTIONS.TolFun');
                     */
                    mlfDisp(
                      mxCreateString(
                        " Relative function value changin"
                        "g by less than OPTIONS.TolFun"));
                /*
                 * end
                 */
                }
                /*
                 * EXITFLAG = 1;
                 */
                mlfAssign(EXITFLAG, mlfScalar(1.0));
            /*
             * elseif (it > 1) & (nrmsx < tol2), 
             */
            } else {
                mxDestroyArray(a_);
                {
                    mxArray * a_ = mclInitialize(mlfGt(it, mlfScalar(1.0)));
                    if (mlfTobool(a_)
                        && mlfTobool(mlfAnd(a_, mlfLt(nrmsx, tol2)))) {
                        mxDestroyArray(a_);
                        /*
                         * ex = 2;   EXITFLAG = 1;
                         */
                        mlfAssign(&ex, mlfScalar(2.0));
                        mlfAssign(EXITFLAG, mlfScalar(1.0));
                        /*
                         * if verb > 0
                         */
                        if (mlfTobool(mlfGt(verb, mlfScalar(0.0)))) {
                            /*
                             * disp('Optimization terminated successfully:')
                             */
                            mlfDisp(
                              mxCreateString(
                                "Optimization terminated successfully:"));
                            /*
                             * disp(' Norm of the current step is less than OPTIONS.TolX');
                             */
                            mlfDisp(
                              mxCreateString(
                                " Norm of the current step i"
                                "s less than OPTIONS.TolX"));
                        /*
                         * end
                         */
                        }
                    /*
                     * 
                     * elseif ((optnrm < tol1) & (posdef ==1) ),  
                     */
                    } else {
                        mxDestroyArray(a_);
                        {
                            mxArray * a_ = mclInitialize(mlfLt(optnrm, tol1));
                            if (mlfTobool(a_)
                                && mlfTobool(
                                     mlfAnd(
                                       a_, mlfEq(posdef, mlfScalar(1.0))))) {
                                mxDestroyArray(a_);
                                /*
                                 * ex = 3;   EXITFLAG = 1;
                                 */
                                mlfAssign(&ex, mlfScalar(3.0));
                                mlfAssign(EXITFLAG, mlfScalar(1.0));
                                /*
                                 * if verb > 0
                                 */
                                if (mlfTobool(mlfGt(verb, mlfScalar(0.0)))) {
                                    /*
                                     * disp('Optimization terminated successfully:')
                                     */
                                    mlfDisp(
                                      mxCreateString(
                                        "Optimization termina"
                                        "ted successfully:"));
                                    /*
                                     * disp(' First-order optimality less than OPTIONS.TolFun, and no zero curvature detected');
                                     */
                                    mlfDisp(
                                      mxCreateString(
                                        " First-order optimality less"
                                        " than OPTIONS.TolFun, and no"
                                        " zero curvature detected"));
                                /*
                                 * end
                                 */
                                }
                            /*
                             * 
                             * elseif it > itb, 
                             */
                            } else {
                                mxDestroyArray(a_);
                                if (mlfTobool(mlfGt(it, itb))) {
                                    /*
                                     * ex = 4;    EXITFLAG = 0;
                                     */
                                    mlfAssign(&ex, mlfScalar(4.0));
                                    mlfAssign(EXITFLAG, mlfScalar(0.0));
                                    /*
                                     * if verb > 0
                                     */
                                    if (mlfTobool(
                                          mlfGt(verb, mlfScalar(0.0)))) {
                                        /*
                                         * disp('Maximum number of iterations exceeded;')
                                         */
                                        mlfDisp(
                                          mxCreateString(
                                            "Maximum number of ite"
                                            "rations exceeded;"));
                                        /*
                                         * disp('   increase options.MaxIter')
                                         */
                                        mlfDisp(
                                          mxCreateString(
                                            "   increase options.MaxIter"));
                                    /*
                                     * end       
                                     */
                                    }
                                }
                            }
                        }
                    }
                }
            }
        /*
         * end
         */
        }
        /*
         * 
         * %     Continue if ex = 0 (i.e., not done yet)
         * if ~ex 
         */
        if (mlfTobool(mlfNot(ex))) {
            /*
             * %       Determine the trust region correction