tcc_3gpp_pc.cpp

This CD-ROM is distributed by Kluwer Academic Publishers with ABSOLUTELY NO SUPPORT and NO WARRANTY

  f2=&rr[0][0];
  for(int i=0;i < N_infobits_per_sequence*N_not_punc;i++)
    f1[i]=f2[i];

  f1=&Pr_i[0];
  f2=&Pr_ii[0];
  for(i=0;i < N_infobits_per_sequence;i++)
    f1[i]=f2[i];

  gamamatrix();
  alfamatrix();
  betamatrix();
  LRarray();
};
//------------------------------------------------------------------------------------//
void decoder::outdecoder(float apriori[])
{
  float *f1,*f2;
  f1=&lr[0];
  f2=&apriori[0];
  for(int i=0;i < N_infobits_per_sequence;i++)
  f2[i]=f1[i];

  //delete pFile;

        delete lr;
	    delete gamamat;
    	delete betamat;
	    delete alfamat;
        delete r;
        delete Pr_i;


};
/*************************************************************************************/
/*                              GAMA MATRIX FUNCTION                         
         */
/* This funnction produces an array consisting of gamamat[t][i][lp][l] for a 
given   */
/*riceived sequence (r[t][v]), trellis sequence (x[lp][l][v]), a priori 
probability  */
/*(Pr_i[t]).                                                                 
         */
/*************************************************************************************/
float decoder::gama(int i,int t,int lp,int l)
{
  if(x[lp][l][0]!=i)                            //if there is no cennection 
between lp and l, according to i.
     return -infinit;

  float acc1=0.5*i*((Lc*r[t][0])+Pr_i[t]);      // float 
acc1=0.5*(Lc*r[t][0])+Pr_i[t]);

  for(int c=1;c < N_not_punc;c++)
    acc1=acc1+0.5*(Lc*r[t][c]*x[lp][l][c]);

  return acc1;
};

void decoder::gamamatrix(void)
{
  for(int t=0;t < N_infobits_per_sequence;t++)
    for(int i=0;i < 2;i++)
      for(int l=0;l < num_of_states;l++)
	for(int lp=0;lp < num_of_states;lp++)
	gamamat[t+1][i][lp][l]=gama((i*2)-1,t,lp,l);
};
/*****************************************************************************************/
/*                                  MAXIMUM FUNCTION                         
             */
/* This funnction choses the maximum value between the two inputs and return 
this value. */
/*****************************************************************************************/
float decoder::maxi(float v1,float v2)
{
	if (v1 > v2)
	  return v1;
	else
	  return v2;
};
/****************************************************************************************/
/*                                ALPHA MATRIX FUNCTION                      
            */
/*This funnction produces an array consisting of alfamat[t][l] for given 
gamamat[][][][]*/
/****************************************************************************************/
void decoder::alfamatrix(void)
{
  for(int t=0;t <= N_infobits_per_sequence;t++)                
//initializing
    for(int l=0;l < num_of_states;l++)
      alfamat[t][l]=-infinit;

  alfamat[0][0]=0;                                             
//initializing


  for(t=1;t <= N_infobits_per_sequence;t++ )
    for(int l=0;l < num_of_states;l++)
      for(int i=0;i < 2;i++)
	for(int lp=0;lp < num_of_states;lp++)
	  alfamat[t][l]=maxi(alfamat[t][l],alfamat[t-1][lp]+gamamat[t][i][lp][l]);
};
/*****************************************************************************************/
/*                                BETA MATRIX FUNCTION                       
             */
/*This funnction produces an array consisting of betaamat[t][l] for given 
gamamat[][][][]*/
/*****************************************************************************************/
void decoder::betamatrix(void)
{
  for(int t=0;t <= N_infobits_per_sequence;t++)                              
//initializing
    for(int l=0;l < num_of_states;l++)
       betamat[t][l]=-infinit;

   if (betainit == 0)
     betamat[N_infobits_per_sequence][0]=log(1.0);                           
//initializing
   else
     {for(int l=0;l < num_of_states;l++)
       betamat[N_infobits_per_sequence][l]=log(1/(num_of_states+0.0));};



  for(t=N_infobits_per_sequence-1;t >= 0;t-- )
    for(int l=0;l < num_of_states;l++)
      for(int i=0;i < 2;i++)
	for(int lp=0;lp < num_of_states;lp++)
	   betamat[t][l]=maxi(betamat[t][l], 
betamat[t+1][lp]+gamamat[t+1][i][l][lp]);
};
/****************************************************************************************/
/*                                MAXIMUM LIKELIHOOD RATIO                   
            */
/*                                                                           
            */
