mvec_02.cc

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

  //
  val0.assign((TIntegral)100);
  val1.log10(val0);
  if (!val1.almostEqual((TIntegral)2)) {
    val1.debug(L"log10");
    return Error::handle(TVector::name(), L"log10",
			 Error::TEST, __FILE__, __LINE__);
  }
  
  val1.exp10();
  if (!val0.almostEqual(val1)) {
    val1.debug(L"exp10 test");
    return Error::handle(TVector::name(), L"exp10",
			 Error::TEST, __FILE__, __LINE__);
  }
  
  // test square root/ square
  //
  val0.assign((TIntegral)81);
  val1.sqrt(val0);
  
  if (!val1.almostEqual((TIntegral)9)) {
    val1.debug(L"sqrt(81)");
    return Error::handle(TVector::name(), L"sqrt",
			 Error::TEST, __FILE__, __LINE__);
  }
  
  val1.square();
  if (!val0.almostEqual(val1)) {
    val1.debug(L"square(9)");
    return Error::handle(TVector::name(), L"square",
			 Error::TEST, __FILE__, __LINE__);
  }
  
  // test inverse
  //
  val0.assign((TIntegral)27);
  val1.inverse(val0);
  val0.inverse();
  
  if (!val1.almostEqual((TIntegral)1 / (TIntegral)27) ||
      !val0.almostEqual((TIntegral)1 / (TIntegral)27)) {
    val1.debug(L"inverse(27)");
    val0.debug(L"inverse(27)");
    return Error::handle(TVector::name(), L"inverse",
			 Error::TEST, __FILE__, __LINE__);
  }
  
  // test pow
  //
  val0.assign((TIntegral)5);
  val0.pow((double)3.0);
  if (!val0.almostEqual((TIntegral)125)) {
    val0.debug(L"sqrt(5^3)");
    return Error::handle(TVector::name(), L"pow",
			 Error::TEST, __FILE__, __LINE__);
  }
  
  // test factorial
  //
  val0.assign((TIntegral)5);
  val2.assign((TIntegral)120);
  val1.factorial(val0);
  
  if (!val1.almostEqual(val2)) {
    val1.debug(L"5! = ");
    return Error::handle(TVector::name(), L"factorial",
			 Error::TEST, __FILE__, __LINE__);
  }
  
  // test ramp
  //
  val0.setLength(25);
  val0.ramp(5, 2);
  val1.assign(L"5,7,9,11,13,15,17,19,21,23,25,27,29,31,33,35,37,39,41,43,45,47,49,51,53");
  
  if (!val1.almostEqual(val0)) {
    val0.debug(L"ramp");
    return Error::handle(TVector::name(), L"ramp",
			 Error::TEST, __FILE__, __LINE__);
  }
  
  // test the ramp overload
  //
  val0.setLength(0);
  val0.ramp(5, 2, 53);
  
  if (!val1.almostEqual(val0)) {
    val0.debug(L"ramp");
    return Error::handle(TVector::name(), L"ramp",
			 Error::TEST, __FILE__, __LINE__);
  }

  // test sort
  //
  if (level_a > Integral::BRIEF) {
    Console::put(L"testing sort:\n");
  }

  val0.setLength(10);
  TVector val0a;
  
  val0.assign(L"71,9,13,17,25,21,123,25,127,53");    
  val0a.sort(val0);
  
  for (long i = 0; i < 9; i++) {
    if (val0a(i) > val0a(i + 1)) {
      val0a.debug(L"sort");
      return Error::handle(TVector::name(), L"sort",
			   Error::TEST, __FILE__, __LINE__);
    }
  }
  
  val0a.sort(val0, Integral::DESCENDING);
  
  for (long i = 0; i < 9; i++) {
    if (val0a(i) < val0a(i + 1)) {
      val0a.debug(L"sort");
      return Error::handle(TVector::name(), L"sort",
			   Error::TEST, __FILE__, __LINE__);
    }
  }
  val0a.clear();
  
  
  // test float and double specific operations
  //
  if ((typeid(TIntegral) == typeid(float)) ||
      (typeid(TIntegral) == typeid(double))) {
    
    if (level_a > Integral::BRIEF) {
      Console::put(L"testing floating point methods:\n");
    }
    
    val0.setLength(10);
    val1.setLength(10);
    val2.setLength(10);
    val3.setLength(10);
    
    // test round
    //
    TIntegral num0 = (TIntegral)2.4;
    TIntegral num1 = (TIntegral)2.6;
    TIntegral res0 = (TIntegral)2.0;
    TIntegral res1 = (TIntegral)3.0;
    
    val0.assign(num0);
    val1.assign(num1);
    val2.assign(res0);
    val3.assign(res1);
    
    val0.round();
    val1.round();
    
    if ((!val0.almostEqual(val2)) || (!val1.almostEqual(val3))) {
      return Error::handle(TVector::name(), L"round",
			   Error::TEST, __FILE__, __LINE__);
    }
    
    // test floor
    //
    num0 = (TIntegral)2.4;
    num1 = (TIntegral)-20.3;
    res0 = (TIntegral)2.0;
    res1 = (TIntegral)-21.0;
    
    val0.assign(num0);
    val1.assign(num1);
    val2.assign(res0);
    val3.assign(res1);
    
    val0.floor();
    val1.floor();
    if ((!val0.almostEqual(val2)) || (!val1.almostEqual(val3))) {
      return Error::handle(TVector::name(), L"floor",
			   Error::TEST, __FILE__, __LINE__);
    }
    
    // test ceil
    //
    num0 = (TIntegral)2.4;
    num1 = (TIntegral)-20.3;
    res0 = (TIntegral)3.0;
    res1 = (TIntegral)-20.0;
    
    val0.assign(num0);
    val1.assign(num1);
    val2.assign(res0);
    val3.assign(res1);
    
    val0.ceil();
    val1.ceil();
    if ((!val0.almostEqual(val2)) || (!val1.almostEqual(val3))) {
      return Error::handle(TVector::name(), L"floor",
			   Error::TEST, __FILE__, __LINE__);
    }
    
    // test rfloor
    //
    num0 = (TIntegral)2.4;
    num1 = (TIntegral)-20.3;
    res0 = (TIntegral)-0.4;
    res1 = (TIntegral)-0.7;
    
    val0.assign(num0);
    val1.assign(num1);
    val2.assign(res0);
    val3.assign(res1);
    
    val0.rfloor();
    val1.rfloor();
    if ((!val0.almostEqual(val2)) || (!val1.almostEqual(val3))) {
      return Error::handle(TVector::name(), L"floor",
			   Error::TEST, __FILE__, __LINE__);
    }
    
    // test rceil
    //
    num0 = (TIntegral)2.4;
    num1 = (TIntegral)-20.3;
    res0 = (TIntegral)0.6;
    res1 = (TIntegral)0.3;
    
    val0.assign(num0);
    val1.assign(num1);
    val2.assign(res0);
    val3.assign(res1);
    
    val0.rceil();
    val1.rceil();
    if ((!val0.almostEqual(val2)) || (!val1.almostEqual(val3))) {
      return Error::handle(TVector::name(), L"floor",
			   Error::TEST, __FILE__, __LINE__);
    }
    
    // test fraction
    //
    num0 = (TIntegral)2.4;
    num1 = (TIntegral)-34.1;
    res0 = (TIntegral)0.4;
    res1 = (TIntegral)-0.1;
    
    val0.assign(num0);
    val1.assign(num1);
    val2.assign(res0);
    val3.assign(res1);
    
    val0.fraction();
    val1.fraction();
    if ((!val0.almostEqual(val2)) || (!val1.almostEqual(val3))) {
      return Error::handle(TVector::name(), L"fraction",
			   Error::TEST, __FILE__, __LINE__);
    }
    
    // test sin/asin
    //
    num0 = (TIntegral)(Integral::PI / 6);
    num1 = (TIntegral)0.5;
    val0.assign(num0);
    val2.assign(num1);
    
    val1.sin(val0);
    
    if (!val1.almostEqual(val2)) {
      return Error::handle(TVector::name(), L"sin",
			   Error::TEST, __FILE__, __LINE__);
    }
    
    val1.asin();
    if (!val0.almostEqual(val1)) {
      return Error::handle(TVector::name(), L"asin",
			   Error::TEST, __FILE__, __LINE__);
    }
    
    // test asinh / sinh
    //
    val0.assign((TIntegral)(Integral::PI / (double)6));
    val1.sinh(val0);
    val1.asinh();
    if (!val0.almostEqual(val1)) {
      val0.debug(L"val0.asinh");
      val1.debug(L"val1.asinh");              
      return Error::handle(name(), L"asinh", Error::TEST, __FILE__, __LINE__);
    }

    
    // test cos/acos
    //
    num0 = (TIntegral)(Integral::PI / 3);
    num1 = (TIntegral)0.5;
    val0.assign(num0);
    val2.assign(num1);
    
    val1.cos(val0);
    
    if (!val1.almostEqual(val2)) {
      return Error::handle(TVector::name(), L"cos",
			   Error::TEST, __FILE__, __LINE__);
    }
    
    val1.acos();
    if (!val0.almostEqual(val1)) {
      return Error::handle(TVector::name(), L"acos",
			   Error::TEST, __FILE__, __LINE__);
    }
    
    // test acosh / cosh
    //
    val0.assign((TIntegral)(Integral::PI / (double)3));
    val1.cosh(val0);
    val1.acosh();    
    if (!val0.almostEqual(val1)) {
      val0.debug(L"val0.acosh");
      val1.debug(L"val1.acosh");      
      return Error::handle(name(), L"acosh", Error::TEST, __FILE__, __LINE__);
    }
    
    // test tan/atan
    //
    num0 = (TIntegral)(Integral::QUARTER_PI);
    num1 = (TIntegral)1.0;
    val0.assign(num0);
    val2.assign(num1);
    
    val1.tan(val0);
    
    if (!val1.almostEqual(val2)) {
      return Error::handle(TVector::name(), L"tan",
			   Error::TEST, __FILE__, __LINE__);
    }
    
    val1.atan();
    if (!val0.almostEqual(val1)) {
      return Error::handle(TVector::name(), L"atan",
			   Error::TEST, __FILE__, __LINE__);
    }

    // test atanh /tanh
    //
    val0.assign((TIntegral)(Integral::QUARTER_PI));    
    val1.tanh(val0);
    val1.atanh();    
    if (!val0.almostEqual(val1)) {
      val0.debug(L"val0.atanh");
      val1.debug(L"val1.atanh");              
      return Error::handle(name(), L"atanh", Error::TEST, __FILE__, __LINE__);
    }
  }

  // testing vector to scalar mathematical methods
  //
  val0.assign(L"-1, 3, 5, 7, -9");
  TScalar new_value;
  
  new_value = val0.sum();
  if (!new_value.almostEqual((TIntegral)5)) {
    return Error::handle(TVector::name(), L"sum",
			 Error::TEST, __FILE__, __LINE__);
  }
  
  new_value = val0.sumSquare();
  if (!new_value.almostEqual((TIntegral)165)) {
    return Error::handle(TVector::name(), L"sumSquare",
			 Error::TEST, __FILE__, __LINE__);
  }
  
  new_value = val0.mean();
  if (!new_value.almostEqual((TIntegral)1)) {
    return Error::handle(TVector::name(), L"mean",
			 Error::TEST, __FILE__, __LINE__);
  }

  // test median for a vector of odd length
  //
  TVector val_ss;
  val_ss.assign(L"1, 3, 9, 6, 7");
  
  new_value = val_ss.median();

  if (!new_value.almostEqual((TIntegral)6)) {
    val_ss.debug(L"vector");
    new_value.debug(L"new_value");
    return Error::handle(TVector::name(), L"median",
			 Error::TEST, __FILE__, __LINE__);
  }

  // test median for an even vector
  //
  val_ss.assign(L"1, 3, 4, 6, 7, 9");
  new_value = val_ss.median();
    
  if (!new_value.almostEqual((TIntegral)5)) {
    val_ss.debug(L"vector");
    new_value.debug(L"new_value");
    return Error::handle(TVector::name(), L"median",
			 Error::TEST, __FILE__, __LINE__);
  }
  
  new_value = val0.rms() + (TIntegral)0.4;
  if (!new_value.almostEqual((TIntegral)6.144562647)) {
    val0.debug(L"val0");
    new_value.debug(L"rms");
    return Error::handle(TVector::name(), L"rms",
			 Error::TEST, __FILE__, __LINE__);
  }
  
  new_value = val0.var();
  if (!new_value.almostEqual((TIntegral)32)) {
    return Error::handle(TVector::name(), L"var",
			 Error::TEST, __FILE__, __LINE__);
  }
  
  new_value = val0.stdev() + (TIntegral)0.4;
  if (!new_value.almostEqual((TIntegral)6.05685424949238058)) {
    val0.debug(L"val0");
    new_value.debug(L"stdevcl");
    return Error::handle(TVector::name(), L"stdev",
			 Error::TEST, __FILE__, __LINE__);
  }
  
  new_value = val0.dotProduct(val0);    
  if (!new_value.almostEqual((TIntegral)165)) {
    return Error::handle(TVector::name(), L"dotProduct ",
			 Error::TEST, __FILE__, __LINE__);
  }
  
  new_value = val0.norm();

  if (!new_value.almostEqual((TIntegral)12.8452)) {
    new_value.debug(L"norm");
    return Error::handle(TVector::name(), L"norm",
			 Error::TEST, __FILE__, __LINE__);
  }
  
  val1.assign(L"1, 5, 5, 5, -7");
  
  new_value = val0.distance(val1);
  if (!new_value.almostEqual((TIntegral)4.0000)) {
    new_value.debug(L"distance");
    return Error::handle(TVector::name(), L"distance",
			 Error::TEST, __FILE__, __LINE__);
  }
  
  new_value = val0.distanceSquare(val1);
  if (!new_value.almostEqual((TIntegral)16)) {
    new_value.debug(L"distanceSquare");
    return Error::handle(TVector::name(), L"distanceSquare ",
			 Error::TEST, __FILE__, __LINE__);
  }
  
  long count = val0.numNotEqual(3);
  if (count != 4) {
    return Error::handle(TVector::name(), L"numNotEqual",
			 Error::TEST, __FILE__, __LINE__);
  }
  
  count = val0.numEqual(3);
  if (count != 1) {
    return Error::handle(TVector::name(), L"numNotEqual",
			 Error::TEST, __FILE__, __LINE__);
  }

  //---------------------------------------------------------------------------
  //
  // testing vector to scalar mathematical methods for complex numbers
  //
  //---------------------------------------------------------------------------

