calcjejj.c

nnToolKit 神经网络工具包是基于 MATLAB 神经网络工具箱自行开发的一组神经网络算法函数库

     * %
     * % Em - sum(Vi)xQ matrix
     * % Ex - sum(Vi)*Q vector
     * % Jx - XLenxsum(Vi)*Q matrix
     * %
     * % Outputs
     * %
     * % JE - XLen vector
     * % JJ - XLenxXLen matrix
     * 
     * % Standard Calculation
     * if (MR == 1)
     */
    if (mclEqBool(mclVa(MR, "MR"), _mxarray0_)) {
        /*
         * Em = cell2mat(En);
         */
        mlfAssign(&Em, mlfCell2mat(mclVa(En, "En")));
        /*
         * Ex = Em(:);
         */
        mlfAssign(&Ex, mclArrayRef1(mclVv(Em, "Em"), mlfCreateColonIndex()));
        /*
         * Jx = calcjx(net,Pd,Zb,Zi,Zl,N,Ac,Q,TS);
         */
        mlfAssign(
          &Jx,
          mlfCalcjx(
            mclVa(net, "net"),
            mclVa(Pd, "Pd"),
            mclVa(Zb, "Zb"),
            mclVa(Zi, "Zi"),
            mclVa(Zl, "Zl"),
            mclVa(N, "N"),
            mclVa(Ac, "Ac"),
            mclVa(Q, "Q"),
            mclVa(TS, "TS")));
        /*
         * JE = Jx * Ex;
         */
        mlfAssign(&JE, mclMtimes(mclVv(Jx, "Jx"), mclVv(Ex, "Ex")));
        /*
         * JJ = Jx * Jx';
         */
        mlfAssign(
          JJ,
          mlf_times_transpose(mclVv(Jx, "Jx"), mclVv(Jx, "Jx"), _mxarray1_));
    /*
     * 
     * % Reduced Memory Calculation
     * else
     */
    } else {
        /*
         * MR = min(MR,Q);
         */
        mlfAssign(&MR, mlfMin(NULL, mclVa(MR, "MR"), mclVa(Q, "Q"), NULL));
        /*
         * Qstop = floor((1:MR)*(Q/MR));
         */
        mlfAssign(
          &Qstop,
          mlfFloor(
            mclMtimes(
              mlfColon(_mxarray0_, mclVa(MR, "MR"), NULL),
              mclMrdivide(mclVa(Q, "Q"), mclVa(MR, "MR")))));
        /*
         * Qstart = [0 Qstop(1:(end-1))]+1;
         */
        mlfAssign(
          &Qstart,
          mclPlus(
            mlfHorzcat(
              _mxarray2_,
              mclArrayRef1(
                mclVv(Qstop, "Qstop"),
                mlfColon(
                  _mxarray0_,
                  mclMinus(
                    mlfEnd(mclVv(Qstop, "Qstop"), _mxarray0_, _mxarray0_),
                    _mxarray0_),
                  NULL)),
              NULL),
            _mxarray0_));
        /*
         * Q2 = Qstop-Qstart+1;
         */
        mlfAssign(
          &Q2,
          mclPlus(
            mclMinus(mclVv(Qstop, "Qstop"), mclVv(Qstart, "Qstart")),
            _mxarray0_));
        /*
         * 
         * Pd = batchdiv(Pd,MR,Qstart,Qstop);
         */
        mlfAssign(
          &Pd,
          mlfCalcjejj_batchdiv(
            mclVa(Pd, "Pd"),
            mclVa(MR, "MR"),
            mclVv(Qstart, "Qstart"),
            mclVv(Qstop, "Qstop")));
        /*
         * Zb = batchdiv(Zb,MR,Qstart,Qstop);
         */
        mlfAssign(
          &Zb,
          mlfCalcjejj_batchdiv(
            mclVa(Zb, "Zb"),
            mclVa(MR, "MR"),
            mclVv(Qstart, "Qstart"),
            mclVv(Qstop, "Qstop")));
        /*
         * Zi = batchdiv(Zi,MR,Qstart,Qstop);
         */
        mlfAssign(
          &Zi,
          mlfCalcjejj_batchdiv(
            mclVa(Zi, "Zi"),
            mclVa(MR, "MR"),
            mclVv(Qstart, "Qstart"),
            mclVv(Qstop, "Qstop")));
        /*
         * Zl = batchdiv(Zl,MR,Qstart,Qstop);
         */
        mlfAssign(
          &Zl,
          mlfCalcjejj_batchdiv(
            mclVa(Zl, "Zl"),
            mclVa(MR, "MR"),
            mclVv(Qstart, "Qstart"),
            mclVv(Qstop, "Qstop")));
        /*
         * N = batchdiv(N,MR,Qstart,Qstop);
         */
        mlfAssign(
          &N,
          mlfCalcjejj_batchdiv(
            mclVa(N, "N"),
            mclVa(MR, "MR"),
            mclVv(Qstart, "Qstart"),
            mclVv(Qstop, "Qstop")));
        /*
         * Ac = batchdiv(Ac,MR,Qstart,Qstop);
         */
        mlfAssign(
          &Ac,
          mlfCalcjejj_batchdiv(
            mclVa(Ac, "Ac"),
            mclVa(MR, "MR"),
            mclVv(Qstart, "Qstart"),
            mclVv(Qstop, "Qstop")));
        /*
         * En = batchdiv(En,MR,Qstart,Qstop);
         */
        mlfAssign(
          &En,
          mlfCalcjejj_batchdiv(
            mclVa(En, "En"),
            mclVa(MR, "MR"),
            mclVv(Qstart, "Qstart"),
            mclVv(Qstop, "Qstop")));
        /*
         * 
         * Em = cell2mat(En{1});
         */
        mlfAssign(
          &Em,
          mclFeval(
            mclValueVarargout(),
            mlxCell2mat,
            mlfIndexRef(mclVa(En, "En"), "{?}", _mxarray0_),
            NULL));
        /*
         * Ex = Em(:);
         */
        mlfAssign(&Ex, mclArrayRef1(mclVv(Em, "Em"), mlfCreateColonIndex()));
        /*
         * Jx = calcjx(net,Pd{1},Zb{1},Zi{1},Zl{1},N{1},Ac{1},Q2(1),TS);
         */
        mlfAssign(
          &Jx,
          mclFeval(
            mclValueVarargout(),
            mlxCalcjx,
            mclVa(net, "net"),
            mlfIndexRef(mclVa(Pd, "Pd"), "{?}", _mxarray0_),
            mlfIndexRef(mclVa(Zb, "Zb"), "{?}", _mxarray0_),
            mlfIndexRef(mclVa(Zi, "Zi"), "{?}", _mxarray0_),
            mlfIndexRef(mclVa(Zl, "Zl"), "{?}", _mxarray0_),
            mlfIndexRef(mclVa(N, "N"), "{?}", _mxarray0_),
            mlfIndexRef(mclVa(Ac, "Ac"), "{?}", _mxarray0_),
            mclIntArrayRef1(mclVv(Q2, "Q2"), 1),
            mclVa(TS, "TS"),
            NULL));
        /*
         * JE = Jx * Ex;
         */
        mlfAssign(&JE, mclMtimes(mclVv(Jx, "Jx"), mclVv(Ex, "Ex")));
        /*
         * JJ = Jx * Jx';
         */
        mlfAssign(
          JJ,
          mlf_times_transpose(mclVv(Jx, "Jx"), mclVv(Jx, "Jx"), _mxarray1_));
        /*
         * for q=2:MR
         */
        {
            int v_ = mclForIntStart(2);
            int e_ = mclForIntEnd(mclVa(MR, "MR"));
            if (v_ > e_) {
                mlfAssign(&q, _mxarray3_);
            } else {
                /*
                 * Em = cell2mat(En{q});
                 * Ex = Em(:);
                 * Jx = calcjx(net,Pd{q},Zb{q},Zi{q},Zl{q},N{q},Ac{q},Q2(q),TS);
                 * JE = JE + Jx * Ex;
                 * JJ = JJ + Jx * Jx';
                 * end
                 */
                for (; ; ) {
                    mlfAssign(
                      &Em,
                      mclFeval(
                        mclValueVarargout(),
                        mlxCell2mat,
                        mlfIndexRef(mclVa(En, "En"), "{?}", mlfScalar(v_)),
                        NULL));
                    mlfAssign(
                      &Ex,
                      mclArrayRef1(mclVv(Em, "Em"), mlfCreateColonIndex()));
                    mlfAssign(
                      &Jx,
                      mclFeval(
                        mclValueVarargout(),
                        mlxCalcjx,
                        mclVa(net, "net"),
                        mlfIndexRef(mclVa(Pd, "Pd"), "{?}", mlfScalar(v_)),
                        mlfIndexRef(mclVa(Zb, "Zb"), "{?}", mlfScalar(v_)),
                        mlfIndexRef(mclVa(Zi, "Zi"), "{?}", mlfScalar(v_)),
                        mlfIndexRef(mclVa(Zl, "Zl"), "{?}", mlfScalar(v_)),
                        mlfIndexRef(mclVa(N, "N"), "{?}", mlfScalar(v_)),
                        mlfIndexRef(mclVa(Ac, "Ac"), "{?}", mlfScalar(v_)),
                        mclIntArrayRef1(mclVv(Q2, "Q2"), v_),
                        mclVa(TS, "TS"),
                        NULL));
                    mlfAssign(
                      &JE,
                      mclPlus(
                        mclVv(JE, "JE"),
                        mclMtimes(mclVv(Jx, "Jx"), mclVv(Ex, "Ex"))));
                    mlfAssign(
                      JJ,
                      mclPlus(
                        mclVv(*JJ, "JJ"),
                        mlf_times_transpose(
                          mclVv(Jx, "Jx"), mclVv(Jx, "Jx"), _mxarray1_)));
                    if (v_ == e_) {
                        break;
                    }
                    ++v_;
                }
                mlfAssign(&q, mlfScalar(v_));
            }
        }
    /*
     * end
     */
    }
    /*
     * 
     * normJE = sqrt(JE'*JE);
     */
    mlfAssign(
      normJE,
      mlfSqrt(
        mlf_times_transpose(mclVv(JE, "JE"), mclVv(JE, "JE"), _mxarray4_)));
    mclValidateOutput(JE, 1, nargout_, "JE", "calcjejj");
    mclValidateOutput(*JJ, 2, nargout_, "JJ", "calcjejj");
    mclValidateOutput(*normJE, 3, nargout_, "normJE", "calcjejj");
    mxDestroyArray(Em);
    mxDestroyArray(Ex);
    mxDestroyArray(Jx);
    mxDestroyArray(Qstop);
    mxDestroyArray(Qstart);
    mxDestroyArray(Q2);
    mxDestroyArray(q);
    mxDestroyArray(MR);
    mxDestroyArray(TS);
    mxDestroyArray(Q);
    mxDestroyArray(En);
    mxDestroyArray(Ac);
    mxDestroyArray(N);
    mxDestroyArray(Zl);
    mxDestroyArray(Zi);
    mxDestroyArray(Zb);
    mxDestroyArray(Pd);
    mxDestroyArray(net);
    mclSetCurrentLocalFunctionTable(save_local_function_table_);
    return JE;
    /*
     * 
     * %===============================================================
     */
}

