(DO NOT USE) Smart-temporary Real Double-precision General Sparse Matrix Class More...

#include <_zgsmatrix.hpp>

Public Member Functions
	_zgsmatrix ()

	_zgsmatrix (const _zgsmatrix &)

	~_zgsmatrix ()

_zgematrix	to_zgematrix () const

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

void	write (const char *) const

void	nullify () const

void	destroy () const

Public Attributes
CPPL_INT	m
	matrix row size More...

CPPL_INT	n
	matrix column size More...

std::vector< zcomponent >	data
	matrix data More...

std::vector< std::vector < CPPL_INT > >	rows
	array of vector to store the entry information of component for each row More...

std::vector< std::vector < CPPL_INT > >	cols
	array of vector to store the entry information of component for each column More...

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

_zgsmatrix	t (const zgsmatrix &)

void	idamax (CPPL_INT &, CPPL_INT &, const zgsmatrix &)

comple	damax (const zgsmatrix &)

const _zgsmatrix &	operator+ (const _zgsmatrix &)

_zgsmatrix	operator- (const _zgsmatrix &)

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

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

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

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

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

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

_zgsmatrix	operator+ (const _zgsmatrix &, const zgsmatrix &)

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

_zgsmatrix	operator+ (const _zgsmatrix &, const zhsmatrix &)

_zgsmatrix	operator+ (const _zgsmatrix &, const _zhsmatrix &)

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

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

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

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

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

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

_zgsmatrix	operator- (const _zgsmatrix &, const zgsmatrix &)

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

_zgsmatrix	operator- (const _zgsmatrix &, const zhsmatrix &)

_zgsmatrix	operator- (const _zgsmatrix &, const _zhsmatrix &)

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

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

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

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

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

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

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

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

_zgsmatrix	operator* (const _zgsmatrix &, const zgsmatrix &)

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

_zgsmatrix	operator* (const _zgsmatrix &, const zhsmatrix &)

_zgsmatrix	operator* (const _zgsmatrix &, const _zhsmatrix &)

_zgsmatrix	operator* (const _zgsmatrix &, const double &)

_zgsmatrix	operator* (const _zgsmatrix &, const comple &)

_zgsmatrix	operator/ (const _zgsmatrix &, const double &)

_zgsmatrix	operator/ (const _zgsmatrix &, const comple &)

_zgsmatrix	operator* (const double &, const _zgsmatrix &)

_zgsmatrix	operator* (const comple &, const _zgsmatrix &)

Detailed Description

(DO NOT USE) Smart-temporary Real Double-precision General Sparse Matrix Class

Definition at line 3 of file _zgsmatrix.hpp.

Constructor & Destructor Documentation

_zgsmatrix::_zgsmatrix ( )

inline

_zgsmatrix constructor without arguments

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

References cols, data, m, n, and rows.

 {CPPL_VERBOSE_REPORT;
   //////// initialize ////////
   m =0;
   n =0;
   data.clear();
   rows.clear();
   cols.clear();
 }

_zgsmatrix::_zgsmatrix ( const _zgsmatrix & mat )

inline

_zgsmatrix copy constructor

Definition at line 15 of file _zgsmatrix-constructor.hpp.

References cols, data, m, n, nullify(), and rows.

 {CPPL_VERBOSE_REPORT;
   //////// initialize ////////
   m =mat.m;
   n =mat.n;
   data.swap(mat.data);
   rows.swap(mat.rows);
   cols.swap(mat.cols);
   
   mat.nullify();
 }

_zgsmatrix::~_zgsmatrix ( )

inline

_zgsmatrix destructor

Definition at line 33 of file _zgsmatrix-constructor.hpp.

References cols, data, and rows.

 {CPPL_VERBOSE_REPORT;
   data.clear();
   rows.clear();
   cols.clear();
 }

Member Function Documentation

_zgematrix _zgsmatrix::to_zgematrix ( ) const

inline

convert to _zgematrix

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

