mmatrixmethods.h

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

		     TIntegral value);

  template <class TScalar, class TIntegral, class TAScalar, class TAIntegral>
  static boolean add(MMatrix<TScalar, TIntegral>& obj,
		     const MMatrix<TAScalar, TAIntegral>& m1);

  template <class TScalar, class TIntegral, class TAScalar, class TAIntegral>
  static boolean add(MMatrix<TScalar, TIntegral>& obj,
		     const MMatrix<TScalar, TIntegral>& m1, 
		     const MMatrix<TAScalar, TAIntegral>& m2);

  template <class TScalar, class TIntegral>
  static boolean add(MMatrix<TScalar, TIntegral>& obj,
		     const MMatrix<TScalar, TIntegral>& source_matrix, 
		     TIntegral value);

  template <class TScalar, class TIntegral>
  static boolean sub(MMatrix<TScalar, TIntegral>& obj,
		     TIntegral value);

  template <class TScalar, class TIntegral, class TAScalar, class TAIntegral>
  static boolean sub(MMatrix<TScalar, TIntegral>& obj,
		     const MMatrix<TAScalar, TAIntegral>& m1);

  template <class TScalar, class TIntegral, class TAScalar, class TAIntegral>
  static boolean sub(MMatrix<TScalar, TIntegral>& obj,
		     const MMatrix<TScalar, TIntegral>& m1, 
		     const MMatrix<TAScalar, TAIntegral>& m2);

  template <class TScalar, class TIntegral>
  static boolean sub(MMatrix<TScalar, TIntegral>& obj,
		     const MMatrix<TScalar, TIntegral>& source_matrix, 
		     TIntegral value);

  template <class TScalar, class TIntegral, class TAScalar, class TAIntegral>
  static boolean mult(MMatrix<TScalar, TIntegral>& obj,
		      const MMatrix<TScalar, TIntegral>& m1, 
		      const MMatrix<TAScalar, TAIntegral>& m2);

  //---------------------------------------------------------------------------
  //
  // class-specific public methods:
  //  other mathematical methods
  //
  //--------------------------------------------------------------------------
  
  template <class TScalar, class TIntegral>
  static TIntegral min(const MMatrix<TScalar, TIntegral>& obj);

  template <class TScalar, class TIntegral>
  static TIntegral min(const MMatrix<TScalar, TIntegral>& obj, 
		       long& row_index, long& col_index);

  template <class TScalar, class TIntegral>
  static TIntegral max(const MMatrix<TScalar, TIntegral>& obj); 

  template <class TScalar, class TIntegral>
  static TIntegral max(const MMatrix<TScalar, TIntegral>& obj,
		       long& row_index, long& col_index);

  template <class TScalar, class TIntegral>
  static double minMag(const MMatrix<TScalar, TIntegral>& obj); 

  template <class TScalar, class TIntegral>
  static double minMag(const MMatrix<TScalar, TIntegral>& obj, 
			  long& row_index, long& col_index);
  
  template <class TScalar, class TIntegral>
  static double maxMag(const MMatrix<TScalar, TIntegral>& obj); 

  template <class TScalar, class TIntegral>
  static double maxMag(const MMatrix<TScalar, TIntegral>& obj, 
			  long& row_index, long& col_index);

  // random number generation methods
  //
  template <class TScalar, class TIntegral>
  static boolean rand(MMatrix<TScalar, TIntegral>& obj,
		      Random& generator);
  
  template <class TScalar, class TIntegral>
  static boolean rand(MMatrix<TScalar, TIntegral>& obj,
		      TIntegral min_val, TIntegral max_val,
		      Random& generator);
  
  template <class TScalar, class TIntegral>
  static boolean grand(MMatrix<TScalar,TIntegral>& obj,
		       TIntegral mean, TIntegral stdev, Random& generator);
  
  template <class TScalar, class TIntegral>
  static boolean randIndicesSparse(MMatrix<TScalar,TIntegral>& obj,
				   Random& generator);
  
  //---------------------------------------------------------------------------
  //
  // class-specific public methods:
  //  linear algebra related methods 
  //
  //--------------------------------------------------------------------------
  
  // determinant and inverse methods
  //
  template <class TScalar, class TIntegral>
  static TIntegral determinant(const MMatrix<TScalar, TIntegral>& obj); 

  template <class TScalar, class TIntegral>
  static TIntegral determinantLU(const MMatrix<TScalar, TIntegral>& obj); 

  template <class TScalar, class TIntegral>
  static TIntegral determinantMinor(const MMatrix<TScalar, TIntegral>& obj); 

  template <class TScalar, class TIntegral>
  static boolean inverse(MMatrix<TScalar, TIntegral>& obj, 
			 const MMatrix<TScalar, TIntegral>& matrix);

  template <class TScalar, class TIntegral>
  static boolean transpose(MMatrix<TScalar, TIntegral>& obj, 
			   const MMatrix<TScalar, TIntegral>& matrix);

  template <class TScalar, class TIntegral>
  static long rank(const MMatrix<TScalar, TIntegral>& obj);

  template <class TScalar, class TIntegral>
  static TIntegral trace(const MMatrix<TScalar, TIntegral>& obj);
  
  // decomposition methods
  //
  template <class TScalar, class TIntegral>
  static boolean decompositionLU(const MMatrix<TScalar,TIntegral>& input,
				 MMatrix<TScalar, TIntegral>& l,
				 MMatrix<TScalar, TIntegral>& u,
				 MVector<Long, long>& index,
				 long& sign,
				 double stabilize);

  template <class TScalar, class TIntegral>
  static boolean decompositionCholesky(const MMatrix<TScalar,TIntegral>& input,
				       MMatrix<TScalar, TIntegral>& l);
    
  template <class TScalar, class TIntegral>
  static boolean decompositionSVD(const MMatrix<TScalar,TIntegral>& input,
  				  MMatrix<TScalar, TIntegral>& u,
  				  MMatrix<TScalar, TIntegral>& w,
  				  MMatrix<TScalar, TIntegral>& v);

  // methods to compute eigenvalues and eigenvectors
  //
  template <class TScalar, class TIntegral>
  static boolean eigen(const MMatrix<TScalar,TIntegral>& obj,
		       MVector<TScalar, TIntegral>& eigvals,
		       MMatrix<TScalar, TIntegral>& eigvects);

  template <class TScalar, class TIntegral>  
  static boolean eigenComputeVector(MMatrix<TScalar, TIntegral>& obj,
				    MVector<TScalar, TIntegral>& eigvect,
				    TIntegral eigval);

  template <class TScalar, class TIntegral>    
  static boolean eigenBalance(MMatrix<TScalar, TIntegral>& obj);

  template <class TScalar, class TIntegral>    
  static boolean eigenEliminateHessenberg(MMatrix<TScalar, TIntegral>& obj);

  template <class TScalar, class TIntegral>    
  static boolean eigenHessenbergQR(MMatrix<TScalar, TIntegral>& obj,
				   MVector<TScalar, TIntegral>& eig_val_real,
				   MVector<TScalar, TIntegral>& eig_val_imag);

  template<class TScalar, class TIntegral>
  static boolean luSolve(MVector<TScalar, TIntegral>& out_vec,
			 const MMatrix<TScalar, TIntegral>& l,
			 const MMatrix<TScalar, TIntegral>& u,
			 const VectorLong& index,
			 const MVector<TScalar, TIntegral>& in_vec);
 
  template<class TScalar, class TIntegral>
  static boolean choleskySolve(MVector<TScalar, TIntegral>& out_vec,
			       const MMatrix<TScalar, TIntegral>& l,
			       const MVector<TScalar, TIntegral>& in_vec);
 
  template<class TScalar, class TIntegral>
  static boolean svdSolve(MVector<TScalar, TIntegral>& out_vec,
			  const MMatrix<TScalar, TIntegral>& u,
			  const MMatrix<TScalar, TIntegral>& w,
			  const MMatrix<TScalar, TIntegral>& v,
			  const MVector<TScalar, TIntegral>& in_vec,
			  boolean zero_singulars);
 
  template <class TScalar, class TIntegral>
  static boolean multv(const MMatrix<TScalar, TIntegral>& obj, 
		       MVector<TScalar, TIntegral>& output_vector,
		       const MVector<TScalar, TIntegral>& input_vector);

  template <class TScalar, class TIntegral>
  static boolean vmult(const MMatrix<TScalar, TIntegral>& obj, 
		       MVector<TScalar, TIntegral>& output_vector,
		       const MVector<TScalar, TIntegral>& input_vector);

  template <class TScalar, class TIntegral>
  static boolean quadratic(TIntegral& output, 
			   const MMatrix<TScalar, TIntegral>& obj, 
			   const MVector<TScalar, TIntegral>& input_vector);

  template <class TScalar, class TIntegral>
  static boolean quadratic(MMatrix<TScalar, TIntegral>& output,
			   const MMatrix<TScalar, TIntegral>& input_mat1, 
			   const MMatrix<TScalar, TIntegral>& input_mat2);

  template <class TScalar, class TIntegral, class TAScalar, class TAIntegral>
  static boolean outerProduct(MMatrix<TScalar, TIntegral>& out_matrix,
			      const MMatrix<TScalar, TIntegral>& input_mat1, 
			      const MMatrix<TAScalar, TAIntegral>& input_mat2);

  template <class TScalar, class TIntegral, class TAScalar, class TAIntegral>
  static boolean outerProduct(MMatrix<TScalar, TIntegral>& out_matrix,
			      const MVector<TScalar, TIntegral>& input_vec1, 
			      const MVector<TAScalar, TAIntegral>& input_vec2);

  //---------------------------------------------------------------------------
  //
  // class-specific public methods:
  //  summation methods
  //
  //--------------------------------------------------------------------------

  template <class TScalar, class TIntegral>
  static TIntegral sum(const MMatrix<TScalar, TIntegral>& obj);

  template <class TScalar, class TIntegral>
  static TIntegral sumSquare(const MMatrix<TScalar, TIntegral>& obj);

  template <class TScalar, class TIntegral>	
  static TIntegral sumColumn(const MMatrix<TScalar, TIntegral>& obj, 
			     long col_index);

  template <class TScalar, class TIntegral>	
  static TIntegral sumRow(const MMatrix<TScalar, TIntegral>& obj, 
			  long row_index);

  template <class TScalar, class TIntegral>
  static TIntegral var(const MMatrix<TScalar, TIntegral>& obj);

  //---------------------------------------------------------------------------
  //
  // class-specific public methods:
  //  methods that are private in MMatrix
  //
  //--------------------------------------------------------------------------

  template <class TScalar, class TIntegral>
  static boolean reverseIndex(const MMatrix<TScalar, TIntegral>& obj,
			   long& row, long& col, long vec_index);
  
  template <class TScalar, class TIntegral, class TAScalar, class TAIntegral>
  static TIntegral multiplyRowByColumn(const MMatrix<TScalar, TIntegral>& obj, 
				       const MMatrix<TScalar, TIntegral>&
				       matrix_for_row, 
				       const MMatrix<TAScalar, TAIntegral>&
				       matrix_for_col, 
				       long row_index, long col_index);
  
  template<class TScalar, class TIntegral, class TAScalar, class TAIntegral>
  static TIntegral multiplyRowByRow(const MMatrix<TScalar, TIntegral>& obj, 
				    const MMatrix<TScalar, TIntegral>& m1, 
				    const MMatrix<TAScalar, TAIntegral>& m2,
				    long row_m1, long row_m2);

  template <class TScalar, class TIntegral>
  static boolean assignStream(MMatrix<TScalar, TIntegral>& obj, 
			      long nrows, long ncols, 
			      const MVector<TScalar, TIntegral>& vec, 
			      Integral::MTYPE type);

  //---------------------------------------------------------------------------
  //
  // class-specific public methods:
  //  diagnostic methods
  //
  //--------------------------------------------------------------------------

  // test general methods

  template <class TScalar, class TIntegral>
  static boolean diagnose0(Integral::DEBUG level);

  // test single matrix->scalar methods
  //
  template <class TScalar, class TIntegral>
  static boolean diagnose1(Integral::DEBUG level);

  // test single matrix->vector methods
  //
  template <class TScalar, class TIntegral>
  static boolean diagnose2(Integral::DEBUG level);

  // test single matrix->matrix methods
  //
  template <class TScalar, class TIntegral>
  static boolean diagnose3(Integral::DEBUG level);

  // test (matrix, matrix)->matrix methods (real)
  //
  template <class TScalar, class TIntegral>
  static boolean diagnose4(Integral::DEBUG level);

  // test (matrix, matrix)->matrix methods (complex)
  //
  template <class TScalar, class TIntegral>
  static boolean diagnose5(Integral::DEBUG level);

  //---------------------------------------------------------------------------
  //
  // private methods
  //
  //---------------------------------------------------------------------------
private:
  
  // destructor/constructor(s):
  // the constructors and destructors are declared private so that a
  // compilation error will be generated if the user tries to construct an
  // object of this type
  //
  ~MMatrixMethods();
  MMatrixMethods();
  MMatrixMethods(const MMatrixMethods& arg);

  // method: name
  //  make this method private so it is never called outside this class
  //
  static const String& name();
};

// end of include file
//
#endif