sfdnls.c

ASUFIT－Matlab－全局拟合程序

            /*
             * A = sparse(i,j,full(val),m,n);
             */
            mlfAssign(&A, mlfSparse(i, j, mlfFull(val), m, n, NULL));
            /*
             * J = J + A;
             */
            mlfAssign(&J, mlfPlus(J, A));
        /*
         * end
         */
        }
    /*
     * else % ncol ==n
     */
    } else {
        /*
         * J = full(J);
         */
        mlfAssign(&J, mlfFull(J));
        /*
         * for k = 1:n
         */
        for (mclForStart(&iterator_0, mlfScalar(1.0), n, NULL);
             mclForNext(&iterator_0, &k);
             ) {
            /*
             * if nargin < 5
             */
            if (mlfTobool(mlfLt(nargin_, mlfScalar(5.0)))) {
                /*
                 * xnrm = norm(x(k));
                 */
                mlfAssign(&xnrm, mlfNorm(mlfIndexRef(x, "(?)", k), NULL));
                /*
                 * xnrm = max(xnrm,1);
                 */
                mlfAssign(&xnrm, mlfMax(NULL, xnrm, mlfScalar(1.0), NULL));
                /*
                 * alpha(k) = alpha(k)*xnrm;
                 */
                mlfIndexAssign(
                  &alpha,
                  "(?)",
                  k,
                  mlfMtimes(mlfIndexRef(alpha, "(?)", k), xnrm));
            /*
             * end
             */
            }
            /*
             * y = x;
             */
            mlfAssign(&y, x);
            /*
             * y(k) = y(k) + alpha(k);
             */
            mlfIndexAssign(
              &y,
              "(?)",
              k,
              mlfPlus(mlfIndexRef(y, "(?)", k), mlfIndexRef(alpha, "(?)", k)));
            /*
             * %v = feval(fun,y,fdata);
             * xcurr(:) = y;  % reshape for userfunction
             */
            mlfIndexAssign(&xcurr, "(?)", mlfCreateColonIndex(), y);
            /*
             * v = feval(fun,xcurr,varargin{:});
             */
            mlfAssign(
              &v,
              mlfFeval(
                mclValueVarargout(),
                mclFevalLookup(fun, 0, NULL),
                xcurr,
                mlfIndexRef(varargin, "{?}", mlfCreateColonIndex()),
                NULL));
            /*
             * if ~isempty(YDATA)
             */
            if (mlfTobool(mlfNot(mlfIsempty(YDATA)))) {
                /*
                 * v = v - YDATA;
                 */
                mlfAssign(&v, mlfMinus(v, YDATA));
            /*
             * end
             */
            }
            /*
             * v = v(:);
             */
            mlfAssign(&v, mlfIndexRef(v, "(?)", mlfCreateColonIndex()));
            /*
             * J(:,k) = (v-valx)/alpha(k);
             */
            mlfIndexAssign(
              &J,
              "(?,?)",
              mlfCreateColonIndex(),
              k,
              mlfMrdivide(mlfMinus(v, valx), mlfIndexRef(alpha, "(?)", k)));
        /*
         * end
         */
        }
    /*
     * end
     */
    }
    mclValidateOutputs("sfdnls", 2, nargout_, &J, ncol);
    mxDestroyArray(A);
    mxDestroyArray(YDATA);
    mxDestroyArray(alpha);
    mxDestroyArray(cols);
    mxDestroyArray(d);
    mxDestroyArray(epsi);
    mxDestroyArray(i);
    mxDestroyArray(ind);
    mxDestroyArray(j);
    mxDestroyArray(k);
    mxDestroyArray(lpoint);
    mxDestroyArray(m);
    mxDestroyArray(n);
    mxDestroyArray(nargin_);
    mxDestroyArray(p);
    mxDestroyArray(v);
    mxDestroyArray(val);
    mxDestroyArray(w);
    mxDestroyArray(x);
    mxDestroyArray(xcurr);
    mxDestroyArray(xnrm);
    mxDestroyArray(y);
    /*
     * 
     * 
     */
    return J;
}

