Complex Double-precision General Band Matrix Class. More...

#include <zgbmatrix.hpp>

Public Member Functions
	zgbmatrix ()

	zgbmatrix (const zgbmatrix &)

	zgbmatrix (const _zgbmatrix &)

	zgbmatrix (const CPPL_INT &, const CPPL_INT &, const CPPL_INT &, const CPPL_INT &)

	zgbmatrix (const char *)

	~zgbmatrix ()

_zgematrix	to_zgematrix () const

comple &	operator() (const CPPL_INT &, const CPPL_INT &)

comple	operator() (const CPPL_INT &, const CPPL_INT &) const

zgbmatrix &	set (const CPPL_INT &, const CPPL_INT &, const comple &)

void	write (const char *) const

void	read (const char *)

void	clear ()

zgbmatrix &	zero ()

zgbmatrix &	identity ()

void	chsign ()

void	copy (const zgbmatrix &)

void	shallow_copy (const _zgbmatrix &)

void	resize (const CPPL_INT &, const CPPL_INT &, const CPPL_INT &, const CPPL_INT &)

_zrovector	row (const CPPL_INT &) const

_zcovector	col (const CPPL_INT &) const

CPPL_INT	zgbsv (zgematrix &)

CPPL_INT	zgbsv (zcovector &)

zgbmatrix &	operator= (const zgbmatrix &)

zgbmatrix &	operator= (const _zgbmatrix &)

zgbmatrix &	operator+= (const zgbmatrix &)

zgbmatrix &	operator+= (const _zgbmatrix &)

zgbmatrix &	operator-= (const zgbmatrix &)

zgbmatrix &	operator-= (const _zgbmatrix &)

zgbmatrix &	operator*= (const zgbmatrix &)

zgbmatrix &	operator*= (const _zgbmatrix &)

zgbmatrix &	operator*= (const double &)

zgbmatrix &	operator*= (const comple &)

zgbmatrix &	operator/= (const double &)

zgbmatrix &	operator/= (const comple &)

Public Attributes
CPPL_INT	m
	matrix row size More...

CPPL_INT	n
	matrix column size More...

CPPL_INT	kl
	lower band width More...

CPPL_INT	ku
	upper band width More...

comple *	array
	1D array to store matrix data More...

comple **	darray
	array of pointers of column head addresses More...

Friends
std::ostream &	operator<< (std::ostream &, const zgbmatrix &)

void	swap (zgbmatrix &, zgbmatrix &)

_zgbmatrix	_ (zgbmatrix &)

_zgbmatrix	t (const zgbmatrix &)

_zgematrix	i (const zgbmatrix &)

_zgbmatrix	conj (const zgbmatrix &)

_zgbmatrix	conjt (const zgbmatrix &)

const zgbmatrix &	operator+ (const zgbmatrix &)

_zgbmatrix	operator- (const zgbmatrix &)

_zgematrix	operator+ (const zgbmatrix &, const zgematrix &)

_zgematrix	operator+ (const zgbmatrix &, const _zgematrix &)

_zgematrix	operator+ (const zgbmatrix &, const zhematrix &)

_zgematrix	operator+ (const zgbmatrix &, const _zhematrix &)

_zgbmatrix	operator+ (const zgbmatrix &, const zgbmatrix &)

_zgbmatrix	operator+ (const zgbmatrix &, const _zgbmatrix &)

_zgematrix	operator+ (const zgbmatrix &, const zgsmatrix &)

_zgematrix	operator+ (const zgbmatrix &, const _zgsmatrix &)

_zgematrix	operator+ (const zgbmatrix &, const zhsmatrix &)

_zgematrix	operator+ (const zgbmatrix &, const _zhsmatrix &)

_zgematrix	operator- (const zgbmatrix &, const zgematrix &)

_zgematrix	operator- (const zgbmatrix &, const _zgematrix &)

_zgematrix	operator- (const zgbmatrix &, const zhematrix &)

_zgematrix	operator- (const zgbmatrix &, const _zhematrix &)

_zgbmatrix	operator- (const zgbmatrix &, const zgbmatrix &)

_zgbmatrix	operator- (const zgbmatrix &, const _zgbmatrix &)

_zgematrix	operator- (const zgbmatrix &, const zgsmatrix &)

_zgematrix	operator- (const zgbmatrix &, const _zgsmatrix &)

_zgematrix	operator- (const zgbmatrix &, const zhsmatrix &)

_zgematrix	operator- (const zgbmatrix &, const _zhsmatrix &)

_zcovector	operator* (const zgbmatrix &, const zcovector &)

_zcovector	operator* (const zgbmatrix &, const _zcovector &)

_zgematrix	operator* (const zgbmatrix &, const zgematrix &)

_zgematrix	operator* (const zgbmatrix &, const _zgematrix &)

_zgematrix	operator* (const zgbmatrix &, const zhematrix &)

_zgematrix	operator* (const zgbmatrix &, const _zhematrix &)

_zgbmatrix	operator* (const zgbmatrix &, const zgbmatrix &)

_zgbmatrix	operator* (const zgbmatrix &, const _zgbmatrix &)

_zgematrix	operator* (const zgbmatrix &, const zgsmatrix &)

_zgematrix	operator* (const zgbmatrix &, const _zgsmatrix &)

_zgematrix	operator* (const zgbmatrix &, const zhsmatrix &)

_zgematrix	operator* (const zgbmatrix &, const _zhsmatrix &)

_zgbmatrix	operator* (const zgbmatrix &, const double &)

_zgbmatrix	operator* (const zgbmatrix &, const comple &)

_zgbmatrix	operator/ (const zgbmatrix &, const double &)

_zgbmatrix	operator/ (const zgbmatrix &, const comple &)

_zgbmatrix	operator* (const double &, const zgbmatrix &)

_zgbmatrix	operator* (const comple &, const zgbmatrix &)

Detailed Description

Complex Double-precision General Band Matrix Class.

Definition at line 3 of file zgbmatrix.hpp.

Constructor & Destructor Documentation

zgbmatrix::zgbmatrix ( )

inline

zgbmatrix constructor

Definition at line 3 of file zgbmatrix-constructor.hpp.

References array, darray, kl, ku, m, and n.

 {CPPL_VERBOSE_REPORT;
   //////// initialize ////////
   m =0;
   n =0;
   kl =0;
   ku =0;
   array =NULL;
   darray =NULL;
 }

zgbmatrix::zgbmatrix ( const zgbmatrix & mat )

inline

zgbmatrix copy constructor

Definition at line 20 of file zgbmatrix-constructor.hpp.

References array, darray, i, kl, ku, m, and n.

 {CPPL_VERBOSE_REPORT;
   //////// initialize ////////
   m =mat.m;
   n =mat.n;
   kl =mat.kl;
   ku =mat.ku;
   array =new comple[(kl+ku+1)*n];
   darray =new comple*[n];
   for(int i=0; i<n; i++){
     darray[i] =&array[i*(kl+ku+1)];
   }
 
   //////// copy ////////
   CPPL_INT size =(kl+ku+1)*n;
   CPPL_INT inc =1;
   zcopy_(&size, mat.array, &inc, array, &inc);
 }

zgbmatrix::zgbmatrix ( const _zgbmatrix & mat )

inline

zgbmatrix constructor to cast _zgbmatrix

Definition at line 41 of file zgbmatrix-constructor.hpp.

References array, _zgbmatrix::array, darray, _zgbmatrix::darray, kl, _zgbmatrix::kl, _zgbmatrix::ku, ku, m, _zgbmatrix::m, _zgbmatrix::n, n, and _zgbmatrix::nullify().

 {CPPL_VERBOSE_REPORT;
   m =mat.m;
   n =mat.n;
   kl =mat.kl;
   ku =mat.ku;
   array =mat.array;
   darray =mat.darray;
   
   mat.nullify();
 }

zgbmatrix::zgbmatrix	(	const CPPL_INT &	_m,
		const CPPL_INT &	_n,
		const CPPL_INT &	_kl,
		const CPPL_INT &	_ku
	)

inline

zgbmatrix constructor with size specification

Definition at line 59 of file zgbmatrix-constructor.hpp.

References array, darray, i, kl, ku, m, and n.

 {CPPL_VERBOSE_REPORT;
 #ifdef  CPPL_DEBUG
   if( _m<0 || _n<0 || _kl<0 || _ku<0 || _m<_kl || _n<_ku ){
     ERROR_REPORT;
     std::cerr << "It is impossible to make a matrix you ordered. " << std::endl
               << "Your input was (" << _m << "," << _n << ","<< _ku << "," << _kl << ")." << std::endl;
     exit(1);
   }
 #endif//CPPL_DEBUG
   
   //////// initialize ////////
   m =_m;
   n =_n;
   kl =_kl;
   ku =_ku;
   array =new comple[(kl+ku+1)*n];
   darray =new comple*[n];
   for(int i=0; i<n; i++){
     darray[i] =&array[i*(kl+ku+1)];
   }
 }

zgbmatrix::zgbmatrix ( const char * filename )

inline

zgbmatrix constructor with filename

Definition at line 85 of file zgbmatrix-constructor.hpp.

References array, darray, and read().

 {CPPL_VERBOSE_REPORT;
   array =NULL;
   darray =NULL;
   
   //// read ////
   read(filename);
 }

zgbmatrix::~zgbmatrix ( )

inline

zgbmatrix destructor

Definition at line 100 of file zgbmatrix-constructor.hpp.

References array, and darray.

 {CPPL_VERBOSE_REPORT;
   //////// delete array ////////
   delete [] array;
   delete [] darray;
 }

