rsc_trellis1n.cpp

Turbo 码的logmap算法实现。用于通信系统仿真

//Author NiuKai
//Date  Jan, 11th, 2003
//Function to generate the Trellis for RSC code Rate=1/n

#include "PCCC_para.h"

void RSC_Trellis1n(int Gen_polynomial_numerator[],
                                      int  Gen_polynomial_denominator[],
				                      int Forward_State_Table[],
           	                          int Forward_Branch_Table[],
                                      int Reverse_State_Table[],
 	                                  int Reverse_Branch_Table[],
                                      int Reverse_State_LLR_Table[],
								      int Reverse_Branch_LLR_Table[],
                                      int RSC_Rate,int RSC_Constrain_Len)
{  int *RSC_Register,*branch;
   
   int i,j,k,l;
   int temp,temp1,input_bit,mask,temp_state;
   const int Mem_Len=RSC_Constrain_Len-1;
   const int RSC_StateNumber=(int)pow(2,Mem_Len);
   //const int RSC_BitCombine=2*(RSC_Rate+1);
       
   RSC_Register=(int *)calloc(Mem_Len,sizeof(int));
   branch=(int *)calloc(RSC_Rate,sizeof(int));

   for(i=0;i<Mem_Len;i++)
         RSC_Register[i]=0;
   
   for(i=0;i<RSC_StateNumber;i++)
   {    temp=i;
         mask=1;
         for(j=0;j<Mem_Len;j++)
		 {    RSC_Register[j]=(temp&mask)>>j;     //状态寄存器LSB--MSB对应状态的低位到高位
		       mask<<=1;
		 }
                
		 temp_state=RSC_Register[Mem_Len-2];
		 for(j=Mem_Len-3;j>=0;j--)
			   temp_state=temp_state*2+RSC_Register[j];
                                                                                                        
		 for(j=0;j<2;j++)
		 {     
               //generate reverse transition branch table
			   //compute transition branch bit 
               input_bit=j;
               for(k=0;k<Mem_Len;k++)
                     input_bit^=Gen_polynomial_denominator[k+1]*RSC_Register[k];
               
               //initialization
			   branch[0]=j;
               for(k=1;k<RSC_Rate;k++)
			         branch[k]=input_bit;
               
               for(k=1;k<RSC_Rate;k++)
				     for(l=0;l<Mem_Len;l++)
					        branch[k]^=Gen_polynomial_numerator[(k-1)*RSC_Constrain_Len+l+1]*RSC_Register[l];
                //convert binary to decimal
               temp=branch[0];
			   for(k=1;k<RSC_Rate;k++)
				     temp=temp*2+branch[k];
               //generate reverse transition state table 
			   temp1=temp_state*2+input_bit;
               //construct reverse branch encoding bit map table
			   for(k=0;k<RSC_Rate;k++)
                     Reverse_Branch_LLR_Table[(k*2+branch[k])*RSC_StateNumber+i]=temp;
               //construct reverse branch map table
               Reverse_Branch_Table[j*RSC_StateNumber+i]=temp;
                
			   //construct reverse state associated with encoding bit map table
			   for(k=0;k<RSC_Rate;k++)
			   	     Reverse_State_LLR_Table[(k*2+branch[k])*RSC_StateNumber+i]=temp1;
               //construct reverse state map table
               Reverse_State_Table[j*RSC_StateNumber+i]=temp1;

               //construct forward branch map table
               Forward_Branch_Table[j*RSC_StateNumber+temp1]=temp;
               //construct forward state map table
               Forward_State_Table[j*RSC_StateNumber+temp1]=i;
		 }
   }
  
   free(RSC_Register);
   free(branch);
}