#ifdef ISIP_TEMPLATE_complex

  val0.assign(L"-1-3j, 3+2j, 5+7j, 7+4j, -9-8j");
  
  new_value = val0.dotProduct(val0);    
  if (!new_value.almostEqual(TIntegral(307, 0))) {
    return Error::handle(TVector::name(), L"dotProduct ",
			 Error::TEST, __FILE__, __LINE__);
  }

  val1.assign(L"2+4j, -4-5j, 7+2j, 6+0j, -3+4j");
  new_value = val0.dotProduct(val1);
  if (!new_value.almostEqual(TIntegral(50, -128))) {
    return Error::handle(TVector::name(), L"dotProduct ",
			 Error::TEST, __FILE__, __LINE__);
  }
#endif
  
  // exit gracefully
  //
  return true;
}

// method: diagnose7
//
// arguments:
//  Integral::DEBUG level: (input) debug level for diagnostics
//
// return: a boolean value indicating status
//
// this method tests sign and dsp related methods 
//
template<class TVector, class TScalar, class TIntegral>
boolean MVectorMethods::diagnose7(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");
  
  TVector val2;
  
  // if the type is signed, test sign-specific functions
  //
  if ((typeid(TIntegral) != typeid(ushort)) &&
      (typeid(TIntegral) != typeid(ulong)) &&
      (typeid(TIntegral) != typeid(ullong)) &&
      (typeid(TIntegral) != typeid(byte))) {