Member Function Documentation

_zgematrix zgbmatrix::to_zgematrix ( ) const

inline

convert to _zgematrix

Definition at line 3 of file zgbmatrix-cast.hpp.

References _, i, kl, ku, m, n, and zero().

 {CPPL_VERBOSE_REPORT;
   zgematrix newmat( zgematrix(m,n).zero() );
   
   for(CPPL_INT i=0; i<m; i++){
     const CPPL_INT jmax =std::min(n,i+ku+1);
     for(CPPL_INT j=std::max(CPPL_INT(0),i-kl); j<jmax; j++){
       newmat(i,j) =(*this)(i,j);
     }
   }
   
   return _(newmat);
 }

comple & zgbmatrix::operator()	(	const CPPL_INT &	i,
		const CPPL_INT &	j
	)

inline

operator() for non-const object

Definition at line 3 of file zgbmatrix-io.hpp.

References darray, i, kl, ku, m, and n.

Referenced by identity(), operator*=(), operator+=(), operator-=(), read(), write(), and zgbsv().

 {CPPL_VERBOSE_REPORT;
 #ifdef  CPPL_DEBUG
   if( i<0 || j<0 || m<=i || n<=j || i-j>kl || j-i>ku ){
     ERROR_REPORT;
     std::cerr << "The required component is out of the matrix size." << std::endl
               << "Your input is (" << i << "," << j << "), whereas the matrix size is " << m << "x" << n << " with kl=" << kl << ", ku=" << ku << "." << std::endl;
     exit(1);
   }
 #endif//CPPL_DEBUG
   
   //return array[ku+i+(kl+ku)*j];
   return darray[j][ku-j+i];
 }

comple zgbmatrix::operator()	(	const CPPL_INT &	i,
		const CPPL_INT &	j
	)		const

inline

operator() for const object

Definition at line 20 of file zgbmatrix-io.hpp.

References darray, i, kl, ku, m, and n.

 {CPPL_VERBOSE_REPORT;
 #ifdef  CPPL_DEBUG
   if( i<0 || j<0 || m<=i || n<=j || i-j>kl || j-i>ku ){
     ERROR_REPORT;
     std::cerr << "The required component is out of the matrix size." << std::endl
               << "Your input is (" << i << "," << j << "), whereas the matrix size is " << m << "x" << n << " with kl=" << kl << ", ku=" << ku << "." << std::endl;
     exit(1);
   }
 #endif//CPPL_DEBUG
   
   //return array[ku+i+(kl+ku)*j];
   return darray[j][ku-j+i];
 }

zgbmatrix & zgbmatrix::set	(	const CPPL_INT &	i,
		const CPPL_INT &	j,
		const comple &	v
	)

inline

set value for const object

Definition at line 41 of file zgbmatrix-io.hpp.

References darray, i, kl, ku, m, and n.

 {CPPL_VERBOSE_REPORT;
 #ifdef  CPPL_DEBUG
   if( i<0 || j<0 || m<=i || n<=j || i-j>kl || j-i>ku ){
     ERROR_REPORT;
     std::cerr << "The required component is out of the matrix size." << std::endl
               << "Your input is (" << i << "," << j << "), whereas the matrix size is " << m << "x" << n << " with kl=" << kl << ", ku=" << ku << "." << std::endl;
     exit(1);
   }
 #endif//CPPL_DEBUG
   
   //array[ku+i+(kl+ku)*j] =v;
   darray[j][ku-j+i] =v;
   
   return *this;
 }

void zgbmatrix::write ( const char * filename ) const

inline

Definition at line 81 of file zgbmatrix-io.hpp.

References i, kl, ku, m, n, and operator()().

 {CPPL_VERBOSE_REPORT;
   std::ofstream ofs(filename, std::ios::trunc);
   ofs.setf(std::cout.flags());
   ofs.precision(std::cout.precision());
   ofs.width(std::cout.width());
   ofs.fill(std::cout.fill());
   
   ofs << "#zgbmatrix" << " " << m << " " << n << " " << kl << " " << ku << std::endl;
   for(CPPL_INT i=0; i<m; i++){
     const CPPL_INT jmax =std::min(n,i+ku+1);
     for(CPPL_INT j=std::max(CPPL_INT(0),i-kl); j<jmax; j++){
       ofs << operator()(i,j) << " ";
     }
     ofs << std::endl;
   }
   
   ofs.close();
 }

void zgbmatrix::read ( const char * filename )

inline

Definition at line 102 of file zgbmatrix-io.hpp.

References i, kl, ku, m, n, operator()(), and resize().

Referenced by zgbmatrix().

 {CPPL_VERBOSE_REPORT;
   std::ifstream s( filename );
   if(!s){
     ERROR_REPORT;
     std::cerr << "The file \"" << filename << "\" can not be opened." << std::endl;
     exit(1);
   }
 
   std::string id;
   s >> id;
   if( id != "zgbmatrix" && id != "#zgbmatrix" ){
     ERROR_REPORT;
     std::cerr << "The type name of the file \"" << filename << "\" is not zgbmatrix." << std::endl
               << "Its type name was " << id << " ." << std::endl;
     exit(1);
   }
   
   s >> m >> n >> kl >> ku;
   resize(m, n, kl, ku);
   for(CPPL_INT i=0; i<m; i++){
     const CPPL_INT jmax =std::min(n,i+ku+1);
     for(CPPL_INT j=std::max(CPPL_INT(0),i-kl); j<jmax; j++){
       s >> operator()(i,j);
     }
   }
   if(s.eof()){
     ERROR_REPORT;
     std::cerr << "There is something is wrong with the file \"" << filename << "\"." << std::endl
               << "Most likely, there is not enough data components, or a linefeed code or space code is missing at the end of the last line." << std::endl;
     exit(1);
   }
   
   s >> id;
   if(!s.eof()){
     ERROR_REPORT;
     std::cerr << "There is something is wrong with the file \"" << filename << "\"." << std::endl
               << "Most likely, there are extra data components." << std::endl;
     exit(1);
   }
   
   s.close();
 }

void zgbmatrix::clear ( )

inline

clear all the matrix data and set the sizes 0

Definition at line 3 of file zgbmatrix-misc.hpp.

References array, darray, kl, ku, m, and n.

 {CPPL_VERBOSE_REPORT;
   m =0;
   n =0;
   kl =0;
   ku =0;
   delete [] array;
   array =NULL;
   delete [] darray;
   darray =NULL;
 }

zgbmatrix & zgbmatrix::zero ( )

inline

change the matrix into a zero matrix

Definition at line 18 of file zgbmatrix-misc.hpp.

References array, i, kl, ku, and n.

Referenced by operator*(), operator*=(), operator+(), operator+=(), operator-(), operator-=(), and to_zgematrix().

 {CPPL_VERBOSE_REPORT;
   const CPPL_INT size =(kl+ku+1)*n;
   for(CPPL_INT i=0; i<size; i++){
     array[i] =comple(0.,0.);
   }
   return *this;
 }

zgbmatrix & zgbmatrix::identity ( )

inline

change the matrix into an identity matrix

Definition at line 29 of file zgbmatrix-misc.hpp.

References array, i, kl, ku, m, n, and operator()().

 {CPPL_VERBOSE_REPORT;
 #ifdef  CPPL_DEBUG
   if(m!=n){
     ERROR_REPORT;
     std::cerr << "Only square matrix can be a identity matrix." << std::endl
               << "The matrix size was " << m << "x" << n << "." << std::endl;
     exit(1);
   }
 #endif//CPPL_DEBUG
   
   const CPPL_INT size =(kl+ku+1)*n;
   for(CPPL_INT i=0; i<size; i++){
     array[i] =comple(0.,0.);
   }
   for(CPPL_INT i=0; i<m; i++){
     operator()(i,i) =comple(1.,0.);
   }
   
   return *this;
 }

void zgbmatrix::chsign ( )

inline

change sign(+/-) of the matrix

Definition at line 53 of file zgbmatrix-misc.hpp.

References array, i, kl, ku, and n.

 {CPPL_VERBOSE_REPORT;
   const CPPL_INT size =(kl+ku+1)*n;
   for(CPPL_INT i=0; i<size; i++){
     array[i] =-array[i];
   }
 }

void zgbmatrix::copy ( const zgbmatrix & mat )

inline

make a deep copy of the matrix

Definition at line 63 of file zgbmatrix-misc.hpp.

References array, darray, i, kl, ku, m, and n.

Referenced by operator=().

 {CPPL_VERBOSE_REPORT;
   m =mat.m;
   n =mat.n;
   kl =mat.kl;
   ku =mat.ku;
   delete [] array;
   array =new comple[(mat.kl+mat.ku+1)*mat.n];
   delete [] darray;
   darray =new comple*[n];
   for(int i=0; i<n; i++){
     darray[i] =&array[i*(kl+ku+1)];
   }
   
   CPPL_INT size =(mat.kl+mat.ku+1)*mat.n;
   CPPL_INT inc =1;
   zcopy_(&size, mat.array, &inc, array, &inc);
 }

void zgbmatrix::shallow_copy ( const _zgbmatrix & mat )

inline

make a shallow copy of the matrix
This function is not designed to be used in project codes.

Definition at line 85 of file zgbmatrix-misc.hpp.

References array, _zgbmatrix::array, darray, _zgbmatrix::darray, kl, _zgbmatrix::kl, _zgbmatrix::ku, ku, m, _zgbmatrix::m, _zgbmatrix::n, n, and _zgbmatrix::nullify().

