mscl_02.cc

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

// method: diagnose2
//
//  arguments:
//  Integral::DEBUG level: (input) debug level for diagnostics
//
// return: logical error status
//
// this method tests math functions and private methods.
//
template<class TScalar, class TIntegral>
boolean MScalarMethods::diagnose2(Integral::DEBUG level_a) {

  //---------------------------------------------------------------------------
  //
  // class-specific public methods:
  //  basic mathematical methods
  //
  //---------------------------------------------------------------------------

  // declare local variables
  //
  TScalar val0;
  TScalar val1;
  TScalar val2;

  // set indentation
  //
  if (level_a > Integral::NONE) {
    Console::put(L"testing class-specific public methods: basic mathematical methods...\n");
    Console::increaseIndention();
  }
  
  // test add
  //
  val0.assign((TIntegral)3);
  val1.assign((TIntegral)2);
  val2.add(val0, val1);
  if (val2 != (TIntegral)5) {
    return Error::handle(name(), L"add", Error::TEST, __FILE__, __LINE__);
  }
  
  // test sub
  // 
  val0.assign((TIntegral)3);
  val1.assign((TIntegral)2);
  val2.sub(val0, val1);
  if (val2 != (TIntegral)1) {
    return Error::handle(name(), L"sub", Error::TEST, __FILE__, __LINE__);
  }
  
  // test mult
  //
  val0.assign((TIntegral)3);
  val1.assign((TIntegral)2);
  val2.mult(val0, val1);
  if (val2 != (TIntegral)6) {
    return Error::handle(name(), L"mult", Error::TEST, __FILE__, __LINE__);
  }

  // test div
  //
  val0.assign((TIntegral)5);
  val1.assign((TIntegral)2);
  val2.div(val0, val1);
  if (val2 != (TIntegral)2.5) {
    return Error::handle(name(), L"div", Error::TEST, __FILE__, __LINE__);
  }
 
  // test mod
  //
  if ((typeid(TIntegral) != typeid(double)) &&
      (typeid(TIntegral) != typeid(float))) {
    val0.assign((TIntegral)8);
    val1.assign((TIntegral)3);
    val2.mod(val0, val1);
    if (val2 != (TIntegral)2) {
      return Error::handle(name(), L"mod", Error::TEST, __FILE__, __LINE__);
    }
  }
  
  // reset indentation
  //
  if (level_a > Integral::NONE) {
    Console::decreaseIndention();
  }
  
  //---------------------------------------------------------------------------
  //
  // class-specific public methods:
  //  other mathematical methods (listed alphabetically)
  //
  //--------------------------------------------------------------------------

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

  // test abs
  //
  if ((typeid(TIntegral) == typeid(float)) ||
      (typeid(TIntegral) == typeid(double)) ||
      (typeid(TIntegral) == typeid(llong)) ||
      (typeid(TIntegral) == typeid(short)) ||
      (typeid(TIntegral) == typeid(long)) ) {
    
    val0.abs(200);
    if (!val0.almostEqual(200)) {
      return Error::handle(name(), L"abs", Error::TEST, __FILE__, __LINE__);
    }
    
    val0.abs(-45);
    if (!val0.almostEqual(45)) {
      return Error::handle(name(), L"abs", Error::TEST, __FILE__, __LINE__);
    }
  }

  // test functions only work for floating point
  //  
  if ((typeid(TIntegral) == typeid(float)) ||
      (typeid(TIntegral) == typeid(double))) {
    
    // test acos
    //    
    val0.assign(Integral::PI / (double)3);
    val1.cos(val0);
    if (!val0.almostEqual(val1.acos())) {
      return Error::handle(name(), L"acos", Error::TEST, __FILE__, __LINE__);
    }

    // test acosh
    //
    val0.assign((TIntegral)0.5); 
    val1.cosh(val0);
    if (!val0.almostEqual(val1.acosh())) {
      return Error::handle(name(), L"acosh", Error::TEST, __FILE__, __LINE__);
    }
    
    // test asin
    //
    val0.assign(Integral::PI / (double)6);
    val1.sin(val0);
    if (!val0.almostEqual(val1.asin())) {
      return Error::handle(name(), L"asin", Error::TEST, __FILE__, __LINE__);
    }
    
    // test asinh
    //
    val0.assign((TIntegral)0.5); 
    val1.sinh(val0);
    if (!val0.almostEqual(val1.asinh())) {
      return Error::handle(name(), L"asinh", Error::TEST, __FILE__, __LINE__);
    }
    
    // test atan
    //
    val0.assign(Integral::QUARTER_PI);
    val1.tan(val0);
    if (!val0.almostEqual(val1.atan())) {
      return Error::handle(name(), L"atan", Error::TEST, __FILE__, __LINE__);
    }
    
    // test atanh
    //
    val0.assign((TIntegral)0.5); 
    val1.tanh(val0);
    if (!val0.almostEqual(val1.atanh())) {
      return Error::handle(name(), L"atanh", Error::TEST, __FILE__, __LINE__);
    }
    
    // test ceil
    //
    val0.ceil((TIntegral)2.4);
    val1.ceil((TIntegral)20.3);
    if ((!val0.almostEqual((TIntegral)3.0)) ||
	(!val1.almostEqual((TIntegral)21.0))) {
      val0.debug(L"val0");
      val1.debug(L"val1");
      return Error::handle(name(), L"ceil", Error::TEST, __FILE__, __LINE__);
    }
    
    // test centerClip
    //
    val0.assign((long)24);
    val1.assign((long)200);
    val2.assign((long)-34);  
    TScalar res0;
    TScalar res1;
    TScalar res2;
    res0.centerClip(-50, 50, val0);
    res1.centerClip(-50, 50, val1);
    res2.centerClip(-50, 50, val2);
    
    if ((!res0.almostEqual(50))|| (!res1.almostEqual(200)) ||
	(!res2.almostEqual(-50))) {
      return Error::handle(name(), L"centerClip",
			   Error::TEST, __FILE__, __LINE__);
    }
  
    // test cos
    //
    val0.assign(Integral::PI / (double)3);
    val1.cos(val0);
    if (!val1.almostEqual((TIntegral)0.5)) {
      return Error::handle(name(), L"cos", Error::TEST, __FILE__, __LINE__);
    }
    
    // test cosh
    //
    val0.assign((TIntegral)0.5); 
    val1.cosh(val0);
    val1.acosh();
    if (!val1.almostEqual(val0)) {
      return Error::handle(name(), L"cosh", Error::TEST, __FILE__, __LINE__);
    }
  }
  
  // test exp
  //
  val0.assign((TIntegral)55);                  
  val1.log(val0);
  val1.exp();
  if (!val0.almostEqual(val1))  {
    val1.debug(L"val1 exp");
    val0.debug(L"val0 exp");
    return Error::handle(name(), L"exp", Error::TEST, __FILE__, __LINE__);
  }
    
  // test exp2
  //
  val0.assign((TIntegral)64);
  val1.log2(val0);
  val1.exp2();
  if (!val0.almostEqual(val1)) {
    val1.debug(L"exp2");
    return Error::handle(name(), L"exp2", Error::TEST, __FILE__, __LINE__);
  }
    
  // test exp10
  //
  val0.assign((TIntegral)100);
  val1.log10(val0);
  val1.exp10();
  if (!val0.almostEqual(val1)) {
    val1.debug(L"exp10 test");
    return Error::handle(name(), L"exp10", Error::TEST, __FILE__, __LINE__);
  }

  // test factorial
  //
  val0.factorial(5);
  if (!val0.almostEqual(120)) {
    val0.debug(L"5!");
    return Error::handle(name(), L"factorial", Error::TEST,
			 __FILE__, __LINE__);
  }
 
  // test floor
  //
  if ((typeid(TIntegral) == typeid(float)) ||
      (typeid(TIntegral) == typeid(double))) {
    val0.floor((TIntegral)2.4);
    val1.floor((TIntegral)-20.3);
    if ((!val0.almostEqual((TIntegral)2.0)) ||
	(!val1.almostEqual((TIntegral)-21.0))) {
      return Error::handle(name(), L"floor", Error::TEST, __FILE__, __LINE__);
    }
  }
  
  // test fraction
  //
  if ((typeid(TIntegral) == typeid(float)) &&
      (typeid(TIntegral) == typeid(double))) {
    val0.fraction((TIntegral)2.4);
    val1.fraction((TIntegral)34.1);
    if ((!val0.almostEqual((TIntegral)0.4)) ||
	(!val0.almostEqual((TIntegral)0.1))) {
      return Error::handle(name(), L"fraction",
			   Error::TEST, __FILE__, __LINE__);
    }
  }
    
  // test grand:
  //  see the section of code below that tests random numbers
  //

  // test hash
  //
  val0.assign((TIntegral)87.30);
  ulong h1 = val0.hash((long)104);
  if (!(typeid(TIntegral) == typeid(float) && (h1 == (ulong)16)) &&
      !(typeid(TIntegral) == typeid(double) && (h1 == (ulong)4)) &&
      !(h1 == (ulong)87)) {
    return Error::handle(name(), L"hash",Error::TEST, __FILE__, __LINE__);
  }
  
  // test inverse
  //
  val0.assign((TIntegral)216);
  val0.inverse();
  if (!val0.almostEqual((TIntegral)0.0046296)) {
    val0.debug(L"1/216");
    return Error::handle(name(), L"inverse", Error::TEST, __FILE__,__LINE__);
  }

  // declare local variables
  //
  TScalar res0;
  TScalar res1;
  TScalar res2;

  // test limit
  //
  val0.assign((long)24);
  val1.assign((long)200);

  res0.limit(0, 100, val0);
  res1.limit(0, 100, val1);
  if ((!res0.almostEqual(24)) ||
      (!res1.almostEqual(100))) {
    return Error::handle(name(), L"limit", Error::TEST, __FILE__, __LINE__);
  }
      
  // test limitMag
  // test limit using negative values
  //
  if ((typeid(TIntegral) == typeid(float)) ||
      (typeid(TIntegral) == typeid(double)) ||
      (typeid(TIntegral) == typeid(long)) ||
      (typeid(TIntegral) == typeid(short)) ||
      (typeid(TIntegral) == typeid(llong))) {
    
    val2.assign((long)-34);    
    res1.limit(0, 100, val2);    
    if (!res1.almostEqual(0)) {
      return Error::handle(name(), L"limit", Error::TEST, __FILE__, __LINE__);
    }
    
    res0.limitMag(30, -5, val0);
    res1.limitMag(30, -5, val1);
    res2.limitMag(30, -5, val2);
    
    if ((!res0.almostEqual(24)) ||
	(!res1.almostEqual(-5)) ||
	(!res2.almostEqual(-5))) {
      return Error::handle(name(), L"limitMag", Error::TEST,
			   __FILE__, __LINE__);
    }
  }
  
  // test log
  //
  val0.assign((TIntegral)55);                  
  val1.log(val0);
  if (!val1.almostEqual((TIntegral)4.00733318523)) {
    val1.debug(L"log");
    return Error::handle(name(), L"log", Error::TEST, __FILE__, __LINE__);
  }
  
  // test log2
  //
  val0.assign((TIntegral)64);
  val1.log2(val0);
  if (!val1.almostEqual((TIntegral)6)) {
    val1.debug(L"log2");
    return Error::handle(name(), L"log2", Error::TEST, __FILE__, __LINE__);
  }

  // test log10
  //
  val0.assign((TIntegral)100);
  val1.log10(val0);
  if (!val1.almostEqual((TIntegral)2)) {
    val1.debug(L"log10");
    return Error::handle(name(), L"log10", Error::TEST, __FILE__, __LINE__);
  }
    
  // test log1p
  //
  val0.assign((TIntegral)54);                
  val1.log1p(val0);
  if (!val1.almostEqual((TIntegral)4.00733318523)) {
    val1.debug(L"log1p");
    return Error::handle(name(), L"log1p", Error::TEST, __FILE__, __LINE__);
  }

  // test max
  //
  val0.max(43, 52);
  val1.max(43, 33);
  if ((!val0.almostEqual(52)) || (!val1.almostEqual(43))) {
    return Error::handle(name(), L"max", Error::TEST, __FILE__, __LINE__);
  }
  
  // test min
  //   
  val0.min(43, 52);
  val1.min(43, 33);
  if ((!val0.almostEqual(43)) || (!val1.almostEqual(33))) {
    return Error::handle(name(), L"min", Error::TEST, __FILE__, __LINE__);
  }
  
  // test neg
  //
  if ((typeid(TIntegral) == typeid(float)) ||
      (typeid(TIntegral) == typeid(double)) ||
      (typeid(TIntegral) == typeid(llong)) ||
      (typeid(TIntegral) == typeid(long)) ||
      (typeid(TIntegral) == typeid(short))) {
    val0.neg(-44);
    if (!val0.almostEqual(44)) {
      return Error::handle(name(), L"neg", Error::TEST, __FILE__, __LINE__);
    }

    val0.neg(200);
    if (!val0.almostEqual(-200)) {
      return Error::handle(name(), L"neg", Error::TEST, __FILE__, __LINE__);
    }
  }
     
  // test pow
  //
  val0.assign((TIntegral)5);
  val0.pow((TIntegral)3.0);
  if (!val0.almostEqual(125)) {
    val0.debug(L"pow(5^3)");
    return Error::handle(name(), L"pow", Error::TEST, __FILE__, __LINE__);
  }
 
  // test rand:
  //  see the section of code below that tests random numbers
  //

  // test functions only work for floating point
  //
  if ((typeid(TIntegral) == typeid(float)) ||
      (typeid(TIntegral) == typeid(double))) {

    // test rceil
    //
    val0.rceil((TIntegral)2.4);
    val1.rceil((TIntegral)-20.3);
    if ((!val0.almostEqual((TIntegral)0.6)) ||
	(!val1.almostEqual((TIntegral)0.3))) {
      return Error::handle(name(), L"rceil", Error::TEST, __FILE__, __LINE__);
    }

    // test rfloor
    //
    val0.rfloor((TIntegral)2.4);
    val1.rfloor((TIntegral)-20.3);
    if ((!val0.almostEqual((TIntegral)-0.4)) ||
	(!val1.almostEqual((TIntegral)-0.7))) {
      return Error::handle(name(), L"rfloor", Error::TEST, __FILE__, __LINE__);
    }

    // test round
    //
    val0.round((TIntegral)2.4);
    val1.round((TIntegral)2.6);
    if ((!val0.almostEqual((TIntegral)2.0)) ||
	(!val1.almostEqual((TIntegral)3.0))) {
      return Error::handle(name(), L"round", Error::TEST, __FILE__, __LINE__);
    }
  }

  // test functions work for all point
  //
  {
    // test ceil
    //
    val0.ceil((float)2.4);
    val1.ceil((float)20.3);
    if ((!val0.almostEqual((TIntegral)3.0)) ||
	(!val1.almostEqual((TIntegral)21.0))) {
      val0.debug(L"val0");
      val1.debug(L"val1");
      return Error::handle(name(), L"ceil", Error::TEST, __FILE__, __LINE__);
    }

    // test floor
    //
    val0.floor((float)2.4);
    val1.floor((float)20.8);
    if ((!val0.almostEqual((TIntegral)2.0)) ||
	(!val1.almostEqual((TIntegral)20.0))) {
      val0.debug(L"val0 = 2.0");
      val1.debug(L"val1 = -21");
      return Error::handle(name(), L"floor", Error::TEST, __FILE__, __LINE__);
    }

    // test round
    //
    val0.round((float)2.4);
    val1.round((float)2.6);
    if ((!val0.almostEqual((TIntegral)2.0)) ||
	(!val1.almostEqual((TIntegral)3.0))) {
      return Error::handle(name(), L"round", Error::TEST, __FILE__, __LINE__);
    }
  }
   
  // test sign
  //
  if ((typeid(TIntegral) == typeid(float)) ||
      (typeid(TIntegral) == typeid(double)) ||
      (typeid(TIntegral) == typeid(llong)) ||
      (typeid(TIntegral) == typeid(long)) ||
      (typeid(TIntegral) == typeid(short))) {
    val0.sign(-44);
    if (!val0.almostEqual(-1)) {
      return Error::handle(name(), L"sign", Error::TEST, __FILE__, __LINE__);
    }
   
    val0.sign(200);
    if (!val0.almostEqual(1)) {
      return Error::handle(name(), L"sign", Error::TEST, __FILE__, __LINE__);
    }
  }

  // test sin
  //
  if ((typeid(TIntegral) == typeid(float)) ||
      (typeid(TIntegral) == typeid(double))) {  
    val0.assign(Integral::PI / (double)6);    
    val1.sin(val0);  
    if (!val1.almostEqual((TIntegral)0.5)) {
      return Error::handle(name(), L"sin", Error::TEST, __FILE__, __LINE__);
    }
  }
  
  // test sinh
  //
  if ((typeid(TIntegral) == typeid(float)) ||
      (typeid(TIntegral) == typeid(double))) {  
    val0.assign((TIntegral)0); 
    val1.sinh(val0);
    if (!val1.almostEqual((TIntegral)0)) {