www.pudn.com > Image_segment.rar > Lapack.h

//Copyright (c) 2004-2005, Baris Sumengen 
//All rights reserved. 
// 
// CIMPL Matrix Performance Library 
// 
//Redistribution and use in source and binary 
//forms, with or without modification, are 
//permitted provided that the following 
//conditions are met: 
// 
//    * No commercial use is allowed.  
//    This software can only be used 
//    for non-commercial purposes. This  
//    distribution is mainly intended for 
//    academic research and teaching. 
//    * Redistributions of source code must 
//    retain the above copyright notice, this 
//    list of conditions and the following 
//    disclaimer. 
//    * Redistributions of binary form must 
//    mention the above copyright notice, this 
//    list of conditions and the following 
//    disclaimer in a clearly visible part  
//    in associated product manual,  
//    readme, and web site of the redistributed  
//    software. 
//    * Redistributions in binary form must 
//    reproduce the above copyright notice, 
//    this list of conditions and the 
//    following disclaimer in the 
//    documentation and/or other materials 
//    provided with the distribution. 
//    * The name of Baris Sumengen may not be 
//    used to endorse or promote products 
//    derived from this software without 
//    specific prior written permission. 
// 
//THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT 
//HOLDERS AND CONTRIBUTORS "AS IS" AND ANY 
//EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT 
//NOT LIMITED TO, THE IMPLIED WARRANTIES OF 
//MERCHANTABILITY AND FITNESS FOR A PARTICULAR 
//PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE 
//CONTRIBUTORS BE LIABLE FOR ANY 
//DIRECT, INDIRECT, INCIDENTAL, SPECIAL, 
//EXEMPLARY, OR CONSEQUENTIAL DAMAGES 
//(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT 
//OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 
//DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 
//HOWEVER CAUSED AND ON ANY THEORY OF 
//LIABILITY, WHETHER IN CONTRACT, STRICT 
//LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR 
//OTHERWISE) ARISING IN ANY WAY OUT OF THE USE 
//OF THIS SOFTWARE, EVEN IF ADVISED OF THE 
//POSSIBILITY OF SUCH DAMAGE. 
 
 
 
#pragma once 
#ifndef LAPACK_H 
#define LAPACK_H 
 
 
#include "cimpl.h" 
using namespace CIMPL; 
 
#include  
#include  
 
#include  
using std::numeric_limits; 
 
 
 
/// \brief Lapack Toolbox 
namespace Lapack 
{ 
 
//========================================================= 
// Linear equations solver 
//========================================================= 
	 
	// Gesv 
	 Matrix Gesv(Matrix& A, Matrix& B); 
	 Matrix Gesv(Matrix& A, Matrix& B); 
	 Matrix Gesv(Matrix& A, Matrix& B); 
	 Matrix Gesv(Matrix& A, Matrix& B); 
 
	//Gesvx 
	 
	 
	//Posv 
	 Matrix Posv(Matrix& A, Matrix& B); 
	 Matrix Posv(Matrix& A, Matrix& B); 
	 Matrix Posv(Matrix& A, Matrix& B); 
	 Matrix Posv(Matrix& A, Matrix& B); 
 
	//Posvx 
 
	//Sysv 
	 Matrix Sysv(Matrix& A, Matrix& B); 
	 Matrix Sysv(Matrix& A, Matrix& B); 
	 Matrix Sysv(Matrix& A, Matrix& B); 
	 Matrix Sysv(Matrix& A, Matrix& B); 
 
	//Sysvx 
 
 
	//Hesv 
	 Matrix Hesv(Matrix& A, Matrix& B); 
	 Matrix Hesv(Matrix& A, Matrix& B); 
 
	//Hesvx 
	 
 
//========================================================= 
// Linear Least Squares problems 
//========================================================= 
 
 
	// Gels 
	 Matrix Gels(Matrix& A, Matrix& B); 
	 Matrix Gels(Matrix& A, Matrix& B); 
	 Matrix Gels(Matrix& A, Matrix& B); 
	 Matrix Gels(Matrix& A, Matrix& B); 
	 
	// Gelsy 
	 Matrix Gelsy(Matrix& A, Matrix& B); 
	 Matrix Gelsy(Matrix& A, Matrix& B); 
	 Matrix Gelsy(Matrix& A, Matrix& B); 
	 Matrix Gelsy(Matrix& A, Matrix& B); 
	 
	// Gelss 
	 Matrix Gelss(Matrix& A, Matrix& B); 
	 Matrix Gelss(Matrix& A, Matrix& B); 
	 Matrix Gelss(Matrix& A, Matrix& B); 
	 Matrix Gelss(Matrix& A, Matrix& B); 
	 
