mvec_02.cc

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

  //
  text_file.open(tmp_filename0);
  bin_file.open(tmp_filename1);

  if (level_a > Integral::BRIEF) {
    Console::put(L"files written, closed, and opened:\n");
  }
  
  // test reading zero and single element vector
  //
  if (!val2.read(text_file, (long)10) || (val2.length() != 0)) {
    return Error::handle(TVector::name(), L"read-text", Error::TEST,
			 __FILE__, __LINE__);
  }
  val2.clear();
    
  if (!val2.read(bin_file, (long)10) || (val2.length() != 0)) {
    return Error::handle(TVector::name(), L"read-bin", Error::TEST,
			 __FILE__, __LINE__);
  }
  val2.clear();
  
  if (!val2.read(text_file, (long)11) || (val2.length() != 1)
      || (!val2(0).almostEqual(42))) {
    return Error::handle(TVector::name(), L"read-text", Error::TEST,
			 __FILE__, __LINE__);
  }
  val2.clear();
  
  if (!val2.read(bin_file, (long)11) || (val2.length() != 1)
      || (!val2(0).almostEqual(42))) {
    return Error::handle(TVector::name(), L"read-bin", Error::TEST,
			 __FILE__, __LINE__);
  }
  val2.clear();
  
  // read other values back in
  //
  if (!val2.read(text_file, (long)0) || (!val2.almostEqual(val0))) {
    val0.debug(L"val0");
    val2.debug(L"val2");
    return Error::handle(TVector::name(), L"read-text", Error::TEST,
			 __FILE__, __LINE__);
  }
  val2.clear();
  
  if (!val2.read(bin_file, (long)0) || (!val2.almostEqual(val0))) {
    return Error::handle(TVector::name(), L"read-bin", Error::TEST,
			 __FILE__, __LINE__);
  }
  val2.clear();
  
  if (!val2.read(text_file, (long)1) || (!val2.almostEqual(val1))) {
    val2.debug(L"val2");
    val1.debug(L"val1");
    return Error::handle(TVector::name(), L"read-text", Error::TEST,
			 __FILE__, __LINE__);
  }
  val2.clear();
  
  if (!val2.read(bin_file, (long)1) || (!val2.almostEqual(val1))) {
    return Error::handle(TVector::name(), L"read-bin", Error::TEST,
			 __FILE__, __LINE__);
  }
  val2.clear();
  
  if (level_a > Integral::DETAILED) {
    Console::put(L"reading big text\n");
  }
  
  if (!val2.read(text_file, (long)7) || (!val4.almostEqual(val2))) {
    return Error::handle(TVector::name(), L"read-big-text", Error::TEST,
			 __FILE__, __LINE__);
  }
  val2.clear();
  
  if (level_a > Integral::DETAILED) {
    Console::put(L"reading big binary\n");
  }
  
  if (!val2.read(bin_file, (long)7) || (!val4.almostEqual(val2))) {
    return Error::handle(TVector::name(), L"read-big-bin", Error::TEST,
			 __FILE__, __LINE__);
  }
  val2.clear();
  
  if (level_a > Integral::DETAILED) {
    Console::put(L"completed read big\n");
  }
  
  if (!val2.read(bin_file, (long)9) || (!big_val.almostEqual(val2))) {
    return Error::handle(TVector::name(), L"read-big-bin", Error::TEST,
			 __FILE__, __LINE__);
  }
  val2.clear();
  
  if (!val2.read(bin_file, (long)9) || (!big_val.almostEqual(val2))) {
    return Error::handle(TVector::name(), L"read-big-bin", Error::TEST,
			 __FILE__, __LINE__);
  }
  val2.clear();

  // close the temporary files
  //
  text_file.close();
  bin_file.close();


  // reset indentation
  //
  if (level_a > Integral::NONE) {
    Console::decreaseIndention();
  }
  
  // set indentation
  //
  if (level_a > Integral::NONE) {
    Console::put(L"testing class-specific public methods: ext. to required methods...\n");
    Console::increaseIndention();
  }
  
  val0.assign(L"1, 3, 5, 7, 9");
  val1.assign(L"0, 2, 4, 6, 8");
  
  test_size = 1024;
  val4.setLength(test_size);
  val5.setLength(test_size);

  // open files in read mode
  //
  text_file.open(tmp_filename0, File::READ_ONLY, File::TEXT);
  bin_file.open(tmp_filename1, File::READ_ONLY, File::BINARY);
  
  // test partial reads (last 128 entries, specify 256)
  //
  if (level_a > Integral::BRIEF) {
    Console::put(L"testing partial io methods:\n");
  }

  if (!text_file.find(TVector::name(), (long)7)) {
    return Error::handle(name(), L"find", Error::TEST, __FILE__, __LINE__);
  }

  if (!bin_file.find(TVector::name(), (long)7)) {
    return Error::handle(name(), L"find", Error::TEST, __FILE__, __LINE__);
  }
  
  if (!val2.readStart(text_file)) {
    return Error::handle(name(), L"readStart", Error::TEST, __FILE__,
			 __LINE__);
  }

  if (!val3.readStart(bin_file)) {
    return Error::handle(name(), L"readStart", Error::TEST, __FILE__,
			 __LINE__);
  }

  if (val2.readPartialData(text_file, test_size - 128, 256) != 128) {
    return Error::handle(TVector::name(), L"readPartial (text)", Error::TEST,
			 __FILE__, __LINE__);
  }
  if (val3.readPartialData(bin_file, test_size - 128, 256) != 128) {
    return Error::handle(TVector::name(), L"readPartial (binary)", Error::TEST,
			 __FILE__, __LINE__);
  }
  
  for (long i = 0; i < 128; i++) {
    if (!val2(i).almostEqual((test_size - 128 + i) * 3)) {
      return Error::handle(TVector::name(), L"readPartialData (text)",
			   Error::TEST, __FILE__, __LINE__);
    }
    if (!val3(i).almostEqual((test_size - 128 + i) * 3)) {
      return Error::handle(TVector::name(), L"readPartialData (binary)",
			   Error::TEST, __FILE__, __LINE__);
    }
  }

  // test readTerminate
  //
  val2.readTerminate(text_file);
  val3.readTerminate(bin_file);

  // test partial reads (last 128 entries, specify 64)
  //
  val2.clear();
  val3.clear();
  
  if (!text_file.find(TVector::name(), (long)7)) {
    return Error::handle(name(), L"find", Error::TEST, __FILE__, __LINE__);
  }

  if (!bin_file.find(TVector::name(), (long)7)) {
    return Error::handle(name(), L"find", Error::TEST, __FILE__, __LINE__);
  }

  if (!val2.readStart(text_file)) {
    return Error::handle(name(), L"readStart", Error::TEST, __FILE__,
			 __LINE__);
  }

  if (!val3.readStart(bin_file)) {
    return Error::handle(name(), L"readStart", Error::TEST, __FILE__,
			 __LINE__);
  }

  if (val2.readPartialData(text_file, test_size - 128, 64) != 64) {
    return Error::handle(TVector::name(), L"readPartial (text)", Error::TEST,
			 __FILE__, __LINE__);
  }
  if (val3.readPartialData(bin_file, test_size - 128, 64) != 64) {
    return Error::handle(TVector::name(), L"readPartial (binary)", Error::TEST,
			 __FILE__, __LINE__);
  }
  
  for (long i = 0; i < 64; i++) {
    if (!val2(i).almostEqual((test_size - 128 + i) * 3)) {
      return Error::handle(TVector::name(), L"readPartialData (text)",
			   Error::TEST,  __FILE__, __LINE__);
    }
    if (!val3(i).almostEqual((test_size - 128 + i) * 3)) {
      val3.debug(L"Wrong vector:");
      return Error::handle(TVector::name(), L"readPartialData (binary)",
			   Error::TEST,  __FILE__, __LINE__);
    }
  }
  val2.clear();
  val3.clear();

  val2.readTerminate(text_file);
  val3.readTerminate(bin_file);

  text_file.close();
  bin_file.close();

  // test partial write
  //
  text_file.open(tmp_filename0, File::WRITE_ONLY, File::TEXT);
  bin_file.open(tmp_filename1, File::WRITE_ONLY, File::BINARY);

  val4.setLength(0);
  
  val1.setLength(50);
  text_file.put(val1.name(), 0, -1);
  bin_file.put(val1.name(), 0, val4.sofSize());
  val1.writeStart(text_file);
  val1.writeStart(bin_file);

  val1.assign((TIntegral)20);
  val4.concat(val1);
  val1.writePartialData(text_file, 0, val1.length());
  val1.writePartialData(bin_file, 0, val1.length());

  val1.assign((TIntegral)25);
  val4.concat(val1);
  val1.writePartialData(text_file, 0, val1.length());
  val1.writePartialData(bin_file, 0, val1.length());

  val1.assign((TIntegral)30);
  val4.concat(val1);
  val1.writePartialData(text_file, 0, val1.length());
  val1.writePartialData(bin_file, 0, val1.length());

  val1.assign((TIntegral)35);
  val4.concat(val1);
  val1.writePartialData(text_file, 0, val1.length());
  val1.writePartialData(bin_file, 0, val1.length());

  val1.writeTerminate(text_file);
  val1.writeTerminate(bin_file);

  text_file.close();
  bin_file.close();

  text_file.open(tmp_filename0);
  bin_file.open(tmp_filename0);

  val2.read(text_file, 0);
  val3.read(bin_file, 0);

  if (val2.length() != 200) {
    val2.debug(L"Wrong Vector:");
    return Error::handle(name(), L"writePartial", Error::TEST, __FILE__,
			 __LINE__);
  }

  if (val3.length() != 200) {
    return Error::handle(name(), L"writePartial", Error::TEST, __FILE__,
			 __LINE__);
  }

  if (!val2.almostEqual(val4)) {
    return Error::handle(name(), L"writePartial", Error::TEST, __FILE__,
			 __LINE__);
  }

  // close and  delete the temporary files
  //
  text_file.close();
  bin_file.close();
  File::remove(tmp_filename0);
  File::remove(tmp_filename1);

  // test assignment methods
  //
  val0.setLength(num_elem);
  val1.setLength(num_elem);
  
  // assign values
  //
  val0.assign((TIntegral)43);
  val1.assign(val0);
  
  if (val0.ne(val1)) {
    return Error::handle(TVector::name(), L"assign", Error::TEST,
			 __FILE__, __LINE__);
  }
  
  // test assignments
  //
  ushort* scalar_ushort = new ushort[num_elem];
  ulong* scalar_ulong = new ulong[num_elem];
  ullong* scalar_ullong = new ullong[num_elem];
  short* scalar_short = new short[num_elem];
  long* scalar_long = new long[num_elem];
  llong* scalar_llong = new llong[num_elem];
  float* scalar_float = new float[num_elem];
  double* scalar_double = new double[num_elem];
  byte* scalar_byte = new byte[num_elem];
  complexdouble* complex_double = new complexdouble[num_elem];
  complexfloat* complex_float = new complexfloat[num_elem];
  complexlong* complex_long = new complexlong[num_elem];
  
  MVector<Byte, byte> vector_byte(num_elem);
  MVector<Ushort, ushort> vector_ushort(num_elem);
  MVector<Ulong, ulong> vector_ulong(num_elem);
  MVector<Ullong, ullong> vector_ullong(num_elem);
  MVector<Short, short> vector_short(num_elem);
  MVector<Long, long> vector_long(num_elem);
  MVector<Llong, llong> vector_llong(num_elem);
  MVector<Float, float> vector_float(num_elem);
  MVector<Double, double> vector_double(num_elem);
  MVector<ComplexDouble, complexdouble> vector_complexdouble(num_elem);
  MVector<ComplexFloat, complexfloat> vector_complexfloat(num_elem);
  MVector<ComplexLong, complexlong> vector_complexlong(num_elem);  
  
  for (int i = 0; i < num_elem; i++) {
    scalar_ushort[i] = (ushort)43;
    scalar_ulong[i] = (ulong)43;
    scalar_ullong[i] = (ullong)43;
    scalar_short[i] = (short)43;
    scalar_long[i] = (long)43;
    scalar_llong[i] = (llong)43;
    scalar_float[i] = (float)43.0;
    scalar_double[i] = (double)43.0;
    scalar_byte[i] = (byte)43;
    complex_double[i] = complexdouble(43, 40);
    complex_float[i] = complexfloat(43, 40);
    complex_long[i] = complexlong(43, 40);    
  }
  
  vector_byte.assign(num_elem, scalar_byte);
  vector_ushort.assign(num_elem, scalar_ushort);
  vector_ulong.assign(num_elem, scalar_ulong);
  vector_ullong.assign(num_elem, scalar_ullong);
  vector_short.assign(num_elem, scalar_short);
  vector_long.assign(num_elem, scalar_long);
  vector_llong.assign(num_elem, scalar_llong);
  vector_float.assign(num_elem, scalar_float);
  vector_double.assign(num_elem, scalar_double);
  vector_complexdouble.assign(num_elem, complex_double);
  vector_complexfloat.assign(num_elem, complex_float);
  vector_complexlong.assign(num_elem, complex_long);  
 
  
  // test assignments from ushort
  //
  val0.assign(num_elem, scalar_ushort);
  if (val0.ne((TIntegral)43)) {
    return Error::handle(TVector::name(), L"assign(long, ushort*)",
			 Error::TEST, __FILE__, __LINE__);
  }
  
  val1.assign(vector_ushort);
  if (val0.ne(val1)) {
    return Error::handle(TVector::name(), L"assign(vector_ushort)",
			 Error::TEST, __FILE__, __LINE__);
  }
  
  // test assignments from ulong
  //
  val0.assign(num_elem, scalar_ulong);
  if (val0.ne((TIntegral)43)) {
    return Error::handle(TVector::name(), L"assign(long, ulong*)", Error::TEST,
			 __FILE__, __LINE__);
  }
  
  val1.assign(vector_ulong);
  if (val0.ne(val1)) {
    return Error::handle(TVector::name(), L"assign(vector_ulong)", Error::TEST,
			 __FILE__, __LINE__);
  }
  
  // test assignments from ullong
  //
  val0.assign(num_elem, scalar_ullong);
  if (val0.ne((TIntegral)43)) {
    return Error::handle(TVector::name(), L"assign(long, ullong*)",
			 Error::TEST, __FILE__, __LINE__);
  }
  
  val1.assign(vector_ullong);
  if (val0.ne(val1)) {
    return Error::handle(TVector::name(), L"assign(vector_ullong)",
			 Error::TEST, __FILE__, __LINE__);
  }
  
  // test assignments from short
  //
  val0.assign(num_elem, scalar_short);
  if (val0.ne((TIntegral)43)) {
    return Error::handle(TVector::name(), L"assign(long, short*)", Error::TEST,
			 __FILE__, __LINE__);
  }
  
  val1.assign(vector_short);
  if (val0.ne(val1)) {
    return Error::handle(TVector::name(), L"assign(vector_short)", Error::TEST,
			 __FILE__, __LINE__);
  }
  
  // test assignments from long
  //
  val0.assign(num_elem, scalar_long);
  if (val0.ne((TIntegral)43)) {
    return Error::handle(TVector::name(), L"assign(long, long*)", Error::TEST,
			 __FILE__, __LINE__);
  }
  
  val1.assign(vector_long);
  if (val0.ne(val1)) {
    return Error::handle(TVector::name(), L"assign(vector_long)", Error::TEST,
			 __FILE__, __LINE__);
  }
  
  // test assignments from llong
  //
  val0.assign(num_elem, scalar_llong);
  if (val0.ne((TIntegral)43)) {
    return Error::handle(TVector::name(), L"assign(long, llong*)", Error::TEST,
			 __FILE__, __LINE__);
  }
  
  val1.assign(vector_llong);
  if (val0.ne(val1)) {
    return Error::handle(TVector::name(), L"assign(vector_llong)", Error::TEST,
			 __FILE__, __LINE__);
  }
  
  // test assignments from float
  //
  val0.assign(num_elem, scalar_float);
  if (val0.ne((TIntegral)43)) {
    return Error::handle(TVector::name(), L"assign(long, float*)", Error::TEST,
			 __FILE__, __LINE__);
  } 
  
  val1.assign(vector_float);
  if (val0.ne(val1)) {
    return Error::handle(TVector::name(), L"assign(vector_float)", Error::TEST,
			 __FILE__, __LINE__);
  }
  
  // test assignments from double
  //
  val0.assign(num_elem, scalar_double);
  if (val0.ne((TIntegral)43)) {
    return Error::handle(TVector::name(), L"assign(long, double*)",
			 Error::TEST, __FILE__, __LINE__);
  }
  
  val1.assign(vector_double);
  if (val0.ne(val1)) {
    return Error::handle(TVector::name(), L"assign(vector_double)",
			 Error::TEST, __FILE__, __LINE__);
  }
  
  // test assignments from byte
  //
  val0.assign(num_elem, scalar_byte);
  if (val0.ne((TIntegral)43)) {
    return Error::handle(TVector::name(), L"assign(long, byte*)", Error::TEST,
			 __FILE__, __LINE__);
  }
  
  val1.assign(vector_byte);
  if (val0.ne(val1)) {
    return Error::handle(TVector::name(), L"assign(vector_byte)", Error::TEST,
			 __FILE__, __LINE__);
  }

#ifdef ISIP_TEMPLATE_complex  
  // test assignments from complexdouble
  //
  val0.assign(num_elem, complex_double);
  if (val0.ne((TIntegral)complexdouble(43, 40))) {
    return Error::handle(TVector::name(), L"assign(long, complexdouble*)",
			 Error::TEST,  __FILE__, __LINE__);
  }
  
  val1.assign(vector_complexdouble);
  if (val0.ne(val1)) {
    return Error::handle(TVector::name(), L"assign(vector_complexdouble)",
			 Error::TEST,  __FILE__, __LINE__);
  }

  // test assignments from complexfloat
  //
  val0.assign(num_elem, complex_float);
  if (val0.ne((TIntegral)complexfloat(43, 40))) {