/*
 * The function "Mcalcjejj_batchdiv" is the implementation version of the
 * "calcjejj/batchdiv" M-function from file
 * "d:\matlab6p5\toolbox\nnet\nnutils\calcjejj.m" (lines 155-172). It contains
 * the actual compiled code for that M-function. It is a static function and
 * must only be called from one of the interface functions, appearing below.
 */
/*
 * function b_div = batchdiv(b,QD,Qstart,Qstop)
 */
static mxArray * Mcalcjejj_batchdiv(int nargout_,
                                    mxArray * b,
                                    mxArray * QD,
                                    mxArray * Qstart,
                                    mxArray * Qstop) {
    mexLocalFunctionTable save_local_function_table_
      = mclSetCurrentLocalFunctionTable(&_local_function_table_calcjejj);
    mxArray * b_div = NULL;
    mxArray * i = NULL;
    mxArray * Qind = NULL;
    mxArray * b_div_q = NULL;
    mxArray * q = NULL;
    mxArray * len_b = NULL;
    mxArray * size_b = NULL;
    mclCopyArray(&b);
    mclCopyArray(&QD);
    mclCopyArray(&Qstart);
    mclCopyArray(&Qstop);
    /*
     * 
     * size_b = size(b);
     */
    mlfAssign(&size_b, mlfSize(mclValueVarargout(), mclVa(b, "b"), NULL));
    /*
     * len_b = prod(size_b);
     */
    mlfAssign(&len_b, mlfProd(mclVv(size_b, "size_b"), NULL));
    /*
     * b_div = cell(1,QD);
     */
    mlfAssign(&b_div, mlfCell(_mxarray0_, mclVa(QD, "QD"), NULL));
    /*
     * for q=1:QD
     */
    {
        int v_ = mclForIntStart(1);
        int e_ = mclForIntEnd(mclVa(QD, "QD"));
        if (v_ > e_) {
            mlfAssign(&q, _mxarray3_);
        } else {
            /*
             * b_div_q = cell(size_b);
             * Qind = Qstart(q):Qstop(q);
             * for i=1:len_b
             * if ~isempty(b{i})
             * b_div_q{i} = b{i}(:,Qind);
             * end
             * end
             * b_div{q} = b_div_q;
             * end
             */
            for (; ; ) {
                mlfAssign(&b_div_q, mlfCell(mclVv(size_b, "size_b"), NULL));
                mlfAssign(
                  &Qind,
                  mlfColon(
                    mclIntArrayRef1(mclVa(Qstart, "Qstart"), v_),
                    mclIntArrayRef1(mclVa(Qstop, "Qstop"), v_),
                    NULL));
                {
                    int v_0 = mclForIntStart(1);
                    int e_0 = mclForIntEnd(mclVv(len_b, "len_b"));
                    if (v_0 > e_0) {
                        mlfAssign(&i, _mxarray3_);
                    } else {
                        for (; ; ) {
                            if (mclNotBool(
                                  mclFeval(
                                    mclValueVarargout(),
                                    mlxIsempty,
                                    mlfIndexRef(
                                      mclVa(b, "b"), "{?}", mlfScalar(v_0)),
                                    NULL))) {
                                mlfIndexAssign(
                                  &b_div_q,
                                  "{?}",
                                  mlfScalar(v_0),
                                  mlfIndexRef(
                                    mclVa(b, "b"),
                                    "{?}(?,?)",
                                    mlfScalar(v_0),
                                    mlfCreateColonIndex(),
                                    mclVv(Qind, "Qind")));
                            }
                            if (v_0 == e_0) {
                                break;
                            }
                            ++v_0;
                        }
                        mlfAssign(&i, mlfScalar(v_0));
                    }
                }
                mlfIndexAssign(
                  &b_div, "{?}", mlfScalar(v_), mclVv(b_div_q, "b_div_q"));
                if (v_ == e_) {
                    break;
                }
                ++v_;
            }
            mlfAssign(&q, mlfScalar(v_));
        }
    }
    mclValidateOutput(b_div, 1, nargout_, "b_div", "calcjejj/batchdiv");
    mxDestroyArray(size_b);
    mxDestroyArray(len_b);
    mxDestroyArray(q);
    mxDestroyArray(b_div_q);
    mxDestroyArray(Qind);
    mxDestroyArray(i);
    mxDestroyArray(Qstop);
    mxDestroyArray(Qstart);
    mxDestroyArray(QD);
    mxDestroyArray(b);
    mclSetCurrentLocalFunctionTable(save_local_function_table_);
    return b_div;
    /*
     * 
     * %===============================================================
     */
}