complex.c

This model is just testing an idea of MIMO, which IEEE802.11n will have. But I havo not seen the s

/*****************************************************************************/
/*   FIle Name : complex.c                                                   */
/*   Description : utilities for complex & sets of complex                   */
/*   author : miffie                                                         */
/*   Date   : aug/09/05                                                      */
/*   Copyright (c) 2005 miffie   All rights reserved.                        */
/*****************************************************************************/
#include <stdio.h>
#include <math.h>

struct complex {
  double  realp ; //real part
  double  image ;
} ;

struct complexset {
  int 	size ;
  struct complex 	*data ;
} ;

struct complexsetset {
  int 	size ;
  struct complexset 	*set ;
} ;

struct complex multiply_complex( struct complex a,
                                 struct complex b ) {
struct complex product ;
  //printf(" (%6.3f %6.3f) * (%6.3f %6.3f) = ",  a.realp, a.image, b.realp, b.image ) ;

  product.realp  = a.realp*b.realp - a.image*b.image ;
  product.image  = a.realp*b.image + a.image*b.realp ;
  //printf(" (%6.3f %6.3f)\n",  product.realp, product.image ) ;

return (product) ;
} //multiply_complex


struct complex multiply_complexT( struct complex a,
                                 struct complex b ) {
struct complex product ;
//a *bT = a * (b.realp -j*b.image) 

  product.realp  = a.realp*b.realp + a.image*b.image ;
  product.image  = -a.realp*b.image + a.image*b.realp ;

return (product) ;
} //multiply_complexT

struct complex division_complex( struct complex a,
                                 struct complex b ) {
struct complex 	division  ;
double 		denominator ;

  denominator = (b.realp*b.realp) + (b.image*b.image ) ;
  if (denominator==0) { //error
    division.realp = 0 ;
    division.image = 0 ;
  } //error
  else {
    division.realp  = a.realp*b.realp + a.image*b.image ;
    division.realp  = division.realp / denominator ;
    division.image  = a.image*b.realp - a.realp*b.image ;
    division.image  = division.image / denominator ;
  }
//printf("a=%6.3f +j %6.3f b=%6.3f +j %6.3f a/b=%6.3f +j %6.3f \n",
//       a.realp, a.image, b.realp, b.image, division.realp, division.image ) ;
return (division) ;
} //division_complex

double power_radius( struct complex a ) {
double 		radius ;
  radius = a.realp*a.realp + a.image*a.image ;
return (radius) ;
} //power_radius

double polarizer( struct complex a ) {
struct complex 	division  ;
static  double pi = 3.14159265 ;
double 		angle ;
  // 
  angle = atan2( a.image , a.realp ) ;
  //PRINTF(" polarizer %6.3f + j* %6.3f = %6.3f\n", a.realp, a.image, angle ) ;
return (angle) ;
} //polarizer

struct complex cordic( struct complex a ) {
//realp : radius
//image : phase
struct complex 	out  ;
  // 
  out.realp = sqrt( (a.realp*a.realp) + (a.image*a.image) ) ; //radius
  out.image = atan2( a.image , a.realp ) ; //phase
return (out) ;
} //cordic

void print_complexset(struct complexset datain ) { 
struct complex 	*p ;
int 	ii ;
  if ( print_on ) { //
      PRINTF("print_complexset size=%d\n", datain.size ) ;
      p = datain.data ;
      ii = 0 ;
      for( ii=0;ii<datain.size;ii++) {//for
        PRINTF("%d %6.3f + j * %6.3f\n", ii, p->realp, p->image ) ;
        p++ ;
      } //for
  } // print_on 
}//print_complexset 

void fprint_complexset(char *filename, struct complexset datain ) { 
FILE 	*fp ;
struct complex 	*p ;
int 	ii ;

  if ( ( fp = fopen ( filename , "w"))==NULL) { //not open
         printf(" cannot open %s\n", *filename ) ;
  } //not open
  else { //open
      fprintf(fp, "print_complexset size=%d\n", datain.size ) ;
      p = datain.data ;
      ii = 0 ;
      for( ii=0;ii<datain.size;ii++) {//for
        fprintf(fp, "%d %6.3f + j * %6.3f\n", ii, p->realp, p->image ) ;
        p++ ;
      } //for
  } // open 
}//fprint_complexset 