	// Gelsd 
	 Matrix Gelsd(Matrix& A, Matrix& B); 
	 Matrix Gelsd(Matrix& A, Matrix& B); 
	 Matrix Gelsd(Matrix& A, Matrix& B); 
	 Matrix Gelsd(Matrix& A, Matrix& B); 
 
 
 
//========================================================= 
// Generalized Linear Least Squares problems 
//========================================================= 
 
 
	// Gglse 
	 Vector Gglse(Matrix& A, Matrix& B, Vector& c, Vector& d); 
	 Vector Gglse(Matrix& A, Matrix& B, Vector& c, Vector& d); 
	 Vector Gglse(Matrix& A, Matrix& B, Vector& c, Vector& d); 
	 Vector Gglse(Matrix& A, Matrix& B, Vector& c, Vector& d); 
 
 
	// Ggglm 
	 void Ggglm(Matrix& A, Matrix& B, Vector& d, Vector& x, Vector& y); 
	 void Ggglm(Matrix& A, Matrix& B, Vector& d, Vector& x, Vector& y); 
	 void Ggglm(Matrix& A, Matrix& B, Vector& d, Vector& x, Vector& y); 
	 void Ggglm(Matrix& A, Matrix& B, Vector& d, Vector& x, Vector& y); 
 
 
 
//========================================================= 
// Symmetric eigenproblem 
//========================================================= 
 
 
 
	// Syevd 
	 Vector Syevd(Matrix& A); 
	 Vector Syevd(Matrix& A, Matrix& EV); 
	 Vector Syevd(Matrix& A); 
	 Vector Syevd(Matrix& A, Matrix& EV); 
	// Heevd 
	 Vector Heevd(Matrix& A); 
	 Vector Heevd(Matrix& A, Matrix& EV); 
	 Vector Heevd(Matrix& A); 
	 Vector Heevd(Matrix& A, Matrix& EV); 
 
 
 
	// Syevr 
	 Vector Syevr(Matrix& A); 
	 Vector Syevr(Matrix& A, int il, int iu); 
	 Vector Syevr(Matrix& A, Matrix& EV); 
	 Vector Syevr(Matrix& A, Matrix& EV, int il, int iu); 
	 Vector Syevr(Matrix& A); 
	 Vector Syevr(Matrix& A, int il, int iu); 
	 Vector Syevr(Matrix& A, Matrix& EV); 
	 Vector Syevr(Matrix& A, Matrix& EV, int il, int iu); 
 
	// Heevr 
	 Vector Heevr(Matrix& A); 
	 Vector Heevr(Matrix& A, int il, int iu); 
	 Vector Heevr(Matrix& A, Matrix& EV); 
	 Vector Heevr(Matrix& A, Matrix& EV, int il, int iu); 
	 Vector Heevr(Matrix& A); 
	 Vector Heevr(Matrix& A, int il, int iu); 
	 Vector Heevr(Matrix& A, Matrix& EV); 
	 Vector Heevr(Matrix& A, Matrix& EV, int il, int iu); 
 
	 
	 
	 
 
 
//========================================================= 
// Non-Symmetric eigenvalue problem 
//========================================================= 
 
 
	// Gees 
	 Vector Gees(Matrix& A, Matrix& T); 
	 Vector Gees(Matrix& A, Matrix& T, Matrix& Z); 
	 Vector Gees(Matrix& A, Matrix& T); 
	 Vector Gees(Matrix& A, Matrix& T, Matrix& Z); 
	 Vector Gees(Matrix& A, Matrix& T); 
	 Vector Gees(Matrix& A, Matrix& T, Matrix& Z); 
	 Vector Gees(Matrix& A, Matrix& T); 
	 Vector Gees(Matrix& A, Matrix& T, Matrix& Z); 
	 
	 
	 
	 
	// Geesx 
	 
	 
	 
	 
	 
	// Geev 
	 Vector Geev(Matrix& A); 
	 Vector Geev(Matrix& A, Matrix& Vl, Matrix& Vr); 
	 Vector Geev(Matrix& A); 
	 Vector Geev(Matrix& A, Matrix& Vl, Matrix& Vr); 
	 Vector Geev(Matrix& A); 
	 Vector Geev(Matrix& A, Matrix& Vl, Matrix& Vr); 
	 Vector Geev(Matrix& A); 
	 Vector Geev(Matrix& A, Matrix& Vl, Matrix& Vr); 
	 
	 
	 
	 
	// Geevx 
 
 
 
 
 
 
 
 
 
 
//========================================================= 
// Singular Value Decomposition (SVD) 
//========================================================= 
 
 
	// Gesvd 
	 
	 
	 
	 
	 
	// Gesdd 
	 Vector Gesdd(Matrix& A); 
	 Vector Gesdd(Matrix& A, Matrix& U, Matrix& V); 
	 Vector Gesdd(Matrix& A); 
	 Vector Gesdd(Matrix& A, Matrix& U, Matrix& V); 
	 Vector Gesdd(Matrix& A); 
	 Vector Gesdd(Matrix& A, Matrix& U, Matrix& V); 
	 Vector Gesdd(Matrix& A); 
	 Vector Gesdd(Matrix& A, Matrix& U, Matrix& V); 
 
 
 
 
 
 
//========================================================= 
// Generalized Symmetric Definite eigenproblem 
//========================================================= 
 
 
	// Sygv 
	 
	 
	 
	 
	// Sygvx 
	 
	 
	 
	 
	 