/****************************************************************************************/
void decoder::LRarray(void)
{
  float a0,a1;

  for(int t=1;t <= N_infobits_per_sequence;t++ )
    {
      a1=-infinit;
      a0=-infinit;

      for(int l=0;l < num_of_states;l++)
        for(int lp=0;lp < num_of_states;lp++)
	  {
	    a1=maxi(a1,gamamat[t][1][lp][l]+alfamat[t-1][lp]+betamat[t][l]);
	    a0=maxi(a0,gamamat[t][0][lp][l]+alfamat[t-1][lp]+betamat[t][l]);
	  };

      lr[t-1]=a1-a0;
      lr[t-1]=lr[t-1]-(Lc*r[t-1][0])-Pr_i[t-1];
    };
};
/**************************************************************************************/
/*                        CONVERTING BINARY TO BPSK FUNCTION                 
          */
/**************************************************************************************/
int b_to_bpsk(int a)
{
  return (a*2-1);
};
/**************************************************************************************/
/*                           ENCODER PROCEDURE FUNCTION                      
          */
/**************************************************************************************/
void encode_procedure(int info_seq[],int enc1out[],int enc2out[],int 
info_seq_interleaved[],
		     encoder &rsc1,encoder &rsc2)
  {
    rsc1.resetenc();
    rsc2.resetenc();
    // Producing iformation bits and output of encoder 1.
    for(int counter=0;counter < N_infobits_per_sequence - 
num_of_registers;counter++)
      {
	info_seq[counter]=randombinarygenerator();
	enc1out[counter]=rsc1.encin(info_seq[counter]);
      };

    for(counter=num_of_registers;counter > 0;counter--)
      {
        info_seq[N_infobits_per_sequence - counter]=rsc1.encgozero();
        enc1out[N_infobits_per_sequence - 
counter]=rsc1.encin(info_seq[N_infobits_per_sequence - counter]);
      };

    // Producing interleaved iformation bits and output of encoder 2.
    for(counter=0;counter < N_infobits_per_sequence;counter++)
      info_seq_interleaved[counter]=info_seq[counter];

    interleaver(info_seq_interleaved);

    for(counter=0;counter < N_infobits_per_sequence;counter++)
      enc2out[counter]=rsc2.encin(info_seq_interleaved[counter]);

    for(counter=0;counter < N_infobits_per_sequence;counter++)
	  {
	    info_seq[counter]=b_to_bpsk(info_seq[counter]);
	    enc1out[counter]=b_to_bpsk(enc1out[counter]);
	    info_seq_interleaved[counter]=b_to_bpsk(info_seq_interleaved[counter]);
	    enc2out[counter]=b_to_bpsk(enc2out[counter]);
	  };
  };
/*************************************************************************************/
/*                                 ADDING AWGN TO CHANNEL                    
         */
/*************************************************************************************/
void add_channel_noise(int info_seq[],int enc1out[],int enc2out[],
		       float r1[][N_not_punc],float r2[][N_not_punc])
  {

    float inter_info[N_infobits_per_sequence];

	for(int counter=0;counter < N_infobits_per_sequence;counter++)
	  {
	    r1[counter][0]=info_seq[counter]+gaussian();
	    r1[counter][1]=enc1out[counter]+gaussian();
	    inter_info[counter]=r1[counter][0];
	    r2[counter][1]=enc2out[counter]+gaussian();
	  };

	interleaver(inter_info);

	for(counter=0;counter < N_infobits_per_sequence;counter++)
	    r2[counter][0]=inter_info[counter];
  };
/**************************************************************************************/
/*                           DECODER PROCEDURE FUNCTION                      
          */
/**************************************************************************************/
void decode_procedure(float Pr_i1[],float Pr_i2[],float 
r1[][N_not_punc],float r2[][N_not_punc],
			  decoder &dec1,decoder &dec2,int info_seq[])
  {
	float Pr_i_f[N_infobits_per_sequence];
	int   out_seq[N_infobits_per_sequence];
	int   nof=1;
	int   counter=0;

	for(counter=0;counter < N_infobits_per_sequence;counter++)
	  Pr_i2[counter]=0;

	counter=0;
	for(counter=0;((counter < limit) && (nof != 0));counter++)
	  {
	    dec1.indecoder(r1,Pr_i2);
	    dec1.outdecoder(Pr_i1);
	    interleaver(Pr_i1);

	    dec2.indecoder(r2,Pr_i1);
	    dec2.outdecoder(Pr_i2);
	    deinterleaver(Pr_i2);

	deinterleaver(Pr_i1);
	nof=0;
	for(int co=0;co < N_infobits_per_sequence;co++ )
	  {
	    Pr_i_f[co]=Pr_i1[co]+Pr_i2[co]+(Lc*r1[co][0]);
	    if (Pr_i_f[co] >= 0)
	      out_seq[co]=1;
	    else
	      out_seq[co]=-1;

	    if (out_seq[co] != info_seq[co])
	      nof++;
	  };

	  };
	if ((counter == limit) && (nof != 0)) N_of_frames_in_error++;

  };
