viterbi_decode.c

vitebi算法的程序

                                                mclVe(
                                                  mclArrayRef2(
                                                    mclVsa(GEN, "GEN"),
                                                    mlfScalar(v_1),
                                                    mlfCreateColonIndex())))),
                                            NULL)),
                                        _mxarray4_));
                                    if (v_1 == e_1) {
                                        break;
                                    }
                                    ++v_1;
                                }
                                mlfAssign(&ii, mlfScalar(v_1));
                            }
                        }
                        if (v_0 == e_0) {
                            break;
                        }
                        ++v_0;
                    }
                    mlfAssign(&j, mlfScalar(v_0));
                }
                if (v_ == e_) {
                    break;
                }
                ++v_;
            }
            mlfAssign(&i, mlfScalar(v_));
        }
    }
    /*
     * y=y*2-1;%{-1,+1}
     */
    mlfAssign(&y, mclMinus(mclMtimes(mclVv(y, "y"), _mxarray4_), _mxarray5_));
    /*
     * 
     * if select==1  %hard decison
     */
    if (mclEqBool(mclVa(select, "select"), _mxarray5_)) {
        /*
         * code=sign(code);
         */
        mlfAssign(&code, mlfSign(mclVa(code, "code")));
    /*
     * end
     */
    }
    /*
     * 
     * %beginning decoding from initial state 0
     * metirc(1)=0;
     */
    mclIntArrayAssign1(&metirc, _mxarray8_, 1);
    /*
     * metric(2:state_num)=-10000;
     */
    mclArrayAssign1(
      &metric,
      _mxarray9_,
      mlfColon(_mxarray4_, mclVv(state_num, "state_num"), NULL));
    /*
     * for bit=1:frame_length
     */
    {
        int v_ = mclForIntStart(1);
        int e_ = mclForIntEnd(mclVv(frame_length, "frame_length"));
        if (v_ > e_) {
            mlfAssign(&bit, _mxarray6_);
        } else {
            /*
             * for i=1:state_num
             * for j=1:2^k
             * path_value(i,j)=metric(rem((i-1)*2,state_num)+j)+...
             * sum(code(n*(bit-1)+1:n*(bit-1)+n).*y(fix((i-1)*2/state_num)+1,1:n,rem((i-1)*2,state_num)+j));
             * end
             * end
             * for i=1:state_num
             * if path_value(i,1)>path_value(i,2)
             * metric(i)=path_value(i,1);
             * history(i,bit)=0;
             * else
             * metric(i)=path_value(i,2);
             * history(i,bit)=1;
             * end
             * end
             * end
             */
            for (; ; ) {
                int v_2 = mclForIntStart(1);
                int e_2 = mclForIntEnd(mclVv(state_num, "state_num"));
                if (v_2 > e_2) {
                    mlfAssign(&i, _mxarray6_);
                } else {
                    for (; ; ) {
                        int v_3 = mclForIntStart(1);
                        int e_3
                          = mclForIntEnd(mclMpower(_mxarray4_, mclVa(k, "k")));
                        if (v_3 > e_3) {
                            mlfAssign(&j, _mxarray6_);
                        } else {
                            for (; ; ) {
                                mclIntArrayAssign2(
                                  &path_value,
                                  mclPlus(
                                    mclVe(
                                      mclArrayRef1(
                                        mclVsv(metric, "metric"),
                                        mclPlus(
                                          mclVe(
                                            mlfRem(
                                              mclMtimes(
                                                mlfScalar(v_2 - 1), _mxarray4_),
                                              mclVv(state_num, "state_num"))),
                                          mlfScalar(v_3)))),
                                    mclVe(
                                      mlfSum(
                                        mclTimes(
                                          mclVe(
                                            mclArrayRef1(
                                              mclVsa(code, "code"),
                                              mlfColon(
                                                mclPlus(
                                                  mclMtimes(
                                                    mclVa(n, "n"),
                                                    mlfScalar(v_ - 1)),
                                                  _mxarray5_),
                                                mclPlus(
                                                  mclMtimes(
                                                    mclVa(n, "n"),
                                                    mlfScalar(v_ - 1)),
                                                  mclVa(n, "n")),
                                                NULL))),
                                          mclVe(
                                            mlfIndexRef(
                                              mclVsv(y, "y"),
                                              "(?,?,?)",
                                              mclPlus(
                                                mclVe(
                                                  mlfFix(
                                                    mclMrdivide(
                                                      mclMtimes(
                                                        mlfScalar(v_2 - 1),
                                                        _mxarray4_),
                                                      mclVv(
                                                        state_num,
                                                        "state_num")))),
                                                _mxarray5_),
                                              mlfColon(
                                                _mxarray5_,
                                                mclVa(n, "n"),
                                                NULL),
                                              mclPlus(
                                                mclVe(
                                                  mlfRem(
                                                    mclMtimes(
                                                      mlfScalar(v_2 - 1),
                                                      _mxarray4_),
                                                    mclVv(
                                                      state_num, "state_num"))),
                                                mlfScalar(v_3))))),
                                        NULL))),
                                  v_2,
                                  v_3);
                                if (v_3 == e_3) {
                                    break;
                                }
                                ++v_3;
                            }
                            mlfAssign(&j, mlfScalar(v_3));
                        }
                        if (v_2 == e_2) {
                            break;
                        }
                        ++v_2;
                    }
                    mlfAssign(&i, mlfScalar(v_2));
                }
                {
                    int v_4 = mclForIntStart(1);
                    int e_4 = mclForIntEnd(mclVv(state_num, "state_num"));
                    if (v_4 > e_4) {
                        mlfAssign(&i, _mxarray6_);
                    } else {
                        for (; ; ) {
                            if (mclGtBool(
                                  mclVe(
                                    mclIntArrayRef2(
                                      mclVsv(path_value, "path_value"),
                                      v_4,
                                      1)),
                                  mclVe(
                                    mclIntArrayRef2(
                                      mclVsv(path_value, "path_value"),
                                      v_4,
                                      2)))) {
                                mclIntArrayAssign1(
                                  &metric,
                                  mclIntArrayRef2(
                                    mclVsv(path_value, "path_value"), v_4, 1),
                                  v_4);
                                mclIntArrayAssign2(
                                  &history, _mxarray8_, v_4, v_);
                            } else {
                                mclIntArrayAssign1(
                                  &metric,
                                  mclIntArrayRef2(
                                    mclVsv(path_value, "path_value"), v_4, 2),
                                  v_4);
                                mclIntArrayAssign2(
                                  &history, _mxarray5_, v_4, v_);
                            }
                            if (v_4 == e_4) {
                                break;
                            }
                            ++v_4;
                        }
                        mlfAssign(&i, mlfScalar(v_4));
                    }
                }
                if (v_ == e_) {
                    break;
                }
                ++v_;
            }
            mlfAssign(&bit, mlfScalar(v_));
        }
    }
    /*
     * 
     * search=1;%searching the emit branch from last state S1
     */
    mlfAssign(&search, _mxarray5_);
    /*
     * for bit=frame_length-(N-1):-1:1
     */
    {
        mclForLoopIterator viter__;
        for (mclForStart(
               &viter__,
               mclMinus(
                 mclVv(frame_length, "frame_length"),
                 mclMinus(mclVa(N, "N"), _mxarray5_)),
               _mxarray7_,
               _mxarray5_);
             mclForNext(&viter__, &bit);
             ) {
            /*
             * output(bit)=history(search,bit+N-1);
             */
            mclArrayAssign1(
              &output,
              mclArrayRef2(
                mclVsv(history, "history"),
                mclVsv(search, "search"),
                mclMinus(
                  mclPlus(mclVv(bit, "bit"), mclVa(N, "N")), _mxarray5_)),
              mclVsv(bit, "bit"));
            /*
             * search=rem((search-1)*2,state_num)+1+output(bit);
             */
            mlfAssign(
              &search,
              mclPlus(
                mclPlus(
                  mclVe(
                    mlfRem(
                      mclMtimes(
                        mclMinus(mclVv(search, "search"), _mxarray5_),
                        _mxarray4_),
                      mclVv(state_num, "state_num"))),
                  _mxarray5_),
                mclVe(
                  mclArrayRef1(mclVsv(output, "output"), mclVsv(bit, "bit")))));
        /*
         * end
         */
        }
        mclDestroyForLoopIterator(viter__);
    }
    mclValidateOutput(output, 1, nargout_, "output", "viterbi_decode");
    mxDestroyArray(state_num);
    mxDestroyArray(frame_length);
    mxDestroyArray(i);
    mxDestroyArray(deci);
    mxDestroyArray(j);
    mxDestroyArray(state);
    mxDestroyArray(a);
    mxDestroyArray(ii);
    mxDestroyArray(y);
    mxDestroyArray(metirc);
    mxDestroyArray(metric);
    mxDestroyArray(bit);
    mxDestroyArray(path_value);
    mxDestroyArray(history);
    mxDestroyArray(search);
    mxDestroyArray(select);
    mxDestroyArray(GEN);
    mxDestroyArray(N);
    mxDestroyArray(k);
    mxDestroyArray(n);
    mxDestroyArray(code);
    mclSetCurrentLocalFunctionTable(save_local_function_table_);
    return output;
    /*
     * 
     */
}