References _(), data, destroy(), m, n, and zgematrix::zero().

Referenced by operator+(), and operator-().

 {CPPL_VERBOSE_REPORT;
   zgematrix newmat(m,n);
   newmat.zero();
   
   const std::vector<zcomponent>::const_iterator data_end =data.end();
   for(std::vector<zcomponent>::const_iterator it=data.begin(); it!=data_end; it++){
     newmat(it->i,it->j) = it->v;
   }
   
   destroy();
   return _(newmat);
 }

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

inline

operator() for const object

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

References data, i(), m, n, and rows.

 {CPPL_VERBOSE_REPORT;
 #ifdef  CPPL_DEBUG
   if( i<0 || j<0 || m<=i || n<=j ){
     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 << "." << std::endl;
     exit(1);
   }
 #endif//CPPL_DEBUG
   
   //////// search (i,j) component ////////
   const std::vector<CPPL_INT>::iterator rows_i_end =rows[i].end();
   for(std::vector<CPPL_INT>::iterator p=rows[i].begin(); p!=rows_i_end; p++){
     if( data[*p].j==j ){ return data[*p].v; }
   }
   
   //////// (i,j) component was not found ////////
   return comple(0.0,0.0);
 }

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

inline

Definition at line 53 of file _zgsmatrix-io.hpp.

References data, destroy(), m, and n.

 {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 << "#zgsmatrix " << m << " " << n << " " << data.size() << std::endl;
   
   const std::vector<zcomponent>::const_iterator data_end =data.end();
   for(std::vector<zcomponent>::const_iterator it=data.begin(); it!=data_end; it++){
     ofs << it->i << " " << it->j << " " << it->v << std::endl;
   }
   
   ofs.close();
   destroy();
 }

void _zgsmatrix::nullify ( ) const

inline

nullify all the matrix data

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

References cols, data, m, n, and rows.

Referenced by _zgsmatrix(), zgsmatrix::shallow_copy(), and zgsmatrix::zgsmatrix().

 {CPPL_VERBOSE_REPORT;
   m=0;
   n=0;
   data.clear();
   rows.clear();
   cols.clear();
 }

void _zgsmatrix::destroy ( ) const

inline

destroy all the matrix data

Definition at line 14 of file _zgsmatrix-misc.hpp.

References cols, data, and rows.

Referenced by damax(), idamax(), operator*(), zgsmatrix::operator*=(), operator+(), zgsmatrix::operator+=(), operator-(), zgsmatrix::operator-=(), operator<<(), to_zgematrix(), and write().

 {CPPL_VERBOSE_REPORT;
   data.clear();
   rows.clear();
   cols.clear();
 }

Friends And Related Function Documentation

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

friend

Definition at line 29 of file _zgsmatrix-io.hpp.

 {CPPL_VERBOSE_REPORT;
   for(CPPL_INT i=0; i<mat.m; i++){
     for(CPPL_INT j=0; j<mat.n; j++){
       std::vector<CPPL_INT>::iterator q;
       const std::vector<CPPL_INT>::iterator mat_rows_i_end =mat.rows[i].end();
       for(q=mat.rows[i].begin(); q!=mat_rows_i_end; q++){
         if( mat.data[*q].j==j ){ break; }
       }
       if(q!=mat_rows_i_end){ s << " " << mat.data[*q].v; }
       else{ s << " x"; }
     }
     s << std::endl;
   }
   
   mat.destroy();
   return s;
 }

_zgsmatrix t ( const zgsmatrix & mat )

friend

return transposed zgsmatrix

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

 {CPPL_VERBOSE_REPORT;
   zgsmatrix newmat =mat;
   
   std::swap(newmat.m,newmat.n);
   std::swap(newmat.rows,newmat.cols);
   const std::vector<zcomponent>::iterator newmat_data_end =newmat.data.end();
   for(std::vector<zcomponent>::iterator it=newmat.data.begin(); it!=newmat_data_end; it++){
     std::swap(it->i,it->j);
   }
   
   return _(newmat);
 }

