btc_atm_unix.cpp

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

  u1 /= RAND_MAX;
  i2 = rand();
  u2 = (float)i2;
  u2 /= RAND_MAX;
  if(u1 != 0)temp=sqrt(-2*log(u1)); else temp=sqrt(-2*log(1.0e-9));
  g1=mean+sigma*temp*cos(2.*M_PI*u2);
  return g1;
}

int print_e_r(void)
{
  int i, j, k, m, error_count;
  int num;
  int error_countarea1,error_countarea2;
  int temp1,temp2;
  temp1 = (int) RM_K/2;
  temp2 = RM_K-temp1;
  
  error_countarea1 = 0;
  error_countarea2 = 0;
  num = 0;
  for(i=0; i < RM_K-nzero; i++)
    for(j=temp1; j < RM_K; j++)
      if(num < RM_K*RM_K-dimfill1*dimfill2)
	if((2*DIN[i][j]-1)*FinalSoft[i][j] <=0.0) {error_countarea1 = error_countarea1 + 1; num++;}
  
  for(i=0; i < RM_K-nzero; i++)
    for(j=0; j < temp1; j++)
      if(num < RM_K*RM_K-dimfill1*dimfill2)
	if((2*DIN[i][j]-1)*FinalSoft[i][j] <=0.0) {error_countarea2 = error_countarea2 + 1; num++;}
  
  
  total_errorsarea1[iteration] = total_errorsarea1[iteration] + error_countarea1;
  total_errorsarea2[iteration] = total_errorsarea2[iteration] + error_countarea2;
  return (error_countarea1+error_countarea2);
  
}


void generateG(int order)
{
  int i,j,k,Maxj;
  int Numorder,row,bits=0;
  int temprow;
  for(i=0; i < RM_K; i++)
    for(j=0; j < RM_N; j++)
      Gx[i][j] = 0;
  
  for(i=0; i < RM_N; i++)
    Gx[0][i] = 1;
  
  bits = (int) (log(RM_N)/log(2));

  for(i=bits; i >= 1 ; i--)
    {
      Maxj = (int)pow(2,i);
      for(j=0; j < Maxj; j++)
	{
	  if (fmod(j,2.0)==0)
	    {
	      for(k = RM_N-(RM_N*(Maxj-j)/Maxj); k < RM_N-(RM_N*(Maxj-j-1)/Maxj); k++)
		Gx[bits-i+1][k] = 0;
	    }
	  else
	    {
	      for(k = RM_N-(RM_N*(Maxj-j)/Maxj); k < RM_N-(RM_N*(Maxj-j-1)/Maxj); k++)
		Gx[bits-i+1][k] = 1;
	    }
	}
    }
  
  row = bits+1;
  for(Numorder = 2; Numorder <= order ; Numorder ++)
    {
      if(Numorder == 2)
	{
	  while(row < (bits+1)+bico((bits),Numorder))
	    {
	      for(i=1; i < bits+1; i++)
		{
		  for(j=i+1; j < bits+1; j++)
		    {
		      multiply(Gx[row],Gx[i],Gx[j]);
		      row++;
		    }
		} 
	    }
	}
      if(Numorder == 3)
	{
	  temprow = row;
	  while (row < temprow + bico((bits),Numorder))
	    {
	      for(i=1; i < bits+1; i++)
		{
		  for(j=i+1; j < bits+1; j++)
		    {
		      for(k = j+1; k < bits+1; k++)
			{
			  multiply(Gx[row],Gx[i],Gx[j]);
			  multiply(Gx[row],Gx[row],Gx[k]);
			  row++;
			}
		    }
		}
	    }
	}
    }
  
}


void multiply(int *out, int *v1,int *v2)
{
  int i;
  for(i=0; i < RM_N ; i++)
    {
      if((v1[i] == 1) && (v2[i] == 1))
	out[i] = 1;
      else
	out[i] = 0;
    }
}


double bico(int n, int k)
{
  double temp; 
  return (factorial(n)/(factorial(k)*factorial(n-k)));
  
}
int factorial(int n)
{
  int i , temp;
  temp = 1;
  for(i=2; i > n+1; i++)
    temp *= i;
  return temp; 
}