Referenced by operator=().

 {CPPL_VERBOSE_REPORT;
   m =mat.m;
   n =mat.n;
   kl =mat.kl;
   ku =mat.ku;
   delete [] array;
   array =mat.array;
   delete [] darray;
   darray =mat.darray;
   
   mat.nullify();
 }

void zgbmatrix::resize	(	const CPPL_INT &	_m,
		const CPPL_INT &	_n,
		const CPPL_INT &	_kl,
		const CPPL_INT &	_ku
	)

inline

resize the matrix

Definition at line 101 of file zgbmatrix-misc.hpp.

References array, darray, i, kl, ku, m, and n.

Referenced by read().

 {CPPL_VERBOSE_REPORT;
 #ifdef  CPPL_DEBUG
   if( _m<0 || _n<0 || _kl<0 || _ku<0 || _m<_kl || _n<_ku ){
     ERROR_REPORT;
     std::cerr << "It is impossible to make a matrix you ordered. " << std::endl
               << "Your input was (" << _m << "," << _n << ","<< _ku << "," << _kl << ")." << std::endl;
     exit(1);
   }
 #endif//CPPL_DEBUG
   
   m =_m;
   n =_n;
   kl =_kl;
   ku =_ku;
   delete [] array;
   array =new comple[(kl+ku+1)*n];
   delete [] darray;
   darray =new comple*[n];
   for(int i=0; i<n; i++){
     darray[i] =&array[i*(kl+ku+1)];
   }
 }

_zrovector zgbmatrix::row ( const CPPL_INT & _m ) const

inline

get row of the matrix

Definition at line 132 of file zgbmatrix-misc.hpp.

References _, kl, ku, m, n, and zrovector::zero().

 {CPPL_VERBOSE_REPORT;
 #ifdef  CPPL_DEBUG
   if( _m<0 || _m>m ){
     ERROR_REPORT;
     std::cerr << "Input row number must be between 0 and " << m << "." << std::endl
               << "Your input was " << _m << "." << std::endl;
     exit(1);
   }
 #endif//CPPL_DEBUG
   
   zrovector v =zrovector(n).zero();
   
   const CPPL_INT jmax =std::min(n,_m+ku+1);
   for(CPPL_INT j=std::max(CPPL_INT(0),_m-kl); j<jmax; j++){
     v(j)=(*this)(_m,j);
   }
   
   return _(v);
 }

_zcovector zgbmatrix::col ( const CPPL_INT & _n ) const

inline

get column of the matrix

Definition at line 155 of file zgbmatrix-misc.hpp.

References _, i, kl, ku, m, n, and zcovector::zero().

 {CPPL_VERBOSE_REPORT;
 #ifdef  CPPL_DEBUG
   if( _n<0 || _n>n ){
     ERROR_REPORT;
     std::cerr << "Input row number must be between 0 and " << n << "." << std::endl
               << "Your input was " << _n << "." << std::endl;
     exit(1);
   }
 #endif//CPPL_DEBUG
   
   zcovector v =zcovector(m).zero();
   
   const CPPL_INT imax =std::min(m,_n+kl+1);
   for(CPPL_INT i=std::max(CPPL_INT(0),_n-ku); i<imax; i++){
     v(i)=(*this)(i,_n);
   }
   
   return _(v);
 }

CPPL_INT zgbmatrix::zgbsv ( zgematrix & mat )

inline

solve A*X=Y using zgbsv
The argument is zgematrix Y. Y is overwritten and become the solution X. A is also overwritten.

Definition at line 5 of file zgbmatrix-lapack.hpp.

References zgematrix::array, array, i, kl, ku, m, zgematrix::m, n, zgematrix::n, operator()(), and swap.

Referenced by i().

 {CPPL_VERBOSE_REPORT;
 #ifdef  CPPL_DEBUG
   if(m!=n || n!=mat.m){
     ERROR_REPORT;
     std::cerr << "These matrix and vector cannot be solved." << std::endl
               << "Your input was (" << m << "x" << n << ") and (" << mat.m << "x" << mat.n << ")." << std::endl;
     exit(1);
   }
 #endif//CPPL_DEBUG 
   
   zgbmatrix newmat(m,n,kl,ku+kl);
   for(CPPL_INT i=0; i<m; i++){
     const CPPL_INT jmax =std::min(n,i+ku+1);
     for(CPPL_INT j=std::max(CPPL_INT(0),i-kl); j<jmax; j++){
       newmat(i,j) =operator()(i,j);
     }
   }
   
   CPPL_INT NRHS(mat.n), LDAB(2*kl+ku+1), *IPIV(new CPPL_INT[n]), LDB(mat.m), INFO(1);
   zgbsv_(&n, &kl, &ku, &NRHS, newmat.array, &LDAB, IPIV, mat.array, &LDB, &INFO);
   delete [] IPIV;
   
   swap(*this,newmat);
   
   if(INFO!=0){
     WARNING_REPORT;
     std::cerr << "Serious trouble happend. INFO = " << INFO << "." << std::endl;
   }
   return INFO;
 }

CPPL_INT zgbmatrix::zgbsv ( zcovector & vec )

inline

solve A*x=y using zgbsv
The argument is zcovector y. y is overwritten and become the solution x. A is also overwritten.

Definition at line 41 of file zgbmatrix-lapack.hpp.

References zcovector::array, array, i, kl, ku, zcovector::l, m, n, operator()(), and swap.

 {CPPL_VERBOSE_REPORT;
 #ifdef  CPPL_DEBUG
   if(m!=n || n!=vec.l){
     ERROR_REPORT;
     std::cerr << "These matrix and vector cannot be solved." << std::endl
               << "Your input was (" << m << "x" << n << ") and (" << vec.l << ")." << std::endl;
     exit(1);
   }
 #endif//CPPL_DEBUG 
   
   zgbmatrix newmat(m,n,kl,ku+kl);
   for(CPPL_INT i=0; i<m; i++){
     const CPPL_INT jmax =std::min(n,i+ku+1);
     for(CPPL_INT j=std::max(CPPL_INT(0),i-kl); j<jmax; j++){
       newmat(i,j) =operator()(i,j);
     }
   }
   
   CPPL_INT NRHS(1), LDAB(2*kl+ku+1), *IPIV(new CPPL_INT[n]), LDB(vec.l), INFO(1);
   zgbsv_(&n, &kl, &ku, &NRHS, newmat.array, &LDAB, IPIV, vec.array, &LDB, &INFO);
   delete [] IPIV;
   
   swap(*this,newmat);
   
   if(INFO!=0){
     WARNING_REPORT;
     std::cerr << "Serious trouble happend. INFO = " << INFO << "." << std::endl;
   }
   return INFO;
 }

zgbmatrix & zgbmatrix::operator= ( const zgbmatrix & mat )

inline

zgbmatrix=zgbmatrix operator
The left side matrix is overwritten thoroughly including band width.

Definition at line 4 of file zgbmatrix-zgbmatrix.hpp.

References array, and copy().

 {CPPL_VERBOSE_REPORT;
   if(array!=mat.array){ // if it is NOT self substitution
     copy(mat);
   }
   return *this;
 }

zgbmatrix & zgbmatrix::operator= ( const _zgbmatrix & mat )

inline

zgbmatrix=_zgbmatrix operator

Definition at line 3 of file zgbmatrix-_zgbmatrix.hpp.

References shallow_copy().

 {CPPL_VERBOSE_REPORT;
   shallow_copy(mat);
   return *this;
 }

zgbmatrix & zgbmatrix::operator+= ( const zgbmatrix & mat )

inline

zgbmatrix+=zgbmatrix operator
If the band width of the left side matrix is narrower than the right side matrix, the band width of the left side matrix become thicker as same as the right side matrix.

Definition at line 19 of file zgbmatrix-zgbmatrix.hpp.

References i, kl, ku, m, n, operator()(), swap, and zero().

 {CPPL_VERBOSE_REPORT;
 #ifdef  CPPL_DEBUG
   if(n!=mat.n || m!=mat.m){
     ERROR_REPORT;
     std::cerr << "These two matrises can not make a summation." << std::endl
               << "Your input was" << "(" << m <<"x"<< n <<","<< kl <<":"<< ku << ") "<< "+=" << "("<< mat.m <<"x"<< mat.n <<","<< mat.kl <<":"<< mat.ku <<") " << std::endl;
     exit(1);
   }
 #endif//CPPL_DEBUG
   
   if(kl>=mat.kl && ku>=mat.ku){
     for(CPPL_INT i=0; i<m; i++){
       const CPPL_INT jmax =std::min(n,i+mat.ku+1);
       for(CPPL_INT j=std::max(CPPL_INT(0),i-mat.kl); j<jmax; j++){
         operator()(i,j) += mat(i,j);
       }
     }
     
     return *this;
   }
   
   else{
     zgbmatrix newmat(m,n,std::max(kl,mat.kl),std::max(ku,mat.ku));
     newmat.zero();
     for(CPPL_INT i=0; i<m; i++){
       const CPPL_INT jmax1 =std::min(n,i+ku+1);
       for(CPPL_INT j=std::max(CPPL_INT(0),i-kl); j<jmax1; j++){
         newmat(i,j) += operator()(i,j);
       }
       const CPPL_INT jmax2 =std::min(mat.n,i+mat.ku+1);
       for(CPPL_INT j=std::max(CPPL_INT(0),i-mat.kl); j<jmax2; j++){
         newmat(i,j) += mat(i,j);
       }
     }
     
     swap(*this,newmat);
     return *this;
   }
 }

zgbmatrix & zgbmatrix::operator+= ( const _zgbmatrix & mat )

