卷积码BCJR实现

因为在快变信道下，矩阵H进行带状处理后，状态数可以减少。所以可以用减少状态数的MAP算法来实现均衡器的软输出。而MAP算法可以根据BCJR算法来实现。
BCJR算法最初是应用于卷积码的译码软输出，因此先学习在卷积码的情况下BCJR算法的实现。

void CViterbi::Malloc()
{
    int t,s,i,j,edge_cnt;
    int temp,temp_out;
    int state_temp,sub_state;
    m_num_trellis=5;
    m_num_input_bits=1;            //输入比特数 1
    m_num_output_bits=2;           //输出比特数 2
    m_num_reg=2;                   //寄存器数 2
    m_num_input=1<<m_num_input_bits;         //输入比特状态0,1
    m_num_output=1<<m_num_output_bits;
    m_num_state=1<<m_num_reg;               //trellis图状态数
     m_edge_no=m_num_input*m_num_state;     //边标号                                                  

    m_in_lable=new int [m_edge_no];         //输入标签{0 ,1, 0 ,1, 0,1,0,1}
    m_left_vertex=new int [m_edge_no];      //左边状态 {00,00,01,01,10,10,11,11}
    m_right_vertex=new int [m_edge_no];    //右边状态 {00,10,00,10,01,11,01,11}
    m_out_lable=new int [m_edge_no];      //输出标签{00,11,11,00,10,01,01,10}

    m_G=new int [m_num_output_bits];     //生成多项式
    m_G[0]=7;                                                    //g0=1 1 1
    m_G[1]=5;                                                    //g1=1 0 1

    m_input_bit=new int [m_num_input];  //输入比特[0,1]
    m_input_bit[0]=0;
    m_input_bit[1]=1;

    m_output_bit=new int *[m_num_output];
    for(i=0;i<m_num_output;i++)
        m_output_bit[i]=new int [m_num_output_bits];
    m_output_bit[0][0]=0;   m_output_bit[0][1]=0;
    m_output_bit[1][0]=0;   m_output_bit[1][1]=1;
    m_output_bit[2][0]=1;   m_output_bit[2][1]=0;
    m_output_bit[3][0]=1;   m_output_bit[3][1]=1;

     m_delta=new double *[m_num_output];
     m_gama=new double *[m_edge_no];
     for(i=0;i<m_num_output;i++)
          m_delta[i]=new double[m_num_trellis];

     for(i=0;i<m_edge_no;i++)
         m_gama[i]=new double [m_num_trellis];
     m_difference=new double**[m_num_state];
     for(s=0;s<m_num_state;s++){
          m_difference[s]=new double *[m_num_trellis+1];
          for(t=0;t<=m_num_trellis;t++)
              m_difference[s][t]=new double[m_num_input];
     }

     m_edge_to_state=new int*[m_num_state];
     for(s=0;s<m_num_state;s++)
         m_edge_to_state[s]=new int [m_num_input];

    //trellis的构建
     state_temp=0;                                  //临时状态
     sub_state=0;
     temp=0;
     edge_cnt=0;
     for(s=0;s<m_num_state;s++)
     {
         sub_state=s;
         for(i=0;i<m_num_input;i++){
               m_left_vertex[edge_cnt]=sub_state;  //当前状态
               m_in_lable[edge_cnt]=i;             //当前输入
               m_out_lable[edge_cnt] = 0;
               m_right_vertex[edge_cnt] = 0;       //初始化都是0

               state_temp=(m_input_bit[i]<<m_num_reg)+sub_state;
               temp_out=0;
               for(j=0;j<m_num_output_bits;j++){   //第1,2个输出 
                     temp=BitDotProd(state_temp,m_G[j],m_num_reg+1);      
                    temp_out=( temp_out<<1)+temp; //输出码字比特                                       
               }
               m_out_lable[edge_cnt]=(m_out_lable[edge_cnt])^temp_out;   //输出码字
               m_right_vertex[edge_cnt]=(m_right_vertex[edge_cnt]<<m_num_reg)+ state_temp>>1;  //新状态 m_right_vertex[edge_cnt]初始时都是零       
               edge_cnt++;
         }
     }

     for(s=0;s<m_num_state;s++){
         edge_cnt=0;
         for(i=0;i<m_edge_no;i++){
             if(m_right_vertex[i]==s){
                m_edge_to_state[s][edge_cnt]=i; //到达s状态存储的边号                    
                edge_cnt++;
             }
         }
     }

     m_backtrace=new int **[m_num_state];
     for(s=0;s<m_num_state;s++){
         m_backtrace[s]=new int *[m_num_trellis];
         for(t=0;t<m_num_trellis;t++){
                  m_backtrace[s][t]=new int [m_num_input];
         }
     }

} 

//编码
void CViterbi::Encode(int *uu,int *cc)
{
    int i,t,input,output,state;
    state=0;
    for(t=0;t<m_num_trellis;t++){
         input=uu[t];                     //输入
         for(i=0;i<m_edge_no;i++){
            if(m_left_vertex[i]==state&& m_in_lable[i]==input)
                 output= m_out_lable[i];
                 state=m_right_vertex[i];
                 break;
         }
         for(i=0;i<m_num_output_bits;i++)
             uu[t*m_num_output_bits+i]=m_output_bit[output][i];

    }
    m_end_s = state;    //把最后的状态当做已知的结束状态
}

“`