mvec_02.cc

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

    return Error::handle(TVector::name(), L"assign(long, complexfloat*)",
			 Error::TEST,  __FILE__, __LINE__);
  }
  
  val1.assign(vector_complexfloat);
  if (val0.ne(val1)) {
    return Error::handle(TVector::name(), L"assign(vector_complexfloat)",
			 Error::TEST,  __FILE__, __LINE__);
  }
  
  // test assignments from complexlong
  //
  val0.assign(num_elem, complex_long);
  if (val0.ne((TIntegral)complexlong(43, 40))) {
    return Error::handle(TVector::name(), L"assign(long, complexlong*)",
			 Error::TEST,  __FILE__, __LINE__);
  }
  
  val1.assign(vector_complexlong);
  if (val0.ne(val1)) {
    return Error::handle(TVector::name(), L"assign(vector_complexlong)",
			 Error::TEST,  __FILE__, __LINE__);
  }  
  
#endif    
  
  // free memory
  //
  delete [] scalar_ushort;
  delete [] scalar_ulong;
  delete [] scalar_ullong;
  delete [] scalar_short;
  delete [] scalar_long;
  delete [] scalar_llong;
  delete [] scalar_float;
  delete [] scalar_double;
  delete [] scalar_byte;
  delete [] complex_double;
  delete [] complex_float;
  delete [] complex_long;
  
  val0.assign((long)20, (TIntegral)27);
  if (val0.ne((TIntegral)27) || ((long)(val0.length_d) != 20)) {
    return Error::handle(TVector::name(), L"assign", Error::TEST, __FILE__,
			 __LINE__);
  }

  // test clear
  //
  val0.clear(Integral::RETAIN);
  if (val0.ne(TScalar::DEF_VALUE) || ((long)(val0.length_d) != 20)) {
    return Error::handle(TVector::name(), L"clear", Error::TEST, __FILE__,
			 __LINE__);
  }

  // get the memsize
  //
  long mem_size = val0.memSize();
  
  if (level_a > Integral::BRIEF) {
    SysString numeric;
    numeric.assign(mem_size);
    SysString output(L"memSize of sof_0: ");
    output.concat(numeric);
    Console::put(output);
  }
    
  // exit gracefully
  //
  return true;
}

// method: diagnose2
//
// arguments:
//  Integral::DEBUG level: (input) debug level for diagnostics
//
// return: a boolean value indicating status
//
// this method tests equality and comparison methods
//
template<class TVector, class TScalar, class TIntegral>
boolean MVectorMethods::diagnose2(Integral::DEBUG level_a) {

  // declare local variables
  //
  long num_elem = 5;

  TVector val0;
  val0.assign(L"1, 3, 5, 7, 9");

#ifdef ISIP_TEMPLATE_complex
  val0.assign(L"1+2j, 3+4j, 5+6j, 7+8j, 9+7j");
#endif  
  
  TVector val1;

  // equality methods and operator != and ==
  // 
  val1.setLength(num_elem);
  val1.assign(val0);
  if (val0.ne(val1)) {
    return Error::handle(TVector::name(), L"assign", Error::TEST, __FILE__,
			 __LINE__);
  }

  val1.assign(val0);
  if (!val0.eq(val1)) {
    return Error::handle(TVector::name(), L"eq", Error::TEST, __FILE__,
			 __LINE__);
  }

  // check relational operations and operator >, <,  >=, <=
  //
  val0.assign((TIntegral)30);
  val1.assign((TIntegral)43);
  
  if (val0.gt(42)) {
    return Error::handle(TVector::name(), L"gt", Error::TEST, __FILE__,
			 __LINE__);
  }
  
  if (val0 > (42)) {
    return Error::handle(TVector::name(), L"gt", Error::TEST, __FILE__,
			 __LINE__);
  }
  
  if (val1.lt(42)) {
    return Error::handle(TVector::name(), L"lt", Error::TEST, __FILE__,
			 __LINE__);
  }

  if (val1 < (42)) {
    return Error::handle(TVector::name(), L"lt", Error::TEST, __FILE__,
			 __LINE__);
  }
  
  if (!val1.ge(43)) {
    return Error::handle(TVector::name(), L"ge", Error::TEST, __FILE__,
			 __LINE__);
  }

  if (!(val1 >= (43))) {
    return Error::handle(TVector::name(), L"ge", Error::TEST, __FILE__,
			 __LINE__);
  }    
  
  if (val1.le(42)) {
    return Error::handle(TVector::name(), L"le", Error::TEST, __FILE__,
			 __LINE__);
  }
  
  if (val1 <= (42)) {
    return Error::handle(TVector::name(), L"le", Error::TEST, __FILE__,
			 __LINE__);
  }
    
  if (val0.eq(val1) || !(val1 == ((TIntegral)43))) {
    return Error::handle(TVector::name(), L"eq", Error::TEST, __FILE__,
			 __LINE__);
  }
  
  if (!val0.ne(val1) || val1 != ((TIntegral)43)) {
    return Error::handle(TVector::name(), L"ne", Error::TEST, __FILE__,
			 __LINE__);
  }
  
  // exit gracefully
  //
  return true;
}