void idamax	(	CPPL_INT &	i,
		CPPL_INT &	j,
		const zgsmatrix &	mat
	)

friend

search the index of element having the largest absolute value in 0-based numbering system

Definition at line 57 of file zgsmatrix-calc.hpp.

 {CPPL_VERBOSE_REPORT;
   std::vector<zcomponent>::const_iterator itx(mat.data.begin());
   double vmax =0.;
   
   const std::vector<zcomponent>::const_iterator mat_data_end =mat.data.end();
   for(std::vector<zcomponent>::const_iterator it=mat.data.begin(); it!=mat_data_end; it++){
     if( vmax < norm(it->v) ){
       vmax =norm(it->v);
       itx =it;
     }
   }
   
   i=itx->i;
   j=itx->j;
 }

comple damax ( const zgsmatrix & mat )

friend

return its largest absolute value

Definition at line 76 of file zgsmatrix-calc.hpp.

 {CPPL_VERBOSE_REPORT;
   std::vector<zcomponent>::const_iterator itx(mat.data.begin());
   double vmax =0.;
   
   const std::vector<zcomponent>::const_iterator mat_data_end =mat.data.end();
   for(std::vector<zcomponent>::const_iterator it=mat.data.begin(); it!=mat_data_end; it++){
     if( vmax < norm(it->v) ){
       vmax =norm(it->v);
       itx =it;
     }
   }
   
   return itx->v;
 }

const _zgsmatrix& operator+ ( const _zgsmatrix & mat )

friend

+_zgsmatrix operator

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

 {CPPL_VERBOSE_REPORT;
   return mat;
 }

_zgsmatrix operator- ( const _zgsmatrix & mat )

friend

-_zgsmatrix operator

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

 {CPPL_VERBOSE_REPORT;
   const std::vector<zcomponent>::iterator mat_data_end =mat.data.end();
   for(std::vector<zcomponent>::iterator it=mat.data.begin(); it!=mat_data_end; it++){
     it->v = -it->v;
   }
   
   return mat;
 }

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

friend

_zgsmatrix+zgematrix operator

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

 {CPPL_VERBOSE_REPORT;
 #ifdef  CPPL_DEBUG
   if(matA.m!=matB.m || matA.n!=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.m << "x" << matB.n << ")." << std::endl;
     exit(1);
   }
 #endif//CPPL_DEBUG
   
   zgematrix newmat(matB);
   
   const std::vector<zcomponent>::const_iterator matA_data_end =matA.data.end();
   for(std::vector<zcomponent>::const_iterator it=matA.data.begin(); it!=matA_data_end; it++){
     newmat(it->i,it->j) += it->v;
   }
   
   matA.destroy();
   return _(newmat);
 }

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

friend

_zgsmatrix+_zgematrix operator

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

 {CPPL_VERBOSE_REPORT;
 #ifdef  CPPL_DEBUG
   if(matA.m!=matB.m || matA.n!=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.m << "x" << matB.n << ")." << std::endl;
     exit(1);
   }
 #endif//CPPL_DEBUG
   
   const std::vector<zcomponent>::const_iterator matA_data_end =matA.data.end();
   for(std::vector<zcomponent>::const_iterator it=matA.data.begin(); it!=matA_data_end; it++){
     matB(it->i,it->j) += it->v;
   }
   
   matA.destroy();
   return matB;
 }

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

friend

_zgsmatrix+zhematrix operator

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

 {CPPL_VERBOSE_REPORT;
 #ifdef  CPPL_DEBUG
   if(matA.m!=matB.n || matA.n!=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.to_zgematrix() );
   
   const std::vector<zcomponent>::const_iterator matA_data_end =matA.data.end();
   for(std::vector<zcomponent>::const_iterator it=matA.data.begin(); it!=matA_data_end; it++){
     newmat(it->i,it->j) += it->v;
   }
   
   matA.destroy();
   return _(newmat);
 }

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

friend

