gen_02.cc

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

  // declare an object
  //
  Generator gen8;

  // set the parameters manually
  //
  float freq2;
  float amp2;
  gen8.setSine(freq0, amp0, phase0, bias0);
  gen8.setComputeMode(ACCUMULATE);
  freq2 = gen8.getFrequency();
  amp2 = gen8.getAmplitude();

  if ((freq2 != freq0) || (amp2 != amp0)) {
    return Error::handle(name(), L"setSine", Error::TEST,
                         __FILE__, __LINE__);
  }

  // declare an object
  //
  Generator gen9;

  // set the parameters manually
  //
  float mean3;
  float var2;
  gen9.setAlgorithm(GAUSSIAN);
  gen9.setComputeMode(ACCUMULATE); 
  gen9.setGaussian(mean1, var0);
  mean3 = gen9.getMean();
  var2 = gen9.getVariance();

  if ((mean2 != mean1) || (var2 != var0)) {
    return Error::handle(name(), L"setGaussian", Error::TEST,
                         __FILE__, __LINE__);
  }

  // declare an object
  //
  Generator gen10;

  // set the parameters manually
  //
  float freq4;
  float amp4;
  float val2;
  gen10.setAlgorithm(TRIANGLE);
  gen10.setComputeMode(ACCUMULATE);
  gen10.setTriangle(freq0, amp0, phase0, val0, bias0);
  freq4 = gen10.getFrequency();
  amp4 = gen10.getAmplitude();
  val2 = gen10.getDutyCycle();
  
  if ((freq4 != freq0) || (amp4 != amp0) || (val2 != val0)) {
    return Error::handle(name(), L"setTriangle", Error::TEST,
                         __FILE__, __LINE__);
  }

  // reset indentation
  //
  if (level_a > Integral::NONE) {
    Console::decreaseIndention();
  }
  
  //--------------------------------------------------------------------------
  //
  // 4. class-specific public methods
  //     computation methods
  //
  //--------------------------------------------------------------------------

  if (level_a > Integral::NONE) {
    Console::put(L"testing class-specific public methods: computational methods...\n");
    Console::increaseIndention();
  }

  // test SINE algorithm with sample_frequency = 40, frame_duration = 0.5
  // signal_duration = 1, amplitude = 1, frequency = 2, phase = 0.0,
  // bias = 0.0.
  // 
  Generator gen11;
  Vector< CircularBuffer<AlgorithmData> > in;
  Vector<AlgorithmData> out;
  AlgorithmData data;  
  gen11.setChannel(2);
  out.setLength(2);
  VectorFloat output;
  VectorFloat input;
  VectorFloat ans;
  Vector<VectorFloat> result;
  result.setLength(2);

  // set parameters for computing sine signal samples 
  //
  gen11.setAlgorithm(SINE);
  gen11.setComputeMode(ACCUMULATE);
  gen11.setSampleFrequency(40);
  gen11.setFrameDuration(0.5);
  gen11.setSignalDuration(1);
  gen11.setAmplitude(1);
  gen11.setFrequency(2);
  gen11.setPhase(0);
  gen11.setBias(0); 
  Vector<Long> temAccumFrame;
  temAccumFrame.setLength(2);
  gen11.setAccumFrame(temAccumFrame);

  // compare out with correct result
  //
  result(0).assign(L"0.0, 0.309017, 0.587785, 0.809017, 0.951057, 1, 0.951057, 0.809017, 0.587785, 0.309017, -0, -0.309017, -0.587785, -0.809017, -0.951507, -1, -0.951057, -0.809017, -0.587785, -0.309017");
  result(1).assign(L"0.0, 0.309017, 0.587785, 0.809017, 0.951057, 1, 0.951057, 0.809017, 0.587785, 0.309017, -0, -0.309017, -0.587785, -0.809017, -0.951507, -1, -0.951057, -0.809017, -0.587785, -0.309017");
  for (long i = 0; i < 2; i++) {
    gen11.apply(out, in);
    for (long k = 0; k < 2; k++) {
      if (!result(i).almostEqual(out(k).getVectorFloat())) {
	result(k).debug(L"expected result");
	out(k).debug(L"sine output");
	return Error::handle(name(), L"compute", Error::TEST,
			     __FILE__, __LINE__);
      }
    }
  }
  
  // test PULSE algorithm with sample_frequency = 40, frame_duration = 0.5
  // signal_duration = 0.5, amplitude = 1, frequency = 2, phase = 0.0,
  // bias = 0.0.
  //
  Generator gen12;

  // set parameters for computing pulse signal samples 
  //
  gen12.setAlgorithm(PULSE);
  gen12.setComputeMode(ACCUMULATE);
  Vector<Long> temAccumFrame1;
  temAccumFrame1.setLength(1);
  gen12.setAccumFrame(temAccumFrame1);
  gen12.setSampleFrequency(40);
  gen12.setAmplitude(1);
  gen12.setFrequency(2);
  gen12.setSignalDuration(0.5);
  gen12.setFrameDuration(0.5);
  gen12.setPhase(0);
  gen12.setBias(0);
  gen12.setDutyCycle(50);
  
  // compare out with correct result
  //
  gen12.compute(output, input);
  ans.assign(L"1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0");

  if (!ans.almostEqual(output)) {
    ans.debug(L"expected result");
    output.debug(L"pulse output");
    return Error::handle(name(), L"compute", Error::TEST,
                         __FILE__, __LINE__);
  }
  
  // test SQUARE algorithm with sample_frequency = 40, frame_duration = 0.5
  // signal_duration = 1, amplitude = 1, frequency = 2, phase = 0.0,
  // bias = 0.0, duty_cycle = 50.
  //
  Generator gen13;
  
  // set parameters for computing square signal samples 
  //  
  gen13.setAlgorithm(SQUARE);
  gen13.setComputeMode(ACCUMULATE);
  Vector<Long> temAccumFrame2;
  temAccumFrame2.setLength(1);
  gen13.setAccumFrame(temAccumFrame2);
  gen13.setSampleFrequency(40);
  gen13.setAmplitude(1);
  gen13.setFrequency(2);
  gen13.setSignalDuration(1);
  gen13.setFrameDuration(0.5);
  gen13.setPhase(0.0);
  gen13.setBias(0);
  gen13.setDutyCycle(50);
  
  // compare out with correct result
  //
  gen13.compute(output, input);
  ans.assign(L"0.5, 0.5, 0.5, 0.5, 0.5, 0.5, 0.5, 0.5, 0.5, 0.5, -0.5, -0.5, -0.5, -0.5, -0.5, -0.5, -0.5, -0.5, -0.5, -0.5");

  if (!ans.almostEqual(output)) {
    ans.debug(L"expected result");
    output.debug(L"square output");
    return Error::handle(name(), L"compute", Error::TEST,
                         __FILE__, __LINE__);
  }

  // test TRIANGLE algorithm with sample_frequency = 40, frame_duration = 0.5
  // signal_duration = 0.5, amplitude = 1, frequency = 2, phase = 0.25 PI,
  // bias = 0.0, duty_cycle = 50.
  //
  Generator gen14;

  // set parameters for computing triangle signal samples 
  //
  gen14.setAlgorithm(TRIANGLE);
  gen14.setComputeMode(ACCUMULATE);
  Vector<Long> temAccumFrame3;
  temAccumFrame3.setLength(1);
  gen14.setAccumFrame(temAccumFrame3);
  gen14.setSampleFrequency(40);
  gen14.setAmplitude(1);
  gen14.setFrequency(2);
  gen14.setSignalDuration(0.5);
  gen14.setFrameDuration(0.5); 
  gen14.setPhase(0.25 * Integral::PI);
  gen14.setBias(0);
  gen14.setDutyCycle(50);

  // compare out with correct result
  //
  gen14.compute(output, input);
  ans.assign(L"0.6, 0.8, 1, 0.8, 0.6, 0.4, 0.2, 0, -0.2, -0.4, -0.6, -0.8, -1.0, -0.8, -0.6, -0.4, -0.2, 0, 0.2, 0.4");
  if (!ans.almostEqual(output)) {
    ans.debug(L"expected result");
    output.debug(L"triangle output");
    return Error::handle(name(), L"compute", Error::TEST,
                         __FILE__, __LINE__);
  }

  // test GAUSSIAN algorithm with sample_frequency = 40, frame_duration = 1,
  // signal_duration = 1, mean = 1.5, variance = -0.5
  //
  Generator gen15;
  VectorFloat in15;
  VectorFloat out15;
  VectorFloat ans15;

  // set parameters for computing gaussian signal samples 
  //
  gen15.setAlgorithm(GAUSSIAN);
  gen15.setComputeMode(ACCUMULATE);
  gen15.setMean(1.5);
  gen15.setSampleFrequency(40);
  gen15.setSignalDuration(1);
  gen15.setFrameDuration(1);
  gen15.setVariance(-0.5);
  gen15.setSeed(80);
  
  // compare out with correct result
  //
  gen15.compute(out15, in15);
  ans15.assign(L"0.910724, 0.952605, 1.43932, 1.33778, 2.2354, 1.19658, 1.04011, 1.82564, 1.52397, 1.78422, 1.57108, 0.904335, 2.51376, 1.23344, 1.86863, 1.85403, 1.58034, 1.21719, 1.20197, 1.3536, 1.2777, 0.802797, 1.5905, 2.50756, 0.990713, 1.67548, 1.68828, 1.29188, 2.12157, 1.52868, 1.33, 1.94327, 2.46537, 0.304354, 1.40373, 1.10345, 1.26428, 0.613523, 1.31932, 1.74106");
  if (!ans15.almostEqual(out15)) {
    ans15.debug(L"expected result");
    out15.debug(L"GAUSSIAN output");
    return Error::handle(name(), L"compute", Error::TEST,
                         __FILE__, __LINE__);
  }

  // test SINE algorithm with sample_frequency = 8000, frame_duration = 0.01
  // signal_duration = 0.01, amplitude = 1000, frequency = 200, random phase,
  // bias = 0.0.
  //   
  Generator gen16;

  // set parameters for computing sine signal samples 
  //
  gen16.setAlgorithm(SINE);
  gen16.setComputeMode(ACCUMULATE);
  gen16.setPhaseMode(RANDOM);
  Vector<Long> temAccumFrame4;
  temAccumFrame4.setLength(1);
  gen16.setAccumFrame(temAccumFrame4);
  gen16.setSampleFrequency(8000);
  gen16.setAmplitude(1000);
  gen16.setFrequency(200);
  gen16.setSignalDuration(0.01);
  gen16.setFrameDuration(0.01);
  gen16.setSeed(80); 
  gen16.setPhase();
  gen16.setBias(0);

  // As the phase is random, we cannot get expected result.
  // Therefore, ignore comparing out with correct result.
  //
  gen16.compute(output, input);

  // reset indentation
  //
  if (level_a > Integral::NONE) {
    Console::decreaseIndention();
  }

  //--------------------------------------------------------------------------
  //
  // 5. print completion message
  //
  //--------------------------------------------------------------------------

  // reset indentation
  //
  if (level_a > Integral::NONE) {
    Console::decreaseIndention();
  }
  
  if (level_a > Integral::NONE) {
    SysString output(L"diagnostics passed for class ");
    output.concat(name());
    output.concat(L"\n");
    Console::put(output);
  }
  
  // exit gracefully
  //
  return true;
}