/*************************************************************************************/
/*                                    MAIN FUNCTION                          
         */
/*************************************************************************************/

int main(int argc, char* argv[])
{
	long  correct=0,incorrect=0;
	float acc=0;
	float Pr_i_f[N_infobits_per_sequence];
	int   out_seq[N_infobits_per_sequence];

    int   n_of_seq=0,n_of_error=0;
	int   natural_e=0;
	int   info_seq[N_infobits_per_sequence];
	int   interleaved_info_seq[N_infobits_per_sequence];
	int   enc1out[N_infobits_per_sequence];
	int   enc2out[N_infobits_per_sequence];
	int   pnatural_e=0;
	int   xm[num_of_states][num_of_states][N_not_punc]={-1,-1,+1,+1, 0, 0, 0, 
0, 0, 0, 0, 0, 0, 0, 0, 0,
                                                             0, 0, 0, 
0,-1,+1,+1,-1, 0, 0, 0, 0, 0, 0, 0, 0,
                                                             0, 0, 0, 0, 0, 
0, 0, 0,+1,-1,-1,+1, 0, 0, 0, 0,
                                                             0, 0, 0, 0, 0, 
0, 0, 0, 0, 0, 0, 0,+1,+1,-1,-1,
                                                            +1,+1,-1,-1, 0, 
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
                                                             0, 0, 0, 
0,+1,-1,-1,+1, 0, 0, 0, 0, 0, 0, 0, 0,
                                                             0, 0, 0, 0, 0, 
0, 0, 0,-1,+1,+1,-1, 0, 0, 0, 0,
                                                             0, 0, 0, 0, 0, 
0, 0, 0, 0, 0, 0, 0,-1,-1,+1,+1};   // This matrix is describing the trellis 
structure of encoders.

	int   qi[5]={1,0,1,1,0};                              // Encoders 
coefficients.
	int   ai[5]={1,1,0,1,0};                              // Encoders 
coefficients.

	encoder rsc1(num_of_registers,ai,qi);
	encoder rsc2(num_of_registers,ai,qi);


    float r1[N_infobits_per_sequence][N_not_punc];
    float r2[N_infobits_per_sequence][N_not_punc];
    float Pr_i1[N_infobits_per_sequence];
    float Pr_i2[N_infobits_per_sequence];                 // Initialize it 
for first itereation.
	for(int counter=0;counter < N_infobits_per_sequence;counter++)
	  Pr_i2[counter]=0;

	decoder dec1(xm,0);
	decoder dec2(xm,1);

	for(n_of_seq=1;(N_of_frames_in_error < Max_n_frames_in_error);n_of_seq++)
	  {

        //-------------------------encoding one 
sequence----------------------------------------
	    
encode_procedure(info_seq,enc1out,enc2out,interleaved_info_seq,rsc1,rsc2);

	    //-------------------------forming channel 
data-----------------------------------------
	    add_channel_noise(info_seq,enc1out,enc2out,r1,r2);

	    //-------------------------decoding one 
sequence------------------------------------------
	    decode_procedure(Pr_i1,Pr_i2,r1,r2,dec1,dec2,info_seq);

	    //---------------------------Final decoding 
step------------------------------------------
	    for(int counter=0;counter < N_infobits_per_sequence;counter++ )
	      {
		Pr_i_f[counter]=Pr_i1[counter]+Pr_i2[counter]+(Lc*r1[counter][0]);
		if (Pr_i_f[counter] >= 0)
		  out_seq[counter]=1;
		else
		  out_seq[counter]=-1;

		if (out_seq[counter] != info_seq[counter])
		  n_of_error++;
	      };

	    if((n_of_seq % 5) == 0 )
		printf("\n Number of frames run so far is %d.",n_of_seq);

	  };

	printf("\n\n\n\n");
	printf("\n Total number of frames is %d.",n_of_seq);
	printf("\n");
	printf("\n Final Frame-error-rate is %5.12f.",N_of_frames_in_error / 
(n_of_seq + 0.0));
	printf("\n");
	printf("\n Final Bit-error-rate is %5.12f.\n",n_of_error / 
(n_of_seq*N_infobits_per_sequence*1.0));
	printf("\n\n");
	return 0;
}