	// Sygvd,Hegvd 
	 Vector Sygvd(Matrix& A, Matrix& B, int ptype); 
	 Vector Sygvd(Matrix& A, Matrix& B, Matrix& EV, int ptype); 
	 Vector Sygvd(Matrix& A, Matrix& B, int ptype); 
	 Vector Sygvd(Matrix& A, Matrix& B, Matrix& EV, int ptype); 
	  
	 Vector Hegvd(Matrix& A, Matrix& B, int ptype); 
	 Vector Hegvd(Matrix& A, Matrix& B, Matrix& EV, int ptype); 
	 Vector Hegvd(Matrix& A, Matrix& B, int ptype); 
	 Vector Hegvd(Matrix& A, Matrix& B, Matrix& EV, int ptype); 
 
 
 
 
 
 
 
 
 
//========================================================= 
// Generalized Non-Symmetric eigenvalue problem 
//========================================================= 
 
 
	// Gges 
	 void Gges(Matrix& A, Matrix& B, Vector& alpha, Vector& beta, Matrix& S, Matrix& T); 
	 void Gges(Matrix& A, Matrix& B, Vector& alpha, Vector& beta, Matrix& S, Matrix& T, Matrix& Vl, Matrix& Vr); 
	 void Gges(Matrix& A, Matrix& B, Vector& alpha, Vector& beta, Matrix& S, Matrix& T); 
	 void Gges(Matrix& A, Matrix& B, Vector& alpha, Vector& beta, Matrix& S, Matrix& T, Matrix& Vl, Matrix& Vr); 
	 void Gges(Matrix& A, Matrix& B, Vector& alpha, Vector& beta, Matrix& S, Matrix& T); 
	 void Gges(Matrix& A, Matrix& B, Vector& alpha, Vector& beta, Matrix& S, Matrix& T, Matrix& Vl, Matrix& Vr); 
	 void Gges(Matrix& A, Matrix& B, Vector& alpha, Vector& beta, Matrix& S, Matrix& T); 
	 void Gges(Matrix& A, Matrix& B, Vector& alpha, Vector& beta, Matrix& S, Matrix& T, Matrix& Vl, Matrix& Vr); 
	 
	 
 
	// Ggesx 
	 
	 
	 
	 
 
	// Ggev 
	 
	 void Ggev(Matrix& A, Matrix& B, Vector& alpha, Vector& beta); 
	 void Ggev(Matrix& A, Matrix& B, Vector& alpha, Vector& beta, Matrix& Vl, Matrix& Vr); 
	 void Ggev(Matrix& A, Matrix& B, Vector& alpha, Vector& beta); 
	 void Ggev(Matrix& A, Matrix& B, Vector& alpha, Vector& beta, Matrix& Vl, Matrix& Vr); 
	 void Ggev(Matrix& A, Matrix& B, Vector& alpha, Vector& beta); 
	 void Ggev(Matrix& A, Matrix& B, Vector& alpha, Vector& beta, Matrix& Vl, Matrix& Vr); 
	 void Ggev(Matrix& A, Matrix& B, Vector& alpha, Vector& beta); 
	 void Ggev(Matrix& A, Matrix& B, Vector& alpha, Vector& beta, Matrix& Vl, Matrix& Vr); 
	 
	 
	 
 
	// Ggevx 
 
 
 
 
 
 
//========================================================= 
// Generalized Singular Value Decomposition (SVD) 
//========================================================= 
 
 
 
 
	// Ggsvd 
 
	 void Ggsvd(Matrix& A, Matrix& B, Vector& alpha, Vector& beta); 
	 void Ggsvd(Matrix& A, Matrix& B, Vector& alpha, Vector& beta, Matrix& U, Matrix& V, Matrix& Q); 
	 void Ggsvd(Matrix& A, Matrix& B, Vector& alpha, Vector& beta); 
	 void Ggsvd(Matrix& A, Matrix& B, Vector& alpha, Vector& beta, Matrix& U, Matrix& V, Matrix& Q); 
 
	 void Ggsvd(Matrix& A, Matrix& B, Vector& alpha, Vector& beta); 
	 void Ggsvd(Matrix& A, Matrix& B, Vector& alpha, Vector& beta, Matrix& U, Matrix& V, Matrix& Q); 
	 void Ggsvd(Matrix& A, Matrix& B, Vector& alpha, Vector& beta); 
	 void Ggsvd(Matrix& A, Matrix& B, Vector& alpha, Vector& beta, Matrix& U, Matrix& V, Matrix& Q); 
 
 
 
 
 
 
 
 
 
 
}; 
 
 
 
 
 
 
#endif