inline

zgbmatrix+=_zgbmatrix operator
If the band width of the left side matrix is narrower than the right side matrix, the band width of the left side matrix become thicker as same as the right side matrix.

Definition at line 16 of file zgbmatrix-_zgbmatrix.hpp.

References _zgbmatrix::destroy(), i, kl, _zgbmatrix::kl, _zgbmatrix::ku, ku, m, _zgbmatrix::m, _zgbmatrix::n, n, operator()(), swap, and zero().

 {CPPL_VERBOSE_REPORT;
 #ifdef  CPPL_DEBUG
   if(n!=mat.n || m!=mat.m){
     ERROR_REPORT;
     std::cerr << "These two matrises can not make a summation." << std::endl
               << "Your input was" << "(" << m <<"x"<< n <<","<< kl <<":"<< ku << ") "<< "+=" << "("<< mat.m <<"x"<< mat.n <<","<< mat.kl <<":"<< mat.ku <<") " << std::endl;
     exit(1);
   }
 #endif//CPPL_DEBUG
   
   if(kl>=mat.kl && ku>=mat.ku){
     for(CPPL_INT i=0; i<m; i++){
       const CPPL_INT jmax =std::min(n,i+mat.ku+1);
       for(CPPL_INT j=std::max(CPPL_INT(0),i-mat.kl); j<jmax; j++){
         operator()(i,j) += mat(i,j);
       }
     }
     
     mat.destroy();
     return *this;
   }
   else{
     zgbmatrix newmat(m,n,std::max(kl,mat.kl),std::max(ku,mat.ku));
     newmat.zero();
     for(CPPL_INT i=0; i<m; i++){
       const CPPL_INT jmax1 =std::min(n,i+ku+1);
       for(CPPL_INT j=std::max(CPPL_INT(0),i-kl); j<jmax1; j++){
         newmat(i,j) += operator()(i,j);
       }
       const CPPL_INT jmax2 =std::min(mat.n,i+mat.ku+1);
       for(CPPL_INT j=std::max(CPPL_INT(0),i-mat.kl); j<jmax2; j++){
         newmat(i,j) += mat(i,j);
       }
     }
     
     swap(*this,newmat);
     mat.destroy();
     return *this;
   }
 }

zgbmatrix & zgbmatrix::operator-= ( const zgbmatrix & mat )

inline

zgbmatrix-=zgbmatrix operator
If the band width of the left side matrix is narrower than the right side matrix, the band width of the left side matrix become thicker as same as the right side matrix.

Definition at line 63 of file zgbmatrix-zgbmatrix.hpp.

References i, kl, ku, m, n, operator()(), swap, and zero().

 {CPPL_VERBOSE_REPORT;
 #ifdef  CPPL_DEBUG
   if(n!=mat.n || m!=mat.m){
     ERROR_REPORT;
     std::cerr << "These two matrises can not make a subtraction." << std::endl
               << "Your input was" << "(" << m <<"x"<< n <<","<< kl <<":"<< ku << ") "<< "-=" << "("<< mat.m <<"x"<< mat.n <<","<< mat.kl <<":"<< mat.ku <<") " << std::endl;
     exit(1);
   }
 #endif//CPPL_DEBUG
   
   if(kl>=mat.kl && ku>=mat.ku){
     for(CPPL_INT i=0; i<m; i++){
       const CPPL_INT jmax =std::min(n,i+mat.ku+1);
       for(CPPL_INT j=std::max(CPPL_INT(0),i-mat.kl); j<jmax; j++){
         operator()(i,j) -= mat(i,j);
       }
     }
     
     return *this;
   }
   
   else{
     zgbmatrix newmat(m,n,std::max(kl,mat.kl),std::max(ku,mat.ku));
     newmat.zero();
     for(CPPL_INT i=0; i<m; i++){
       const CPPL_INT jmax1 =std::min(n,i+ku+1);
       for(CPPL_INT j=std::max(CPPL_INT(0),i-kl); j<jmax1; j++){
         newmat(i,j) += operator()(i,j);
       }
       const CPPL_INT jmax2 =std::min(mat.n,i+mat.ku+1);
       for(CPPL_INT j=std::max(CPPL_INT(0),i-mat.kl); j<jmax2; j++){
         newmat(i,j) -= mat(i,j);
       }
     }
     
     swap(*this,newmat);
     return *this;
   }
 }

zgbmatrix & zgbmatrix::operator-= ( const _zgbmatrix & mat )

inline

zgbmatrix-=_zgbmatrix operator
If the band width of the left side matrix is narrower than the right side matrix, the band width of the left side matrix become thicker as same as the right side matrix.

Definition at line 61 of file zgbmatrix-_zgbmatrix.hpp.

References _zgbmatrix::destroy(), i, kl, _zgbmatrix::kl, _zgbmatrix::ku, ku, m, _zgbmatrix::m, _zgbmatrix::n, n, operator()(), swap, and zero().

 {CPPL_VERBOSE_REPORT;
 #ifdef  CPPL_DEBUG
   if(n!=mat.n || m!=mat.m){
     ERROR_REPORT;
     std::cerr << "These two matrises can not make a subtraction." << std::endl
               << "Your input was" << "(" << m <<"x"<< n <<","<< kl <<":"<< ku << ") "<< "-=" << "("<< mat.m <<"x"<< mat.n <<","<< mat.kl <<":"<< mat.ku <<") " << std::endl;
     exit(1);
   }
 #endif//CPPL_DEBUG
   
   if(kl>=mat.kl && ku>=mat.ku){
     for(CPPL_INT i=0; i<m; i++){
       const CPPL_INT jmax =std::min(n,i+mat.ku+1);
       for(CPPL_INT j=std::max(CPPL_INT(0),i-mat.kl); j<jmax; j++){
         operator()(i,j) -= mat(i,j);
       }
     }
     
     mat.destroy();
     return *this;
   }
   else{
     zgbmatrix newmat(m,n,std::max(kl,mat.kl),std::max(ku,mat.ku));
     newmat.zero();
     for(CPPL_INT i=0; i<m; i++){
       const CPPL_INT jmax1 =std::min(n,i+ku+1);
       for(CPPL_INT j=std::max(CPPL_INT(0),i-kl); j<jmax1; j++){
         newmat(i,j) += operator()(i,j);
       }
       const CPPL_INT jmax2 =std::min(mat.n,i+mat.ku+1);
       for(CPPL_INT j=std::max(CPPL_INT(0),i-mat.kl); j<jmax2; j++){
         newmat(i,j) -= mat(i,j);
       }
     }
     
     swap(*this,newmat);
     mat.destroy();
     return *this;
   }
 }

zgbmatrix & zgbmatrix::operator*= ( const zgbmatrix & mat )

inline

zgbmatrix*=zgbmatrix operator

Definition at line 106 of file zgbmatrix-zgbmatrix.hpp.

References i, kl, ku, m, n, operator()(), swap, and zero().

 {CPPL_VERBOSE_REPORT;
 #ifdef  CPPL_DEBUG
   if(n!=mat.m){
     ERROR_REPORT;
     std::cerr << "These two matrises can not make a product." << std::endl
               << "Your input was (" << m << "x" << n << ") * (" << mat.m << "x" << mat.n << ")." << std::endl;
     exit(1);
   }
 #endif//CPPL_DEBUG
   
   zgbmatrix newmat( m, mat.n, std::min(kl+mat.kl, m-1), std::min(ku+mat.ku, mat.n-1) );
   newmat.zero();
   
   for(CPPL_INT i=0; i<newmat.m; i++){
     const CPPL_INT jmax =std::min(newmat.n,i+newmat.ku+1);
     for(CPPL_INT j=std::max(CPPL_INT(0),i-newmat.kl); j<jmax; j++){
       const CPPL_INT kmax =std::min( std::min(n,i+ku+1), std::min(mat.m,j+mat.kl+1) );
       for(CPPL_INT k=std::max( std::max(CPPL_INT(0),i-kl), std::max(CPPL_INT(0),j-mat.ku) ); k<kmax; k++){
         newmat(i,j)+= operator()(i,k)*mat(k,j);
       }
     }
   }
   
   swap(*this,newmat);
   return *this;
 }

zgbmatrix & zgbmatrix::operator*= ( const _zgbmatrix & mat )

inline

zgbmatrix*=_zgbmatrix operator

Definition at line 105 of file zgbmatrix-_zgbmatrix.hpp.

References _zgbmatrix::destroy(), i, kl, _zgbmatrix::kl, _zgbmatrix::ku, ku, _zgbmatrix::m, m, _zgbmatrix::n, n, operator()(), swap, and zero().

 {CPPL_VERBOSE_REPORT;
 #ifdef  CPPL_DEBUG
   if(n!=mat.m){
     ERROR_REPORT;
     std::cerr << "These two matrises can not make a product." << std::endl
               << "Your input was (" << m << "x" << n << ") * (" << mat.m << "x" << mat.n << ")." << std::endl;
     exit(1);
   }
 #endif//CPPL_DEBUG
   
   zgbmatrix newmat( m, mat.n, std::min(kl+mat.kl, m-1), std::min(ku+mat.ku, mat.n-1) );
   newmat.zero();
   
   for(CPPL_INT i=0; i<newmat.m; i++){
     const CPPL_INT jmax =std::min(newmat.n,i+newmat.ku+1);
     for(CPPL_INT j=std::max(CPPL_INT(0),i-newmat.kl); j<jmax; j++){
       const CPPL_INT kmax =std::min( std::min(n,i+ku+1), std::min(mat.m,j+mat.kl+1) );
       for(CPPL_INT k=std::max( std::max(CPPL_INT(0),i-kl), std::max(CPPL_INT(0),j-mat.ku) ); k<kmax; k++){
         newmat(i,j) += operator()(i,k)*mat(k,j);
       }
     }
   }
   
   swap(*this,newmat);
   mat.destroy();
   return *this;
 }