_zgsmatrix+_zhematrix operator

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

 {CPPL_VERBOSE_REPORT;
 #ifdef  CPPL_DEBUG
   if(matA.m!=matB.n || matA.n!=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.to_zgematrix() );
   
   const std::vector<zcomponent>::const_iterator matA_data_end =matA.data.end();
   for(std::vector<zcomponent>::const_iterator it=matA.data.begin(); it!=matA_data_end; it++){
     newmat(it->i,it->j) += it->v;
   }
   
   matA.destroy();
   matB.destroy();
   return _(newmat);
 }

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

friend

_zgsmatrix+zgbmatrix operator

Definition at line 3 of file _zgsmatrix-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
   
   zgematrix newmat( matA.to_zgematrix() );
   
   for(CPPL_INT i=0; i<matB.m; i++){
     const CPPL_INT jmax =std::min(matB.n,i+matB.ku+1);
     for(CPPL_INT j=std::max(CPPL_INT(0),i-matB.kl); j<jmax; j++){
       newmat(i,j) +=matB(i,j);
     }
   }
   
   matA.destroy();
   return _(newmat);
 }

_zgematrix operator+	(	const _zgsmatrix &	matA,
		const _zgbmatrix &	matB
	)

friend

_zgsmatrix+_zgbmatrix operator

Definition at line 3 of file _zgsmatrix-_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
   
   zgematrix newmat( matA.to_zgematrix() );
   
   for(CPPL_INT i=0; i<matB.m; i++){
     const CPPL_INT jmax =std::min(matB.n,i+matB.ku+1);
     for(CPPL_INT j=std::max(CPPL_INT(0),i-matB.kl); j<jmax; j++){
       newmat(i,j) +=matB(i,j);
     }
   }
   
   matA.destroy();
   matB.destroy();
   return _(newmat);
 }

_zgsmatrix operator+	(	const _zgsmatrix &	matA,
		const zgsmatrix &	matB
	)

friend

_zgsmatrix+zgsmatrix operator

Definition at line 3 of file _zgsmatrix-zgsmatrix.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
   
   zgsmatrix newmat(matA);
   
   const std::vector<zcomponent>::const_iterator matB_data_end =matB.data.end();
   for(std::vector<zcomponent>::const_iterator it=matB.data.begin(); it!=matB_data_end; it++){
     newmat(it->i, it->j) +=it->v;
   }
   
   return _(newmat);
 }

_zgsmatrix operator+	(	const _zgsmatrix &	matA,
		const _zgsmatrix &	matB
	)

friend

_zgsmatrix+_zgsmatrix operator

Definition at line 3 of file _zgsmatrix-_zgsmatrix.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
   
   zgsmatrix newmat(matA);
   
   const std::vector<zcomponent>::const_iterator matB_data_end =matB.data.end();
   for(std::vector<zcomponent>::const_iterator it=matB.data.begin(); it!=matB_data_end; it++){
     newmat(it->i,it->j) += it->v;
   }
   
   matB.destroy();
   return _(newmat);
 }

_zgsmatrix operator+	(	const _zgsmatrix &	,
		const zhsmatrix &
	)

friend

_zgsmatrix operator+	(	const _zgsmatrix &	,
		const _zhsmatrix &
	)

friend

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

friend

_zgsmatrix-zgematrix operator

Definition at line 27 of file _zgsmatrix-zgematrix.hpp.

 {CPPL_VERBOSE_REPORT;
 #ifdef  CPPL_DEBUG
   if(matA.m!=matB.m || matA.n!=matB.n){
     ERROR_REPORT;
     std::cerr << "These two matrises can not make a subtraction." << 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);
   
   const std::vector<zcomponent>::const_iterator matA_data_end =matA.data.end();
   for(std::vector<zcomponent>::const_iterator it=matA.data.begin(); it!=matA_data_end; it++){
     newmat(it->i,it->j) += it->v;
   }
   
   matA.destroy();
   return _(newmat);
 }

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

friend