void Find_L_R(int *L,int *R,int *Given_row, int n)
{

  int i;
  for (i = 0; i < RM_N; i++)
    {
      if(Given_row[i] == 1)
	{
	  L[n] = i;
	  break;
	}
    }

  for(i = RM_N-1; i >= 0; i--)
    {
      if(Given_row[i] == 1)
	{
	  R[n] = i; 
	  break;
	}
    }
}


void AddXYtoX(int *X,int *Y)
{
  int i; 
  for (i = 0; i < RM_N; i++)
    {
      X[i] = X[i]^Y[i];
    }

}

char Check(int *L, int *R)
{
  int i,j;
  for (i = 0 ; i < RM_K ; i++)
    {
      for (j = i+1; j < RM_K; j++)
	{
	  if ((L[i] == L[j])|| (R[i] == R[j]))
	    {
	      return('y');
	      break;
	    }
	}
    }
  return('n'); 
}


void MSGM(int Gen[][33])
{
  int i,j,k;
  int Temp[RM_K][RM_N];
  for(i = 0; i < RM_K; i++)
    Find_L_R(Left,Right,Gen[i],i);

  
  while (Check(Left,Right) == 'y')
    {
      for (i = 0; i < RM_K; i++)
	{
	  for (j = i+1; j < RM_K; j++)
	    {
	      if(Left[i] == Left[j])
		{
		  if(Right[i] >= Right[j])
		    {
		      AddXYtoX(Gen[i],Gen[j]);
		      Find_L_R(Left,Right,Gen[i],i);
		    }
		  else
		    {
		      AddXYtoX(Gen[j],Gen[i]);
		      Find_L_R(Left,Right,Gen[j],j);
		    }
		}
	      else
		{
		  if(Right[i] == Right[j])
		    {
		      if(Left[i] >= Left[j])
			{
			  AddXYtoX(Gen[j],Gen[i]);
			  Find_L_R(Left,Right,Gen[j],j);
			}
		      else
			{
			  AddXYtoX(Gen[i],Gen[j]);
			  Find_L_R(Left,Right,Gen[i],i);
			}
		    }
		}
	    }
	}
    }
  
  int numk=0;
  for(i=0; i < RM_N; i++)
    {
      for(j=0; j < RM_K; j++)
	{
	  if(Left[j] == i)
	    {
	      for(k=0; k < RM_N; k++)
		Temp[numk][k] = Gen[j][k];
	      numk++;
	      break;
	    }
	}
    }

  for(i=0; i < RM_K; i++)
    for(j=0; j < RM_N; j++)
      Gen[i][j] = Temp[i][j];

  for(i=0; i < RM_K; i++)
    Find_L_R(Left,Right,Gen[i],i);



  Echelon(Gen);
  
  int past[RM_N];
  int future[RM_N];
  
  for (i=0; i < RM_N; i++)
    {
      past[i] = 0;
      future[i] = 0;
    }
       

  for (i=0; i < RM_N; i++)
    {
      for (j=0; j < RM_K; j++)
	{
	  if (Right[j] <= i)
	    past[i]++;
	}
      for (k=0; k < RM_K ; k++)
	{
	  if (Left[k] >= i+1)
	    future[i]++;
	}
    }

  statecomplex[0] = 0;
  for(i = 1; i <= RM_N ; i++)
    {
      statecomplex[i] =  RM_K-past[i-1]-future[i-1]; 
    }

  for(i = 1; i <= RM_N ; i++)
    {
      statecomplex[i] =  RM_K-past[i-1]-future[i-1]; 
    }
}

void Echelon(int Gen[][33])
{
  int i,j;
  for(i=0; i < RM_K; i++)
    {
      for(j=i-1; j >= 0; j--)
	{
	  if(Gen[j][Left[i]] == 1)
	    AddXYtoX(Gen[j],Gen[i]);
	}
    }
}

