encoder_rm64.h

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

#include <iostream.h>
#include <stdlib.h>
#include <iomanip.h>
#include <stdio.h>
#include <time.h>
#include <math.h>

const double mean = 0.0;

class Encoder_double64
{
 private:
  int k;
  int n;
  double d; //sigma: variance for AWGN
  int U[ROW][ROW];
  int G_echelon[ROW][COLUMN];
  int Code_Vertical[ROW][COLUMN];
  int Code_Horizontal[ROW][COLUMN];
  int X_Vertical[ROW][COLUMN];
  int X_Horizontal[ROW][COLUMN];
  int Modify_X[COLUMN][COLUMN];
  double Y_H_V[COLUMN][COLUMN];
  void set_U();

 public:
  Encoder_double64(int[][65], int, int, double);
  void set_Code_H();
  void set_Code_V();
  void set_X_H();
  void set_X_V();
  void set_Modify_X();
  void set_Y_H_V();
  int* get_U();
  int* get_Code_H();
  int* get_Code_V();
  int* get_X_H();
  int* get_X_V();
  double* get_Y_H_V();
  double gaussian(double);
  void display_U();
  void display_Code_H();
  void display_Modify_X();
  bool test(int[][65], int);
  void display_Code_V();
  void display_Y_H_V();
};
Encoder_double64::Encoder_double64(int echelon_G[][65], int _k, int _n, double sigma)
{
  int i, j, l;
  d = sigma;
  k = _k; n = _n;
    for ( i = 0; i < k; i++){
        for ( j = 0; j < k; j++)
       U[i][j] = 0;
    for ( l = 0; l < n; l++)
      {Code_Vertical[i][l] = echelon_G[i][l];
      Code_Horizontal[i][l] = echelon_G[i][l];
      G_echelon[i][l] = echelon_G[i][l];
      X_Vertical[i][l] = 0;
      X_Horizontal[i][l] = 0;
    }}
    for (i=0; i < n; i++)
      {  for (j = 0; j < n; j++)
	Modify_X[i][j] = 0;
      Y_H_V[i][j] = 0;}
}
void Encoder_double64::set_U()
{
  int i, j;
  srand( time(0));
  for (j = 0; j < k; j++)
    {
      for (i = 0; i < k; i++)
	U[i][j]=rand()%2;
    }
}
void Encoder_double64::display_U()
{
  set_U();
  cout << " The U[" << k << "][" << k << "] =" << endl;
  for (int i = 0; i < k; i++){
    for (int j = 0; j < k; j++)
      cout << U[i][j] << " ";
    cout << " \n";
  }
}
void Encoder_double64::set_Code_V()
{
  int sum;
  // set_U();
  for(int b = 0; b < n; b++ ){
    for(int a = 0; a < k; a++ ){   
      sum = 0;	
      for(int i = 0; i < k; i++ ) 
	{
	  sum = U[i][a] * G_echelon[i][b] ^ sum;
	  Code_Vertical[a][b] = sum;
	}
    }
  }
}
void Encoder_double64::display_Code_H()
{
  set_Code_H();
  cout << "Code Sequence for Horizontal is:" << endl;
  for (int i = 0; i < k; i++){
    for (int j = 0; j < n; j++)
      cout << Code_Horizontal[i][j] << " ";
    cout << " \n";
  }
}
void Encoder_double64::set_Code_H()
{
  int sum;
  // set_U();
  for (int a = 0; a < k; a++)
    {
      for(int b = 0; b < n; b++ ){
	sum = 0;	
	for(int i = 0; i < k; i++ ) 
	  {
	    sum = U[a][i] * G_echelon[i][b] ^ sum;
	    Code_Horizontal[a][b] = sum;
	  }
      }
    }
}
void Encoder_double64::display_Code_V()
{
  set_Code_V();
  cout << "Code Sequence for Vertical is:" << endl;
  for (int i = 0; i < k; i++){
    for (int j = 0; j < n; j++)
      cout << Code_Vertical[i][j] << " ";
    cout << " \n";
  }
}
void Encoder_double64::set_X_H()
{
  set_Code_H();
  for (int i = 0; i < k; i++)
    {
      for (int j = 0; j < n; j++)
	{
	  if ( Code_Horizontal[i][j] == 0) 
	    X_Horizontal[i][j] = -1; 
	  else
	    X_Horizontal[i][j] = Code_Horizontal[i][j];
	}
    }
}
void Encoder_double64::set_X_V()
{
  set_Code_V();
  for (int i = 0; i < k; i++)
    {
      for (int j = 0; j < n; j++)
	{
	  if ( Code_Vertical[i][j] == 0) 
	    X_Vertical[i][j] = -1; 
	  else
	    X_Vertical[i][j] = Code_Vertical[i][j];
	}
    }
}
void Encoder_double64::set_Modify_X()
{
  int i,j;
  int row = 0, column = 0, count = 0, column1 = 0;
  set_X_H();
  set_X_V();
  while(column < n) {
    if(G_echelon[k-1][column] == 1)
      break;
    if (test( G_echelon, column) )
      column++;
    else 
      {
	count++;
	if (count == 1)	
	  {
	    for (i = row; i < column; i++){
	      for ( j = 0; j < n; j++){
		Modify_X[i][j] = X_Horizontal[i][j];
		Modify_X[j][i] = X_Vertical[i][j];}
	    }
	    column1 = column;
	    column++;
	  }
	else if (count == 2)
	  {	    row = column1 + 1;
	  for (i = row; i < column ; i++)
	    for ( j = 0; j < n; j++){
	      Modify_X[i][j] = X_Horizontal[i - count +1][j];	
	      Modify_X[j][i] = X_Vertical[i - count +1][j]; }
	  column1 = column;
	  column++;
	  }
	else if (count == 3)
	  {	    row = column1 + 1;
	  for (i = row; i < column ; i++)
	    for ( j = 0; j < n; j++){
	      Modify_X[i][j] = X_Horizontal[i - count +1][j];	
	      Modify_X[j][i] = X_Vertical[i - count +1][j]; }
	  column1 = column;
	  column++;
	  }
	else
	  {
	    row = column1 + 1;
	    for (i = row; i < column ; i++)
	      for ( j = 0; j < n; j++){
		Modify_X[i][j] = X_Horizontal[i - count + 1][j];
		Modify_X[j][i] = X_Vertical[i - count + 1][j];}
	    column++;
	  }
      }}
  row = column; 
  for ( j = 0; j < n; j++){
    Modify_X[row][j] = X_Horizontal[k-1][j];
    Modify_X[j][row] = X_Vertical[k-1][j];}
}
void Encoder_double64::display_Modify_X()
{
  set_Modify_X();
  cout << "Combintaion of Horizontal and Vertical is:" << endl;
  for (int i = 0; i < n; i++){
    for (int j = 0; j < n; j++)
      cout << setw(3) << Modify_X[i][j] << " ";
    cout << " \n";
  }
}

