lapack.h

图像分割算法

	 Vector<double> Heevr(Matrix<ComplexDouble>& A, Matrix<ComplexDouble>& EV, int il, int iu);

	
	
	


//=========================================================
// Non-Symmetric eigenvalue problem
//=========================================================


	// Gees
	 Vector<ComplexFloat> Gees(Matrix<float>& A, Matrix<float>& T);
	 Vector<ComplexFloat> Gees(Matrix<float>& A, Matrix<float>& T, Matrix<float>& Z);
	 Vector<ComplexDouble> Gees(Matrix<double>& A, Matrix<double>& T);
	 Vector<ComplexDouble> Gees(Matrix<double>& A, Matrix<double>& T, Matrix<double>& Z);
	 Vector<ComplexFloat> Gees(Matrix<ComplexFloat>& A, Matrix<ComplexFloat>& T);
	 Vector<ComplexFloat> Gees(Matrix<ComplexFloat>& A, Matrix<ComplexFloat>& T, Matrix<ComplexFloat>& Z);
	 Vector<ComplexDouble> Gees(Matrix<ComplexDouble>& A, Matrix<ComplexDouble>& T);
	 Vector<ComplexDouble> Gees(Matrix<ComplexDouble>& A, Matrix<ComplexDouble>& T, Matrix<ComplexDouble>& Z);
	
	
	
	
	// Geesx
	
	
	
	
	
	// Geev
	 Vector<ComplexFloat> Geev(Matrix<float>& A);
	 Vector<ComplexFloat> Geev(Matrix<float>& A, Matrix<ComplexFloat>& Vl, Matrix<ComplexFloat>& Vr);
	 Vector<ComplexDouble> Geev(Matrix<double>& A);
	 Vector<ComplexDouble> Geev(Matrix<double>& A, Matrix<ComplexDouble>& Vl, Matrix<ComplexDouble>& Vr);
	 Vector<ComplexFloat> Geev(Matrix<ComplexFloat>& A);
	 Vector<ComplexFloat> Geev(Matrix<ComplexFloat>& A, Matrix<ComplexFloat>& Vl, Matrix<ComplexFloat>& Vr);
	 Vector<ComplexDouble> Geev(Matrix<ComplexDouble>& A);
	 Vector<ComplexDouble> Geev(Matrix<ComplexDouble>& A, Matrix<ComplexDouble>& Vl, Matrix<ComplexDouble>& Vr);
	
	
	
	
	// Geevx










//=========================================================
// Singular Value Decomposition (SVD)
//=========================================================


	// Gesvd
	
	
	
	
	
	// Gesdd
	 Vector<float> Gesdd(Matrix<float>& A);
	 Vector<float> Gesdd(Matrix<float>& A, Matrix<float>& U, Matrix<float>& V);
	 Vector<double> Gesdd(Matrix<double>& A);
	 Vector<double> Gesdd(Matrix<double>& A, Matrix<double>& U, Matrix<double>& V);
	 Vector<float> Gesdd(Matrix<ComplexFloat>& A);
	 Vector<float> Gesdd(Matrix<ComplexFloat>& A, Matrix<ComplexFloat>& U, Matrix<ComplexFloat>& V);
	 Vector<double> Gesdd(Matrix<ComplexDouble>& A);
	 Vector<double> Gesdd(Matrix<ComplexDouble>& A, Matrix<ComplexDouble>& U, Matrix<ComplexDouble>& V);






//=========================================================
// Generalized Symmetric Definite eigenproblem
//=========================================================


	// Sygv
	
	
	
	
	// Sygvx
	
	
	
	
	
	// Sygvd,Hegvd
	 Vector<float> Sygvd(Matrix<float>& A, Matrix<float>& B, int ptype);
	 Vector<float> Sygvd(Matrix<float>& A, Matrix<float>& B, Matrix<float>& EV, int ptype);
	 Vector<double> Sygvd(Matrix<double>& A, Matrix<double>& B, int ptype);
	 Vector<double> Sygvd(Matrix<double>& A, Matrix<double>& B, Matrix<double>& EV, int ptype);
	 
	 Vector<float> Hegvd(Matrix<ComplexFloat>& A, Matrix<ComplexFloat>& B, int ptype);
	 Vector<float> Hegvd(Matrix<ComplexFloat>& A, Matrix<ComplexFloat>& B, Matrix<ComplexFloat>& EV, int ptype);
	 Vector<double> Hegvd(Matrix<ComplexDouble>& A, Matrix<ComplexDouble>& B, int ptype);
	 Vector<double> Hegvd(Matrix<ComplexDouble>& A, Matrix<ComplexDouble>& B, Matrix<ComplexDouble>& EV, int ptype);









