卷积码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<//输入比特状态0,1
    m_num_output=1<1<//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;inew 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;inew double[m_num_trellis];

     for(i=0;inew double [m_num_trellis];
     m_difference=new double**[m_num_state];
     for(s=0;snew 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;snew int [m_num_input];

    //trellis的构建
     state_temp=0;                                  //临时状态
     sub_state=0;
     temp=0;
     edge_cnt=0;
     for(s=0;sfor(i=0;i//当前状态
               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]<0;
               for(j=0;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]<>1;  //新状态 m_right_vertex[edge_cnt]初始时都是零       
               edge_cnt++;
         }
     }

     for(s=0;s0;
         for(i=0;iif(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;snew int *[m_num_trellis];
         for(t=0;tnew int [m_num_input];
         }
     }

} 

//编码
void CViterbi::Encode(int *uu,int *cc)
{
    int i,t,input,output,state;
    state=0;
    for(t=0;t//输入
         for(i=0;iif(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]=m_output_bit[output][i];

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

“`