code4.c

快速傅立叶变换程序代码,学信号的同学,可要注意了

    break ; 
  case(4):
    code->C1 = cmatrix ( 1 , dc->N , 1 , dc->N ) ; 
    code->C1I = cmatrix ( 1 , dc->N , 1 , dc->N ) ; 
  
    code->C2 = cmatrix ( 1 , dc->N , 1 , dc->N ) ; 
    code->C2I = cmatrix ( 1 , dc->N , 1 , dc->N ) ; 
    sparse_invertible_cmatrix ( code->C1I , code->C1 , dc->pC1.per_row , dc->N ) ;
    sparse_invertible_cmatrix ( code->C2 , code->C2I , dc->pC2.per_row , dc->N ) ;
  
    status += cmatrices_2_alist ( code->C2 , code->C1I , a , dc->N , 0 ) ;
    break; 
  case(1): 
  
    code->C1 = cmatrix ( 1 , dc->N , 1 , dc->N ) ; 
    code->C1I = cmatrix ( 1 , dc->N , 1 , dc->N ) ; 
    sparse_invertible_cmatrix ( code->C1 , code->C1I , dc->pC1.per_row , dc->N ) ;
    
    status += cmatrix_2_alist ( code->C1 , a , dc->N ) ; 
    break ;
  case(3):
  
    code->C1 = cmatrix ( 1 , dc->N , 1 , dc->N ) ; 
    code->C1I = cmatrix ( 1 , dc->N , 1 , dc->N ) ; 
    sparse_invertible_cmatrix ( code->C1 , code->C1I , dc->pC1.per_row , dc->N ) ;
    
    status += cmatrix_andI_2_alist ( code->C1 , a , dc->N , 0 ) ;
    break ;
  case ( 0):
/* make MNC=0 style of A matrix -- see cg.c, but go directly to list 
 representation */
    status += code0_matrix_alist ( a , dc->N , dc->M , dc->pC1.per_row ) ;
    break ; 
  default : 
    status --;
    break ; 
  }

  if ( dc->pbm_o ) {
    fp = fopen ( dc->pbm_ofile , "w" ) ;
    if ( !fp ) fprintf ( stderr ,  "can't open %s \n" , dc->pbm_ofile ) ; 
    else {
      cmatrix2pbm ( code->C1I , 1 , dc->N , 1 , dc->N , fp ) ; 
      fclose ( fp ) ; 
    }
    fp = fopen ( dc->pbm_ofile2 , "w" ) ;
    if ( !fp ) fprintf ( stderr, "can't open %s \n" , dc->pbm_ofile2 ) ; 
    else {
      cmatrix2pbm ( code->C2 , 1 , dc->N , 1 , dc->N , fp ) ; 
      fclose ( fp ) ; 
    }
    if ( dc->pbm_xv ) {
      sprintf ( junk , "xv %s -geometry +10+10 &" , dc->pbm_ofile ) ;
      system ( junk ) ;
      sprintf ( junk , "xv %s -geometry +200+10 &" , dc->pbm_ofile2 ) ;
      system ( junk ) ;
    }
  }
  return status ; 
}

static int report_code ( code_creation *dc , mnc_code *code , alist_matrix *a ) {
  int status = 0 ; 

  if ( dc->verbose ) printf ( "The code\n" ) ; 

  if ( dc->verbose ) {
    switch ( dc->MNC ) {
    case ( 2) :
      printoutcmatrix ( code->C1 , 1 , dc->N , 1 , dc->N ) ; 
      printoutcmatrix ( code->C2I , 1 , dc->N , 1 , dc->N ) ; 
      break ; 
    case(4):
      printoutcmatrix ( code->C1I , 1 , dc->N , 1 , dc->N ) ; 
      printoutcmatrix ( code->C2 , 1 , dc->N , 1 , dc->N ) ; 
      break; 
    case(1): 
      printoutcmatrix ( code->C1 , 1 , dc->N , 1 , dc->N ) ; 
      break ;
    case(3):
      printoutcmatrix ( code->C1 , 1 , dc->N , 1 , dc->N ) ; 
      break ;
    case ( 0):
      printf ( "Code is only defined by alist\n" ) ; 
      break ; 
    default : 
      status --;
      break ; 
    }
    report_alist ( a , dc->verbose + 1 ) ; 
  }

  return status ; 
}

static int free_code ( code_creation *dc , mnc_code *code ) {
/* frees up the C matrix bit of the code (leaving the alist alone) */
  int status = 0 ; 
  int N = dc->N ; 

  switch ( dc->MNC ) {
  case ( 2) :
    free_cmatrix (     code->C1 , 1 , N , 1 , N ) ; 
    free_cmatrix (     code->C1I , 1 , N , 1 , N ) ; 
    free_cmatrix (     code->C2 , 1 , N , 1 , N ) ; 
    free_cmatrix (     code->C2I , 1 , N , 1 , N ) ; 
    break ; 
  case(4):
    free_cmatrix (     code->C1 , 1 , N , 1 , N ) ; 
    free_cmatrix (     code->C1I , 1 , N , 1 , N ) ; 
    free_cmatrix (     code->C2 , 1 , N , 1 , N ) ; 
    free_cmatrix (     code->C2I , 1 , N , 1 , N ) ; 
    break; 
  case(1): 
    free_cmatrix (     code->C1 , 1 , N , 1 , N ) ; 
    free_cmatrix (     code->C1I , 1 , N , 1 , N ) ; 
    break ;
  case(3):
    free_cmatrix (     code->C1 , 1 , N , 1 , N ) ; 
    free_cmatrix (     code->C1I , 1 , N , 1 , N ) ; 
    break ;
  case ( 0):
    break ; 
  default : 
    status --;
    break ; 
  }
  return status ; 
}