zgbmatrix & zgbmatrix::operator*= ( const double & d )

inline

zgbmatrix*=double operator

Definition at line 3 of file zgbmatrix-double.hpp.

References array, kl, ku, and n.

 {CPPL_VERBOSE_REPORT;
   CPPL_INT size =(kl+ku+1)*n;
   CPPL_INT inc =1;
   zdscal_(&size, &d, array, &inc);
   return *this;
 }

zgbmatrix & zgbmatrix::operator*= ( const comple & d )

inline

zgbmatrix*=comple operator

Definition at line 3 of file zgbmatrix-complex.hpp.

References array, kl, ku, and n.

 {CPPL_VERBOSE_REPORT;
   CPPL_INT size =(kl+ku+1)*n;
   CPPL_INT inc =1;
   zscal_(&size, &d, array, &inc);
   return *this;
 }

zgbmatrix & zgbmatrix::operator/= ( const double & d )

inline

zgbmatrix/=double operator

Definition at line 13 of file zgbmatrix-double.hpp.

References array, kl, ku, and n.

 {CPPL_VERBOSE_REPORT;
   CPPL_INT size =(kl+ku+1)*n;
   double dinv =1./d;
   CPPL_INT inc =1;
   zdscal_(&size, &dinv, array, &inc);
   return *this;
 }

zgbmatrix & zgbmatrix::operator/= ( const comple & d )

inline

zgbmatrix/=comple operator

Definition at line 13 of file zgbmatrix-complex.hpp.

References array, kl, ku, and n.

 {CPPL_VERBOSE_REPORT;
   CPPL_INT size =(kl+ku+1)*n;
   comple dinv =1./d;
   CPPL_INT inc =1;
   zscal_(&size, &dinv, array, &inc);
   return *this;
 }

Friends And Related Function Documentation

std::ostream& operator<<	(	std::ostream &	s,
		const zgbmatrix &	mat
	)

friend

Definition at line 63 of file zgbmatrix-io.hpp.

 {CPPL_VERBOSE_REPORT;
   for(CPPL_INT i=0; i<mat.m; i++){
     for(CPPL_INT j=0; j<mat.n; j++){
       if( i-j>mat.kl || j-i>mat.ku ){ s << " x"; }
       else{ s << " " << mat(i,j); }
     }
     s << std::endl;
   }
   
   return s;
 }

void swap	(	zgbmatrix &	A,
		zgbmatrix &	B
	)

friend

swap two matrices

Definition at line 182 of file zgbmatrix-misc.hpp.

Referenced by operator*=(), operator+=(), operator-=(), and zgbsv().

 {CPPL_VERBOSE_REPORT;
   CPPL_INT A_m =A.m, A_n =A.n, A_kl =A.kl, A_ku =A.ku;
   comple* A_array =A.array;
   comple** A_darray =A.darray;
   
   A.m=B.m; A.n=B.n; A.kl=B.kl; A.ku=B.ku; A.array=B.array; A.darray=B.darray;
   B.m=A_m; B.n=A_n; B.kl=A_kl; B.ku=A_ku; B.array=A_array; B.darray=A_darray;
 }

_zgbmatrix _ ( zgbmatrix & mat )

friend

convert user object to smart-temporary object

Definition at line 194 of file zgbmatrix-misc.hpp.

Referenced by col(), row(), and to_zgematrix().

 {CPPL_VERBOSE_REPORT;
   _zgbmatrix newmat;
   
   //////// shallow copy ////////
   newmat.m =mat.m;
   newmat.n =mat.n;
   newmat.kl =mat.kl;
   newmat.ku =mat.ku;
   newmat.array =mat.array;
   newmat.darray =mat.darray;
   
   //////// nullify ////////
   mat.m =0;
   mat.n =0;
   mat.kl =0;
   mat.ku =0;
   mat.array =NULL;
   mat.darray =NULL;
   
   return newmat;
 }

_zgbmatrix t ( const zgbmatrix & mat )

friend

return transposed zgbmatrix

Definition at line 3 of file zgbmatrix-calc.hpp.

 {CPPL_VERBOSE_REPORT;
   zgbmatrix newmat(mat.n, mat.m, mat.ku, mat.kl);
   
   for(CPPL_INT i=0; i<newmat.m; i++){
     const CPPL_INT jmax =std::min(newmat.n,i+newmat.ku+1);
     for(CPPL_INT j=std::max(CPPL_INT(0),i-newmat.kl); j<jmax; j++){
       newmat(i,j) =mat(j,i);
     }
   }
   
   return _(newmat);
 }

_zgematrix i ( const zgbmatrix & mat )

friend

return its inverse matrix

Definition at line 19 of file zgbmatrix-calc.hpp.

Referenced by chsign(), col(), copy(), identity(), operator()(), operator*=(), operator+=(), operator-=(), read(), resize(), set(), to_zgematrix(), write(), zero(), zgbmatrix(), and zgbsv().

 {CPPL_VERBOSE_REPORT;
 #ifdef  CPPL_DEBUG
   if(mat.m!=mat.n){
     ERROR_REPORT;
     std::cerr << "This matrix is not square and has no inverse matrix." << std::endl
               << "Your input was (" << mat.m << "x" << mat.n << ")." << std::endl;
     exit(1);
   }
 #endif//CPPL_DEBUG
   
   zgbmatrix mat_cp(mat);
   zgematrix mat_inv(mat.m,mat.n);
   mat_inv.identity();
   mat_cp.zgbsv(mat_inv);
   
   return _(mat_inv);
 }

_zgbmatrix conj ( const zgbmatrix & mat )

friend

return its conjugate matrix

Definition at line 44 of file zgbmatrix-calc.hpp.

 {CPPL_VERBOSE_REPORT;
   zgbmatrix newmat(mat.m, mat.n, mat.kl, mat.ku);
   
   for(CPPL_INT i=0; i<mat.m; i++){
     const CPPL_INT jmax =std::min(mat.n,i+mat.ku+1);
     for(CPPL_INT j=std::max(CPPL_INT(0),i-mat.kl); j<jmax; j++){
       newmat(i,j) =std::conj(mat(i,j));
     }
   }
   
   return _(newmat);
 }

_zgbmatrix conjt ( const zgbmatrix & mat )

friend

return its conjugate transposed zgbmatrix

Definition at line 60 of file zgbmatrix-calc.hpp.

 {CPPL_VERBOSE_REPORT;
   zgbmatrix newmat(mat.n, mat.m, mat.ku, mat.kl);
   
   for(CPPL_INT i=0; i<newmat.m; i++){
     const CPPL_INT jmax =std::min(newmat.n,i+newmat.ku+1);
     for(CPPL_INT j=std::max(CPPL_INT(0),i-newmat.kl); j<jmax; j++){
       newmat(i,j) =std::conj(mat(j,i));
     }
   }
   
   return _(newmat);
 }

const zgbmatrix& operator+ ( const zgbmatrix & mat )

friend

+zgbmatrix operator

Definition at line 3 of file zgbmatrix-unary.hpp.

 {CPPL_VERBOSE_REPORT;
   return mat;
 }

_zgbmatrix operator- ( const zgbmatrix & mat )

friend

-zgbmatrix operator

Definition at line 10 of file zgbmatrix-unary.hpp.

 {CPPL_VERBOSE_REPORT;
   zgbmatrix newmat(mat.m,mat.n,mat.kl,mat.ku);
   for(CPPL_INT i=0; i<(newmat.kl+newmat.ku+1)*newmat.n; i++){
     newmat.array[i]=-mat.array[i];
   }
   
   return _(newmat);
 }

_zgematrix operator+	(	const zgbmatrix &	matA,
		const zgematrix &	matB
	)

friend

zgbmatrix+zgematrix operator

Definition at line 3 of file zgbmatrix-zgematrix.hpp.

 {CPPL_VERBOSE_REPORT;
 #ifdef  CPPL_DEBUG
   if(matA.n!=matB.n || matA.m!=matB.m){
     ERROR_REPORT;
     std::cerr << "These two matrises can not make a summation." << std::endl
               << "Your input was (" << matA.m << "x" << matA.n << ") + (" << matB.m << "x" << matB.n << ")." << std::endl;
     exit(1);
   }
 #endif//CPPL_DEBUG
 
   zgematrix newmat(matB);
   
   for(CPPL_INT i=0; i<matA.m; i++){
     const CPPL_INT jmax =std::min(matA.n,i+matA.ku+1);
     for(CPPL_INT j=std::max(CPPL_INT(0),i-matA.kl); j<jmax; j++){
       newmat(i,j)+=matA(i,j);
     }
   }
   
   return _(newmat);
 }

_zgematrix operator+	(	const zgbmatrix &	matA,
		const _zgematrix &	matB
	)

friend

zgbmatrix+_zgematrix operator

Definition at line 3 of file zgbmatrix-_zgematrix.hpp.

 {CPPL_VERBOSE_REPORT;
 #ifdef  CPPL_DEBUG
   if(matA.n!=matB.n || matA.m!=matB.m){
     ERROR_REPORT;
     std::cerr << "These two matrises can not make a summation." << std::endl
               << "Your input was (" << matA.m << "x" << matA.n << ") + (" << matB.m << "x" << matB.n << ")." << std::endl;
     exit(1);
   }
 #endif//CPPL_DEBUG
   
   for(CPPL_INT i=0; i<matA.m; i++){
     const CPPL_INT jmax =std::min(matA.n,i+matA.ku+1);
     for(CPPL_INT j=std::max(CPPL_INT(0),i-matA.kl); j<jmax; j++){
       matB(i,j)+=matA(i,j);
     }
   }
   
   return matB;
 }

