itgl_02.cc

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

    return Error::handle(name(), L"atan", Error::TEST, __FILE__, __LINE__);
  }

  if (!almostEqual(atanh(0.9172), M_PI_2)) {
    return Error::handle(name(), L"atanh", Error::TEST, __FILE__, __LINE__);
  }

  if (!almostEqual(ceil(26.1), 27.0)) {
    return Error::handle(name(), L"ceil", Error::TEST, __FILE__, __LINE__);
  }

  if (!almostEqual(cos(M_PI_2), 0.0)) {
    return Error::handle(name(), L"cos", Error::TEST, __FILE__, __LINE__);
  }

  if (!almostEqual(cosh(0.0), 1.0)) {
    return Error::handle(name(), L"cosh", Error::TEST, __FILE__, __LINE__);
  }

  if (!almostEqual(exp(1.0), M_E)) {
    return Error::handle(name(), L"exp", Error::TEST, __FILE__, __LINE__);
  }

  if (!almostEqual(exp2(1.0), 2.0)) {
    return Error::handle(name(), L"exp2", Error::TEST, __FILE__, __LINE__);
  }

  if (!almostEqual(exp10(1.0), 10.0)) {
    return Error::handle(name(), L"exp10", Error::TEST, __FILE__, __LINE__);
  }

  if (!almostEqual(floor(27.1), 27.0)) {
    return Error::handle(name(), L"floor", Error::TEST, __FILE__, __LINE__);
  }

  if (!almostEqual(fraction(27.1), 0.1)) {
    return Error::handle(name(), L"fraction", Error::TEST, __FILE__, __LINE__);
  }

  ulong foo[] = {5, 27, 99, 10192, 3932};
  if (hash(foo, 5, 128) != 53) {
    return Error::handle(name(), L"hash", Error::TEST, __FILE__, __LINE__);
  }
  
  if (!almostEqual(integer(27.1), 27.0)) {
    return Error::handle(name(), L"integer", Error::TEST, __FILE__, __LINE__);
  }

  if (!almostEqual(log(M_E), 1.0)) {
    return Error::handle(name(), L"log", Error::TEST, __FILE__, __LINE__);
  }

  if (!almostEqual(log2(2.0) / log2(M_E), log(2.0))) {
    return Error::handle(name(), L"log2", Error::TEST, __FILE__, __LINE__);
  }

  if (!almostEqual(log10(10.0) / log10(M_E), log(10.0))) {
    return Error::handle(name(), L"log10", Error::TEST, __FILE__, __LINE__);
  }

  if (!almostEqual(log1p(M_E - 1.0), 1.0)) {
    return Error::handle(name(), L"log1p", Error::TEST, __FILE__, __LINE__);
  }

  if (!almostEqual(max(1.0, 2.0), 2.0)) {
    return Error::handle(name(), L"max", Error::TEST, __FILE__, __LINE__);
  }

  if (!almostEqual(min(1.0, 2.0), 1.0)) {
    return Error::handle(name(), L"min", Error::TEST, __FILE__, __LINE__);
  }

  if (!almostEqual(pow(M_E, 2.0), exp(2.0))) {
    return Error::handle(name(), L"pow", Error::TEST, __FILE__, __LINE__);
  }

  if ((!almostEqual(round(27.49), 27.0)) ||
      (!almostEqual(round(26.51), 27.0)) ||
      (!almostEqual(round(-27.1), -27.0)) ||
      (!almostEqual(round(-26.51), -27.0))) {
    return Error::handle(name(), L"round", Error::TEST, __FILE__, __LINE__);
  }

  if (!almostEqual(sin(M_PI_2), 1.0)) {
    return Error::handle(name(), L"sin", Error::TEST, __FILE__, __LINE__);
  }

  if (!almostEqual(sinh(M_PI_2), 2.3013)) {
    return Error::handle(name(), L"sinh", Error::TEST, __FILE__, __LINE__);
  }

  // test sleep:
  //  there is no easy way to test this since the unix time function is not
  //  very accurate and we can't guarantee this program won't be preempted.
  //
  sleep(1);

  if (!almostEqual(sqrt(pow(M_E, 2.0)), M_E)) {
    return Error::handle(name(), L"sqrt", Error::TEST, __FILE__, __LINE__);
  }

  if (!almostEqual(tan(M_PI_4), 1.0)) {
    return Error::handle(name(), L"tan", Error::TEST, __FILE__, __LINE__);
  }

  if (!almostEqual(tanh(M_PI_2), 0.9172)) {
    return Error::handle(name(), L"tanh", Error::TEST, __FILE__, __LINE__);
  }

  // reset indentation
  //
  if (level_a > Integral::NONE) {
    Console::decreaseIndention();
  }
  
  //--------------------------------------------------------------------------
  //
  // 5. class-specific public methods:
  //     math functions for complex numbers
  //
  //--------------------------------------------------------------------------
  
  // set indentation
  //
  if (level_a > Integral::NONE) {
    Console::put(L"testing class-specific public methods: complex number math functions...\n");
    Console::increaseIndention();
  }

  const complexdouble c0(4.0, 2.0);
  const complexdouble c1(3.5, 2.2);

  if (Integral::almostEqual(c0, c1)) {
    return Error::handle(name(), L"almostEqual",
			 Error::TEST, __FILE__, __LINE__);
  }

  if (!Integral::almostEqual(c0, complexdouble(4.00001, 1.99999))) {
    return Error::handle(name(), L"almostEqual",
			 Error::TEST, __FILE__, __LINE__);
  }

  if (!Integral::almostEqual(abs(c0), 4.4721)) {
    return Error::handle(name(), L"abs", Error::TEST, __FILE__, __LINE__);
  }

  if (!Integral::almostEqual(acos(c0), complexdouble(0.4739, -2.1836))) {
    return Error::handle(name(), L"acos", Error::TEST, __FILE__, __LINE__);
  }

  if (!Integral::almostEqual(acosh(c0), complexdouble(2.1836, 0.4739))) {
    return Error::handle(name(), L"acosh", Error::TEST, __FILE__, __LINE__);
  }

  if (!Integral::almostEqual(asin(c0), complexdouble(1.0969, 2.1836))) {
    return Error::handle(name(), L"asin", Error::TEST, __FILE__, __LINE__);
  }

  if (!Integral::almostEqual(asinh(c0), complexdouble(2.1986, 0.4539))) {
    return Error::handle(name(), L"asinh", Error::TEST, __FILE__, __LINE__);
  }

  if (!Integral::almostEqual(atan(c0), complexdouble(1.3715, 0.0964))) {
    return Error::handle(name(), L"atan", Error::TEST, __FILE__, __LINE__);
  }

  if (!Integral::almostEqual(atanh(c0), complexdouble(0.2006, 1.4670))) {
    return Error::handle(name(), L"atanh", Error::TEST, __FILE__, __LINE__);
  }

  if (!Integral::almostEqual(ceil(c0), complexdouble(4.0000, 2.0000))) {
    return Error::handle(name(), L"ceil", Error::TEST, __FILE__, __LINE__);
  }

  if (!Integral::almostEqual(cos(c0), complexdouble(-2.4591, 2.7448))) {
    return Error::handle(name(), L"cos", Error::TEST, __FILE__, __LINE__);
  }

  if (!Integral::almostEqual(cosh(c0), complexdouble(-11.3642, 24.8147))) {
    return Error::handle(name(), L"cosh", Error::TEST, __FILE__, __LINE__);
  }

  if (!Integral::almostEqual(exp(c0), complexdouble(-22.7208, 49.6460))) {
    return Error::handle(name(), L"exp", Error::TEST, __FILE__, __LINE__);
  }

  if (!Integral::almostEqual(exp2(c0), complexdouble(2.9353, 15.7284))) {
    return Error::handle(name(), L"exp2", Error::TEST, __FILE__, __LINE__);
  }

  if (!Integral::almostEqual(exp10(c0), complexdouble(-1070.1, -9942.6))) {
    return Error::handle(name(), L"exp10", Error::TEST, __FILE__, __LINE__);
  }

  if (!Integral::almostEqual(floor(c0), complexdouble(4.000, 2.0000))) {
    return Error::handle(name(), L"floor", Error::TEST, __FILE__, __LINE__);
  }

  if (!Integral::almostEqual(log(c0), complexdouble(1.4979, 0.4636))) {
    return Error::handle(name(), L"log", Error::TEST, __FILE__, __LINE__);
  }

  if (!Integral::almostEqual(log2(c0), complexdouble(2.1610, 0.6689))) {
    return Error::handle(name(), L"log2", Error::TEST, __FILE__, __LINE__);
  }

  if (!Integral::almostEqual(log10(c0), complexdouble(0.6505, 0.2014))) {
    return Error::handle(name(), L"log10", Error::TEST, __FILE__, __LINE__);
  }

  if (!Integral::almostEqual(log1p(c0), complexdouble(1.6836, 0.3805))) {
    return Error::handle(name(), L"log1p", Error::TEST, __FILE__, __LINE__);
  }

  if (!Integral::almostEqual(max(c0, c1), c0)) {
    return Error::handle(name(), L"max", Error::TEST, __FILE__, __LINE__);
  }

  if (!Integral::almostEqual(min(c0, c1), c1)) {
    return Error::handle(name(), L"min", Error::TEST, __FILE__, __LINE__);
  }

  if (!Integral::almostEqual(pow(c0, c1), complexdouble(13.9298, -66.7666))) {
    return Error::handle(name(), L"pow", Error::TEST, __FILE__, __LINE__);
  }

  if (!Integral::almostEqual(round(c0), c0)) {
    return Error::handle(name(), L"round", Error::TEST, __FILE__, __LINE__);
  }

  if (!Integral::almostEqual(sin(c0), complexdouble(-2.8472, -2.3707))) {
    return Error::handle(name(), L"sin", Error::TEST, __FILE__, __LINE__);
  }

  if (!Integral::almostEqual(sinh(c0), complexdouble(-11.3566, 24.8313))) {
    return Error::handle(name(), L"sinh", Error::TEST, __FILE__, __LINE__);
  }

  if (!Integral::almostEqual(sqrt(c0), complexdouble(2.0582, 0.4859))) {
    return Error::handle(name(), L"sqrt", Error::TEST, __FILE__, __LINE__);
  }

  if (!Integral::almostEqual(tan(c0), complexdouble(0.0364, 1.0047))) {
    return Error::handle(name(), L"tan", Error::TEST, __FILE__, __LINE__);
  }

  if (!Integral::almostEqual(tanh(c0), complexdouble(1.0004, -0.0005))) {
    return Error::handle(name(), L"tanh", Error::TEST, __FILE__, __LINE__);
  }

  // reset indentation
  //
  if (level_a > Integral::NONE) {
    Console::decreaseIndention();
  }

  //--------------------------------------------------------------------------
  //
  // 6. class-specific public methods:
  //     other math functions useful for speech research
  //
  //--------------------------------------------------------------------------

  // set indentation
  //
  if (level_a > Integral::NONE) {
    Console::put(L"testing class-specific public methods: other math functions...\n");
    Console::increaseIndention();
  }
  
  // test logAddLog
  //
  if (!almostEqual(logAddLog(log(2.0), log(3.0)), (double)1.609437912)) {
    return Error::handle(name(), L"logAddLog",
			 Error::TEST, __FILE__, __LINE__);
  }

  // reset indentation
  //
  if (level_a > Integral::NONE) {
    Console::decreaseIndention();
  }

  //---------------------------------------------------------------------------
  //
  // 7. print completion message
  //
  //---------------------------------------------------------------------------

  // reset indentation
  //
  if (level_a > Integral::NONE) {
    Console::decreaseIndention();
  }
  
  if (level_a > Integral::NONE) {
    SysString output(L"diagnostics passed for class ");
    output.concat(name());
    output.concat(L"\n");
    Console::put(output);
  }

  // exit gracefully
  //
  return true;
}