optim_private_snls.c

ASUFIT－Matlab－全局拟合程序

                 */
                } else {
                    mxDestroyArray(a_);
                    if (mlfTobool(mlfLe(ratio, mlfScalar(.25)))) {
                        /*
                         * delta = min(nrmsx/4,delta/4);
                         */
                        mlfAssign(
                          &delta,
                          mlfMin(
                            NULL,
                            mlfMrdivide(nrmsx, mlfScalar(4.0)),
                            mlfMrdivide(delta, mlfScalar(4.0)),
                            NULL));
                    }
                }
            /*
             * end
             */
            }
            /*
             * if isinf(newval) 
             */
            if (mlfTobool(mlfIsinf(newval))) {
                /*
                 * delta = min(nrmsx/20,delta/20); 
                 */
                mlfAssign(
                  &delta,
                  mlfMin(
                    NULL,
                    mlfMrdivide(nrmsx, mlfScalar(20.0)),
                    mlfMrdivide(delta, mlfScalar(20.0)),
                    NULL));
            /*
             * end
             */
            }
            /*
             * 
             * %       Update
             * if newval < val
             */
            if (mlfTobool(mlfLt(newval, val))) {
                /*
                 * xold = x; 
                 */
                mlfAssign(&xold, x);
                /*
                 * x=newx; 
                 */
                mlfAssign(&x, newx);
                /*
                 * val = newval; 
                 */
                mlfAssign(&val, newval);
                /*
                 * g= newgrad; 
                 */
                mlfAssign(&g, newgrad);
                /*
                 * A = newA; 
                 */
                mlfAssign(&A, newA);
                /*
                 * Z = [];
                 */
                mlfAssign(&Z, mclCreateEmptyArray());
                /*
                 * fvec = newfvec;
                 */
                mlfAssign(fvec, newfvec);
                /*
                 * 
                 * %          Extract the Newton direction?
                 * if pp == 2, 
                 */
                if (mlfTobool(mlfEq(pp, mlfScalar(2.0)))) {
                    /*
                     * dnewt = newfvec(1:n,2); 
                     */
                    mlfAssign(
                      &dnewt,
                      mlfIndexRef(
                        newfvec,
                        "(?,?)",
                        mlfColon(mlfScalar(1.0), n, NULL),
                        mlfScalar(2.0)));
                /*
                 * end
                 */
                }
            /*
             * end
             */
            }
            /*
             * it=it+1; 
             */
            mlfAssign(&it, mlfPlus(it, mlfScalar(1.0)));
            /*
             * vval(it,1) = val;
             */
            mlfIndexAssign(&vval, "(?,?)", it, mlfScalar(1.0), val);
        /*
         * end
         */
        }
        /*
         * if it > itb 
         */
        if (mlfTobool(mlfGt(it, itb))) {
            /*
             * ex=4; EXITFLAG = 0;
             */
            mlfAssign(&ex, mlfScalar(4.0));
            mlfAssign(EXITFLAG, mlfScalar(0.0));
            /*
             * it = it-1; 
             */
            mlfAssign(&it, mlfMinus(it, mlfScalar(1.0)));
            /*
             * if verb > 0
             */
            if (mlfTobool(mlfGt(verb, mlfScalar(0.0)))) {
                /*
                 * disp('Maximum number of iterations exceeded;')
                 */
                mlfDisp(
                  mxCreateString("Maximum number of iterations exceeded;"));
                /*
                 * disp('   increase options.MaxIter')
                 */
                mlfDisp(mxCreateString("   increase options.MaxIter"));
            /*
             * end       
             */
            }
        /*
         * end
         */
        }
        /*
         * if numFunEvals > maxfunevals 
         */
        if (mlfTobool(mlfGt(numFunEvals, maxfunevals))) {
            /*
             * ex=4; EXITFLAG = 0;
             */
            mlfAssign(&ex, mlfScalar(4.0));
            mlfAssign(EXITFLAG, mlfScalar(0.0));
            /*
             * it = it - 1;
             */
            mlfAssign(&it, mlfMinus(it, mlfScalar(1.0)));
            /*
             * if verb > 0
             */
            if (mlfTobool(mlfGt(verb, mlfScalar(0.0)))) {
                /*
                 * disp('Maximum number of function evaluations exceeded;')
                 */
                mlfDisp(
                  mxCreateString(
                    "Maximum number of function evaluations exceeded;"));
                /*
                 * disp('   increase options.MaxFunEvals')
                 */
                mlfDisp(mxCreateString("   increase options.MaxFunEvals"));
            /*
             * end       
             */
            }
        /*
         * end
         */
        }
    /*
     * end
     */
    }
    /*
     * %
     * %   Display
     * if showstat > 1 
     */
    if (mlfTobool(mlfGt(showstat, mlfScalar(1.0)))) {
        /*
         * display1('final',figtr);
         */
        mclAssignAns(
          &ans,
          mlfOptim_private_display1(
            mclAnsVarargout(), mxCreateString("final"), figtr, NULL));
    /*
     * end
     */
    }
    /*
     * if showstat 
     */
    if (mlfTobool(showstat)) {
        /*
         * xplot(it,vval,voptnrm,vflops,vpos,vdeg,vpcg);
         */
        mclAssignAns(
          &ans,
          mlfOptim_private_xplot(it, vval, voptnrm, vflops, vpos, vdeg, vpcg));
    /*
     * end
     */
    }
    /*
     * JACOB = sparse(A);     % A is the Jacobian, not the gradient.
     */
    mlfAssign(JACOB, mlfSparse(A, NULL, NULL, NULL, NULL, NULL));
    /*
     * OUTPUT.firstorderopt = optnrm;
     */
    mlfIndexAssign(OUTPUT, ".firstorderopt", optnrm);
    /*
     * OUTPUT.iterations = it;
     */
    mlfIndexAssign(OUTPUT, ".iterations", it);
    /*
     * OUTPUT.funcCount = numFunEvals;
     */
    mlfIndexAssign(OUTPUT, ".funcCount", numFunEvals);
    /*
     * OUTPUT.cgiterations = npcg;
     */
    mlfIndexAssign(OUTPUT, ".cgiterations", npcg);
    /*
     * OUTPUT.algorithm = 'large-scale: trust-region reflective Newton'; 
     */
    mlfIndexAssign(
      OUTPUT,
      ".algorithm",
      mxCreateString("large-scale: trust-region reflective Newton"));
    /*
     * xcurr(:)=x;
     */
    mlfIndexAssign(&xcurr, "(?)", mlfCreateColonIndex(), x);
    /*
     * 
     * if computeLambda
     */
    if (mlfTobool(computeLambda)) {
        /*
         * LAMBDA.lower = zeros(length(l),1);
         */
        mlfIndexAssign(
          LAMBDA, ".lower", mlfZeros(mlfLength(l), mlfScalar(1.0), NULL));
        /*
         * LAMBDA.upper = zeros(length(u),1);
         */
        mlfIndexAssign(
          LAMBDA, ".upper", mlfZeros(mlfLength(u), mlfScalar(1.0), NULL));
        /*
         * argl = logical(abs(x-l) < active_tol);
         */
        mlfAssign(&argl, mlfLogical(mlfLt(mlfAbs(mlfMinus(x, l)), active_tol)));
        /*
         * argu = logical(abs(x-u) < active_tol);
         */
        mlfAssign(&argu, mlfLogical(mlfLt(mlfAbs(mlfMinus(x, u)), active_tol)));
        /*
         * 
         * g = full(g);
         */
        mlfAssign(&g, mlfFull(g));
        /*
         * 
         * LAMBDA.lower(argl) = (g(argl));
         */
        mlfIndexAssign(LAMBDA, ".lower(?)", argl, mlfIndexRef(g, "(?)", argl));
        /*
         * LAMBDA.upper(argu) = -(g(argu));
         */
        mlfIndexAssign(
          LAMBDA, ".upper(?)", argu, mlfUminus(mlfIndexRef(g, "(?)", argu)));
    /*
     * else
     */
    } else {
        /*
         * LAMBDA = [];
         */
        mlfAssign(LAMBDA, mclCreateEmptyArray());
    /*
     * end
     */
    }
    mclValidateOutputs(
      "optim/private/snls",
      6,
      nargout_,
      &xcurr,
      fvec,
      LAMBDA,
      JACOB,
      EXITFLAG,
      OUTPUT);
    mxDestroyArray(A);
    mxDestroyArray(D);
    mxDestroyArray(DS);
    mxDestroyArray(Z);
    mxDestroyArray(active_tol);
    mxDestroyArray(ans);
    mxDestroyArray(arg);
    mxDestroyArray(arg2);
    mxDestroyArray(argl);
    mxDestroyArray(argu);
    mxDestroyArray(aug);
    mxDestroyArray(bndfeas);
    mxDestroyArray(currOutput);
    mxDestroyArray(dd);
    mxDestroyArray(degen);
    mxDestroyArray(del);
    mxDestroyArray(delbnd);
    mxDestroyArray(delta);
    mxDestroyArray(diff);
    mxDestroyArray(dnewt);
    mxDestroyArray(dv);
    mxDestroyArray(errmsg);
    mxDestroyArray(ex);
    mxDestroyArray(fdata);
    mxDestroyArray(figtr);
    mxDestroyArray(findiffevals);
    mxDestroyArray(formatstr);
    mxDestroyArray(g);
    mxDestroyArray(gopt);
    mxDestroyArray(grad);
    mxDestroyArray(gradflag);
    mxDestroyArray(group);
    mxDestroyArray(header);
    mxDestroyArray(it);
    mxDestroyArray(itb);
    mxDestroyArray(kmax);
    mxDestroyArray(l);
    mxDestroyArray(lsotframe);
    mxDestroyArray(maxfunevals);
    mxDestroyArray(mm);
    mxDestroyArray(mtxmpy);
    mxDestroyArray(n);
    mxDestroyArray(nbnds);
    mxDestroyArray(newA);
    mxDestroyArray(newfvec);
    mxDestroyArray(newgrad);
    mxDestroyArray(newval);
    mxDestroyArray(newx);
    mxDestroyArray(npcg);
    mxDestroyArray(nrmsx);
    mxDestroyArray(numFunEvals);
    mxDestroyArray(numGradEvals);
    mxDestroyArray(numberOfVariables);
    mxDestroyArray(oposdef);
    mxDestroyArray(optnrm);
    mxDestroyArray(oval);
    mxDestroyArray(p);
    mxDestroyArray(pcflags);
    mxDestroyArray(pcgit);
    mxDestroyArray(pcgtol);
    mxDestroyArray(pcmtx);
    mxDestroyArray(pert);
    mxDestroyArray(posdef);
    mxDestroyArray(pp);
    mxDestroyArray(prev_diff);
    mxDestroyArray(qp);
    mxDestroyArray(r);
    mxDestroyArray(ratio);
    mxDestroyArray(showstat);
    mxDestroyArray(snod);
    mxDestroyArray(sx);
    mxDestroyArray(theta);
    mxDestroyArray(tol);
    mxDestroyArray(tol1);
    mxDestroyArray(tol2);
    mxDestroyArray(totls);
    mxDestroyArray(typx);
    mxDestroyArray(u);
    mxDestroyArray(v);
    mxDestroyArray(val);
    mxDestroyArray(vdeg);
    mxDestroyArray(vflops);
    mxDestroyArray(voptnrm);
    mxDestroyArray(vpcg);
    mxDestroyArray(vpos);
    mxDestroyArray(vval);
    mxDestroyArray(warnstr);
    mxDestroyArray(x);
    mxDestroyArray(xold);
    mxDestroyArray(xstart);
    /*
     * 
     * 
     * 
     * 
     * 
     * 
     */
    return xcurr;
}

/*
 * The functi