common.c

此文件用于仿真MIMO-STBC 系统性能程序

/*********************************************************************/
/*  The file consists random number generation function         		*/
/*********************************************************************/

#include "STBC_includ.h"

/* generate a uniform number in (0,1) */
double ran1(long *idum)
{
   int j;
   long k;
   static long iy=0;
   static long iv[NTAB];
   double temp;

   /* printf("incoming idum: %d\n",*idum); */
   if (*idum <=0 || !iy) 
   {
      if (-(*idum) < 1) *idum=1;
      else *idum = -(*idum);
      /* printf("in routine1: %d\n",*idum); */
      for (j=NTAB+7; j>=0; j--) 
      {
         k=(*idum)/IQ;
         *idum=IA*(*idum-k*IQ)-IR*k;
      /* printf("in routine %d: %d\n",j,*idum); */
         if (*idum < 0) *idum += IM;
         if (j < NTAB) iv[j] = *idum;
      }
      iy = iv[0];
   }
   k=(*idum)/IQ;
   *idum=IA*(*idum-k*IQ)-IR*k;
   if (*idum < 0) *idum += IM;
   j=iy/NDIV;
   iy=iv[j];
   iv[j] = *idum;
     /* printf("in routine: %d\n",*idum); */
   if ((temp=AM*iy) > RNMX) return RNMX;
   else return temp;
}

/*generate Gaussian distribution,mean 0 and standard deviate 1*/
t_COMPLEX Cgaussian(long *idum)
{
   static int iset=0;
   static double gset;
   double fac,r,v1,v2;
   t_COMPLEX s_temp_complex;
    
   do 
   {
      v1=2.0*ran1(idum)-1.0;
      v2=2.0*ran1(idum)-1.0;
      r=v1*v1+v2*v2;
   } while (r >= 1.0 || r == 0.0);
   fac=sqrt(-2.0*log(r)/r);

   s_temp_complex.real = sqrt(1.0/2.0)* v1*fac;
   s_temp_complex.imag = sqrt(1.0/2.0)* v2*fac;
   
   return s_temp_complex;
}

t_COMPLEX complextimes(t_COMPLEX a, t_COMPLEX b)
{
   t_COMPLEX c;

   c.real = a.real * b.real - a.imag * b.imag;
   c.imag = a.imag * b.real + a.real * b.imag;

   return c;
}

double complex_dist(t_COMPLEX a)
{
   double c;

   c = sqrt(pow(a.real,2) + pow(a.imag,2));

   return c;
}

double get_max(double *p_array,int size)
{
   double *p_temp;
   double d_max;
   int j;

   p_temp = p_array;
   d_max = *p_temp;

   for (j=2;j<size;j++)
   {
      p_temp++;
      if (*p_temp > d_max)
         d_max = *p_temp;
   }
   return d_max;
}

double get_min(double *p_array,int size)
{
   double *p_temp;
   double d_min;
   int j;

   p_temp = p_array;
   d_min = *p_temp;

   for (j=1;j<size;j++)
   {
      p_temp++;
      if (*p_temp < d_min)
         d_min = *p_temp;
   }
   return d_min;
}

/* change the decimal number into binary vector*/
void de_to_bi(int num, int *bin, int length)
{
	int dec;

	dec = num;
   /* the start point from length - 1*/
   length--;
	while (dec != 0 )
	{	
      if (dec%2 == 0)
         bin[length] = 0;
      else
         bin[length] = 1;
      dec = dec/2;
      length--;
	}
}

/* change the decimal number into binary vector*/
void vec_to_matrix(int *gen_vector, int gen_matrix_temp[][N_BIT])
{
   int i,j;
   int *pointer_temp_1;

   /* point to the first address of the vector*/
   pointer_temp_1 = gen_vector;

   for(i = 0; i < K_BIT; i++)
      for(j = 0; j < N_BIT; j++)
      {
         gen_matrix_temp[i][j] = *pointer_temp_1;
         pointer_temp_1++;
      }
}

/*matrix multiplication, modulate M*/
void mtxmtx(int **a, int **b, int **c,int m,int l,int n, int M)
/* c[m][n]=a[m][l]*b[l][n] */
{
   int i,j,k;
   int *a_1[MAX_K_BIT], *b_1[MAX_K_BIT],*c_1[MAX_K_BIT];
   
   /* transform each vector a, b, c into matrix*/
   for (i = 0; i < m; i++)
      a_1[i] = (int *)a + i * l;

   for (i = 0; i < l; i++)
      b_1[i] = (int *)b + i * n;

   for (i = 0; i < m; i++)
      c_1[i] = (int *)c + i * n;

   for (i=0; i<m; i++)
      for (j=0; j<n; j++)
      { 
         c_1[i][j]=0;
	      for (k=0; k<l; k++)
	         c_1[i][j] += a_1[i][k] * b_1[k][j]; 
                  
         /* each element mod M*/
         c_1[i][j] = c_1[i][j] % M;
      }
}


/* convert the block matrix into gray code matrix, each row will consist num_sig of signals*/
void binary_to_gray(int conv_bit[][N_BIT], int row, int col, int num_sig)
{
   int i, j, k;
   int num_bit_sig; 

   /*number of bit per signal*/
   num_bit_sig = col / num_sig;
   
   for (i = 0; i < row; i++)
      for (j = 0; j < num_sig; j++)
         for (k = 1; k < num_bit_sig; k++)
            if(conv_bit[i][j*num_bit_sig + k - 1] == 1)
               conv_bit[i][j*num_bit_sig + k] = 1 - conv_bit[i][j * num_bit_sig + k];
}