_zgsmatrix-_zgematrix operator

Definition at line 25 of file _zgsmatrix-_zgematrix.hpp.

 {CPPL_VERBOSE_REPORT;
 #ifdef  CPPL_DEBUG
   if(matA.m!=matB.m || matA.n!=matB.n){
     ERROR_REPORT;
     std::cerr << "These two matrises can not make a subtraction." << std::endl
               << "Your input was (" << matA.m << "x" << matA.n << ") - (" << matB.n << "x" << matB.n << ")." << std::endl;
     exit(1);
   }
 #endif//CPPL_DEBUG
   
   //// change sign ////
   for(int i=0; i<matB.m*matB.n; i++){
     matB.array[i] = -matB.array[i];
   }
   
   //// add ////
   const std::vector<zcomponent>::const_iterator matA_data_end =matA.data.end();
   for(std::vector<zcomponent>::const_iterator it=matA.data.begin(); it!=matA_data_end; it++){
     matB(it->i,it->j) += it->v;
   }
   
   matA.destroy();
   return matB;
 }

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

friend

_zgsmatrix-zhematrix operator

Definition at line 27 of file _zgsmatrix-zhematrix.hpp.

 {CPPL_VERBOSE_REPORT;
 #ifdef  CPPL_DEBUG
   if(matA.m!=matB.n || matA.n!=matB.n){
     ERROR_REPORT;
     std::cerr << "These two matrises can not make a subtraction." << std::endl
               << "Your input was (" << matA.m << "x" << matA.n << ") - (" << matB.n << "x" << matB.n << ")." << std::endl;
     exit(1);
   }
 #endif//CPPL_DEBUG
   
   //// shallow copy to zgematrix ////
   zgematrix newmat( (-matB).to_zgematrix() );
   
   //// add ////
   const std::vector<zcomponent>::const_iterator matA_data_end =matA.data.end();
   for(std::vector<zcomponent>::const_iterator it=matA.data.begin(); it!=matA_data_end; it++){
     newmat(it->i,it->j) += it->v;
   }
   
   //// return ////
   matA.destroy();
   return _(newmat);
 }

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

friend

_zgsmatrix-_zhematrix operator

Definition at line 28 of file _zgsmatrix-_zhematrix.hpp.

 {CPPL_VERBOSE_REPORT;
 #ifdef  CPPL_DEBUG
   if(matA.m!=matB.n || matA.n!=matB.n){
     ERROR_REPORT;
     std::cerr << "These two matrises can not make a subtraction." << std::endl
               << "Your input was (" << matA.m << "x" << matA.n << ") - (" << matB.n << "x" << matB.n << ")." << std::endl;
     exit(1);
   }
 #endif//CPPL_DEBUG
   
   //// shallow copy to zgematrix  ////
   zgematrix newmat( (-matB).to_zgematrix() );
   
   //// add ////
   const std::vector<zcomponent>::const_iterator matA_data_end =matA.data.end();
   for(std::vector<zcomponent>::const_iterator it=matA.data.begin(); it!=matA_data_end; it++){
     newmat(it->i,it->j) += it->v;
   }
   
   ////////
   matA.destroy();
   matB.destroy();
   return _(newmat);
 }

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

friend

_zgsmatrix-zgbmatrix operator

Definition at line 29 of file _zgsmatrix-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
   
   zgematrix newmat( matA.to_zgematrix() );
   
   for(CPPL_INT i=0; i<matB.m; i++){
     const CPPL_INT jmax =std::min(matB.n,i+matB.ku+1);
     for(CPPL_INT j=std::max(CPPL_INT(0),i-matB.kl); j<jmax; j++){
       newmat(i,j) -=matB(i,j);
     }
   }
   
   matA.destroy();
   return _(newmat);
 }

_zgematrix operator-	(	const _zgsmatrix &	matA,
		const _zgbmatrix &	matB
	)

friend

_zgsmatrix-_zgbmatrix operator