bool Encoder_double64::test(int G[][65], int column)
{
  int count = 0, row = 0;
    while(row < k) {
      if(G[row][column] == 1)
	count++;
      
      if(count == 2){
	return false;
	break;
      }
      row++;
    }
    return true;		
}
 
double Encoder_double64::gaussian(double d)
{
  int val1, val2;
  double uniform_rand1;
  double uniform_rand2;
  double gauss_rand1, gauss_rand2, temp;
 
  val1 = rand();
  uniform_rand1 = (double) val1; 
  uniform_rand1 /= RAND_MAX;
  val2 = rand();
  uniform_rand2 = (double) val2;
  uniform_rand2 /= RAND_MAX;
  if  (uniform_rand1!=0)
      temp = sqrt(-2.0*log(uniform_rand1));
  else
    temp = sqrt(-2*log(1.0e-9));
  gauss_rand1 = mean + temp*cos(2*M_PI*uniform_rand2)*d;
  gauss_rand2 = temp*sin(2*M_PI*uniform_rand2)*d;
    
  return( gauss_rand1);
}
/*
double Encoder_double64::gaussian()
{
  int i;
  double uniform_rand1, uniform_rand2, temp, d;
  double gauss_rand1, gauss_rand2;

   d = pow(10, -SNR/20);
    uniform_rand1 = (double) rand()/RAND_MAX;
    uniform_rand2 = (double) rand()/RAND_MAX;
    if (uniform_rand1!=0) 
      temp = sqrt(-2*log(uniform_rand1));
    gauss_rand1 = temp*cos(2*M_PI*uniform_rand2)*d;
    gauss_rand2 = temp*sin(2*M_PI*uniform_rand2)*d;
    
    return gauss_rand1;
}*/
void Encoder_double64::set_Y_H_V()
{
  set_Modify_X();
  double dd;
  // cout << endl << "Please give SNR (dB) for your wish: " ;
  // cin >> SNR;
  // dd = pow (10, -SNR/20);
  for (int i = 0; i < n; i++)
    {
      for (int j = 0; j < n; j++)
	if( Modify_X[i][j] == 1 || Modify_X[i][j] == -1)
	Y_H_V[i][j] = ( double)Modify_X[i][j] + gaussian(d);
      //  cout << endl << " gaussian noise is :" << gaussian();
    }
}
void Encoder_double64::display_Y_H_V()
{
  set_Y_H_V();

  cout << "Combintaion of Horizontal and Vertical for received sequence are:" << endl;
  for (int i = 0; i < n; i++){
    for (int j = 0; j < n; j++)
      cout << setw(3) << Y_H_V[i][j] << ", ";   
    cout << " \n";
  }
}
/*void Encoder_Modify::set_Y_V()
{
  set_X_V ();
  double dd;
  // cout << endl << "Please give SNR (dB) for your wish: " ;
  //cin >> SNR;
  dd = pow (10, -SNR/20);
  for (int i = 0; i < k; i++)
    {
      for (int j = 0; j < n; j++)
	Y_Vertical[i][j] = ( double)X_Vertical[i][j] + gaussian(dd);
    }
}*/
int* Encoder_double64::get_U()
{
  set_U();
  return &U[0][0];
}

int* Encoder_double64::get_Code_H()
{
  set_Code_H();
  return &Code_Horizontal[0][0];
}
int* Encoder_double64::get_Code_V()
{
  set_Code_V();
  return &Code_Vertical[0][0];
}
int* Encoder_double64::get_X_H()
{
  set_X_H();
  return &X_Horizontal[0][0];
}
int* Encoder_double64::get_X_V()
{
  set_X_V();
  return &X_Vertical[0][0];
}
/*double* Encoder_Modify::get_Y_H()
{
  set_Y_H();
  return &Y_Horizontal[0][0];
}*/
double* Encoder_double64::get_Y_H_V()
{
  set_Y_H_V();
  return &Y_H_V[0][0];
}