mscl_02.cc

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

// file: $isip/class/math/scalar/MScalar/mscl_02.cc
// version: $Id: mscl_02.cc,v 1.23 2002/08/02 23:46:56 zheng Exp $
//

// isip include files
//
#include "MScalarMethods.h"
#include "MScalar.h"
#include <Console.h>
#include <typeinfo>

// method: diagnose
//
// arguments:
//  Integral::DEBUG level: (input) debug level for diagnostics
//
// return: logical error status
//
// this method is split into three methods:
//  diagnose0: tests required methods and operator overloads
//  diagnose1: tests bitwise methods
//  diagnose2: tests math and private methods.
//  
template<class TScalar, class TIntegral>
boolean MScalarMethods::diagnose(Integral::DEBUG level_a) {

  //----------------------------------------------------------------------
  //
  // preliminaries
  //
  //----------------------------------------------------------------------

  // output the class name
  //
  if (level_a > Integral::NONE) {
    SysString output(L"diagnosing class ");
    output.concat(name());
    output.concat(L": ");
    Console::put(output);
  }
  
  // call the sub diagnose method
  //
  diagnose0<TScalar, TIntegral>(level_a);
  diagnose1<TScalar, TIntegral>(level_a);
  diagnose2<TScalar, TIntegral>(level_a);
  
  //---------------------------------------------------------------------
  //
  //  print completion message
  //
  //---------------------------------------------------------------------

  if (level_a > Integral::NONE) {
    String output(L"diagnostics passed for class ");
    output.concat(name());
    output.concat(L"\n");
    Console::put(output);   
  }
  
  // exit gracefully
  //
  return true;
}

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

  // declare some local variables
  //
  TScalar val0;
  TScalar val1;
  TScalar val2;
  
  //---------------------------------------------------------------------------
  //
  // required public methods
  //
  //---------------------------------------------------------------------------
  
  // set indentation
  //
  if (level_a > Integral::NONE) {
    Console::put(L"testing class-specific public methods: required public methods...\n");
    Console::increaseIndention();
  }
   						   
  // test clear
  //
  val0.clear();
  if (val0 != TScalar::DEF_VALUE) {
    val0.debug(L"val0");
    return Error::handle(name(), L"clear", Error::TEST, __FILE__, __LINE__);
  }

  // reset indentation
  //
  if (level_a > Integral::NONE) {
    Console::decreaseIndention();
  }
    
  //---------------------------------------------------------------------------
  //
  // class-specific public methods:
  //  extensions to required methods
  //
  //---------------------------------------------------------------------------

  // set indentation
  //
  if (level_a > Integral::NONE) {
    Console::put(L"testing class-specific public methods: extension to required methods..");
    Console::increaseIndention();
  }
  
  // test assign
  //
  val0.assign((TIntegral)3);
  if (val0 != (TIntegral)3) {
    return Error::handle(name(), L"assign", Error::TEST, __FILE__, __LINE__);
  }

  // test assign from String
  // 
  String in0(L"3.5");
  val0.assign(in0);

  String in1(L"2.5");
  val1.assign(in1);

  val2 = val0 - val1;
  if (val2 != (TIntegral)1) {  
    return Error::handle(name(), L"<String::assign>",
			 Error::TEST, __FILE__, __LINE__);
  }
  // test get from String
  // 
  val0.assign(3.5);
  val0.get(in0);
  val1.assign(in0);
  if (val1 != val0) {  
    return Error::handle(name(), L"<String::get>",
			 Error::TEST, __FILE__, __LINE__);
  }
    
  // test almostEqual
  //
  val0.assign(1.0001);
  val1.assign(1.0002);
  
  if (!val0.almostEqual(val1)) {
    return Error::handle(name(), L"almostEqual", Error::TEST,
			 __FILE__, __LINE__);
  }
  
  val0.assign(1.0);
  val1.assign(2.0);
  
  if (val0.almostEqual(val1)) {
    return Error::handle(name(), L"almostEqual", Error::TEST,
			 __FILE__, __LINE__);
  }

  // reset indentation
  //
  if (level_a > Integral::NONE) {
    Console::decreaseIndention();
  }
  
  //---------------------------------------------------------------------------
  //
  // class-specific public methods:
  //  operator overloads
  //
  //---------------------------------------------------------------------------

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

  // test operator TIntegral()
  //
  val0.assign((TIntegral)3);
  if (val0 != (TIntegral)3) {
    return Error::handle(name(), L"TIntegral",
			 Error::TEST, __FILE__, __LINE__);
  }
  
  // test operator +
  //
  val0.assign((TIntegral)3);
  val1.assign((TIntegral)2);
  val2 = val0 + val1;
  if (val2 != (TIntegral)5) {
    return Error::handle(name(), L"+", Error::TEST, __FILE__, __LINE__);
  }

  // test operator -
  //
  val0.assign((TIntegral)3);
  val1.assign((TIntegral)2);
  val2 = val0 - val1;
  if (val2 != (TIntegral)1) {
    return Error::handle(name(), L"operator -",
			 Error::TEST, __FILE__, __LINE__);
  }
 
  // test operator *
  //
  val0.assign((TIntegral)3);
  val1.assign((TIntegral)2);
  val2 = val0 * val1 * val0;
  if (val2 != (TIntegral)18) {
    return Error::handle(name(), L"operator *",
			 Error::TEST, __FILE__, __LINE__);
  }
  
  // test operator /
  //
  val0.assign((TIntegral)3);
  val1.assign((TIntegral)2);
  val2 = val0 / val1;
  if (val2 != (TIntegral)1.5) {
    return Error::handle(name(), L"operator /",
			 Error::TEST, __FILE__, __LINE__);
  }

  // test operator %
  //
  if ((typeid(TIntegral) != typeid(double)) &&
      (typeid(TIntegral) != typeid(float))) {
    val0.assign((TIntegral)8);
    val1.assign((TIntegral)3);
    val2 = val0 % val1;
    if (val2 != (TIntegral)2.0) {
      return Error::handle(name(), L"operator%",
			   Error::TEST, __FILE__, __LINE__);
    }
  }
  
  // test operator ++
  //
  val0.assign((TIntegral)3);
  val1.assign(val0++);
  if (!val0.almostEqual((TIntegral)4) || !val1.almostEqual((TIntegral)3)) {
    return Error::handle(name(), L"operator++",
			 Error::TEST, __FILE__, __LINE__);
  }

  // test operator --
  //
  val0.assign((TIntegral)3);
  val1.assign(val0--);
  if (!val0.almostEqual((TIntegral)2) || !val1.almostEqual((TIntegral)3)) {
    return Error::handle(name(), L"operator--",
			 Error::TEST, __FILE__, __LINE__);
  }

  // test operator ++
  //
  val0.assign((TIntegral)3);
  val1.assign(++val0);
  if (!val0.almostEqual((TIntegral)4) || !val1.almostEqual((TIntegral)4)) {
    return Error::handle(name(), L"operator++",
			 Error::TEST, __FILE__, __LINE__);
  }
  
  // test operator --
  //
  val0.assign((TIntegral)3);
  val1.assign(--val0);
  if (!val0.almostEqual((TIntegral)2) || !val1.almostEqual((TIntegral)2)) {
    return Error::handle(name(), L"operator--",
			 Error::TEST, __FILE__, __LINE__);
  }
    
  // test operator +=
  //
  val0.assign((TIntegral)43);
  val0 += (TIntegral)4;
  if (!val0.almostEqual((TIntegral)47)) {
    return Error::handle(name(), L"operator+=",
			 Error::TEST, __FILE__, __LINE__);
  }
  
  // test operator -=
  //
  val0 -= (TIntegral)7;
  if (!val0.almostEqual((TIntegral)40)) {
    return Error::handle(name(), L"operator-=",
			 Error::TEST, __FILE__, __LINE__);
  }
  
  // test operator *=
  //
  val0 *= (TIntegral)2;
  if (!val0.almostEqual((TIntegral)80)) {
    return Error::handle(name(), L"operator*=",
			 Error::TEST, __FILE__, __LINE__);
  }
  
  // test operator /=
  //
  val0 /= (TIntegral)10;
  if (!val0.almostEqual((TIntegral)8)) {
    return Error::handle(name(), L"operator/=",
			 Error::TEST, __FILE__, __LINE__);
  }
  
  // test operator %=
  //
  if ((typeid(TIntegral) != typeid(double)) &&
      (typeid(TIntegral) != typeid(float))) {
    val0 %= (TIntegral)10;
    if (!val0.almostEqual((TIntegral)8)) {
      val0.debug(L"val0");
      return Error::handle(name(), L"operator%=",
			   Error::TEST, __FILE__, __LINE__);
    }
  }
  
  // test operator ==
  //
  val0.assign((TIntegral)3);
  val2 = val0;
  if (!(val0 == val2)) {
    return Error::handle(name(), L"operator==",
			 Error::TEST, __FILE__, __LINE__);
  }

  // test operator !=
  //
  val0.assign((TIntegral)3);
  if (val0 != (TIntegral)3) {
    return Error::handle(name(), L"operator !=",
			 Error::TEST, __FILE__, __LINE__);
  }
  
  // test operator <
  //
  val0.assign((TIntegral)3);
  if (val0 < (TIntegral)3) {
    return Error::handle(name(), L"operator <",
			 Error::TEST, __FILE__, __LINE__);
  }
  
  // test operator <=
  //
  val0.assign((TIntegral)3);
  if (val0 <= (TIntegral)2) {
    return Error::handle(name(), L"operator <=",
			 Error::TEST, __FILE__, __LINE__);
  }
  
  // test operator >
  //
  val0.assign((TIntegral)3);
  if (val0 > (TIntegral)3) {
    return Error::handle(name(), L"operator >",
			 Error::TEST, __FILE__, __LINE__);
  }
  
  // test operator >=
  //						   
  val0.assign((TIntegral)3);
  if (val0 >= (TIntegral)4) {
    return Error::handle(name(), L"operator >=",
			 Error::TEST, __FILE__, __LINE__);
  }

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

  //---------------------------------------------------------------------------
  //
  // class-specific public methods:
  //  equality and comparison methods
  //
  //---------------------------------------------------------------------------

  // set indentation
  //
  if (level_a > Integral::NONE) {
    Console::put
      (L"testing class-specific public methods: equality methods...\n");
    Console::increaseIndention();
  }
  
  // test eq
  //
  val0.assign((TIntegral)4);
  val1.assign((TIntegral)3);
  val2.assign((TIntegral)4);
  if (val2.eq(val0, val1) || !(val0.eq(val2))) {
    return Error::handle(name(), L"eq", Error::TEST, __FILE__, __LINE__);
  }
   
  // test ne
  //
  val0.assign((TIntegral)3);
  val2.assign((TIntegral)3);
  if (val2.ne(val0)) {
    return Error::handle(name(), L"ne", Error::TEST, __FILE__, __LINE__);
  }
  
  // test lt
  //
  val0.assign((TIntegral)4);
  val2.assign((TIntegral)4);
  if (val2.lt(val0)) {
    return Error::handle(name(), L"lt", Error::TEST, __FILE__, __LINE__);
  }

  // test le
  //
  val0.assign((TIntegral)4);
  val2.assign((TIntegral)5);
  if (val2.le(val0)) {
    return Error::handle(name(), L"le", Error::TEST, __FILE__, __LINE__);
  }

  // test gt
  //
  val0.assign((TIntegral)5);
  val2.assign((TIntegral)4);
  if (val2.gt(val0)) {
    return Error::handle(name(), L"gt", Error::TEST, __FILE__, __LINE__);
  } 

  // test ge
  //
  val0.assign((TIntegral)3);
  val1.assign((TIntegral)4);
  val2.assign((TIntegral)4);
  if (val0.ge(val2)) {
    return Error::handle(name(), L"ge", Error::TEST, __FILE__, __LINE__);
  }
  
  // reset indentation
  //
  if (level_a > Integral::NONE) {
    Console::decreaseIndention();
  }
 
  // exit gracefully
  //
  return true;
}

