ft_02.cc

这是一个从音频信号里提取特征参量的程序

	  
	  // output the experiment characteristics
	  //
	  if (level_a >= Integral::DETAILED) {
	    
	    String value;
	    String output;
	    
	    // output the current data precision
	    //
	    value.assign(L"float");
	    output.debugStr(name(), L"forward transform", L"data precision",
			    value);
	    Console::put(output);
	    
	    // output the current order
	    //
	    value.assign(curr_length);
	    output.debugStr(name(), L"forward transform", L"transform order",
			    value);
	    Console::put(output);
	    
	    // output the forward implementation type
	    //
	    output.debugStr(name(), L"forward transform", L"forward impl",
			    IMPL_MAP.getName(ft5.getImplementation()));
	    Console::put(output);
	  }
	  
	  // make sure we aren't doing a dft on a very large order
	  //
	  if (((curr_forward_algo != DFT) && (curr_inverse_algo != DFT)) ||
	      (curr_length <= 1024)) {
	    
	    // compute the forward real transform
	    //
	    ft5.setDirection(FourierTransform::FORWARD);	      
	    if (!ft5.compute(freq_vector, real_input_vector)) {
	      Error::handle(name(), L"compute", Error::TEST,
			    __FILE__, __LINE__);
	    }
	    
	    // now setup the the inverse complex transform
	    //
	    ft5.setAlgorithm(curr_inverse_algo);
	    ft5.setImplementation(curr_inverse_impl);
	    ft5.setDirection(FourierTransform::INVERSE);
	    
	    // output the experiment characteristics
	    //
	    if (level_a >= Integral::DETAILED) {
	      
	      String value;
	      String output;
	      
	      // output the inverse implementation type
	      //
	      output.debugStr(name(), L"inverse transform", L"inverse impl",
			      IMPL_MAP.getName(ft5.getImplementation()));
	      Console::put(output);
	      
	      // output input and output vectors
	      //
	      real_input_vector.debug(L"real_input");
	      freq_vector.debug(L"freq_output");
	    }
	    
	    // compute the inverse complex transform
	    //
	    if (!ft5.compute(inverse_vector, freq_vector)) {
	      Error::handle(name(), L"compute", Error::TEST,
			    __FILE__, __LINE__);
	    }
	    
	    // compute the snr for this operation
	    //
	    // get the sum of the squares for the input
	    //
	    double signal_power = real_input_vector.sumSquare();
	    
	    // get the real part of the inverse vector
	    //
	    inverse_vector.real(real_inverse_vector);
	    
	    // generate the difference signal - for the real transform, we
	    // need to remove the 0.0 imaginary parts - we'll just add them
	    // to the noise component
	    //
	    real_diff_vector.sub(real_inverse_vector, real_input_vector);
	    double noise_power = (double)real_diff_vector.sumSquare();
	    
	    // compute the snr
	    //
	    Double snr = signal_power / noise_power;
	    snr.log10();
	    snr *= Integral::DB_POW_SCALE_FACTOR;
	    
	    // print the snr
	    //
	    if (level_a >= Integral::DETAILED) {
	      
	      String value;
	      String output;
	      
	      // output the current order
	      //
	      value.assign(snr, L"%g");
	      output.debugStr(name(), L"forward to inverse", L"SNR",
			      value);
	      Console::put(output);
	      
	      // output vectors
	      //
	      inverse_vector.debug(L"inverse_output");
	      
	      Float temp_float;
	      temp_float = signal_power;
	      temp_float.debug(L"signal_power");
	      temp_float = noise_power;
	      temp_float.debug(L"noise_power");
	    }
	    
	    // print a separating line
	    //
	    if (level_a >= Integral::DETAILED) {
	      Console::put(L"\n");
	    }
	    
	    // repeat for complex transforms:
	    //  setup the forward complex transform
	    //
	    ft5.setAlgorithm(curr_forward_algo);
	    ft5.setImplementation(curr_forward_impl);
	    
	    // output the experiment characteristics
	    //
	    if (level_a >= Integral::DETAILED) {
	      
	      String value;
	      String output;
	      
	      // output the data precision
	      //
	      value.assign(L"float");
	      output.debugStr(name(), L"forward transform",
			      L"data precision", value);
	      Console::put(output);
	      
	      // output the current order
	      //
	      value.assign(curr_length);
	      output.debugStr(name(), L"forward transform",
			      L"transform order", value);
	      Console::put(output);
	      
	      // output the forward implementation type
	      //
	      output.debugStr(name(), L"forward transform", L"forward impl",
			      IMPL_MAP.getName(ft5.getImplementation()));
	      Console::put(output);
	    }
	    
	    // compute the forward complex transform
	    //
	    ft5.setDirection(FourierTransform::FORWARD);
	    if (!ft5.compute(freq_vector, complex_input_vector)) {
	      Error::handle(name(), L"compute", Error::TEST, __FILE__,
			    __LINE__);
	    }
	    
	    // now setup the the inverse complex transform
	    //
	    ft5.setAlgorithm(curr_inverse_algo);		
	    ft5.setImplementation(curr_inverse_impl);
	    ft5.setDirection(FourierTransform::INVERSE);
	    
	    // output the experiment characteristics
	    //
	    if (level_a >= Integral::DETAILED) {
	      
	      String value;
	      String output;
	      
	      // output the current order
	      //
	      output.debugStr(name(), L"inverse transform", L"inverse impl",
			      IMPL_MAP.getName(ft5.getImplementation()));
	      Console::put(output);
	      
	      // output input and output vectors
	      //
	      complex_input_vector.debug(L"complex_input");
	      freq_vector.debug(L"freq_output");
	    }
	    
	    // compute the inverse complex transform
	    //
	    if (!ft5.compute(inverse_vector, freq_vector)) {
	      Error::handle(name(), L"compute", Error::TEST, __FILE__,
			    __LINE__);
	    }
	    
	    // compute the snr for this operation
	    //  get the sum of the squares for the input
	    //
	    // signal_power = complex_input_vector.sumSquare();
	    //
	    signal_power = 0;
	    for (long i = 0; i < complex_input_vector.length(); i++) {
	      float temp_float = complex_input_vector(i).mag();
	      signal_power += temp_float * temp_float;
	    }
	    
	    // generate the difference signal - for the real transform, we
	    // need to remove the 0.0 imaginary parts - we'll just add them
	    // to the noise component
	    //
	    complex_diff_vector.assign(complex_input_vector);
	    complex_diff_vector.sub(inverse_vector);
	    
	    // noise_power = complex_diff_vector.sumSquare();
	    //
	    noise_power = 0;
	    for (long i = 0; i < complex_diff_vector.length(); i++) {
	      float temp_float = complex_diff_vector(i).mag();
	      noise_power += temp_float * temp_float;
	    }
	    
	    // compute the snr
	    //
	    snr = signal_power / noise_power;
	    snr.log10();
	    snr *= Integral::DB_POW_SCALE_FACTOR;
	    
	    // print the snr
	    //
	    if (level_a >= Integral::DETAILED) {
	      
	      String value;
	      String output;
	      
	      // output the current order
	      //
	      value.assign(snr, L"%g");
	      output.debugStr(name(), L"forward to inverse", L"SNR",
			      value);
	      Console::put(output);
	      
	      // output vectors
	      //
	      inverse_vector.debug(L"inverse_output");
	      
	      Float temp_float;
	      temp_float = signal_power;
	      temp_float.debug(L"signal_power");
	      temp_float = noise_power;
	      temp_float.debug(L"noise_power");
	    }
	    
	    // make sure the snr is sufficient
	    //
	    if (snr < min_float_prec) {
	      Error::handle(name(), L"snr too low", Error::TEST, __FILE__,
			    __LINE__);
	    }
	    
	    // print a separating line
	    //
	    if (level_a >= Integral::DETAILED) {
	      Console::put(L"\n");
	    }
	  }
	  else {
	    if (level_a >= Integral::DETAILED) {	      
	      String tmp(L"skipping DFT test for this length");
	      Console::put(tmp);
	    }
	  }
	} // end loop over inverse transform implementations
      } // end loop over forward transform implementations
    } // end loop over the test_data_type
  } // end of data length loop
  
  // check implementation accuracy for zero-padded data
  //
  if (level_a > Integral::BRIEF) {
    Console::put(L"\ntesting implementations. running randomized data through a");
    Console::put(L"forward transform and then inverting. if the SNRs");
    Console::put(L"between the input and inverse are less than 100dB for");
    Console::put(L"floats the test fails. zero-padding is used for ");
    Console::put(L"transforms where the size is incompatible\n");
  }
  
  // create a block for floats
  //
  
  // create a temporary FourierTransform object for computation
  //
  ft5.setResolution(FourierTransform::FIXED);
  
  // setup vectors for holding data
  //
  real_input_vector.setCapacity(data_lengths[num_lengths - 1]);
  
  complex_input_vector.setCapacity(data_lengths[num_lengths - 1]);
  
  freq_vector.setCapacity(data_lengths[num_lengths - 1]);
  
  inverse_vector.setCapacity(data_lengths[num_lengths - 1]);
  
  real_inverse_vector.setCapacity(data_lengths[num_lengths - 1]);
  
  real_diff_vector.setCapacity(data_lengths[num_lengths - 1]);
  
  complex_diff_vector.setCapacity(data_lengths[num_lengths - 1]);
  
  // loop over the different data lengths
  //
  for (long length_ind = 0; length_ind < num_lengths; length_ind++) {
    
    long curr_length = data_lengths[length_ind];
    long curr_desired_length = desired_lengths[length_ind];
    
    // clear all of the data arrays and start over
    //
    real_input_vector.setLength(curr_length, false);
    complex_input_vector.setLength(curr_length, false);
    
    // generate the input data
    //
    real_input_vector.rand();
    complex_input_vector.rand();
    
    // loop over the different implementation types for doing the forward
    // transform
    //
    for (long forward_ind = 0; forward_ind < num_impls; forward_ind++) {
      
      // set the forward transform implementation for this pass
      //
      ALGORITHM curr_forward_algo = forward_algo[forward_ind];
      IMPLEMENTATION curr_forward_impl = forward_impl[forward_ind];
      
      // loop over the different implementation types for doing the inverse
      // transform
      //
      for (long inverse_ind = 0; inverse_ind < num_inverse_impls;
	   inverse_ind++) {
	
	// set the forward transform implementation for this pass
	//
	ALGORITHM curr_inverse_algo = inverse_algo[inverse_ind];
	IMPLEMENTATION curr_inverse_impl = inverse_impl[inverse_ind];
	
	// setup the forward real transform
	//
	ft5.setImplementation(curr_forward_impl);
	
	// output the experiment characteristics
	//
	if (level_a >= Integral::DETAILED) {
	  
	  String value;
	  String output;
	  
	  // output the data precision
	  //
	  value.assign(L"float");
	  output.debugStr(name(), L"forward transform", L"data precision",
			  value);
	  Console::put(output);
	  
	  // output the current order
	  //
	  value.assign(curr_desired_length);
	  output.debugStr(name(), L"forward transform", L"transform order",
			  value);
	  Console::put(output);
	  
	  // output the data length
	  //
	  value.assign(curr_length);
	  output.debugStr(name(), L"forward transform", L"data length",
			  value);
	  Console::put(output);
	  
	  // output the forward implementation type
	  //
	  output.debugStr(name(), L"forward transform", L"forward impl",
			  IMPL_MAP.getName(ft5.getImplementation()));
	  Console::put(output);
	}
	
	// make sure we aren't doing a dft on a very large order
	//
	if (((curr_forward_algo != DFT) && (curr_inverse_algo != DFT)) ||
	    (curr_desired_length <= 1024)) {
	  
	  // compute the forward real transform
	  //
	  ft5.setAlgorithm(curr_forward_algo);
	  ft5.setImplementation(curr_forward_impl);
	  ft5.setDirection(FourierTransform::FORWARD);
	  ft5.setOrder(curr_desired_length);
	  ft5.setInputLength(curr_desired_length);
	  ft5.setOutputLength(curr_desired_length);	      
	  if (!ft5.compute(freq_vector, real_input_vector)) {
	    Error::handle(name(), L"compute", Error::TEST, __FILE__,
			  __LINE__);
	  }
	  
	  // now setup the the inverse complex transform
	  //
	  ft5.setAlgorithm(curr_inverse_algo);
	  ft5.setImplementation(curr_inverse_impl);
	  ft5.setDirection(FourierTransform::INVERSE);
	  
	  // output the experiment characteristics
	  //
	  if (level_a >= Integral::DETAILED) {
	    
	    String value;
	    String output;
	    
	    // output the current order
	    //
	    output.debugStr(name(), L"inverse transform", L"inverse impl",
			    IMPL_MAP.getName(ft5.getImplementation()));