Definition at line 30 of file _zgsmatrix-_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
   
   zgematrix newmat( matA.to_zgematrix() );
   
   for(CPPL_INT i=0; i<matB.m; i++){
     const CPPL_INT jmax =std::min(matB.n,i+matB.ku+1);
     for(CPPL_INT j=std::max(CPPL_INT(0),i-matB.kl); j<jmax; j++){
       newmat(i,j) -=matB(i,j);
     }
   }
   
   matA.destroy();
   matB.destroy();
   return _(newmat);
 }

_zgsmatrix operator-	(	const _zgsmatrix &	matA,
		const zgsmatrix &	matB
	)

friend

_zgsmatrix-zgsmatrix operator

Definition at line 26 of file _zgsmatrix-zgsmatrix.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
 
   zgsmatrix newmat(matA);
   
   const std::vector<zcomponent>::const_iterator matB_data_end =matB.data.end();
   for(std::vector<zcomponent>::const_iterator it=matB.data.begin(); it!=matB_data_end; it++){
     newmat(it->i, it->j) -=it->v;
   }
   
   return _(newmat);
 }

_zgsmatrix operator-	(	const _zgsmatrix &	matA,
		const _zgsmatrix &	matB
	)

friend

_zgsmatrix-_zgsmatrix operator

Definition at line 27 of file _zgsmatrix-_zgsmatrix.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
   
   zgsmatrix newmat(matA);
   
   const std::vector<zcomponent>::const_iterator matB_data_end =matB.data.end();
   for(std::vector<zcomponent>::const_iterator it=matB.data.begin(); it!=matB_data_end; it++){
     newmat(it->i,it->j) -= it->v;
   }
   
   matB.destroy();
   return _(newmat);
 }

_zgsmatrix operator-	(	const _zgsmatrix &	,
		const zhsmatrix &
	)

friend

_zgsmatrix operator-	(	const _zgsmatrix &	,
		const _zhsmatrix &
	)

friend

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

friend

_zgsmatrix*zcovector operator

Definition at line 3 of file _zgsmatrix-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);
   newvec.zero();
   
   const std::vector<zcomponent>::const_iterator mat_data_end =mat.data.end();
   for(std::vector<zcomponent>::const_iterator it=mat.data.begin(); it!=mat_data_end; it++){
     newvec(it->i) += it->v*vec(it->j);
   }
   
   mat.destroy();
   return _(newvec);
 }

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

friend

_zgsmatrix*_zcovector operator

Definition at line 3 of file _zgsmatrix-_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);
   newvec.zero();
   
   const std::vector<zcomponent>::const_iterator mat_data_end =mat.data.end();
   for(std::vector<zcomponent>::const_iterator it=mat.data.begin(); it!=mat_data_end; it++){
     newvec(it->i) += it->v*vec(it->j);
   }
   
   mat.destroy();
   vec.destroy();
   return _(newvec);
 }

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

friend

_zgsmatrix*zgematrix operator

Definition at line 51 of file _zgsmatrix-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.n << "x" << matB.n << ")." << std::endl;
     exit(1);
   }
 #endif//CPPL_DEBUG
   
   zgematrix newmat(matA.m, matB.n);
   newmat.zero();
   
   const std::vector<zcomponent>::const_iterator matA_data_end =matA.data.end();
   for(std::vector<zcomponent>::const_iterator it=matA.data.begin(); it!=matA_data_end; it++){
     for(CPPL_INT j=0; j<matB.n; j++){
       newmat(it->i,j) += it->v*matB(it->j,j);
     }
   }
   
   matA.destroy();
   return _(newmat);
 }

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

friend

_zgsmatrix*_zgematrix operator

Definition at line 53 of file _zgsmatrix-_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.n << "x" << matB.n << ")." << std::endl;
     exit(1);
   }
 #endif//CPPL_DEBUG
   
   zgematrix newmat(matA.m, matB.n);
   newmat.zero();
   
   const std::vector<zcomponent>::const_iterator matA_data_end =matA.data.end();
   for(std::vector<zcomponent>::const_iterator it=matA.data.begin(); it!=matA_data_end; it++){
     for(CPPL_INT j=0; j<matB.n; j++){
       newmat(it->i,j) += it->v *matB(it->j,j);
     }
   }
   
   matA.destroy();
   matB.destroy();
   return _(newmat);
 }

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