// method: diagnose3
//
// arguments:
//  Integral::DEBUG level: (input) debug level for diagnostics
//
// return: a boolean value indicating status
//
// this method tests get and set methods
//
template<class TVector, class TScalar, class TIntegral>
boolean MVectorMethods::diagnose3(Integral::DEBUG level_a) {

  // declare local variables
  //
  // test constructors
  //
  TVector val_0;

  // test setLength and length
  //
  long num_elem = 5;
  val_0.setLength(num_elem);

  if (val_0.length() != num_elem) {
    return Error::handle(TVector::name(), L"length", Error::TEST,
			 __FILE__,  __LINE__);
  }

  // test operator ()
  //
  val_0.assign((TIntegral)1);
  if (!val_0(2).almostEqual(1)) {
    return Error::handle(TVector::name(), L"operator()", Error::TEST,
			 __FILE__,  __LINE__);
  }

  // exit gracefully
  //
  return true;
}

// method: diagnose4
//
// arguments:
//  Integral::DEBUG level: (input) debug level for diagnostics
//
// return: a boolean value indicating status
//
// this method tests bitwise methods (for non-complex integer types only)
//
template<class TVector, class TScalar, class TIntegral>
boolean MVectorMethods::diagnose4(Integral::DEBUG level_a) {

  //---------------------------------------------------------------------------
  //
  // test bitwise methods
  //
  //---------------------------------------------------------------------------

  // declare local variables
  //
  TVector val0;
  val0.assign(L"1, 3, 5, 7, 9");

  TVector val1;
  val1.assign(L"0, 2, 4, 6, 8");

  TVector val2;

  // modulus
  //
  val1.assign((TIntegral)10);
  val0.mod(val0, val1);
  
  if (val0.ne((TIntegral)3)) {
    return Error::handle(TVector::name(), L"mod",
			 Error::TEST, __FILE__, __LINE__);
  }
  
  val0.assign((TIntegral)43);
  val0.mod(val0, (TIntegral)2);
  
  if (val0.ne((TIntegral)1)) {
    return Error::handle(TVector::name(), L"mod",
			 Error::TEST, __FILE__, __LINE__);
  }
  
  if (level_a > Integral::BRIEF) {
    Console::put(L"testing bitwise operations:\n");
  }
  
  // bitwise operations (num2 = num0 op num1)
  //
  TIntegral num0;
  TIntegral num1;   
  TIntegral num2;
  
  val0.setLength(10);
  val1.setLength(10);
  val2.setLength(10);
  
  // test band
  //
  num0 = 6;
  num1 = 2;
  num2 = 2;
  val0.assign(num0);
  val1.assign(num0);
  val2.assign(num1);
  
  val0.band(val2);
  val1.band(num1);
  
  if ((val0.ne(num2)) || (val1.ne(num2))) {
    return Error::handle(TVector::name(), L"band",
			 Error::TEST, __FILE__, __LINE__);
  }
  
  // test bor
  //
  num2 = 6;
  val0.assign(num0);
  val1.assign(num0);
  val2.assign(num1);
  
  val0.bor(val2);
  val1.bor(num1);
  
  if ((val0.ne(num2)) || (val1.ne(num2))) {
    return Error::handle(TVector::name(), L"bor",
			 Error::TEST, __FILE__, __LINE__);
  }
  
  // test bxor
  //
  num2 = 4;
  val0.assign(num0);
  val1.assign(num0);
  val2.assign(num1);
  
  val0.bxor(val2);
  val1.bxor(num1);
  
  if ((val0.ne(num2)) || (val1.ne(num2))) {
    return Error::handle(TVector::name(), L"bxor",
			 Error::TEST, __FILE__, __LINE__);
  }
  
  // test brs
  //
  num2 = 1;
  val0.assign(num0);
  val1.assign(num0);
  val2.assign(num0);
  
  val0.brs(val2, num1);
  val1.brs(num1);
  
  if ((val0.ne(num2) || (val1.ne(num2)))) {
    val0.debug(L"val0");
    val1.debug(L"val1");
    return Error::handle(TVector::name(), L"brs",
			 Error::TEST, __FILE__, __LINE__);
  }
  
  // test bls
  //
  num2 = 24;
  val0.assign(num0);
  val1.assign(num0);
  val2.assign(num0);
  
  val0.bls(val2, num1);
  val1.bls(num1);
  
  if ((val0.ne(num2)) || (val1.ne(num2))) {
    return Error::handle(TVector::name(), L"bls",
			 Error::TEST, __FILE__, __LINE__);
  }
  
  // test bcmpl: this is tricky with different lengths, constrain to 8 bits
  // 
  num2 = (TIntegral)0xF9;
  num1 = (TIntegral)0xFF;	         // mask off result
  val0.assign(num0);
  val0.bcmpl();
  val0.band(num1);
  
  if (val0.ne(num2)) {
    return Error::handle(TVector::name(), L"bcmpl",
			 Error::TEST, __FILE__, __LINE__);
  }
  
  // exit gracefully
  //
  return true;
}

