mcscl_02.cc

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

  // test sub
  //
  val6.sub(val5, val4);
  if (val6.real() != (TIntegral)2, val6.imag() != (TIntegral)2) {
    return Error::handle(name(), L"sub",
			 Error::TEST, __FILE__, __LINE__);
  }
  
  // test mult
  //
  val6.mult(val5, val4);
  if (val6.real() != (TIntegral)-5, val6.imag() != (TIntegral)10) {
    return Error::handle(name(), L"mult",
			 Error::TEST, __FILE__, __LINE__);
  }
 
  // test div
  //
  val6.div(val5, val4);
  if (!Integral::almostEqual(val6.real(), (TIntegral)2.2) &&
      !Integral::almostEqual(val6.imag(), (TIntegral)-0.4)) {
    return Error::handle(name(), L"div",
 			 Error::TEST, __FILE__, __LINE__);
  }

  // declare some local variables
  //
  TCScalar val0;
  TCScalar val1;
    
  // test functions work for floating point
  //
  if ((typeid(TIntegral) != typeid(long))) {
    
    // test acos
    //    
    val0.assign(SysComplex<TIntegral>
		((TIntegral)(Integral::PI / (TIntegral)3), (TIntegral)0.5));
    val1.cos(val0);
    if (!val0.almostEqual(val1.acos())) {
      val0.debug(L"val0.acos");
      val1.debug(L"val1.acos");      
      return Error::handle(name(), L"acos", Error::TEST, __FILE__, __LINE__);
    }

    // test acosh
    //
    val0.assign(SysComplex<TIntegral>
		((TIntegral)(Integral::PI / (TIntegral)3), (TIntegral)0.5));
    val1.cosh(val0);
    if (!val0.almostEqual(val1.acosh())) {
      val0.debug(L"val0.acosh");
      val1.debug(L"val1.acosh");      
      return Error::handle(name(), L"acosh", Error::TEST, __FILE__, __LINE__);
    }
  
    // test asin
    //
    val0.assign(SysComplex<TIntegral>
		((TIntegral)(Integral::PI / (TIntegral)6), (TIntegral)0.5));
    val1.sin(val0);
    if (!val0.almostEqual(val1.asin())) {
      val0.debug(L"val0.asin");
      val1.debug(L"val1.asin");          
      return Error::handle(name(), L"asin", Error::TEST, __FILE__, __LINE__);
    }

    // test asinh
    //
    val0.assign(SysComplex<TIntegral>
		((TIntegral)(Integral::PI / (TIntegral)6), (TIntegral)0.5));
    val1.sinh(val0);
    if (!val0.almostEqual(val1.asinh())) {
      val0.debug(L"val0.asinh");
      val1.debug(L"val1.asinh");              
      return Error::handle(name(), L"asinh", Error::TEST, __FILE__, __LINE__);
    }
    
    // test atan
    //
    val0.assign(SysComplex<TIntegral>
		((TIntegral)(Integral::QUARTER_PI), (TIntegral)0.5));
    val1.tan(val0);
    if (!val0.almostEqual(val1.atan())) {
      val0.debug(L"val0.atan");
      val1.debug(L"val1.atan");              
      return Error::handle(name(), L"atan", Error::TEST, __FILE__, __LINE__);
    }
  
    // test atanh
    //
    val0.assign(SysComplex<TIntegral>
		((TIntegral)(Integral::QUARTER_PI), (TIntegral)0.5));    
    val1.tanh(val0);
    if (!val0.almostEqual(val1.atanh())) {
      val0.debug(L"val0.atanh");
      val1.debug(L"val1.atanh");              
      return Error::handle(name(), L"atanh", Error::TEST, __FILE__, __LINE__);
    }
 
    // test ceil
    //
    val0.assign ((TIntegral)3.3, (TIntegral)4.3);
    val1.ceil((SysComplex<TIntegral>)val0);
    if ((!val1.almostEqual(SysComplex<TIntegral>
			   ((TIntegral)4, (TIntegral)5)))) {
      return Error::handle(name(), L"ceil", Error::TEST, __FILE__, __LINE__);
    }

    // test centerClip
    // not tested for complex numbers
  
    // test cos
    //
    val0.assign(SysComplex<TIntegral>
		((TIntegral)(Integral::PI / 3), (TIntegral)0.5));    
    val1.cos(val0);
    if (!val1.almostEqual(SysComplex<TIntegral>
			  ((TIntegral)0.5638, (TIntegral)-0.4513))) {
      val0.debug(L"val0.cos");
      val1.debug(L"val1.cos");                  
      return Error::handle(name(), L"cos", Error::TEST, __FILE__, __LINE__);
    }
  
    // test cosh
    //
    val0.assign(SysComplex<TIntegral>
		((TIntegral)(Integral::PI / 3), (TIntegral)0.5));        
    val1.cosh(val0);
    if (!val1.almostEqual(SysComplex<TIntegral>
			  ((TIntegral)1.404, (TIntegral)0.599))) {
      val0.debug(L"val0.cosh");
      val1.debug(L"val1.cosh");                      
      return Error::handle(name(), L"cosh", Error::TEST, __FILE__, __LINE__);
    }
  
    // test exp
    //
    val0.assign (4, 3);
    val1.log(val0);
    val1.exp();
    if (!val0.almostEqual(val1)) {
      val1.debug(L"exp");
      return Error::handle(name(), L"exp", Error::TEST, __FILE__, __LINE__);
    }
 
    // test exp2
    //
    val1.log2(val0);
    val1.exp2();
    if (!val0.almostEqual(val1)) {
      val1.debug(L"exp2 test");
      return Error::handle(name(), L"exp2", Error::TEST, __FILE__, __LINE__);
    }

    // test exp10
    //
    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 floor
    //
    val0.assign((TIntegral)3.3, (TIntegral)4.3);
    val1.floor((SysComplex<TIntegral>)val0);
    if ((!val1.almostEqual(SysComplex<TIntegral>
			   ((TIntegral)3, (TIntegral)4)))) {
      return Error::handle(name(), L"floor", Error::TEST, __FILE__, __LINE__);
    }
  }
   
  // test fraction
  // not tested for complex numbers
  //
   
  // test hash
  //
  val0.assign(4, 3);
  ulong h1 = val0.hash((long)104);
  if (!(h1 == (ulong)42)) {
    return Error::handle(name(), L"hash",Error::TEST, __FILE__, __LINE__);
  }

  // test inverse
  //
  TCScalar val8;
  val8.assign(4, 3);
  val8.inverse();
  if ((!val8.almostEqual(SysComplex<TIntegral>
			 ((TIntegral)0.16, (TIntegral)-0.12)))) {
    return Error::handle(name(), L"inverse", Error::TEST, __FILE__, __LINE__);
  }

  // test centerClip
  //
  val0.assign(40, 30);
  val1.assign(-25, 36);
  val8.assign(-18, -19);  
  val0.centerClip(20, 45);
  val1.centerClip(20, 45);
  val8.centerClip(20, 45);

  if ((!val0.almostEqual(SysComplex<TIntegral>
			 ((TIntegral)40, (TIntegral)30))) ||
      (!val1.almostEqual(SysComplex<TIntegral>
			 ((TIntegral)-25.6678, (TIntegral)36.9616))) ||
      (!val8.almostEqual(SysComplex<TIntegral>
			 ((TIntegral)-13.7549, (TIntegral)-14.5191)))) {
    return Error::handle(name(), L"centerClip",
			 Error::TEST, __FILE__, __LINE__);
  }

  // test fraction
  //
  if (typeid(TIntegral) != typeid(long)) {
    val0.fraction();
    val1.fraction();
    if ((!val0.almostEqual(SysComplex<TIntegral>
			   ((TIntegral)0, (TIntegral)0))) ||
	(!val1.almostEqual(SysComplex<TIntegral>
			   ((TIntegral)-0.6678, (TIntegral)0.9616)))) {
      return Error::handle(name(), L"fraction",
			   Error::TEST, __FILE__, __LINE__);
    }
  }
  
  // test limit
  // not tested for complex numbers
  //
  
  // test limitMag
  // not tested for complex numbers
  //
  TCScalar val9, val_res;
  val_res.assign(SysComplex<TIntegral>((TIntegral)1.6, (TIntegral)1.2));
  val9.assign(4, 3);
  val9.limitMag(4, 2);
  if (!val9.almostEqual(val_res)) {
    val9.debug(L"val9");
    val_res.debug(L"val_res");
      return Error::handle(name(), L"limitMag", Error::TEST, __FILE__, __LINE__);    
    }
  
  // test functions work for floating point
  //
  if ((typeid(TIntegral) != typeid(long))) {
    
    // test log
    //    
    val0.assign (4, 3);
    val1.log(val0);
    if (!val1.almostEqual(SysComplex<TIntegral>
			  ((TIntegral)1.60944, (TIntegral)0.643501))) {
      val1.debug(L"log");
      return Error::handle(name(), L"log", Error::TEST, __FILE__, __LINE__);
    }

    // test log2
    //
    val1.log2(val0);
    if (!val1.almostEqual(SysComplex<TIntegral>
			  ((TIntegral)2.32193, (TIntegral)0.928376))) {
      val1.debug(L"log2");
      return Error::handle(name(), L"log2", Error::TEST, __FILE__, __LINE__);
    }

    // test log10
    //
    val1.log10(val0);
    if (!val1.almostEqual(SysComplex<TIntegral>
			  ((TIntegral)0.69897, (TIntegral)0.279469))) {
      val1.debug(L"log10");
      return Error::handle(name(), L"log10", Error::TEST, __FILE__, __LINE__);
    }
    
    // test log1p
    //
    val1.log1p(val0);
    if (!val1.almostEqual(SysComplex<TIntegral>
			  ((TIntegral)1.76318, (TIntegral)0.54042))) {
      val1.debug(L"log1p");
      return Error::handle(name(), L"log1p", Error::TEST, __FILE__, __LINE__);
    }
  }
  
  // test max
  //
  val1.assign (2, 3);
  val0.assign (3, 4);
  TCScalar val2;
  val2.max(val0, val1);
  if ((!val2.almostEqual(val0))) {
    return Error::handle(name(), L"max", Error::TEST, __FILE__, __LINE__);
  }
      
  // test min
  // 
  val2.min(val0, val1);
  if ((!val2.almostEqual(val1))) {
    return Error::handle(name(), L"min", Error::TEST, __FILE__, __LINE__);
  }
  
  // test neg
  //
  val2.neg(val0);
  if ((!val2.almostEqual(SysComplex<TIntegral>
			 ((TIntegral)-3, (TIntegral)-4)))) {
    val2.debug(L"neg");
    return Error::handle(name(), L"neg", Error::TEST, __FILE__, __LINE__);
  }
  
  // test pow
  //
  val0.pow((TIntegral)2);
  if ((!val0.almostEqual(SysComplex<TIntegral>
			 ((TIntegral)-7, (TIntegral)24)))) {
    val2.debug(L"pow");
    return Error::handle(name(), L"pow", Error::TEST, __FILE__, __LINE__);
  }

  if ((typeid(TIntegral) != typeid(long))) {   

    // test rceil
    //
    val0.assign ((TIntegral)3.3, (TIntegral)4.3);
    val2.rceil(val0);
    if ((!val2.almostEqual(SysComplex<TIntegral>
			   ((TIntegral)0.7, (TIntegral)0.7)))) {
      val2.debug(L"rceil");
      return Error::handle(name(), L"rceil", Error::TEST, __FILE__, __LINE__);
    }
    
    // test rfloor
    //
    val2.rfloor(val0);
    if ((!val2.almostEqual(SysComplex<TIntegral>
			   ((TIntegral)-0.3, (TIntegral)-0.3)))) {
      val2.debug(L"rfloor");
      return Error::handle(name(), L"rfloor", Error::TEST, __FILE__, __LINE__);
    }
    
    // test round
    //
    val2.round((SysComplex<TIntegral>)val0);
    if ((!val2.almostEqual(SysComplex<TIntegral>
			   ((TIntegral)3, (TIntegral)4)))) {
      val2.debug(L"round");
      return Error::handle(name(), L"round", Error::TEST, __FILE__, __LINE__);
    } 
    
    // test sign
    //
    val2.sign(val0);
    if ((!val2.almostEqual(SysComplex<TIntegral>
			   ((TIntegral)1, (TIntegral)0)))) {
      val2.debug(L"sign");
      return Error::handle(name(), L"sign", Error::TEST, __FILE__, __LINE__);
    }
    
    // test sin
    //
    val0.assign(SysComplex<TIntegral>
		((TIntegral)(Integral::PI / (double)6), (TIntegral)0.5));
    val1.sin(val0);
    if (!val1.almostEqual(SysComplex<TIntegral>
			  ((TIntegral)0.5638, (TIntegral)0.4513))) {
      val0.debug(L"val0.sin");
      val1.debug(L"val1.sin");
      return Error::handle(name(), L"sin", Error::TEST, __FILE__, __LINE__);
    }
    
    // test sinh
    //
    val0.assign(SysComplex<TIntegral>