//=========================================================
// Generalized Non-Symmetric eigenvalue problem
//=========================================================


	// Gges
	 void Gges(Matrix<float>& A, Matrix<float>& B, Vector<ComplexFloat>& alpha, Vector<float>& beta, Matrix<float>& S, Matrix<float>& T);
	 void Gges(Matrix<float>& A, Matrix<float>& B, Vector<ComplexFloat>& alpha, Vector<float>& beta, Matrix<float>& S, Matrix<float>& T, Matrix<float>& Vl, Matrix<float>& Vr);
	 void Gges(Matrix<double>& A, Matrix<double>& B, Vector<ComplexDouble>& alpha, Vector<double>& beta, Matrix<double>& S, Matrix<double>& T);
	 void Gges(Matrix<double>& A, Matrix<double>& B, Vector<ComplexDouble>& alpha, Vector<double>& beta, Matrix<double>& S, Matrix<double>& T, Matrix<double>& Vl, Matrix<double>& Vr);
	 void Gges(Matrix<ComplexFloat>& A, Matrix<ComplexFloat>& B, Vector<ComplexFloat>& alpha, Vector<ComplexFloat>& beta, Matrix<ComplexFloat>& S, Matrix<ComplexFloat>& T);
	 void Gges(Matrix<ComplexFloat>& A, Matrix<ComplexFloat>& B, Vector<ComplexFloat>& alpha, Vector<ComplexFloat>& beta, Matrix<ComplexFloat>& S, Matrix<ComplexFloat>& T, Matrix<ComplexFloat>& Vl, Matrix<ComplexFloat>& Vr);
	 void Gges(Matrix<ComplexDouble>& A, Matrix<ComplexDouble>& B, Vector<ComplexDouble>& alpha, Vector<ComplexDouble>& beta, Matrix<ComplexDouble>& S, Matrix<ComplexDouble>& T);
	 void Gges(Matrix<ComplexDouble>& A, Matrix<ComplexDouble>& B, Vector<ComplexDouble>& alpha, Vector<ComplexDouble>& beta, Matrix<ComplexDouble>& S, Matrix<ComplexDouble>& T, Matrix<ComplexDouble>& Vl, Matrix<ComplexDouble>& Vr);
	
	

	// Ggesx
	
	
	
	

	// Ggev
	
	 void Ggev(Matrix<float>& A, Matrix<float>& B, Vector<ComplexFloat>& alpha, Vector<float>& beta);
	 void Ggev(Matrix<float>& A, Matrix<float>& B, Vector<ComplexFloat>& alpha, Vector<float>& beta, Matrix<ComplexFloat>& Vl, Matrix<ComplexFloat>& Vr);
	 void Ggev(Matrix<double>& A, Matrix<double>& B, Vector<ComplexDouble>& alpha, Vector<double>& beta);
	 void Ggev(Matrix<double>& A, Matrix<double>& B, Vector<ComplexDouble>& alpha, Vector<double>& beta, Matrix<ComplexDouble>& Vl, Matrix<ComplexDouble>& Vr);
	 void Ggev(Matrix<ComplexFloat>& A, Matrix<ComplexFloat>& B, Vector<ComplexFloat>& alpha, Vector<ComplexFloat>& beta);
	 void Ggev(Matrix<ComplexFloat>& A, Matrix<ComplexFloat>& B, Vector<ComplexFloat>& alpha, Vector<ComplexFloat>& beta, Matrix<ComplexFloat>& Vl, Matrix<ComplexFloat>& Vr);
	 void Ggev(Matrix<ComplexDouble>& A, Matrix<ComplexDouble>& B, Vector<ComplexDouble>& alpha, Vector<ComplexDouble>& beta);
	 void Ggev(Matrix<ComplexDouble>& A, Matrix<ComplexDouble>& B, Vector<ComplexDouble>& alpha, Vector<ComplexDouble>& beta, Matrix<ComplexDouble>& Vl, Matrix<ComplexDouble>& Vr);
	
	
	

	// Ggevx






//=========================================================
// Generalized Singular Value Decomposition (SVD)
//=========================================================




	// Ggsvd

	 void Ggsvd(Matrix<float>& A, Matrix<float>& B, Vector<float>& alpha, Vector<float>& beta);
	 void Ggsvd(Matrix<float>& A, Matrix<float>& B, Vector<float>& alpha, Vector<float>& beta, Matrix<float>& U, Matrix<float>& V, Matrix<float>& Q);
	 void Ggsvd(Matrix<double>& A, Matrix<double>& B, Vector<double>& alpha, Vector<double>& beta);
	 void Ggsvd(Matrix<double>& A, Matrix<double>& B, Vector<double>& alpha, Vector<double>& beta, Matrix<double>& U, Matrix<double>& V, Matrix<double>& Q);

	 void Ggsvd(Matrix<ComplexFloat>& A, Matrix<ComplexFloat>& B, Vector<float>& alpha, Vector<float>& beta);
	 void Ggsvd(Matrix<ComplexFloat>& A, Matrix<ComplexFloat>& B, Vector<float>& alpha, Vector<float>& beta, Matrix<ComplexFloat>& U, Matrix<ComplexFloat>& V, Matrix<ComplexFloat>& Q);
	 void Ggsvd(Matrix<ComplexDouble>& A, Matrix<ComplexDouble>& B, Vector<double>& alpha, Vector<double>& beta);
	 void Ggsvd(Matrix<ComplexDouble>& A, Matrix<ComplexDouble>& B, Vector<double>& alpha, Vector<double>& beta, Matrix<ComplexDouble>& U, Matrix<ComplexDouble>& V, Matrix<ComplexDouble>& Q);










};






#endif