_zgematrix operator+	(	const zgbmatrix &	matA,
		const zhematrix &	matB
	)

friend

zgbmatrix+zhematrix operator

Definition at line 3 of file zgbmatrix-zhematrix.hpp.

 {CPPL_VERBOSE_REPORT;
 #ifdef  CPPL_DEBUG
   if(matA.n!=matB.n || matA.m!=matB.n){
     ERROR_REPORT;
     std::cerr << "These two matrises can not make a summation." << std::endl
               << "Your input was (" << matA.m << "x" << matA.n << ") + (" << matB.n << "x" << matB.n << ")." << std::endl;
     exit(1);
   }
 #endif//CPPL_DEBUG
   
   zgematrix newmat(matB.n,matB.n);
   
   for(CPPL_INT i=0; i<matA.m; i++){
     for(CPPL_INT j=0; j<matB.n; j++){
       newmat(i,j) =matB(i,j);
     }
     const CPPL_INT jmax =std::min(matA.n,i+matA.ku+1);
     for(CPPL_INT j=std::max(CPPL_INT(0),i-matA.kl); j<jmax; j++){
       newmat(i,j) += matA(i,j);
     }
   }
   
   return _(newmat);
 }

_zgematrix operator+	(	const zgbmatrix &	matA,
		const _zhematrix &	matB
	)

friend

zgbmatrix+_zhematrix operator

Definition at line 3 of file zgbmatrix-_zhematrix.hpp.

 {CPPL_VERBOSE_REPORT;
 #ifdef  CPPL_DEBUG
   if(matA.n!=matB.n || matA.m!=matB.n){
     ERROR_REPORT;
     std::cerr << "These two matrises can not make a summation." << std::endl
               << "Your input was (" << matA.m << "x" << matA.n << ") + (" << matB.n << "x" << matB.n << ")." << std::endl;
     exit(1);
   }
 #endif//CPPL_DEBUG
   
   zgematrix newmat(matB.n,matB.n);
   
   for(CPPL_INT i=0; i<matA.m; i++){
     for(CPPL_INT j=0; j<matB.n; j++){
       newmat(i,j) =matB(i,j);
     }
     const CPPL_INT jmax =std::min(matA.n,i+matA.ku+1);
     for(CPPL_INT j=std::max(CPPL_INT(0),i-matA.kl); j<jmax; j++){
       newmat(i,j) += matA(i,j);
     }
   }
   
   matB.destroy();
   return _(newmat);
 }

_zgbmatrix operator+	(	const zgbmatrix &	matA,
		const zgbmatrix &	matB
	)

friend

zgbmatrix+zgbmatrix operator

Definition at line 140 of file zgbmatrix-zgbmatrix.hpp.

 {CPPL_VERBOSE_REPORT;
 #ifdef  CPPL_DEBUG
   if(matA.n!=matB.n || matA.m!=matB.m){
     ERROR_REPORT;
     std::cerr << "These two matrises can not make a summation." << std::endl
               << "Your input was (" << matA.m << "x" << matA.n << ") + (" << matB.m << "x" << matB.n << ")." << std::endl;
     exit(1);
   }
 #endif//CPPL_DEBUG
   
   zgbmatrix newmat(matA.m,matA.n,std::max(matA.kl,matB.kl),std::max(matA.ku,matB.ku));
   newmat.zero();
   
   for(CPPL_INT i=0; i<matA.m; i++){
     const CPPL_INT jmax1 =std::min(matA.n,i+matA.ku+1);
     for(CPPL_INT j=std::max(CPPL_INT(0),i-matA.kl); j<jmax1; j++){
       newmat(i,j) += matA(i,j);
     }
     const CPPL_INT jmax2 =std::min(matB.n,i+matB.ku+1);
     for(CPPL_INT j=std::max(CPPL_INT(0),i-matB.kl); j<jmax2; j++){
       newmat(i,j) += matB(i,j);
     }
   }
   
   return _(newmat);
 }

_zgbmatrix operator+	(	const zgbmatrix &	matA,
		const _zgbmatrix &	matB
	)

friend

zgbmatrix+_zgbmatrix operator

Definition at line 140 of file zgbmatrix-_zgbmatrix.hpp.

 {CPPL_VERBOSE_REPORT;
 #ifdef  CPPL_DEBUG
   if(matA.n!=matB.n || matA.m!=matB.m){
     ERROR_REPORT;
     std::cerr << "These two matrises can not make a summation." << std::endl
               << "Your input was (" << matA.m << "x" << matA.n << ") + (" << matB.m << "x" << matB.n << ")." << std::endl;
     exit(1);
   }
 #endif//CPPL_DEBUG
   
   if(matB.kl>matA.kl && matB.ku>matA.ku){
     for(CPPL_INT i=0; i<matA.m; i++){
       const CPPL_INT jmax =std::min(matA.n,i+matA.ku+1);
       for(CPPL_INT j=std::max(CPPL_INT(0),i-matA.kl); j<jmax; j++){
         matB(i,j) += matA(i,j);
       }
     }
     return matB;
   }
   
   else{
     zgbmatrix newmat(matA.m,matA.n,std::max(matA.kl,matB.kl),std::max(matA.ku,matB.ku));
     newmat.zero();
     
     for(CPPL_INT i=0; i<matA.m; i++){
       const CPPL_INT jmax1 =std::min(matA.n,i+matA.ku+1);
       for(CPPL_INT j=std::max(CPPL_INT(0),i-matA.kl); j<jmax1; j++){
         newmat(i,j) += matA(i,j);
       }
       const CPPL_INT jmax2 =std::min(matB.n,i+matB.ku+1);
       for(CPPL_INT j=std::max(CPPL_INT(0),i-matB.kl); j<jmax2; j++){
         newmat(i,j) += matB(i,j);
       }
     }
     
     matB.destroy();
     return _(newmat);
   }
 }

_zgematrix operator+	(	const zgbmatrix &	,
		const zgsmatrix &
	)

friend

_zgematrix operator+	(	const zgbmatrix &	,
		const _zgsmatrix &
	)

friend

_zgematrix operator+	(	const zgbmatrix &	,
		const zhsmatrix &
	)

friend

_zgematrix operator+	(	const zgbmatrix &	,
		const _zhsmatrix &
	)

friend

_zgematrix operator-	(	const zgbmatrix &	matA,
		const zgematrix &	matB
	)

friend

zgbmatrix-zgematrix operator

Definition at line 28 of file zgbmatrix-zgematrix.hpp.

 {CPPL_VERBOSE_REPORT;
 #ifdef  CPPL_DEBUG
   if(matA.n!=matB.n || matA.m!=matB.m){
     ERROR_REPORT;
     std::cerr << "These two matrises can not make a summation." << std::endl
               << "Your input was (" << matA.m << "x" << matA.n << ") + (" << matB.m << "x" << matB.n << ")." << std::endl;
     exit(1);
   }
 #endif//CPPL_DEBUG
   
   zgematrix newmat(-matB);
   
   for(CPPL_INT i=0; i<matA.m; i++){
     const CPPL_INT jmax =std::min(matA.n,i+matA.ku+1);
     for(CPPL_INT j=std::max(CPPL_INT(0),i-matA.kl); j<jmax; j++){
       newmat(i,j)+=matA(i,j);
     }
   }
   
   return _(newmat);
 }

_zgematrix operator-	(	const zgbmatrix &	matA,
		const _zgematrix &	matB
	)

friend

zgbmatrix-_zgematrix operator

Definition at line 26 of file zgbmatrix-_zgematrix.hpp.

 {CPPL_VERBOSE_REPORT;
 #ifdef  CPPL_DEBUG
   if(matA.n!=matB.n || matA.m!=matB.m){
     ERROR_REPORT;
     std::cerr << "These two matrises can not make a summation." << std::endl
               << "Your input was (" << matA.m << "x" << matA.n << ") + (" << matB.m << "x" << matB.n << ")." << std::endl;
     exit(1);
   }
 #endif//CPPL_DEBUG
   
   //// change sign ////
   for(CPPL_INT i=0; i<matB.m*matB.n; i++){
     matB.array[i] = -matB.array[i];
   }
   
   //// add ////
   for(CPPL_INT i=0; i<matA.m; i++){
     const CPPL_INT jmax =std::min(matA.n,i+matA.ku+1);
     for(CPPL_INT j=std::max(CPPL_INT(0),i-matA.kl); j<jmax; j++){
       matB(i,j) +=matA(i,j);
     }
   }
   
   return matB;
 }

_zgematrix operator-	(	const zgbmatrix &	matA,
		const zhematrix &	matB
	)

friend

zgbmatrix-zhematrix operator