// method: diagnose1
//
// arguments:
//  Integral::DEBUG level: (input) debug level for diagnostics
//
// return: logical error status
//
// this method tests bitwise operations.
//
template<class TScalar, class TIntegral>
boolean MScalarMethods::diagnose1(Integral::DEBUG level_a) {
  
  //--------------------------------------------------------------------
  //
  //  testing bitwise and integer-specific operations
  //
  //--------------------------------------------------------------------
  
  // declare local variables
  //
  TScalar val0;
  TScalar val1;
  TScalar val2;

  // set indentation
  //
  if (level_a > Integral::NONE) {
    Console::put(L"testing class-specific public methods: bitwise operations...\n");
    Console::increaseIndention();
  }
    
  // unless the type is floating point, test bitwise methods
  //
  if ((typeid(TIntegral) != typeid(float)) &&
      (typeid(TIntegral) != typeid(double))) {
    
    if (val0.band(6, 2) != 2) {
      return Error::handle(name(), L"band", Error::TEST, __FILE__, __LINE__);
    }
    
    if (val0.bor(6, 2) != 6) {
      return Error::handle(name(), L"bor", Error::TEST, __FILE__, __LINE__);
    }
    
    if (val0.bxor(6, 2) != 4) {
      return Error::handle(name(), L"bxor", Error::TEST, __FILE__, __LINE__);
    }
    
    if (val0.brs(6, 2) != 1) {
      return Error::handle(name(), L"brs", Error::TEST, __FILE__, __LINE__);
    }
    
    if (val0.bls(6, 2) != 24) {
      return Error::handle(name(), L"bls", Error::TEST, __FILE__, __LINE__);
    }
    
    // this is tricky with different lengths; constrain to 8 bits
    //
    if (((byte)val0.bcmpl((TIntegral)6) & (byte)0xFF) != (byte)0xF9) {
      return Error::handle(name(), L"bcmpl", Error::TEST, __FILE__, __LINE__);
    }
  }
  
  // reset indentation
  //
  if (level_a > Integral::NONE) {
    Console::decreaseIndention();
  }
    
  // exit gracefully
  //
  return true;
}