turboencoder.c

turbo码simulink编码程序

       for (i=2;i<=x;i++)
          { if (x%i==0 && y%i==0)
               z=i;
	         }
       return (z);
       }
       
       
void interweave_pattern(  int data_len, int *p_inter_perm)

{  
/*******************************************************************************************
***********************数据定义区***********************************************************
********************************************************************************************/

    int i;
    int i1;
	int i2;
    int i3;
    int matrix_row;//row number of the intweave matrix
	int matrix_column;//column of the interweave matrix
    int *p_row_row_permutation;//permutation pattern of row and row
	int interweave_p;//the prime of the interweave
	int interweave_v;//the primitive root of the interweave_p
    int *p_inter_s;//the base permutation sequence of interweave in a row
	int *p_inter_q;//the squence q[i] 
	int *p_inter_r;//the squence r[i]
    int matrix_size;
    int *p_inter_perm1,*p_inter_perm2;
    int *p_inter_ui;
    struct prime_root_table     
      {int p;
	   int v;
	  }  prime_root[52]={{7,3},{11,2},{13,2},{17,3},{19,2},{23,5},{29,2},{31,3},{37,2},{41,6},{43,3},{47,5},{53,2},{59,2},{61,2},{67,2},{71,7},{73,5},{79,3},{83,2},{89,3},{97,5},{101,2},{103,5},{107,2},{109,6},{113,3},{127,3},{131,2},{137,3},{139,2},{149,2},{151,6},{157,5},{163,2},{167,5},{173,2},{179,2},{181,2},{191,19},{193,5},{197,2},{199,3},{211,2},{223,3},{227,2},{229,6},{233,3},{239,7},{241,7},{251,6},{257,3}};/*the table of prime number p and associated primitive root v*/
	static int row_row_permutation1[5]={4,3,2,1,0};
    static int row_row_permutation2[10]={9,8,7,6,5,4,3,2,1,0};
    static int row_row_permutation3[20]={19,9,14,4,0,2,5,7,12,18,16,13,17,15,3,1,6,11,8,10};
    static int row_row_permutation4[20]={19,9,14,4,0,2,5,7,12,18,10,8,13,17,3,1,16,6,15,11};
    
   //{{7,11,13,17,19,23,29,31,37,41,43,47,53,59,61,67,71,73,79,83,89,97,101,103,107,109,113,127,131,137,139,149,151,157,163,167,173,179,181,191,193,197,199,211,223,227,229,233,239,241,251,257},
   //{3, 2, 2, 3, 2, 5, 2, 3, 2, 6, 3, 5, 2, 2, 2, 2, 7, 5, 3, 2, 3, 5, 2,  5,  2,  6,  3,  3,  2,  3,  2,  2,  6,  5,  2,  5,  2,  2,  2,  19, 5,  2,  3,  2,  3,  2,  6,  3,  7,  7,  6,  3}};
/*******************************************************************************************
***********************数据定义区结束*******************************************************
********************************************************************************************/




/*******************************************************************************************
***********************计算矩阵的行和列以及行间交织模式*************************************
********************************************************************************************/  
   //select matrix row and interweave pattern of row and row
  if((data_len<=159)&&(data_len>=40)) 
     {matrix_row=5; 
      p_row_row_permutation=row_row_permutation1;
     }
  else if((data_len<=200)&&(data_len>=160)) 
     {matrix_row=10;
      p_row_row_permutation=row_row_permutation2;}
  else if((data_len<=530)&&(data_len>=481))
     {matrix_row=10;
      p_row_row_permutation=row_row_permutation2;}
  else if(data_len>=531)
      { matrix_row=20;
       if(((data_len>=2281)&&(data_len<=2480))||((data_len>=3161)&&(data_len<=3210)))
		    p_row_row_permutation=row_row_permutation3;
	   else
	   p_row_row_permutation=row_row_permutation4;}
  else 
	 printf("error data length.it's number must >40");
  //select matrix row and interweave pattern of row and row end
/*******************************************************************************************
***********************计算矩阵的行和列以及行间交织模式结束*********************************
********************************************************************************************/ 
  



/*******************************************************************************************
***********************计算交织时用到的素数p以及原根v***************************************
********************************************************************************************/ 
  // select interweave_p,and interweave_v and counte the column of the matrix 
  for(i=0;i<52;i++)
      {if(((prime_root[i].p+1)*matrix_row)>data_len)
        {interweave_p=prime_root[i].p;
         interweave_v=prime_root[i].v;
         if(data_len<=matrix_row*(interweave_p-1))
			 matrix_column=interweave_p-1;
		 else if(data_len>matrix_row*interweave_p)
			 matrix_column=interweave_p+1;
		 else
			 matrix_column=interweave_p;
		 i=52;}
       }
    
   //select interweave_p,and interweave_v and counte the column of the matrix end
/*******************************************************************************************
***********************计算交织时用到的素数p以及原根v结束***********************************
********************************************************************************************/ 

/*******************************************************************************************
***********************计算基本序列s[i]*****************************************************
********************************************************************************************/ 

   // 	Construct the base sequence s
    p_inter_s=(int*)calloc(interweave_p-1,sizeof(int));
	if(p_inter_s==NULL)
	  {printf("Error,the pointer is NULL");
	    exit(0);
      }
    p_inter_s[0]=1;
    for(i=1;i<interweave_p-1;i++)
		p_inter_s[i]=(interweave_v*p_inter_s[i-1])%interweave_p;
    
/******************test区*******************************************************************  
    for (i=0;i<interweave_p-1;i++)
    cout<<p_inter_s[i]<<endl;
    // 	Construct the base sequence s end
/*******************************************************************************************
***********************计算基本序列s[i]结束*************************************************
********************************************************************************************/
	 


/*******************************************************************************************
***********************计算基本序列q[i]*****************************************************
********************************************************************************************/

    // determine the prime integer  qi i=0 1 2 ,.... matrix_row-1
     p_inter_q=(int*)calloc(matrix_row,sizeof(int));
    if(p_inter_q==NULL)
	  {printf("Error,the pointer is NULL");
	    exit(0);
      }
	
	 i1=7;
	 i=0;
	while (i<=(matrix_row-1))
	   {if(gcd(i1,interweave_p-1)==1)	 
	    { p_inter_q[i]=i1;
	      i++;
	    }
	  i1++;
	   }
	
  // determine the prime integer  qi i=0 1 2 ,.... matrix_row-1 end
 /*******************************************************************************************
***********************计算基本序列q[i]结束**************************************************
********************************************************************************************/
  


/*******************************************************************************************
***********************计算基本序列r[i]*****************************************************
********************************************************************************************/
  //determine the prime integer  ri i=0 1 2 ,.... matrix_row-1
	 p_inter_r=(int*)calloc(matrix_row,sizeof(int));
     if(p_inter_r==NULL)
	  {printf("Error,the pointer is NULL");
	    exit(0);
      }
     for(i=0;i<matrix_row;i++)
	 p_inter_r[p_row_row_permutation[i]]=p_inter_q[i];
     
/******************test区*******************************************************************      
     for(i=0;i<matrix_row;i++)
      cout<<p_inter_r[i]<<","<<p_inter_q[i]<<"--"<<p_row_row_permutation[i]<<endl;
    // determine the prime integer  ri i=0 1 2 ,.... matrix_row-1 end 
/*******************************************************************************************
***********************计算基本序列r[i]结束*************************************************
********************************************************************************************/ 




/*******************************************************************************************
**************计算行内交换模式u[i],同时得到在整个序列中行内置换的模式***********************
********************************************************************************************/
    
   matrix_size=matrix_row*matrix_column;
     p_inter_perm1=(int*)calloc(matrix_size,sizeof(int));
	 if(p_inter_perm1==NULL)
	  {printf("Error,the pointer is NULL");
	    exit(0);
      }
     p_inter_perm2=( int*)calloc(matrix_size,sizeof(int));
	 if(p_inter_perm2==NULL)
	  {printf("Error,the pointer is NULL");
	    exit(0);
      }
	 p_inter_ui=(  int*)calloc(matrix_column,sizeof( int));//ui(j)
     if(p_inter_ui==NULL)
	  {printf("Error,the pointer is NULL");
	    exit(0);
      }

	 //for (i2=0;i2<matrix_size;i2++)
     // p_inter_perm1[i2]=i2;// p_inter_perm1 content is 0 1 2 ...... matrix_size-1;
   if(matrix_column==interweave_p) 
    {for (i=0;i<matrix_row;i++)
        {for(i2=0;i2<=interweave_p-2;i2++)
           {p_inter_ui[i2]=p_inter_s[(i2*p_inter_r[i])%(interweave_p-1)];
            //cout<<p_inter_ui[i2]<<endl;
            p_inter_perm2[i*matrix_column+i2]=i*matrix_column+p_inter_ui[i2];
             } 
        p_inter_ui[interweave_p-1]=0;
        p_inter_perm2[i*matrix_column+interweave_p-1]=i*matrix_column+p_inter_ui[interweave_p-1];
         }
     }
   else if(matrix_column==(interweave_p+1))
	{for (i=0;i<matrix_row;i++)
        {for(i2=0;i2<=interweave_p-2;i2++)
            {p_inter_ui[i2]=p_inter_s[(i2*p_inter_r[i])%(interweave_p-1)];
             p_inter_perm2[i*matrix_column+i2]=i*matrix_column+p_inter_ui[i2];
             } 
          p_inter_ui[interweave_p-1]=0;
          p_inter_ui[interweave_p]=interweave_p;
		  p_inter_perm2[i*matrix_column+interweave_p-1]=i*matrix_column+p_inter_ui[interweave_p-1];
          p_inter_perm2[i*matrix_column+interweave_p]=i*matrix_column+p_inter_ui[interweave_p];
   
		  if(data_len==matrix_row*matrix_column)
		     {p_inter_ui[interweave_p]=p_inter_ui[0];
		      p_inter_ui[0]=interweave_p;
			  p_inter_perm2[i*matrix_column+interweave_p]=i*matrix_column+p_inter_ui[interweave_p];
              p_inter_perm2[i*matrix_column+0]=i*matrix_column+p_inter_ui[0];
		      }
             
         }
     }
	  else
      	{for (i=0;i<matrix_row;i++)
	      {for(i2=0;i2<=interweave_p-2;i2++)
	          {p_inter_ui[i2]=p_inter_s[(i2*p_inter_r[i])%(interweave_p-1)]-1;	          
               p_inter_perm2[i*matrix_column+i2]=i*matrix_column+p_inter_ui[i2];
			   //cout<<p_inter_ui[i2]<<"   "<<p_inter_perm2[i*matrix_column+i2]<<endl;
	           } 
		   }    
         }
/******************test区*******************************************************************
  for (i2=0;i2<matrix_row*matrix_column;i2++) 
  cout<<p_inter_perm2[i2]<<endl;
  //counter the interveave pattern in a row
/*******************************************************************************************
**************计算行内交换模式u[i],同时得到在整个序列中行内置换的模式结束*******************
********************************************************************************************/



/*******************************************************************************************
**************计算进行行间交换后的交换模式**************************************************
********************************************************************************************/
    for(i=0;i<matrix_row;i++)
	  {
		for(i2=0;i2<matrix_column;i2++)
   	    p_inter_perm1[i*matrix_column+i2]=p_inter_perm2[p_row_row_permutation[i]*matrix_column+i2];
	   }

/******************test区*******************************************************************
    for (i2=0;i2<matrix_row*matrix_column;i2++) 
    cout<<p_inter_perm1[i2]<<endl;
/*******************************************************************************************
**************计算进行行间交换后的交换模式结束**********************************************
********************************************************************************************/

/*******************************************************************************************
**************计算按列读出后的交换模式******************************************************
********************************************************************************************/
	for(i=0;i<matrix_row;i++)