Definition at line 31 of file zgbmatrix-zhematrix.hpp.

 {CPPL_VERBOSE_REPORT;
 #ifdef  CPPL_DEBUG
   if(matA.n!=matB.n || matA.m!=matB.n){
     ERROR_REPORT;
     std::cerr << "These two matrises can not make a summation." << std::endl
               << "Your input was (" << matA.m << "x" << matA.n << ") + (" << matB.n << "x" << matB.n << ")." << std::endl;
     exit(1);
   }
 #endif//CPPL_DEBUG
   
   zgematrix newmat(matB.n,matB.n);
   for(CPPL_INT i=0; i<matA.m; i++){
     for(CPPL_INT j=0; j<matB.n; j++){
       newmat(i,j) =-matB(i,j);
     }
     const CPPL_INT jmax =std::min(matA.n,i+matA.ku+1);
     for(CPPL_INT j=std::max(CPPL_INT(0),i-matA.kl); j<jmax; j++){
       newmat(i,j) += matA(i,j);
     }
   }
   
   return _(newmat);
 }

_zgematrix operator-	(	const zgbmatrix &	matA,
		const _zhematrix &	matB
	)

friend

zgbmatrix-_zhematrix operator

Definition at line 32 of file zgbmatrix-_zhematrix.hpp.

 {CPPL_VERBOSE_REPORT;
 #ifdef  CPPL_DEBUG
   if(matA.n!=matB.n || matA.m!=matB.n){
     ERROR_REPORT;
     std::cerr << "These two matrises can not make a summation." << std::endl
               << "Your input was (" << matA.m << "x" << matA.n << ") + (" << matB.n << "x" << matB.n << ")." << std::endl;
     exit(1);
   }
 #endif//CPPL_DEBUG
   
   zgematrix newmat(matB.n,matB.n);
   
   for(CPPL_INT i=0; i<matA.m; i++){
     for(CPPL_INT j=0; j<matB.n; j++){
       newmat(i,j) =-matB(i,j);
     }
     const CPPL_INT jmax =std::min(matA.n,i+matA.ku+1);
     for(CPPL_INT j=std::max(CPPL_INT(0),i-matA.kl); j<jmax; j++){
       newmat(i,j) +=matA(i,j);
     }
   }
   
   matB.destroy();
   return _(newmat);
 }

_zgbmatrix operator-	(	const zgbmatrix &	matA,
		const zgbmatrix &	matB
	)

friend

zgbmatrix-zgbmatrix operator

Definition at line 170 of file zgbmatrix-zgbmatrix.hpp.

 {CPPL_VERBOSE_REPORT;
 #ifdef  CPPL_DEBUG
   if(matA.n!=matB.n || matA.m!=matB.m){
     ERROR_REPORT;
     std::cerr << "These two matrises can not make a subtraction." << std::endl
               << "Your input was (" << matA.m << "x" << matA.n << ") - (" << matB.m << "x" << matB.n << ")." << std::endl;
     exit(1);
   }
 #endif//CPPL_DEBUG
   
   zgbmatrix newmat(matA.m,matA.n,std::max(matA.kl,matB.kl),std::max(matA.ku,matB.ku));
   newmat.zero();
   
   for(CPPL_INT i=0; i<matA.m; i++){
     const CPPL_INT jmax1 =std::min(matA.n,i+matA.ku+1);
     for(CPPL_INT j=std::max(CPPL_INT(0),i-matA.kl); j<jmax1; j++){
       newmat(i,j) += matA(i,j);
     }
     const CPPL_INT jmax2 =std::min(matB.n,i+matB.ku+1);
     for(CPPL_INT j=std::max(CPPL_INT(0),i-matB.kl); j<jmax2; j++){
       newmat(i,j) -= matB(i,j);
     }
   }
   
   return _(newmat);
 }

_zgbmatrix operator-	(	const zgbmatrix &	matA,
		const _zgbmatrix &	matB
	)

friend

zgbmatrix-_zgbmatrix operator

Definition at line 183 of file zgbmatrix-_zgbmatrix.hpp.

 {CPPL_VERBOSE_REPORT;
 #ifdef  CPPL_DEBUG
   if(matA.n!=matB.n || matA.m!=matB.m){
     ERROR_REPORT;
     std::cerr << "These two matrises can not make a subtraction." << std::endl
               << "Your input was (" << matA.m << "x" << matA.n << ") - (" << matB.m << "x" << matB.n << ")." << std::endl;
     exit(1);
   }
 #endif//CPPL_DEBUG
   
   zgbmatrix newmat(matA.m,matA.n,std::max(matA.kl,matB.kl),std::max(matA.ku,matB.ku));
   newmat.zero();
   
   for(CPPL_INT i=0; i<matA.m; i++){
     const CPPL_INT jmax1 =std::min(matA.n,i+matA.ku+1);
     for(CPPL_INT j=std::max(CPPL_INT(0),i-matA.kl); j<jmax1; j++){
       newmat(i,j) += matA(i,j);
     }
     const CPPL_INT jmax2 =std::min(matB.n,i+matB.ku+1);
     for(CPPL_INT j=std::max(CPPL_INT(0),i-matB.kl); j<jmax2; j++){
       newmat(i,j) -= matB(i,j);
     }
   }
   
   matB.destroy();
   return _(newmat);
 }

_zgematrix operator-	(	const zgbmatrix &	,
		const zgsmatrix &
	)

friend

_zgematrix operator-	(	const zgbmatrix &	,
		const _zgsmatrix &
	)

friend

_zgematrix operator-	(	const zgbmatrix &	,
		const zhsmatrix &
	)

friend

_zgematrix operator-	(	const zgbmatrix &	,
		const _zhsmatrix &
	)

friend

_zcovector operator*	(	const zgbmatrix &	mat,
		const zcovector &	vec
	)

friend

zgbmatrix*zcovector operator

Definition at line 3 of file zgbmatrix-zcovector.hpp.

 {CPPL_VERBOSE_REPORT;
 #ifdef  CPPL_DEBUG
   if(mat.n!=vec.l){
     ERROR_REPORT;
     std::cerr << "These matrix and vector can not make a product." << std::endl
               << "Your input was (" << mat.m << "x" << mat.n << ") * (" << vec.l << ")." << std::endl;
     exit(1);
   }
 #endif//CPPL_DEBUG
   
   zcovector newvec(mat.m);
   char trans ='n';
   comple alpha =comple(1.,0.);
   CPPL_INT lda =mat.kl+mat.ku+1;
   CPPL_INT inc =1;
   comple beta =comple(0.,0.);
   
   zgbmv_( &trans, &mat.m, &mat.n, &mat.kl, &mat.ku, &alpha, mat.array, &lda, vec.array, &inc, &beta, newvec.array, &inc );
   
   return _(newvec);
 }

_zcovector operator*	(	const zgbmatrix &	mat,
		const _zcovector &	vec
	)

friend

zgbmatrix*_zcovector operator

Definition at line 3 of file zgbmatrix-_zcovector.hpp.

 {CPPL_VERBOSE_REPORT;
 #ifdef  CPPL_DEBUG
   if(mat.n!=vec.l){
     ERROR_REPORT;
     std::cerr << "These matrix and vector can not make a product." << std::endl
               << "Your input was (" << mat.m << "x" << mat.n << ") * (" << vec.l << ")." << std::endl;
     exit(1);
   }
 #endif//CPPL_DEBUG
   
   zcovector newvec(mat.m);
   char trans ='n';
   comple alpha =comple(1.,0.);
   CPPL_INT lda =mat.kl+mat.ku+1;
   CPPL_INT inc =1;
   comple beta =comple(0.,0.);
   
   zgbmv_( &trans, &mat.m, &mat.n, &mat.kl, &mat.ku, &alpha, mat.array, &lda, vec.array, &inc, &beta, newvec.array, &inc );
   
   vec.destroy();
   return _(newvec);
 }

_zgematrix operator*	(	const zgbmatrix &	matA,
		const zgematrix &	matB
	)

friend

zgbmatrix*zgematrix operator

Definition at line 53 of file zgbmatrix-zgematrix.hpp.

 {CPPL_VERBOSE_REPORT;
 #ifdef  CPPL_DEBUG
   if(matA.n!=matB.m){
     ERROR_REPORT;
     std::cerr << "These two matrises can not make a product." << std::endl
               << "Your input was (" << matA.m << "x" << matA.n << ") * (" << matB.m << "x" << matB.n << ")." << std::endl;
     exit(1);
   }
 #endif//CPPL_DEBUG
   
   zgematrix newmat( matA.m, matB.n );
   newmat.zero();
   
   for(CPPL_INT i=0; i<newmat.m; i++){
     for(CPPL_INT j=0; j<newmat.n; j++){
       const CPPL_INT kmax =std::min(matA.n,i+matA.ku+1);
       for(CPPL_INT k=std::max(CPPL_INT(0),i-matA.kl); k<kmax; k++){
         newmat(i,j)+=matA(i,k)*matB(k,j);
       }
     }
   }
   
   return _(newmat);
 }

_zgematrix operator*	(	const zgbmatrix &	matA,
		const _zgematrix &	matB
	)

friend

zgbmatrix*_zgematrix operator

Definition at line 55 of file zgbmatrix-_zgematrix.hpp.

 {CPPL_VERBOSE_REPORT;
 #ifdef  CPPL_DEBUG
   if(matA.n!=matB.m){
     ERROR_REPORT;
     std::cerr << "These two matrises can not make a product." << std::endl
               << "Your input was (" << matA.m << "x" << matA.n << ") * (" << matB.m << "x" << matB.n << ")." << std::endl;
     exit(1);
   }
 #endif//CPPL_DEBUG
   
   zgematrix newmat( matA.m, matB.n );
   newmat.zero();
   
   for(CPPL_INT i=0; i<newmat.m; i++){
     for(CPPL_INT j=0; j<newmat.n; j++){
       const CPPL_INT kmax =std::min(matA.n,i+matA.ku+1);
       for(CPPL_INT k=std::max(CPPL_INT(0),i-matA.kl); k<kmax; k++){
         newmat(i,j)+=matA(i,k)*matB(k,j);
       }
     }
   }
   
   matB.destroy();
   return _(newmat);
 }