friend

_zgsmatrix*zhematrix operator

Definition at line 54 of file _zgsmatrix-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();
   
   const std::vector<zcomponent>::const_iterator matA_data_end =matA.data.end();
   for(std::vector<zcomponent>::const_iterator it=matA.data.begin(); it!=matA_data_end; it++){
     for(CPPL_INT i=0; i<matB.n; i++){
       newmat(it->i,i) += it->v*matB(it->j,i);
     }
   }
   
   matA.destroy();
   return _(newmat);
 }

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

friend

_zgsmatrix*_zhematrix operator

Definition at line 56 of file _zgsmatrix-_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();
   
   const std::vector<zcomponent>::const_iterator matA_data_end =matA.data.end();
   for(std::vector<zcomponent>::const_iterator it=matA.data.begin(); it!=matA_data_end; it++){
     for(CPPL_INT i=0; i<matB.n; i++){
       newmat(it->i,i) += it->v*matB(it->j,i);
     }
   }
   
   matA.destroy();
   matB.destroy();
   return _(newmat);
 }

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

friend

_zgsmatrix*zgbmatrix operator

Definition at line 55 of file _zgsmatrix-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
   
   zgematrix newmat( matA.m, matB.n );
   newmat.zero();
   
   const std::vector<zcomponent>::const_iterator matA_data_end =matA.data.end();
   for(std::vector<zcomponent>::const_iterator it=matA.data.begin(); it!=matA_data_end; it++){
     const CPPL_INT jmax =std::min(matB.n,it->j+matB.ku+1);
     for(CPPL_INT j=std::max(CPPL_INT(0),it->j-matB.kl); j<jmax; j++){
       newmat(it->i,j) += it->v*matB(it->j,j);
     }
   }
   
   matA.destroy();
   return _(newmat);
 }

_zgematrix operator*	(	const _zgsmatrix &	matA,
		const _zgbmatrix &	matB
	)

friend

_zgsmatrix*_zgbmatrix operator

Definition at line 57 of file _zgsmatrix-_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
   
   zgematrix newmat( matA.m, matB.n );
   newmat.zero();
   
   const std::vector<zcomponent>::const_iterator matA_data_end =matA.data.end();
   for(std::vector<zcomponent>::const_iterator it=matA.data.begin(); it!=matA_data_end; it++){
     const CPPL_INT jmax =std::min(matB.n,it->j+matB.ku+1);
     for(CPPL_INT j=std::max(CPPL_INT(0),it->j-matB.kl); j<jmax; j++){
       newmat(it->i,j) += it->v*matB(it->j,j);
     }
   }
   
   matA.destroy();
   matB.destroy();
   return _(newmat);
 }

_zgsmatrix operator*	(	const _zgsmatrix &	matA,
		const zgsmatrix &	matB
	)

friend

_zgsmatrix*zgsmatrix operator

Definition at line 49 of file _zgsmatrix-zgsmatrix.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
   
   zgsmatrix newmat(matA.m, matB.n);
   
   const std::vector<zcomponent>::const_iterator matA_data_end =matA.data.end();
   for(std::vector<zcomponent>::const_iterator it=matA.data.begin(); it!=matA_data_end; it++){
     CPPL_INT k =it->j;
     const std::vector<CPPL_INT>::const_iterator matB_rows_k_end =matB.rows[k].end();
     for(std::vector<CPPL_INT>::const_iterator p=matB.rows[k].begin(); p!=matB_rows_k_end; p++){
       newmat(it->i,matB.data[*p].j) +=it->v*matB.data[*p].v;
     }
   }
   
   matA.destroy();
   return _(newmat);
 }