// method: diagnose5
//
// arguments:
//  Integral::DEBUG level: (input) debug level for diagnostics
//
// return: a boolean value indicating status
//
// this method tests basic mathematical methods
//
template<class TVector, class TScalar, class TIntegral>
boolean MVectorMethods::diagnose5(Integral::DEBUG level_a) {

  // declare local variables
  //
  TVector val0;
  val0.assign(L"1, 3, 5, 7, 9");
  TVector val1;
  val1.assign(L"0, 2, 4, 6, 8");
  
  // addition
  //
  val1.assign((TIntegral)40);
  val0.add(val1, 1);
  val0.add(2);
  
  if (!val0.almostEqual((TIntegral)43)) {
    return Error::handle(TVector::name(), L"add",
			 Error::TEST, __FILE__, __LINE__);
  }
  
  val1.assign((TIntegral)10);
  val0.add(val1);
  val0.add(7);
  
  if (!val0.almostEqual((TIntegral)60)) {
    return Error::handle(TVector::name(), L"add",
			 Error::TEST, __FILE__, __LINE__);
  }
  
  // subtraction
  //
  val1.assign((TIntegral)10);
  val0.sub(val1);
  val0.sub(7);
  
  if (!val0.almostEqual((TIntegral)43)) {
    return Error::handle(TVector::name(), L"sub",
			 Error::TEST, __FILE__, __LINE__);
  }
  
  // multiplication
  //
  val1.assign((TIntegral)2);
  val0.mult(val1);
  val0.mult((TIntegral)2);
  
  if (!val0.almostEqual((TIntegral)172)) {
    return Error::handle(TVector::name(), L"mult",
			 Error::TEST, __FILE__, __LINE__);
  }
  
  // division
  //
  val1.assign((TIntegral)2);
  val0.div(val1);
  val0.div(2);
  
  if (!val0.almostEqual((TIntegral)43)) {
    return Error::handle(TVector::name(), L"div",
			 Error::TEST, __FILE__, __LINE__);
  }
  
  // exit gracefully
  //
  return true;
}

// method: diagnose6
//
// arguments:
//  Integral::DEBUG level: (input) debug level for diagnostics
//
// return: a boolean value indicating status
//
// this method test other mathematical methods
//
template<class TVector, class TScalar, class TIntegral>
boolean MVectorMethods::diagnose6(Integral::DEBUG level_a) {

  // declare local variables
  //
  long num_elem = 5;

  TVector val0;
  val0.assign(L"1, 3, 5, 7, 9");
  TVector val1;
  val1.assign(L"0, 2, 4, 6, 8");
  
  TVector val2;
  val2.setLength(num_elem);

  TVector val3;
  
  // test log/exp
  //
  val0.assign((TIntegral)55);                  // exp**4.007 = 55.0
  val1.log(val0);
  if (!val1.almostEqual((TIntegral)4.00733318523)) {
    val1.debug(L"log");
    return Error::handle(TVector::name(), L"log",
			 Error::TEST, __FILE__, __LINE__);
  }
  
  val1.exp();
  if (!val0.almostEqual(val1)) {
    val1.debug(L"val1 exp");
    val0.debug(L"val0 exp");
    return Error::handle(TVector::name(), L"exp",
			 Error::TEST, __FILE__, __LINE__);
  }
  
  // test log1p
  //
  val0.assign((TIntegral)54);                 // exp**4.007 = 55
  val1.log1p(val0);
  if (!val1.almostEqual((TIntegral)4.00733318523)) {
    val1.debug(L"log1p");
    return Error::handle(TVector::name(), L"log1p",
			 Error::TEST, __FILE__, __LINE__);
  }
  
  // test log2/exp2
  //
  val0.assign((TIntegral)64);
  val1.log2(val0);
  if (!val1.almostEqual((TIntegral)6)) {
    val1.debug(L"log2");
    return Error::handle(TVector::name(), L"log2",
			 Error::TEST, __FILE__, __LINE__);
  }
  
  val1.exp2();
  if (!val0.almostEqual(val1)) {
    val1.debug(L"exp2");
    return Error::handle(TVector::name(), L"exp2",
			 Error::TEST, __FILE__, __LINE__);
  }
  
  // test log10/exp10