_zgematrix operator*	(	const zgbmatrix &	matA,
		const zhematrix &	matB
	)

friend

zgbmatrix*zhematrix operator

Definition at line 58 of file zgbmatrix-zhematrix.hpp.

 {CPPL_VERBOSE_REPORT;
 #ifdef  CPPL_DEBUG
   if(matA.n!=matB.n){
     ERROR_REPORT;
     std::cerr << "These two matrises can not make a product." << std::endl
               << "Your input was (" << matA.m << "x" << matA.n << ") * (" << matB.n << "x" << matB.n << ")." << std::endl;
     exit(1);
   }
 #endif//CPPL_DEBUG
   
   zgematrix newmat( matA.m, matB.n );
   newmat.zero();
   
   for(CPPL_INT i=0; i<newmat.m; i++){
     for(CPPL_INT j=0; j<newmat.n; j++){
       const CPPL_INT kmax =std::min(matA.n,i+matA.ku+1);
       for(CPPL_INT k=std::max(CPPL_INT(0),i-matA.kl); k<kmax; k++){
         newmat(i,j)+=matA(i,k)*matB(k,j);
       }
     }
   }
   
   return _(newmat);
 }

_zgematrix operator*	(	const zgbmatrix &	matA,
		const _zhematrix &	matB
	)

friend

zgbmatrix*_zhematrix operator

Definition at line 61 of file zgbmatrix-_zhematrix.hpp.

 {CPPL_VERBOSE_REPORT;
 #ifdef  CPPL_DEBUG
   if(matA.n!=matB.n){
     ERROR_REPORT;
     std::cerr << "These two matrises can not make a product." << std::endl
               << "Your input was (" << matA.m << "x" << matA.n << ") * (" << matB.n << "x" << matB.n << ")." << std::endl;
     exit(1);
   }
 #endif//CPPL_DEBUG
   
   zgematrix newmat( matA.m, matB.n );
   newmat.zero();
   
   for(CPPL_INT i=0; i<newmat.m; i++){
     for(CPPL_INT j=0; j<newmat.n; j++){
       const CPPL_INT kmax =std::min(matA.n,i+matA.ku+1);
       for(CPPL_INT k=std::max(CPPL_INT(0),i-matA.kl); k<kmax; k++){
         newmat(i,j)+=matA(i,k)*matB(k,j);
       }
     }
   }
   
   matB.destroy();
   return _(newmat);
 }

_zgbmatrix operator*	(	const zgbmatrix &	matA,
		const zgbmatrix &	matB
	)

friend

zgbmatrix*zgbmatrix operator

Definition at line 200 of file zgbmatrix-zgbmatrix.hpp.

 {CPPL_VERBOSE_REPORT;
 #ifdef  CPPL_DEBUG
   if(matA.n!=matB.m){
     ERROR_REPORT;
     std::cerr << "These two matrises can not make a product." << std::endl
               << "Your input was (" << matA.m << "x" << matA.n << ") * (" << matB.m << "x" << matB.n << ")." << std::endl;
     exit(1);
   }
 #endif//CPPL_DEBUG
   
   zgbmatrix newmat( matA.m, matB.n, std::min(matA.kl+matB.kl,matA.m-1), std::min(matA.ku+matB.ku,matB.n-1) );
   newmat.zero();
   
   for(CPPL_INT i=0; i<newmat.m; i++){
     const CPPL_INT jmax =std::min(newmat.n,i+newmat.ku+1);
     for(CPPL_INT j=std::max(CPPL_INT(0),i-newmat.kl); j<jmax; j++){
       const CPPL_INT kmax =std::min( std::min(matA.n,i+matA.ku+1), std::min(matB.m,j+matB.kl+1) );
       for(CPPL_INT k=std::max( std::max(CPPL_INT(0),i-matA.kl), std::max(CPPL_INT(0),j-matB.ku) ); k<kmax; k++){
         newmat(i,j) += matA(i,k)*matB(k,j);
       }
     }
   }
   
   return _(newmat);
 }

_zgbmatrix operator*	(	const zgbmatrix &	matA,
		const _zgbmatrix &	matB
	)

friend

zgbmatrix*_zgbmatrix operator

Definition at line 214 of file zgbmatrix-_zgbmatrix.hpp.

 {CPPL_VERBOSE_REPORT;
 #ifdef  CPPL_DEBUG
   if(matA.n!=matB.m){
     ERROR_REPORT;
     std::cerr << "These two matrises can not make a product." << std::endl
               << "Your input was (" << matA.m << "x" << matA.n << ") * (" << matB.m << "x" << matB.n << ")." << std::endl;
     exit(1);
   }
 #endif//CPPL_DEBUG
   
   zgbmatrix newmat( matA.m, matB.n, std::min(matA.kl+matB.kl,matA.m-1), std::min(matA.ku+matB.ku,matB.n-1) );
   newmat.zero();
   
   for(CPPL_INT i=0; i<newmat.m; i++){
     const CPPL_INT jmax =std::min(newmat.n,i+newmat.ku+1);
     for(CPPL_INT j=std::max(CPPL_INT(0),i-newmat.kl); j<jmax; j++){
       const CPPL_INT kmax =std::min( std::min(matA.n,i+matA.ku+1), std::min(matB.m,j+matB.kl+1) );
       for(CPPL_INT k=std::max( std::max(CPPL_INT(0),i-matA.kl), std::max(CPPL_INT(0),j-matB.ku) ); k<kmax; k++){
         newmat(i,j) += matA(i,k)*matB(k,j);
       }
     }
   }
   
   matB.destroy();
   return _(newmat);
 }

_zgematrix operator*	(	const zgbmatrix &	,
		const zgsmatrix &
	)

friend

_zgematrix operator*	(	const zgbmatrix &	,
		const _zgsmatrix &
	)

friend

_zgematrix operator*	(	const zgbmatrix &	,
		const zhsmatrix &
	)

friend

_zgematrix operator*	(	const zgbmatrix &	,
		const _zhsmatrix &
	)

friend

_zgbmatrix operator*	(	const zgbmatrix &	mat,
		const double &	d
	)

friend

zgbmatrix*double operator

Definition at line 28 of file zgbmatrix-double.hpp.

 {CPPL_VERBOSE_REPORT;
   zgbmatrix newmat(mat.m, mat.n, mat.kl, mat.ku);
   
   const CPPL_INT size =(newmat.kl+newmat.ku+1)*newmat.n;
   for(CPPL_INT i=0; i<size; i++){
     newmat.array[i] =mat.array[i]*d;
   }
   
   return _(newmat);
 }

_zgbmatrix operator*	(	const zgbmatrix &	mat,
		const comple &	d
	)

friend

zgbmatrix*comple operator

Definition at line 28 of file zgbmatrix-complex.hpp.

 {CPPL_VERBOSE_REPORT;
   zgbmatrix newmat(mat.m, mat.n, mat.kl, mat.ku);
   
   const CPPL_INT size =(newmat.kl+newmat.ku+1)*newmat.n;
   for(CPPL_INT i=0; i<size; i++){
     newmat.array[i] =mat.array[i]*d;
   }
   
   return _(newmat);
 }

_zgbmatrix operator/	(	const zgbmatrix &	mat,
		const double &	d
	)

friend

zgbmatrix/double operator

Definition at line 42 of file zgbmatrix-double.hpp.

 {CPPL_VERBOSE_REPORT;
   zgbmatrix newmat(mat.m, mat.n, mat.kl, mat.ku);
   
   const CPPL_INT size =(newmat.kl+newmat.ku+1)*newmat.n;
   for(CPPL_INT i=0; i<size; i++){
     newmat.array[i] =mat.array[i]/d;
   }
   
   return _(newmat);
 }

_zgbmatrix operator/	(	const zgbmatrix &	mat,
		const comple &	d
	)

friend

zgbmatrix/comple operator

Definition at line 42 of file zgbmatrix-complex.hpp.

 {CPPL_VERBOSE_REPORT;
   zgbmatrix newmat(mat.m, mat.n, mat.kl, mat.ku);
   
   const CPPL_INT size =(newmat.kl+newmat.ku+1)*newmat.n;
   for(CPPL_INT i=0; i<size; i++){
     newmat.array[i] =mat.array[i]/d;
   }
   
   return _(newmat);
 }

_zgbmatrix operator*	(	const double &	d,
		const zgbmatrix &	mat
	)

friend

double*zgbmatrix operator

Definition at line 3 of file double-zgbmatrix.hpp.

 {CPPL_VERBOSE_REPORT;
   zgbmatrix newmat(mat.m, mat.n, mat.kl, mat.ku);
   
   const CPPL_INT size =(mat.kl+mat.ku+1)*mat.n;
   for(CPPL_INT i=0; i<size; i++){
     newmat.array[i] =d*mat.array[i];
   }
   
   return _(newmat);
 }

_zgbmatrix operator*	(	const comple &	d,
		const zgbmatrix &	mat
	)

friend

comple*zgbmatrix operator

Definition at line 3 of file complex-zgbmatrix.hpp.

 {CPPL_VERBOSE_REPORT;
   zgbmatrix newmat(mat.m, mat.n, mat.kl, mat.ku);
   
   const CPPL_INT size =(newmat.kl+newmat.ku+1)*newmat.n;
   for(CPPL_INT i=0; i<size; i++){
     newmat.array[i] =d*mat.array[i];
   }
   
   return _(newmat);
 }