void RMencoder(double *Out,int *In)
{
  int i,j;
  double temp;

  for(i=0; i < RM_N; i++)
    {
      temp = 0;
      for(j=0; j < RM_K; j++)
	temp += ((In[j]+1)/2)*Gx[j][i];

      if(fmod(temp,2.0) == 0)
	Out[i] = -1;
      else Out[i] = 1;      
    }
}
void Trellis(void)
{
  int i,j,k;
  int countnode,nodenum,numbranch;
  countnode = 0;
  
  for(i=0; i < RM_N; i++)
    countnode += (int) pow(2,statecomplex[i]);
  
  nodenum = 0;
  for(i=0; i < RM_N+1; i++)
    {
      for(j=0; j < pow(2,statecomplex[i]); j++)
	{
	  node[nodenum].setTime(i);
	  nodenum++;
	}
    }
  
  int startnodeattime;
  startnodeindex[0] = 0;
  startnodeindex[1] = 1;
  for(i=2; i < RM_N+1; i++)
    startnodeindex[i] = startnodeindex[i-1] + (int) pow(2,statecomplex[i-1]);
  
  for(i=1; i < RM_N; i++)
    {
      if(statecomplex[i-1] < statecomplex[i])
	startbranchindex[i] = startbranchindex[i-1] + (int)pow(2,statecomplex[i]);
      else if(statecomplex[i-1] == statecomplex[i])
	startbranchindex[i] = startbranchindex[i-1] + 2*(int)pow(2,statecomplex[i]);
      else if (statecomplex[i-1] > statecomplex[i])
	startbranchindex[i] = startbranchindex[i-1] + (int)pow(2,statecomplex[i-1]);
    }
  
  int id[nodenum][RM_N];
  int dim,s;
  for(i=0; i < nodenum; i++)
    for(j=0; j < RM_N; j++)
      id[i][j] = -1;
  
  id[0][0] = -2;
  
  nodenum = 0;
  numbranch = 0;
  int test;

  for(i=0; i < RM_N; i++)
    {
      for(dim=0; dim < RM_K; dim++)
	{
	  if(i == Left[dim])
	    {s = dim; break;}
	  else {s = -1;}
	}
      
	  if(s >= 0)
	    {
	      int n=0;
	      for(k=0; k < pow(2,statecomplex[i]); k++)
		{
		  if(k == 0)
		    {
		      for(j=0; j < 2; j++)
			{
			  branch[numbranch].setOriginaltime(i);
			  branch[numbranch].setOriginal(findstate(id[nodenum],RM_N-i));
			  branch[numbranch].setOriginalnode(nodenum);
			  
			  if(j==0)
			    {
			      branch[numbranch].setDestinationnode(startnodeindex[i+1]+2*k+j);
			      fillid(id[branch[numbranch].getOriginalnode()],id[branch[numbranch].getDestinationnode()],s,-1);
			      branch[numbranch].setDestination(findstate(id[startnodeindex[i+1]+2*k+j],RM_N-i-1));
			      branch[numbranch].setBit(findbit(i,branch[numbranch].getOriginal(),id[startnodeindex[i+1]+2*k+j]));
			      node[startnodeindex[i+1]+2*k+j].setStage(branch[numbranch].getDestination());
			      n++;
			    }
			  else
			    {
			      branch[numbranch].setDestinationnode(startnodeindex[i+1]+2*k+j);
			      fillid(id[branch[numbranch].getOriginalnode()],id[branch[numbranch].getDestinationnode()],s,1);
			      branch[numbranch].setDestination(findstate(id[startnodeindex[i+1]+2*k+j],RM_N-i-1));
			      branch[numbranch].setBit(findbit(i,branch[numbranch].getOriginal(),id[startnodeindex[i+1]+2*k+j]));
			      node[startnodeindex[i+1]+2*k+j].setStage(branch[numbranch].getDestination());
			      n++;
			    }
			  
			  numbranch++;
			}// loop j
		      nodenum++;
		    } // if(k==0) statement
		  else
		    {
		      int value,l,m, arrayvalue[RM_N];
		      char found;
		      for(j=0; j < 2; j++)
			{
			  branch[numbranch].setOriginaltime(i);
			  branch[numbranch].setOriginal(findstate(id[nodenum],RM_N-i));
			  branch[numbranch].setOriginalnode(nodenum);
			  
			  if(j==0)
			    {
			      
			      value = branch[numbranch].getOriginal();
			      for(l=RM_N-i-1; l >= 0; l--)
				{