calcperf.c

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

                        } else if (mclSwitchCompare(v_2, _mxarray7_)) {
                            mlfIndexAssign(
                              N,
                              "{?,?}",
                              mclVv(i, "i"),
                              mlfScalar(v_),
                              mlfIndexRef(mclVv(Z, "Z"), "{?}", _mxarray0_));
                            {
                                int v_4 = mclForIntStart(2);
                                int e_1 = mclLengthInt(mclVv(Z, "Z"));
                                if (v_4 > e_1) {
                                    mlfAssign(&k, _mxarray1_);
                                } else {
                                    for (; ; ) {
                                        mlfIndexAssign(
                                          N,
                                          "{?,?}",
                                          mclVv(i, "i"),
                                          mlfScalar(v_),
                                          mclFeval(
                                            mclValueVarargout(),
                                            mlxTimes,
                                            mlfIndexRef(
                                              mclVv(*N, "N"),
                                              "{?,?}",
                                              mclVv(i, "i"),
                                              mlfScalar(v_)),
                                            mlfIndexRef(
                                              mclVv(Z, "Z"),
                                              "{?}",
                                              mlfScalar(v_4)),
                                            NULL));
                                        if (v_4 == e_1) {
                                            break;
                                        }
                                        ++v_4;
                                    }
                                    mlfAssign(&k, mlfScalar(v_4));
                                }
                            }
                        } else {
                            mlfIndexAssign(
                              N,
                              "{?,?}",
                              mclVv(i, "i"),
                              mlfScalar(v_),
                              mlfFeval(
                                mclValueVarargout(),
                                mlfIndexRef(
                                  mclVv(netInputFcn, "netInputFcn"),
                                  "{?}",
                                  mclVv(i, "i")),
                                mlfIndexRef(
                                  mclVv(Z, "Z"), "{?}", mlfCreateColonIndex()),
                                NULL));
                        }
                        mxDestroyArray(v_2);
                    }
                    {
                        mxArray * v_5
                          = mclInitialize(
                              mlfIndexRef(
                                mclVv(transferFcn, "transferFcn"),
                                "{?}",
                                mclVv(i, "i")));
                        if (mclSwitchCompare(v_5, _mxarray9_)) {
                            mlfIndexAssign(
                              Ac,
                              "{?,?}",
                              mclVv(i, "i"),
                              mclVv(ts2, "ts2"),
                              mlfIndexRef(
                                mclVv(*N, "N"),
                                "{?,?}",
                                mclVv(i, "i"),
                                mlfScalar(v_)));
                        } else if (mclSwitchCompare(v_5, _mxarray11_)) {
                            mlfAssign(
                              &n,
                              mlfIndexRef(
                                mclVv(*N, "N"),
                                "{?,?}",
                                mclVv(i, "i"),
                                mlfScalar(v_)));
                            mlfAssign(
                              &a,
                              mclMinus(
                                mclRdivide(
                                  _mxarray13_,
                                  mclPlus(
                                    _mxarray0_,
                                    mlfExp(
                                      mclMtimes(_mxarray14_, mclVv(n, "n"))))),
                                _mxarray0_));
                            mlfAssign(
                              &k,
                              mlfFind(
                                NULL, NULL, mclNot(mlfFinite(mclVv(a, "a")))));
                            mclArrayAssign1(
                              &a,
                              mlfSign(
                                mclArrayRef1(mclVv(n, "n"), mclVv(k, "k"))),
                              mclVv(k, "k"));
                            mlfIndexAssign(
                              Ac,
                              "{?,?}",
                              mclVv(i, "i"),
                              mclVv(ts2, "ts2"),
                              mclVv(a, "a"));
                        } else if (mclSwitchCompare(v_5, _mxarray15_)) {
                            mlfAssign(
                              &n,
                              mlfIndexRef(
                                mclVv(*N, "N"),
                                "{?,?}",
                                mclVv(i, "i"),
                                mlfScalar(v_)));
                            mlfAssign(
                              &a,
                              mclRdivide(
                                _mxarray0_,
                                mclPlus(
                                  _mxarray0_,
                                  mlfExp(mclUminus(mclVv(n, "n"))))));
                            mlfAssign(
                              &k,
                              mlfFind(
                                NULL, NULL, mclNot(mlfFinite(mclVv(a, "a")))));
                            mclArrayAssign1(
                              &a,
                              mlfSign(
                                mclArrayRef1(mclVv(n, "n"), mclVv(k, "k"))),
                              mclVv(k, "k"));
                            mlfIndexAssign(
                              Ac,
                              "{?,?}",
                              mclVv(i, "i"),
                              mclVv(ts2, "ts2"),
                              mclVv(a, "a"));
                        } else {
                            mlfIndexAssign(
                              Ac,
                              "{?,?}",
                              mclVv(i, "i"),
                              mclVv(ts2, "ts2"),
                              mlfFeval(
                                mclValueVarargout(),
                                mlfIndexRef(
                                  mclVv(transferFcn, "transferFcn"),
                                  "{?}",
                                  mclVv(i, "i")),
                                mlfIndexRef(
                                  mclVv(*N, "N"),
                                  "{?,?}",
                                  mclVv(i, "i"),
                                  mlfScalar(v_)),
                                NULL));
                        }
                        mxDestroyArray(v_5);
                    }
                }
                mclDestroyForLoopIterator(viter__);
                if (v_ == e_) {
                    break;
                }
                ++v_;
            }
            mlfAssign(&ts, mlfScalar(v_));
        }
    }
    /*
     * 
     * % CALCE: E = calce(net,Ac,T,TS);
     * %===============================
     * 
     * E = cell(net.numLayers,TS);
     */
    mlfAssign(
      E,
      mlfCell(
        mlfIndexRef(mclVa(net, "net"), ".numLayers"), mclVa(TS, "TS"), NULL));
    /*
     * 
     * for ts = 1:TS
     */
    {
        int v_ = mclForIntStart(1);
        int e_ = mclForIntEnd(mclVa(TS, "TS"));
        if (v_ > e_) {
            mlfAssign(&ts, _mxarray1_);
        } else {
            /*
             * for i=net.hint.targetInd
             * E{i,ts} = T{i,ts} - Ac{i,ts+numLayerDelays};
             * end
             * end
             */
            for (; ; ) {
                mclForLoopIterator viter__;
                for (mclForStart(
                       &viter__,
                       mlfIndexRef(mclVa(net, "net"), ".hint.targetInd"),
                       NULL,
                       NULL);
                     mclForNext(&viter__, &i);
                     ) {
                    mlfIndexAssign(
                      E,
                      "{?,?}",
                      mclVv(i, "i"),
                      mlfScalar(v_),
                      mclFeval(
                        mclValueVarargout(),
                        mlxMinus,
                        mlfIndexRef(
                          mclVa(T, "T"), "{?,?}", mclVv(i, "i"), mlfScalar(v_)),
                        mlfIndexRef(
                          mclVv(*Ac, "Ac"),
                          "{?,?}",
                          mclVv(i, "i"),
                          mclPlus(
                            mlfScalar(v_),
                            mclVv(numLayerDelays, "numLayerDelays"))),
                        NULL));
                }
                mclDestroyForLoopIterator(viter__);
                if (v_ == e_) {
                    break;
                }
                ++v_;
            }
            mlfAssign(&ts, mlfScalar(v_));
        }
    }
    /*
     * 
     * % Performance
     * %============
     * 
     * performFcn = net.performFcn;
     */
    mlfAssign(&performFcn, mlfIndexRef(mclVa(net, "net"), ".performFcn"));
    /*
     * if length(performFcn) ==0
     */
    if (mclLengthInt(mclVv(performFcn, "performFcn")) == 0) {
        /*
         * performFcn = 'nullpf';
         */
        mlfAssign(&performFcn, _mxarray17_);
    /*
     * end
     */
    }
    /*
     * perf = feval(performFcn,E,X,net.performParam);
     */
    mlfAssign(
      &perf,
      mlfFeval(
        mclValueVarargout(),
        mclVv(performFcn, "performFcn"),
        mclVv(*E, "E"),
        mclVa(X, "X"),
        mlfIndexRef(mclVa(net, "net"), ".performParam"),
        NULL));
    mclValidateOutput(perf, 1, nargout_, "perf", "calcperf");
    mclValidateOutput(*E, 2, nargout_, "E", "calcperf");
    mclValidateOutput(*Ac, 3, nargout_, "Ac", "calcperf");
    mclValidateOutput(*N, 4, nargout_, "N", "calcperf");
    mclValidateOutput(*BZ, 5, nargout_, "BZ", "calcperf");
    mclValidateOutput(*IWZ, 6, nargout_, "IWZ", "calcperf");
    mclValidateOutput(*LWZ, 7, nargout_, "LWZ", "calcperf");
    mxDestroyArray(ones1xQ);
    mxDestroyArray(i);
    mxDestroyArray(numLayerDelays);
    mxDestroyArray(inputConnectFrom);
    mxDestroyArray(layerConnectFrom);
    mxDestroyArray(biasConnectFrom);
    mxDestroyArray(inputWeightFcn);
    mxDestroyArray(layerWeightFcn);
    mxDestroyArray(netInputFcn);
    mxDestroyArray(transferFcn);
    mxDestroyArray(layerDelays);
    mxDestroyArray(IW);
    mxDestroyArray(LW);
    mxDestroyArray(ts);
    mxDestroyArray(ts2);
    mxDestroyArray(inputInds);
    mxDestroyArray(j);
    mxDestroyArray(layerInds);
    mxDestroyArray(thisLayerDelays);
    mxDestroyArray(Ad);
    mxDestroyArray(Z);
    mxDestroyArray(k);
    mxDestroyArray(n);
    mxDestroyArray(a);
    mxDestroyArray(performFcn);
    mxDestroyArray(TS);
    mxDestroyArray(Q);
    mxDestroyArray(Ai);
    mxDestroyArray(T);
    mxDestroyArray(PD);
    mxDestroyArray(X);
    mxDestroyArray(net);
    mclSetCurrentLocalFunctionTable(save_local_function_table_);
    return perf;
}