lsqnonlin.c

ASUFIT－Matlab－全局拟合程序

        /*
         * 
         * % trust region and not enough equations -- switch to line_search
         * elseif ~line_search & nfun < numberOfVariables 
         */
        } else {
            mxDestroyArray(a_);
            {
                mxArray * a_ = mclInitialize(mlfNot(line_search));
                if (mlfTobool(a_)
                    && mlfTobool(mlfAnd(a_, mlfLt(nfun, numberOfVariables)))) {
                    mxDestroyArray(a_);
                    /*
                     * warnstr = sprintf('%s\n%s\n', ...
                     */
                    mlfAssign(
                      &warnstr,
                      mlfSprintf(
                        NULL,
                        mxCreateString("%s\\n%s\\n"),
                        mxCreateString(
                          "Large-scale method requires at least"
                          " as many equations as variables; "),
                        mxCreateString(
                          "   switching to line-search method instead."
                          "  Upper and lower bounds will be ignored."),
                        NULL));
                    /*
                     * 'Large-scale method requires at least as many equations as variables; ',...
                     * '   switching to line-search method instead.  Upper and lower bounds will be ignored.');
                     * warning(warnstr);
                     */
                    mclAssignAns(&ans, mlfWarning(NULL, warnstr));
                    /*
                     * OUTPUT.algorithm = medium; 
                     */
                    mlfIndexAssign(OUTPUT, ".algorithm", medium);
                /*
                 * 
                 * % line search and no bounds  
                 * elseif line_search & isempty(l(lFinite)) & isempty(u(uFinite))
                 */
                } else {
                    mxDestroyArray(a_);
                    {
                        mxArray * a_ = mclInitialize(line_search);
                        if (mlfTobool(a_)) {
                            mlfAssign(
                              &a_,
                              mlfAnd(
                                a_,
                                mlfIsempty(mlfIndexRef(l, "(?)", lFinite))));
                        } else {
                            mlfAssign(&a_, mlfScalar(0));
                        }
                        if (mlfTobool(a_)
                            && mlfTobool(
                                 mlfAnd(
                                   a_,
                                   mlfIsempty(
                                     mlfIndexRef(u, "(?)", uFinite))))) {
                            mxDestroyArray(a_);
                            /*
                             * OUTPUT.algorithm = medium; 
                             */
                            mlfIndexAssign(OUTPUT, ".algorithm", medium);
                        /*
                         * 
                         * % line search and  bounds  and enough equations, switch to trust region 
                         * elseif line_search & (~isempty(l(lFinite)) | ~isempty(u(uFinite)))  & nfun >= numberOfVariables
                         */
                        } else {
                            mxDestroyArray(a_);
                            {
                                mxArray * a_ = mclInitialize(line_search);
                                if (mlfTobool(a_)) {
                                    mxArray * b_4 = mclInitialize(
                                                      mlfNot(
                                                        mlfIsempty(
                                                          mlfIndexRef(
                                                            l,
                                                            "(?)",
                                                            lFinite))));
                                    if (mlfTobool(b_4)) {
                                        mlfAssign(&b_4, mlfScalar(1));
                                    } else {
                                        mlfAssign(
                                          &b_4,
                                          mlfOr(
                                            b_4,
                                            mlfNot(
                                              mlfIsempty(
                                                mlfIndexRef(
                                                  u, "(?)", uFinite)))));
                                    }
                                    mlfAssign(&a_, mlfAnd(a_, b_4));
                                    mxDestroyArray(b_4);
                                } else {
                                    mlfAssign(&a_, mlfScalar(0));
                                }
                                if (mlfTobool(a_)
                                    && mlfTobool(
                                         mlfAnd(
                                           a_,
                                           mlfGe(nfun, numberOfVariables)))) {
                                    mxDestroyArray(a_);
                                    /*
                                     * warnstr = sprintf('%s\n%s\n', ...
                                     */
                                    mlfAssign(
                                      &warnstr,
                                      mlfSprintf(
                                        NULL,
                                        mxCreateString("%s\\n%s\\n"),
                                        mxCreateString(
                                          "Line-search method does not "
                                          "handle bound constraints; "),
                                        mxCreateString(
                                          "   switching to large-s"
                                          "cale method instead."),
                                        NULL));
                                    /*
                                     * 'Line-search method does not handle bound constraints; ',...
                                     * '   switching to large-scale method instead.');
                                     * warning(warnstr);
                                     */
                                    mclAssignAns(
                                      &ans, mlfWarning(NULL, warnstr));
                                    /*
                                     * OUTPUT.algorithm = large;
                                     */
                                    mlfIndexAssign(OUTPUT, ".algorithm", large);
                                /*
                                 * 
                                 * % can't handle this one:   
                                 * elseif line_search & (~isempty(l(lFinite)) | ~isempty(u(uFinite)))  & nfun < numberOfVariables
                                 */
                                } else {
                                    mxDestroyArray(a_);
                                    {
                                        mxArray * a_ = mclInitialize(
                                                         line_search);
                                        if (mlfTobool(a_)) {
                                            mxArray * b_0 = mclInitialize(
                                                              mlfNot(
                                                                mlfIsempty(
                                                                  mlfIndexRef(
                                                                    l,
                                                                    "(?)",
                                                                    lFinite))));
                                            if (mlfTobool(b_0)) {
                                                mlfAssign(&b_0, mlfScalar(1));
                                            } else {
                                                mlfAssign(
                                                  &b_0,
                                                  mlfOr(
                                                    b_0,
                                                    mlfNot(
                                                      mlfIsempty(
                                                        mlfIndexRef(
                                                          u,
                                                          "(?)",
                                                          uFinite)))));
                                            }
                                            mlfAssign(&a_, mlfAnd(a_, b_0));
                                            mxDestroyArray(b_0);
                                        } else {
                                            mlfAssign(&a_, mlfScalar(0));
                                        }
                                        if (mlfTobool(a_)
                                            && mlfTobool(
                                                 mlfAnd(
                                                   a_,
                                                   mlfLt(
                                                     nfun,
                                                     numberOfVariables)))) {
                                            mxDestroyArray(a_);
                                            /*
                                             * errstr = sprintf('%s\n%s\n%s\n', ...
                                             */
                                            mlfAssign(
                                              &errstr,
                                              mlfSprintf(
                                                NULL,
                                                mxCreateString(
                                                  "%s\\n%s\\n%s\\n"),
                                                mxCreateString(
                                                  "Line-search method does not "
                                                  "handle bound constraints "),
                                                mxCreateString(
                                                  "   and large-scale method "
                                                  "requires at least as many "
                                                  "equations as variables; "),
                                                mxCreateString("   aborting."),
                                                NULL));
                                            /*
                                             * 'Line-search method does not handle bound constraints ',...
                                             * '   and large-scale method requires at least as many equations as variables; ',...
                                             * '   aborting.');
                                             * error(errstr);  
                                             */
                                            mlfError(errstr);
                                        } else {
                                            mxDestroyArray(a_);
                                        }
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    /*
     * end
     */
    }
    /*
     * 
     * if diagnostics > 0
     */
    if (mlfTobool(mlfGt(diagnostics, mlfScalar(0.0)))) {
        /*
         * % Do diagnostics on information so far
         * constflag = 0; gradconstflag = 0; non_eq=0;non_ineq=0;lin_eq=0;lin_ineq=0;
         */
        mlfAssign(&constflag, mlfScalar(0.0));
        mlfAssign(&gradconstflag, mlfScalar(0.0));
        mlfAssign(&non_eq, mlfScalar(0.0));
        mlfAssign(&non_ineq, mlfScalar(0.0));
        mlfAssign(&lin_eq, mlfScalar(0.0));
        mlfAssign(&lin_ineq, mlfScalar(0.0));
        /*
         * confcn{1}=[];c=[];ceq=[];cGRAD=[];ceqGRAD=[];
         */
        mlfIndexAssign(&confcn, "{?}", mlfScalar(1.0), mclCreateEmptyArray());
        mlfAssign(&c, mclCreateEmptyArray());
        mlfAssign(&ceq, mclCreateEmptyArray());
        mlfAssign(&cGRAD, mclCreateEmptyArray());
        mlfAssign(&ceqGRAD, mclCreateEmptyArray());
        /*
         * hessflag = 0; HESS=[];
         */
        mlfAssign(&hessflag, mlfScalar(0.0));
        mlfAssign(&HESS, mclCreateEmptyArray());
        /*
         * msg = diagnose(caller,OUTPUT,gradflag,hessflag,constflag,gradconstflag,...
         */
        mlfAssign(
          &msg,
          mlfOptim_private_diagnose(
            caller,
            *OUTPUT,
            gradflag,
            hessflag,
            constflag,
            gradconstflag,
            line_search,
            options,
            xstart,
            non_eq,
            non_ineq,
            lin_eq,
            lin_ineq,
            l,
            u,
            funfcn,
            confcn,
            f,
            JAC,
            HESS,
            c,
            ceq,
            cGRAD,
            ceqGRAD));
    /*
     * line_search,options,xstart,non_eq,...
     * non_ineq,lin_eq,lin_ineq,l,u,funfcn,confcn,f,JAC,HESS,c,ceq,cGRAD,ceqGRAD);
     * end
     */
    }
    /*
     * 
     * % Execute algorithm
     * if isequal(OUTPUT.algorithm, large)
     */
    if (mlfTobool(
          mlfFeval(
            mclValueVarargout(),
            mlxIsequal,
            mlfIndexRef(*OUTPUT, ".algorithm"),
            large,
            NULL))) {
        /*
         * if ~gradflag % provide sparsity of Jacobian if not provided.
         */
        if (mlfTobool(mlfNot(gradflag))) {
            /*
             * Jstr = optimget(options,'JacobPattern',[]);
             */
            mlfAssign(
              &Jstr,
              mlfOptimget(
                options,
                mxCreateString("JacobPattern"),
                mclCreateEmptyArray()));
            /*
             * if isempty(Jstr)
             */
            if (mlfTobool(mlfIsempty(Jstr))) {
                /*
                 * % Put this code separate as it might generate OUT OF MEMORY error
                 * Jstr = sparse(ones(Jrows,Jcols));
                 */
                mlfAssign(
                  &Jstr,
                  mlfSparse(
                    mlfOnes(Jrows, Jcols, NULL), NULL, NULL, NULL, NULL, NULL));
            /*
             * end
             */
            }
        /*
         * else
         */
        } else {
            /*
             * Jstr = [];
             */
            mlfAssign(&Jstr, mclCreateEmptyArray());
        /*
         * end
         */
        }
        /*
         * [x,FVAL,LAMBDA,JACOB,EXITFLAG,OUTPUT]=...
         * snls(funfcn,x,l,u,verbosity,options,f,JAC,YDATA,caller,Jstr,computeLambda,varargin{:});
         */
        mlfAssign(
          &x,
          mlfOptim_private_snls(
            FVAL,
            LAMBDA,
            JACOB,
            EXITFLAG,
            OUTPUT,
            funfcn,
            x,
            l,
            u,
            verbosity,
            options,
            f,
            JAC,
            YDATA,
            caller,
            Jstr,
            computeLambda,
            mlfIndexRef(varargin, "{?}", mlfCreateColonIndex()),
            NULL));
    /*
     * else 
     */
    } else {
        /*
         * [x,FVAL,JACOB,EXITFLAG,OUTPUT] = ...