struct complexset  allocate_complexset( int size ) {
struct complexset ctop ;
struct  complex	*top ;
     if ((top = (struct complex *)malloc(size*sizeof(struct complex)) ) == NULL) {
        PRINTF( " malloc failed in allocate_complexset\n") ;
     } //fail 
     else { //allocated
       ctop.size = size ;
       ctop.data = top ;
     } //allocated
   return(ctop) ;
}//allocate_complexset

struct complexset  cat_complexset(struct complexset data1,
                                struct complexset data2) { 
//concatinate  data1 followed by data2 into new memory locations 
struct  complex	*p , *q ;
struct  complex	*top ;
int	ii ,jj ;
int	size ;
struct complexset cset ;
     //size is number of bit

     size = data1.size + data2.size ;
     if ((top = (struct complex *)malloc(size*sizeof(struct complex)) ) == NULL) {
        PRINTF( " malloc failed in cat_complexset\n") ;
     } //fail 
     else { //allocated
       p = data1.data ;
       q = top ;
       for (jj=0;jj<data1.size;jj++) { //for
           q->realp = p->realp ;
           q->image = p->image ;
           q++ ; p++ ;
       }//for jj
       p = data2.data ;
       for (jj=0;jj<data2.size;jj++) { //for
           q->realp = p->realp ;
           q->image = p->image ;
           q++ ; p++ ;
       }//for jj
       cset.size = size ;
       cset.data = top ;
     } //allocated
   return(cset) ;
}//cat_complexset

struct complexset  merge_complexset(struct complexset data1,
                                struct complexset data2) { 
//merge  data2 into @ the end of data1 
struct  complex	*p , *q ;
int	jj ;
int	size ;
struct complexset cset ;
     size = data1.size + data2.size ;
     q = &data1.data[data1.size] ;
     p = data2.data ;
     for (jj=0;jj<data2.size;jj++) { //for
         q->realp = p->realp ;
         q->image = p->image ;
         q++ ; p++ ;
     }//for jj
     data1.size = size ;
     return(data1) ;
}//merge_complexset


struct complexset  extract_complexset(struct complexset datain,
                                int offset, int size ) {
struct 	complexset cset ;
struct  complex *top , *tmp1, *tmp2 ;
int     ii ;
//extract_complexset does not change "format"

     if ((offset+size) > datain.size ) { //error
        cset.size = 0 ;
        cset.data = NULL ;
      } //error
     else { //ok
       if ((top = (struct complex *)malloc(size*sizeof(struct complex)) ) == NULL) {
          PRINTF( " malloc failed in extract_complexset\n") ;
       } //fail 
       else { //allocated
         cset.size = size ;
         cset.data = top ; 
         tmp1 = top ;
         tmp2 = &datain.data[offset] ;
         for (ii=0;ii<size;ii++)  { //for
           tmp1->realp = tmp2->realp ;
           tmp1->image = tmp2->image ;
           tmp1++ ;
           tmp2++ ;
         }//for
       } //allocated
     } //ok
   printf("extract_complexset offset=%d size=%d\n", offset, cset.size) ;
   return(cset) ;
}//extract_complexset

struct complexset  copy_complexset(struct complexset datain) {
struct  complex    *p , *q ;
struct  complex    *top ;
int     jj ;
struct  complexset cset ;
     //size is number of byte
      //PRINTF(" copy_complexset size = %d\n" , datain.size ) ;

     if ((top = (struct complex *)malloc((datain.size)*sizeof(struct complex)) ) == NULL) {
        PRINTF( " malloc failed in copy_complexset\n") ;
     } //fail
     else { //allocated
       p = datain.data ;
       q = top ;
       for (jj=0;jj<datain.size;jj++) { //for
           q->realp = p->realp ;
           q->image = p->image ;
           q++ ; p++ ;
       }//for jj
       cset.size = datain.size ;
       cset.data = top ;
     } //allocated
   return(cset) ;
}//copy_complexset