_zgsmatrix operator*	(	const _zgsmatrix &	matA,
		const _zgsmatrix &	matB
	)

friend

_zgsmatrix*_zgsmatrix operator

Definition at line 51 of file _zgsmatrix-_zgsmatrix.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
   
   zgsmatrix newmat(matA.m, matB.n);
   
   const std::vector<zcomponent>::const_iterator matA_data_end =matA.data.end();
   for(std::vector<zcomponent>::const_iterator it=matA.data.begin(); it!=matA_data_end; it++){
     CPPL_INT k =it->j;
     const std::vector<CPPL_INT>::iterator matB_rows_k_end =matB.rows[k].end();
     for(std::vector<CPPL_INT>::iterator p=matB.rows[k].begin(); p!=matB_rows_k_end; p++){
       newmat(it->i,matB.data[*p].j) += it->v*matB.data[*p].v;
     }
   }
   
   matA.destroy();
   matB.destroy();
   return _(newmat);
 }

_zgsmatrix operator*	(	const _zgsmatrix &	,
		const zhsmatrix &
	)

friend

_zgsmatrix operator*	(	const _zgsmatrix &	,
		const _zhsmatrix &
	)

friend

_zgsmatrix operator*	(	const _zgsmatrix &	mat,
		const double &	d
	)

friend

_zgsmatrix*double operator

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

 {CPPL_VERBOSE_REPORT;
   const std::vector<zcomponent>::iterator mat_data_end =mat.data.end();
   for(std::vector<zcomponent>::iterator it=mat.data.begin(); it!=mat_data_end; it++){
     it->v *=d;
   }
   
   return mat;
 }

_zgsmatrix operator*	(	const _zgsmatrix &	mat,
		const comple &	d
	)

friend

_zgsmatrix*comple operator

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

 {CPPL_VERBOSE_REPORT;
   const std::vector<zcomponent>::iterator mat_data_end =mat.data.end();
   for(std::vector<zcomponent>::iterator it=mat.data.begin(); it!=mat_data_end; it++){
     it->v *=d;
   }
   
   return mat;
 }

_zgsmatrix operator/	(	const _zgsmatrix &	mat,
		const double &	d
	)

friend

_zgsmatrix/double operator

Definition at line 15 of file _zgsmatrix-double.hpp.

 {CPPL_VERBOSE_REPORT;
   const std::vector<zcomponent>::iterator mat_data_end =mat.data.end();
   for(std::vector<zcomponent>::iterator it=mat.data.begin(); it!=mat_data_end; it++){
     it->v /=d;
   }
   
   return mat;
 }

_zgsmatrix operator/	(	const _zgsmatrix &	mat,
		const comple &	d
	)

friend

_zgsmatrix/comple operator

Definition at line 15 of file _zgsmatrix-complex.hpp.

 {CPPL_VERBOSE_REPORT;
   const std::vector<zcomponent>::iterator mat_data_end =mat.data.end();
   for(std::vector<zcomponent>::iterator it=mat.data.begin(); it!=mat_data_end; it++){
     it->v /=d;
   }
   
   return mat;
 }

_zgsmatrix operator*	(	const double &	d,
		const _zgsmatrix &	mat
	)

friend

double*_zgsmatrix operator

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

 {CPPL_VERBOSE_REPORT;
   const std::vector<zcomponent>::iterator mat_data_end =mat.data.end();
   for(std::vector<zcomponent>::iterator it=mat.data.begin(); it!=mat_data_end; it++){
     it->v *= d;
   }
   
   return mat;
 }

_zgsmatrix operator*	(	const comple &	d,
		const _zgsmatrix &	mat
	)

friend

complex*_zgsmatrix operator

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

 {CPPL_VERBOSE_REPORT;
   const std::vector<zcomponent>::iterator mat_data_end =mat.data.end();
   for(std::vector<zcomponent>::iterator it=mat.data.begin(); it!=mat_data_end; it++){
     it->v *= d;
   }
   
   return mat;
 }