mmat_02.cc

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

#else
	tmp_mat.assignComplexDiagnose((long)MMAT_ASSIGN_ARG[mat1][MMAT_NROW_LOC], 
		       (long)MMAT_ASSIGN_ARG[mat1][MMAT_NCOL_LOC], 
		       (double*)&MMAT_ASSIGN_ARG[mat1][MMAT_DATA_LOC],
		       MMAT_ARG_MAT_TYPES[mat1]);
#endif    
	res_mat.assign(arg_mat1);
      
	if (!res_mat.almostEqual(tmp_mat)) {
	  Console::put(arg1_str);	    
	  res_mat.debug(L"result matrix");
	  tmp_mat.debug(L"assigned matrix");
	  Error::handle(name(), L"assign from tintegral", Error::TEST, __FILE__, __LINE__);
	}

	// test assignment of a matrix from a string
	//
	if (!tmp_mat.assign((long)MMAT_ARG_MATRICES[mat1][MMAT_NROW_LOC], 
			    (long)MMAT_ARG_MATRICES[mat1][MMAT_NCOL_LOC],
			    MMAT_ASSIGN1_ARG[mat1],
			    MMAT_ARG_MAT_TYPES[mat1])) {
	  Console::put(MMAT_ASSIGN1_ARG[mat1]);
	  Console::put(arg1_str);
	  return Error::handle(name(), L"assignment from string", Error::ARG,
			       __FILE__, __LINE__);
	};
	res_mat.assign(arg_mat1);
      
	if (!res_mat.almostEqual(tmp_mat)) {
	  Console::put(arg1_str);	    
	  res_mat.debug(L"result matrix");
	  tmp_mat.debug(L"assigned matrix");
	  Error::handle(name(), L"assign from string", Error::TEST, __FILE__, __LINE__);
	}
	
	// test i/o method:
	//  create a unique tag by composing the mat1 and type1
	//
	long tag = mat1 * 100 + (long)type1;
	
	// open files in write plus mode so that we can read as soon
	// as we write
	//
	Sof sof_text;
	Sof sof_bin;

	// try to preserve the same file throughout
	//
	if (File::exists(tmp_filename0) && File::exists(tmp_filename1)) {
	  sof_text.open(tmp_filename0, File::READ_PLUS, File::TEXT);
	  sof_bin.open(tmp_filename1, File::READ_PLUS, File::BINARY);
	}
	else {
	  sof_text.open(tmp_filename0, File::WRITE_ONLY, File::TEXT);
	  sof_bin.open(tmp_filename1, File::WRITE_ONLY, File::BINARY);
	}
	
	// write the objects in text as well as binary mode
	//
	arg_mat1.write(sof_text, tag, name());
	arg_mat1.write(sof_bin, tag, name());
	
	// close and reopen the files in read mode
	//
	sof_text.close();
	sof_bin.close();
	sof_text.open(tmp_filename0, File::READ_ONLY, File::TEXT);
	sof_bin.open(tmp_filename1, File::READ_ONLY, File::BINARY);
	
	// clear the matrix
	//
	tmp_mat.clear(Integral::RETAIN);

	// read the text file
	//
	if ((!tmp_mat.read(sof_text, tag, name())) ||
	    (!tmp_mat.almostEqual(arg_mat1))) {
	  Console::put(arg1_str);
	  return Error::handle(name(), L"read", Error::ARG,
			       __FILE__, __LINE__);
	}

	// clear the matrix
	//
	tmp_mat.clear(Integral::RETAIN);
	
	// read the binary file
	//
	if ((!tmp_mat.read(sof_bin, tag, name())) ||
	    (!tmp_mat.almostEqual(arg_mat1))) {
	  Console::put(arg1_str);	    
	  Error::handle(name(), L"read", Error::TEST, __FILE__, __LINE__);
	}

	// close the temporary Sof files
	//
	sof_text.close();
	sof_bin.close();
	
	// delete the temporary Sof files
	//      
	File::remove(tmp_filename0);
	File::remove(tmp_filename1);
	
	// test clear
	//
	res_mat.assign(arg_mat1.getNumRows(), 
		       arg_mat1.getNumColumns(), 
		       (double*)&MMAT_CLEAR_RES[MMAT_DATA_LOC]);
	tmp_mat.assign(arg_mat1);
	
	if (tmp_mat.almostEqual(res_mat)) {
	  Console::put(arg1_str);
	  Error::handle(name(), L"assign", Error::TEST, __FILE__, __LINE__);
	}

	// test when mode is RETAIN
	//
	tmp_mat.clear(Integral::RETAIN);
	
	if (!tmp_mat.almostEqual(res_mat)) {
	  Console::put(arg1_str);
	  Error::handle(name(), L"clear", Error::TEST, __FILE__, __LINE__);
	}

	// test when mode is RESET
	//
	tmp_mat.clear(Integral::RESET);
	
	if ((tmp_mat.getNumRows() != 0) || (tmp_mat.getNumColumns() != 0)) {
	  Console::put(arg1_str);
	  tmp_mat.debug(L"output");
	  res_mat.debug(L"expected");
	  Error::handle(name(), L"clear", Error::TEST, __FILE__, __LINE__);
	}

      	// test when mode is RELEASE
	//
	tmp_mat.assign(arg_mat1);
	tmp_mat.clear(Integral::RELEASE);
	
	if ((tmp_mat.getNumRows() != 0) || (tmp_mat.getNumColumns() != 0) ||
	    (tmp_mat.m_d.length() != 0) ||
	    (tmp_mat.m_d.getCapacity() != 0)) {
	  tmp_mat.m_d.debug(L"m_d");
	
	  Console::put(arg1_str);
	  tmp_mat.debug(L"output");
	  Error::handle(name(), L"clear", Error::TEST, __FILE__, __LINE__);
	}

	// test when mode is FREE
	//
	tmp_mat.assign(arg_mat1);
	tmp_mat.clear(Integral::FREE);
	
	if ((tmp_mat.getNumRows() != 0) || (tmp_mat.getNumColumns() != 0) ||
	    (tmp_mat.m_d.length() != 0) ||
	    (tmp_mat.m_d.getCapacity() != 0)) {
	  
	  Console::put(arg1_str);
	  tmp_mat.debug(L"output");
	  Error::handle(name(), L"clear", 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: a boolean value indicating status
//
// this method tests single matrix to scalar methods for matrix - the
// diagnose method is designed in such a way that it tests the methods
// for 8 different matrices and for every possible type
//
template<class TScalar, class TIntegral>
boolean MMatrixMethods::diagnose1(Integral::DEBUG level_a) {
  
  // define TVector
  //
  typedef MVector<TScalar, TIntegral> TVector;
  
  // set indentation
  //
  if (level_a > Integral::NONE) {
    Console::put(L"testing class-specific public methods: single matrix --> scalar...\n");
    Console::increaseIndention();
  }
  
  // declare an array of matrix to hold all the 8 matrices used for testing
  //
  MMatrix<TScalar, TIntegral> arg_mats[MMAT_NUM_MATS_TEST];
  
  // load up the argument matrices
  //
  for (long i = 0; i < MMAT_NUM_MATS_TEST; i++) {
    
    // assign the arguments
    //
#ifndef ISIP_TEMPLATE_complex
    arg_mats[i].assign((long)MMAT_ARG_MATRICES[i][MMAT_NROW_LOC], 
                       (long)MMAT_ARG_MATRICES[i][MMAT_NCOL_LOC], 
                       (double*)&MMAT_ARG_MATRICES[i][MMAT_DATA_LOC]);
#else
    arg_mats[i].assignComplexDiagnose((long)MMAT_ARG_MATRICES[i][MMAT_NROW_LOC], 
                       (long)MMAT_ARG_MATRICES[i][MMAT_NCOL_LOC], 
                       (double*)&MMAT_ARG_MATRICES[i][MMAT_DATA_LOC]);
#endif    
  }

  // define matrices to be used in the method
  //
  MMatrix<TScalar, TIntegral> res_mat;
  MMatrix<TScalar, TIntegral> tmp_mat;
  MMatrix<TScalar, TIntegral> arg_mat1;
  
  // loop through the different matrices
  //
  for (long mat1 = 0; mat1 < MMAT_NUM_MATS_TEST; mat1++) {  
    
    //  create a diagnostic string 
    // to indicate the matrix and its type
    //
    String arg1_str(L"testing matrix ");
    Char mat1c;
    mat1c.assign((byte)((int)'A' + mat1));
    arg1_str.concat(mat1c);
    
    if (level_a > Integral::BRIEF) {
      Console::put(arg1_str);
      arg_mats[mat1].debug(arg1_str);
      Console::increaseIndention();
    }
  
    // loop through different types of matrices
    //
    for (long type1 = Integral::FULL; type1 <= Integral::SPARSE; type1++) {
      
      // check if the type conversion is possible
      //
      if (arg_mats[mat1].isTypePossible((Integral::MTYPE)type1)) {
	
	String type1_str(MMatrix<TScalar, TIntegral>::TYPE_MAP(type1));
	arg1_str.concat(L" -> ");
	arg1_str.concat(type1_str);
	
	if (level_a > Integral::BRIEF) {
	  String out(L"converting to ");
	  out.concat(type1_str);
	  Console::put(out);
	}
       
	// assign the input matrix and change the type - type is
	// changed here so that this particular matrix can be tested for
	// every type it can have
	//
	arg_mat1.assign(arg_mats[mat1]);
	if (arg_mat1.changeType((Integral::MTYPE)type1) !=
	    MMAT_CHANGE_TYPE_RES[mat1][type1]) {
	  Console::put(arg1_str);
	  Error::handle(name(), L"changeType", Error::TEST, 
			__FILE__, __LINE__);
	}
	
	// test isTypePossible
	//
	if (arg_mats[mat1].isTypePossible((Integral::MTYPE)type1)
	    != MMAT_IS_TYPE_POSSIBLE_RES[mat1][type1]) {
	  Console::put(arg1_str);
	  Error::handle(name(), L"isTypePossible", Error::TEST, 
			__FILE__, __LINE__);
	}
	
	// test isDiagonal
	//
	if (arg_mats[mat1].isDiagonal() != MMAT_IS_DIAGONAL_RES[mat1]) {
	  Console::put(arg1_str);	  
	  Error::handle(name(), L"isDiagonal", Error::TEST, 
			__FILE__, __LINE__);
	}
	
	// test isSymmetric
	//
	if (arg_mats[mat1].isSymmetric() != MMAT_IS_SYMMETRIC_RES[mat1]) {
	  Console::put(arg1_str);	  
	  Error::handle(name(), L"isSymmetric", Error::TEST, 
			__FILE__, __LINE__);
	}
	
	// test isLowerTriangle
	//
	if (arg_mats[mat1].isLowerTriangular() !=
	    MMAT_IS_LOWERTRIANGULAR_RES[mat1]) {
	  Console::put(arg1_str);	  
	  Error::handle(name(), L"isLowerTriangle", Error::TEST, 
			__FILE__, __LINE__);
	}
	
	// test isUpperTriangle
	//
	if (arg_mats[mat1].isUpperTriangular() != 
	    MMAT_IS_UPPERTRIANGULAR_RES[mat1]) {
	  Console::put(arg1_str);	  	  
	  Error::handle(name(), L"isUpperTriangle", Error::TEST, 
			__FILE__, __LINE__);
	}
	
	// test isIdentity - note that we are not testing this method
	// for input matrix as the input matrices are not identity
	// matrices, as a solution we construct a temporary identity
	// matrix for test. we also change the type of the identity
	// matrix so that the method can be tested for all possible types.
	//
	res_mat.changeType(Integral::FULL);
	res_mat.assign(arg_mats[mat1].getNumRows(), 
		       arg_mats[mat1].getNumColumns(),
		       (double*)&MMAT_IDENTITY_MATRICES[MMAT_DATA_LOC]);

	if (res_mat.isTypePossible((Integral::MTYPE)type1)) {	
	  res_mat.changeType((Integral::MTYPE)type1);
	}

	if (res_mat.isSquare()) {
	  if (!res_mat.isIdentity()) {
	    Console::put(arg1_str);
	    Error::handle(name(), L"isIdentity", Error::TEST, 
			  __FILE__, __LINE__);
	  }
	}
	
	// test isOrthogonal
	//
	res_mat.changeType(Integral::FULL);
	res_mat.assign(arg_mats[mat1].getNumRows(), 
		       arg_mats[mat1].getNumColumns(), 
		       (double*)&MMAT_ORTHOGONAL_MATRICES [MMAT_DATA_LOC]);
	
	if (res_mat.isTypePossible((Integral::MTYPE)type1)) {		  
	  res_mat.changeType((Integral::MTYPE)type1);
	}

	if ((typeid(double) == typeid(TIntegral)) ||
	    (typeid(float) == typeid(TIntegral))) {	
	  if (res_mat.isSquare()) {
	    if (!res_mat.isOrthogonal()) {
	      MMatrix<TScalar, TIntegral> my_mat;
	      my_mat.inverse(res_mat);
	      Console::put(arg1_str);
	      my_mat.debug(L"inv");
	      my_mat.transpose(res_mat);
	      my_mat.debug(L"trans");	    
	      Error::handle(name(), L"isOrthogonal", Error::TEST, 
			    __FILE__, __LINE__);
	    }
	  }
	}
	
	// test getNumRows and getNumColumns
	//
	if (arg_mat1.getNumRows()
	    != (long)MMAT_ARG_MATRICES[mat1][MMAT_NROW_LOC]) {
	  Console::put(arg1_str);
	  Error::handle(name(), L"getNumRows", Error::TEST, 
			__FILE__, __LINE__);
	}
	if (arg_mat1.getNumColumns()
	    != (long)MMAT_ARG_MATRICES[mat1][MMAT_NCOL_LOC]) {
	  Console::put(arg1_str);
	  Error::handle(name(), L"getNumColumns", Error::TEST, 
			__FILE__, __LINE__);
	}
	
	// test isSquare
	//
	if (arg_mat1.isSquare(arg_mat1) != MMAT_IS_SQUARE_RES[mat1]) {
	  Console::put(arg1_str);
	  Error::handle(name(), L"isSquare", Error::TEST,
			__FILE__, __LINE__);
	}

	// test isSingular for all but unsigned datatypes
	//
	if (typeid(TIntegral) == typeid(float) ||
	    typeid(TIntegral) == typeid(double) ||
	    typeid(TIntegral) == typeid(llong) ||
	    typeid(TIntegral) == typeid(long) ||
	    typeid(TIntegral) == typeid(short)) {
	  
	  if (arg_mat1.isSquare()) {

	    if (arg_mat1.isSingular(arg_mat1,
				    MMatrix<TScalar, TIntegral>::
				    THRESH_SINGULAR) !=
		MMAT_IS_SINGULAR_RES[mat1]) {
	      Console::put(arg1_str);
	      Error::handle(name(), L"isSingular", Error::TEST,
			    __FILE__, __LINE__);
	    }
	  }
	}

	// test matrix assign from a string
	//
	tmp_mat.assign(4, 4, MMAT_ASSIGN_STRING_INPUT[type1],
		       (Integral::MTYPE)type1);
	res_mat.assign(arg_mat1);
	
	if (((mat1 == 1) && (!tmp_mat.almostEqual(res_mat)))
	    || ((mat1 != 1) && (tmp_mat.almostEqual(res_mat)))) {
	  Console::put(arg1_str);
	  Error::handle(name(), L"assign", Error::TEST, __FILE__, __LINE__);
	}
	
	// test swap
	//