static int check_alist ( alist_matrix *alist ,  code_creation *dc )
{
  int status = 0 ; 
  int tmpi = 0 , n , m , MNC = dc->MNC ; 

  if ( dc->verbose ) printf ( "Checking alist\n" ) ; 

  if ( MNC == 0 || MNC == 1 || MNC == 2 || MNC == 4 ) {
    /* then every col should have more than 1 1 in it */
    for ( n = 1 ; n <= alist->N ; n ++ ) {
      if ( alist->num_nlist[n] <= 1 ) {
	tmpi ++ ; 
	fprintf ( stderr , "%d:" , n ) ; 
      }
    }
    if ( tmpi > 0 ) {
      fprintf ( stderr , "Warning unchecked bits n : %d\n", tmpi ) ;
      status -- ; 
    }
  }

  if ( MNC == 1 || MNC == 2 || MNC == 3 || MNC == 4 ) {
    /* then every row should have more than 1 1 in it */

    tmpi = 0 ; 
    for ( m = 1 ; m <= alist->M ; m ++ )  {
      if ( alist->num_mlist[m] <= 1 ) {
	tmpi ++ ; 
	fprintf ( stderr , "%d:" , m ) ; 
      }
    }
    if ( tmpi > 0 ) {
      fprintf ( stderr , "Warning unchecked bits n : %d\n", tmpi ) ;
      status -= 10 ; 
    }
  }
  if ( status < 0 && dc->verbose ) {
    fprintf ( stderr , "Failing ... here is the offending alist\n" ) ;
    report_alist ( alist , 2 ) ; 
  }
  else if ( dc->verbose >= 2 )   {
    report_alist ( alist , dc->verbose ) ; 
  }
  return status ; 
}

static void dc_defaults ( code_creation *dc ) 
{
#include "code4_var_def.c"
}

static int process_command ( int argc , char **argv , code_creation *dc ) {

  int p_usage = 0 ;
  int status = 0 ;
  int cs , i , fake ;

  if ( argc < 1 )     {
    p_usage = 1 ; 
    status -- ;
  }

#define ERROR1 fprintf ( stderr , "arg to `%s' missing\n" , argv[i] ) ; \
               status --
#define ERROR2 fprintf ( stderr , "args to `%s' missing\n" , argv[i] ) ; \
               status --
#define ERRORREG fprintf ( stderr , "regtype must be defined before `%s'\n" , argv[i] ) ; \
               status --
  for (i = 1 ; i < argc; i++)    {
    cs = 1 ;
    if ( strcmp (argv[i], "-fake") == 0 ) {
      if ( i + 1 == argc ) { ERROR1;      }
      else cs *= sscanf(argv[++i], "%d", &(fake)); 
    }  
#include "code4_var_clr.c"
/*
    else   if ( strcmp (argv[i], "-mseed") == 0 )        {
      if ( i + 1 == argc ) { ERROR1;      }
      else cs *= sscanf(argv[++i], "%ld", &(dc->mseed)); 
    }  
    else if ( strcmp (argv[i], "-t1") == 0 ) {
      if ( i + 1 == argc ) { ERROR1;      }
      else cs *= sscanf(argv[++i], "%d", &(dc->pC1.per_row ) ); 
    }
    else if ( strcmp (argv[i], "-t2") == 0 ) {
      if ( i + 1 == argc ) { ERROR1;      }
      else cs *= sscanf(argv[++i], "%d", &(dc->pC2.per_row ) ); 
    }
    else  if ( strcmp (argv[i], "-o") == 0 )	{
      if ( i + 1 == argc ) 	    { ERROR1;      }
      else {
	strcpy(c->outfile, argv[++i]);
	if ( !(c->printout) ) c->printout = 1 ;
      }
    }
    else  if ( strcmp (argv[i], "-xv") == 0 )	{
      if ( i + 1 == argc ) { ERROR1;      }
      else cs *= sscanf(argv[++i], "%d", &(dc->pbm_xv )); 
    }
    else  if ( strcmp (argv[i], "-pbm") == 0 )	{
      if ( i + 1 == argc ) 	    { ERROR1;      }
      else {
	strcpy(dc->pbm_ofile, argv[++i]);
	if ( !dc->pbm_o ) dc->pbm_o = 1 ;
      }
    }
*/
    else {
      fprintf ( stderr , "arg `%s' not recognised\n" , argv[i] ) ; 
      p_usage = 1 ;
      status -- ;
    }
    if ( cs == 0 ) {
      fprintf ( stderr , "arg at or before `%s' has incorrect format\n" , 
	       argv[i] ) ;
      p_usage = 1 ;
      status -- ;
    }
  }
  if ( p_usage ) print_usage ( argv , stderr , dc ) ;
  return ( status ) ;
}
#undef ERROR1
#undef ERROR2
#undef ERRORREG

#define DNT fprintf( fp, "\n        ")
#define NLNE  fprintf( fp, "\n")

static void print_usage ( char **argv , FILE * fp ,
			  code_creation *dc
)
{
  fprintf( fp, "Usage: %s ",argv[0]);
  fprintf( fp, " [optional arguments]");

#include "code4_var_usg.c"
  return ;
}
#undef DNT
#undef NLNE


/*
<!-- hhmts start -->
Last modified: Tue May  2 18:56:01 1995
<!-- hhmts end -->
*/