/*
 * The function "mlfSfdnls" contains the normal interface for the "sfdnls"
 * M-function from file "C:\MATLABR11\toolbox\optim\sfdnls.m" (lines 1-89).
 * This function processes any input arguments and passes them to the
 * implementation version of the function, appearing above.
 */
mxArray * mlfSfdnls(mxArray * * ncol,
                    mxArray * xcurr,
                    mxArray * valx,
                    mxArray * Jstr,
                    mxArray * group,
                    mxArray * alpha,
                    mxArray * fun,
                    mxArray * YDATA,
                    ...) {
    mxArray * varargin = mclUnassigned();
    int nargout = 1;
    mxArray * J = mclGetUninitializedArray();
    mxArray * ncol__ = mclGetUninitializedArray();
    mlfVarargin(&varargin, YDATA, 0);
    mlfEnterNewContext(
      1, -8, ncol, xcurr, valx, Jstr, group, alpha, fun, YDATA, varargin);
    if (ncol != NULL) {
        ++nargout;
    }
    J
      = Msfdnls(
          &ncol__,
          nargout,
          xcurr,
          valx,
          Jstr,
          group,
          alpha,
          fun,
          YDATA,
          varargin);
    mlfRestorePreviousContext(
      1, 7, ncol, xcurr, valx, Jstr, group, alpha, fun, YDATA);
    mxDestroyArray(varargin);
    if (ncol != NULL) {
        mclCopyOutputArg(ncol, ncol__);
    } else {
        mxDestroyArray(ncol__);
    }
    return mlfReturnValue(J);
}

/*
 * The function "mlxSfdnls" contains the feval interface for the "sfdnls"
 * M-function from file "C:\MATLABR11\toolbox\optim\sfdnls.m" (lines 1-89). The
 * feval function calls the implementation version of sfdnls through this
 * function. This function processes any input arguments and passes them to the
 * implementation version of the function, appearing above.
 */
void mlxSfdnls(int nlhs, mxArray * plhs[], int nrhs, mxArray * prhs[]) {
    mxArray * mprhs[8];
    mxArray * mplhs[2];
    int i;
    if (nlhs > 2) {
        mlfError(
          mxCreateString(
            "Run-time Error: File: sfdnls Line: 1 Column: "
            "0 The function \"sfdnls\" was called with mor"
            "e than the declared number of outputs (2)"));
    }
    for (i = 0; i < 2; ++i) {
        mplhs[i] = NULL;
    }
    for (i = 0; i < 7 && i < nrhs; ++i) {
        mprhs[i] = prhs[i];
    }
    for (; i < 7; ++i) {
        mprhs[i] = NULL;
    }
    mlfEnterNewContext(
      0,
      7,
      mprhs[0],
      mprhs[1],
      mprhs[2],
      mprhs[3],
      mprhs[4],
      mprhs[5],
      mprhs[6]);
    mprhs[7] = NULL;
    mlfAssign(&mprhs[7], mclCreateVararginCell(nrhs - 7, prhs + 7));
    mplhs[0]
      = Msfdnls(
          &mplhs[1],
          nlhs,
          mprhs[0],
          mprhs[1],
          mprhs[2],
          mprhs[3],
          mprhs[4],
          mprhs[5],
          mprhs[6],
          mprhs[7]);
    mlfRestorePreviousContext(
      0,
      7,
      mprhs[0],
      mprhs[1],
      mprhs[2],
      mprhs[3],
      mprhs[4],
      mprhs[5],
      mprhs[6]);
    plhs[0] = mplhs[0];
    for (i = 1; i < 2 && i < nlhs; ++i) {
        plhs[i] = mplhs[i];
    }
    for (; i < 2; ++i) {
        mxDestroyArray(mplhs[i]);
    }
    mxDestroyArray(mprhs[7]);
}