twoway_logmap_algorithm.cpp

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

//Author NiuKai
//Date February,23th 2002
//Function log map algorithm for recursive systematic convolutional code decoding with code rate = 1/n
//positive logarithm map is used in this program and signal map is 1-2d, that is, 0-->1,1-->-1

#include "PCCC_para.h"

void Twoway_Logmap_Algorithm(float SoftIn_code_sequence[],
						                                           float SoftIn_source_sequence[],
                                                                   float SoftOut_source_sequence[],
						                                           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 SymSeq_Len)
{       int  RSC_StateNumber,RSC_BitCombine,RSC_MemLen;
        RSC_MemLen=RSC_Constrain_Len-1;
        RSC_StateNumber=(int)pow(2.0,RSC_MemLen);
        RSC_BitCombine=(int)pow(2.0,RSC_Rate);
        
        int i,j,k,mask;
        float temp,temp0,temp1;
        float *Gamma_metric,*Alpha_metric,*Beta_metric,*State_metric;
        Gamma_metric=(float *)calloc(RSC_BitCombine*SymSeq_Len,sizeof(float));
        Alpha_metric=(float *)calloc(RSC_StateNumber*(SymSeq_Len+1),sizeof(float));
        Beta_metric=(float *)calloc(RSC_StateNumber,sizeof(float));
        State_metric=(float *)calloc(RSC_StateNumber,sizeof(float));
        
        float  *bit_reg,*temp_metric0,*temp_metric1;
        bit_reg=(float *)calloc(RSC_Rate,sizeof(float));
        temp_metric0=(float *)calloc(RSC_StateNumber,sizeof(float));
        temp_metric1=(float *)calloc(RSC_StateNumber,sizeof(float));
        //inilization Alpha and Beta metrics
        Alpha_metric[0]=0;
        Beta_metric[0]=0;
        for(i=1;i<RSC_StateNumber;i++)
        {	     Alpha_metric[i]=-65535;
               Beta_metric[i]=-65535;
        }
         
        //calculate the Gamma metric for the received sequence
        for(i=0;i<RSC_BitCombine;i++)
        {       mask=1;
                for(j=0;j<RSC_Rate;j++)
                {     bit_reg[RSC_Rate-j-1]=1-2*((i&mask)>>j);
  		               mask<<=1;
                }
                
                for(j=0;j<SymSeq_Len;j++)
                {     
																	      temp=0; 	   
  		 	                 for(k=0;k<RSC_Rate;k++)
  		 	                       temp+=bit_reg[k]*SoftIn_code_sequence[j*RSC_Rate+k];
                       if(bit_reg[0]==1)
                             temp+=SoftIn_source_sequence[j]
																													               -__max(0,SoftIn_source_sequence[j])
                                            -log(1+exp(-fabs(SoftIn_source_sequence[j])));
                       else
                             temp+=-__max(0,SoftIn_source_sequence[j])
                                           -log(1+exp(-fabs(SoftIn_source_sequence[j])));
                        
  		 	                 Gamma_metric[j*RSC_BitCombine+i]=temp;
                }
        }
        
        //Forward metric computation
        for(i=0;i<SymSeq_Len;i++)
        {       
                for(j=0;j<RSC_StateNumber;j++)
                {      
                       
                       temp_metric0[j]=
                       Alpha_metric[i*RSC_StateNumber+Forward_State_Table[0*RSC_StateNumber+j]]+
			                    Gamma_metric[i*RSC_BitCombine+Forward_Branch_Table[0*RSC_StateNumber+j]];
                       temp_metric1[j]=
                       Alpha_metric[i*RSC_StateNumber+Forward_State_Table[1*RSC_StateNumber+j]]+
                       Gamma_metric[i*RSC_BitCombine+Forward_Branch_Table[1*RSC_StateNumber+j]];
                        
			                    State_metric[j]=__max(temp_metric0[j],temp_metric1[j])+
				                                      log(1+exp(-fabs(temp_metric0[j]-temp_metric1[j])));
																}
                
                temp=State_metric[0];
                for(j=1;j<RSC_StateNumber;j++)
                        if(temp<=State_metric[j])
				                          temp=State_metric[j];
                for(j=0;j<RSC_StateNumber;j++)
			            Alpha_metric[(i+1)*RSC_StateNumber+j]=State_metric[j]-temp;
								}
        
        /*for(i=0;i<RSC_StateNumber;i++)
        {     for(j=0;j<SymSeq_Len;j++)
                    printf(" %5.2e ",Alpha_metric[j*RSC_StateNumber+i]);
              cout<<endl;
        }*/
        //Backward metric and LLR computation
        for(i=0;i<SymSeq_Len;i++)
        {       
                for(j=0;j<RSC_StateNumber;j++)
																{     
                       temp_metric0[j]=
                       Beta_metric[Reverse_State_Table[0*RSC_StateNumber+j]]+
			                    Gamma_metric[(SymSeq_Len-1-i)*RSC_BitCombine+
                                             Reverse_Branch_Table[0*RSC_StateNumber+j]];
                       
                       temp_metric1[j]=
                       Beta_metric[Reverse_State_Table[1*RSC_StateNumber+j]]+
				                   Gamma_metric[(SymSeq_Len-1-i)*RSC_BitCombine+
                                             Reverse_Branch_Table[1*RSC_StateNumber+j]];
			                    
                       State_metric[j]=__max(temp_metric0[j],temp_metric1[j])+
				                                      log(1+exp(-fabs(temp_metric0[j]-temp_metric1[j])));
																}
                /*for(j=0;j<RSC_StateNumber;j++)
                        printf(" %5.2e ",Beta_metric[j]);
                cout<<endl;*/
                
                //source bit LLR computation
                if(i>=RSC_MemLen)
                {
                      for(j=0;j<RSC_StateNumber;j++)
                      {   
                            temp_metric0[j]=Beta_metric[Reverse_State_LLR_Table[0*RSC_StateNumber+j]]+
			                         Gamma_metric[(SymSeq_Len-1-i)*RSC_BitCombine+
                                                                            Reverse_Branch_LLR_Table[0*RSC_StateNumber+j]];
                               
                            temp_metric1[j]=Beta_metric[Reverse_State_LLR_Table[1*RSC_StateNumber+j]]+
				                        Gamma_metric[(SymSeq_Len-1-i)*RSC_BitCombine+
                                                                            Reverse_Branch_LLR_Table[1*RSC_StateNumber+j]];
                      }  
                        
			                   temp0=temp_metric0[0]+Alpha_metric[(SymSeq_Len-1-i)*RSC_StateNumber];
		                    temp1=temp_metric1[0]+Alpha_metric[(SymSeq_Len-1-i)*RSC_StateNumber];
		                    for(j=1;j<RSC_StateNumber;j++)
                      {
			                          temp0=__max(temp0,temp_metric0[j]+Alpha_metric[(SymSeq_Len-1-i)*RSC_StateNumber+j])+
				                         log(1+exp(-fabs(temp0-temp_metric0[j]-Alpha_metric[(SymSeq_Len-1-i)*RSC_StateNumber+j])));
                             temp1=__max(temp1,temp_metric1[j]+Alpha_metric[(SymSeq_Len-1-i)*RSC_StateNumber+j])+
				                         log(1+exp(-fabs(temp1-temp_metric1[j]-Alpha_metric[(SymSeq_Len-1-i)*RSC_StateNumber+j])));
																						}
        		            SoftOut_source_sequence[SymSeq_Len-1-i]=temp0-temp1
                      -SoftIn_source_sequence[SymSeq_Len-1-i]
                      -2*SoftIn_code_sequence[RSC_Rate*(SymSeq_Len-1-i)];
																}		        
                  		        
                //normalization process
                temp=State_metric[0];
                for(j=1;j<RSC_StateNumber;j++)
                        if(temp<=State_metric[j])
   				                        temp=State_metric[j];
                for(j=0;j<RSC_StateNumber;j++)
  			                  Beta_metric[j]=State_metric[j]-temp;
								}
        
        free(Gamma_metric);
        free(Alpha_metric);
        free(Beta_metric);
        free(State_metric);
        free(bit_reg);
        free(temp_metric0);
        free(temp_metric1);
 }