Real Double-precision General Sparse Matrix Class. More...

#include <dgsmatrix.hpp>

Public Member Functions
	dgsmatrix ()

	dgsmatrix (const dgsmatrix &)

	dgsmatrix (const _dgsmatrix &)

	dgsmatrix (const CPPL_INT &, const CPPL_INT &, const CPPL_INT=0)

	dgsmatrix (const char *)

	~dgsmatrix ()

_zgsmatrix	to_zgsmatrix () const

_dgematrix	to_dgematrix () const

dgrmatrix	to_dgrmatrix () const

double	operator() (const CPPL_INT &, const CPPL_INT &) const

double &	operator() (const CPPL_INT &, const CPPL_INT &)

dgsmatrix &	put (const CPPL_INT &, const CPPL_INT &, const double &)

dgsmatrix &	del (const CPPL_INT, const CPPL_INT)

dgsmatrix &	del (const CPPL_INT)

void	write (const char *) const

void	read (const char *)

void	clear ()

dgsmatrix &	zero ()

dgsmatrix &	identity ()

void	chsign ()

void	copy (const dgsmatrix &)

void	shallow_copy (const _dgsmatrix &)

dgsmatrix &	resize (const CPPL_INT &, const CPPL_INT &, const CPPL_INT=0, const CPPL_INT=0)

void	stretch (const CPPL_INT &, const CPPL_INT &)

bool	isListed (const CPPL_INT &, const CPPL_INT &) const

CPPL_INT	number (const CPPL_INT &, const CPPL_INT &)

void	diet (const double=DBL_MIN)

void	checkup ()

_drovector	row (const CPPL_INT &) const

_dcovector	col (const CPPL_INT &) const

CPPL_INT	pardiso (dcovector &) const

dgsmatrix &	operator= (const dgsmatrix &)

dgsmatrix &	operator= (const _dgsmatrix &)

dgsmatrix &	operator+= (const dgsmatrix &)

dgsmatrix &	operator+= (const _dgsmatrix &)

dgsmatrix &	operator-= (const dgsmatrix &)

dgsmatrix &	operator-= (const _dgsmatrix &)

dgsmatrix &	operator*= (const dgsmatrix &)

dgsmatrix &	operator*= (const _dgsmatrix &)

dgsmatrix &	operator*= (const double &)

dgsmatrix &	operator/= (const double &)

Public Attributes
CPPL_INT	m
	matrix row size More...

CPPL_INT	n
	matrix column size More...

std::vector< dcomponent >	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 dgsmatrix &)

void	swap (dgsmatrix &, dgsmatrix &)

_dgsmatrix	_ (dgsmatrix &)

_dgsmatrix	t (const dgsmatrix &)

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

double	damax (const dgsmatrix &)

const dgsmatrix &	operator+ (const dgsmatrix &)

_dgsmatrix	operator- (const dgsmatrix &)

_dgematrix	operator+ (const dgsmatrix &, const dgematrix &)

_dgematrix	operator+ (const dgsmatrix &, const _dgematrix &)

_dgematrix	operator+ (const dgsmatrix &, const dsymatrix &)

_dgematrix	operator+ (const dgsmatrix &, const _dsymatrix &)

_dgematrix	operator+ (const dgsmatrix &, const dgbmatrix &)

_dgematrix	operator+ (const dgsmatrix &, const _dgbmatrix &)

_dgsmatrix	operator+ (const dgsmatrix &, const dgsmatrix &)

_dgsmatrix	operator+ (const dgsmatrix &, const _dgsmatrix &)

_dgsmatrix	operator+ (const dgsmatrix &, const dssmatrix &)

_dgsmatrix	operator+ (const dgsmatrix &, const _dssmatrix &)

_dgematrix	operator- (const dgsmatrix &, const dgematrix &)

_dgematrix	operator- (const dgsmatrix &, const _dgematrix &)

_dgematrix	operator- (const dgsmatrix &, const dsymatrix &)

_dgematrix	operator- (const dgsmatrix &, const _dsymatrix &)

_dgematrix	operator- (const dgsmatrix &, const dgbmatrix &)

_dgematrix	operator- (const dgsmatrix &, const _dgbmatrix &)

_dgsmatrix	operator- (const dgsmatrix &, const dgsmatrix &)

_dgsmatrix	operator- (const dgsmatrix &, const _dgsmatrix &)

_dgsmatrix	operator- (const dgsmatrix &, const dssmatrix &)

_dgsmatrix	operator- (const dgsmatrix &, const _dssmatrix &)

_dcovector	operator* (const dgsmatrix &, const dcovector &)

_dcovector	operator* (const dgsmatrix &, const _dcovector &)

_dgematrix	operator* (const dgsmatrix &, const dgematrix &)

_dgematrix	operator* (const dgsmatrix &, const _dgematrix &)

_dgematrix	operator* (const dgsmatrix &, const dsymatrix &)

_dgematrix	operator* (const dgsmatrix &, const _dsymatrix &)

_dgematrix	operator* (const dgsmatrix &, const dgbmatrix &)

_dgematrix	operator* (const dgsmatrix &, const _dgbmatrix &)

_dgsmatrix	operator* (const dgsmatrix &, const dgsmatrix &)

_dgsmatrix	operator* (const dgsmatrix &, const _dgsmatrix &)

_dgsmatrix	operator* (const dgsmatrix &, const dssmatrix &)

_dgsmatrix	operator* (const dgsmatrix &, const _dssmatrix &)

_dgsmatrix	operator* (const dgsmatrix &, const double &)

_dgsmatrix	operator/ (const dgsmatrix &, const double &)

_dgsmatrix	operator* (const double &, const dgsmatrix &)

Detailed Description

Real Double-precision General Sparse Matrix Class.

Definition at line 3 of file dgsmatrix.hpp.

Constructor & Destructor Documentation

dgsmatrix::dgsmatrix ( )

inline

dgsmatrix constructor without arguments

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

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

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

dgsmatrix::dgsmatrix ( const dgsmatrix & mat )

inline

dgsmatrix copy constructor

Definition at line 19 of file dgsmatrix-constructor.hpp.

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

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

dgsmatrix::dgsmatrix ( const _dgsmatrix & mat )

inline

dgsmatrix constructor to cast _dgsmatrix

Definition at line 31 of file dgsmatrix-constructor.hpp.

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

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

dgsmatrix::dgsmatrix	(	const CPPL_INT &	_m,
		const CPPL_INT &	_n,
		const CPPL_INT	_c = `0`
	)

inline

dgsmatrix constructor with size specification

Definition at line 52 of file dgsmatrix-constructor.hpp.

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

 {CPPL_VERBOSE_REPORT;
 #ifdef  CPPL_DEBUG
   if( _m<0 || _n<0 || _c<0 ){
     ERROR_REPORT;
     std::cerr << "Matrix sizes and the length of arrays must be positive integers. " << std::endl
               << "Your input was (" << _m << "," << _n << "," << _c << ")." << std::endl;
     exit(1);
   }
 #endif//CPPL_DEBUG
   
   //////// initialize ////////
   m =_m;
   n =_n;
   data.resize(0);
   data.reserve(_c);
   rows.resize(m);
   cols.resize(n);
 }

dgsmatrix::dgsmatrix ( const char * filename )

inline

dgsmatrix constructor with filename

Definition at line 74 of file dgsmatrix-constructor.hpp.

References cols, data, read(), and rows.

 {CPPL_VERBOSE_REPORT;
   data.clear();
   rows.clear();
   cols.clear();
   
   //// read ////
   read(filename);
 }

dgsmatrix::~dgsmatrix ( )

inline

dgsmatrix destructor

Definition at line 90 of file dgsmatrix-constructor.hpp.

References cols, data, and rows.

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

Member Function Documentation

_zgsmatrix dgsmatrix::to_zgsmatrix ( ) const

inline

cast to _zgsmatrix

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

References _, data, m, n, and zgsmatrix::put().

 {CPPL_VERBOSE_REPORT;
   zgsmatrix newmat(m,n,CPPL_INT(data.size()));
   
   const std::vector<dcomponent>::const_iterator data_end =data.end();
   for(std::vector<dcomponent>::const_iterator it=data.begin(); it!=data_end; it++){
     newmat.put(it->i, it->j, comple(it->v,0.));
   }
   
   return _(newmat);
 }

_dgematrix dgsmatrix::to_dgematrix ( ) const

inline

convert to _dgematrix

Definition at line 21 of file dgsmatrix-cast.hpp.

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

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

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

dgrmatrix dgsmatrix::to_dgrmatrix ( ) const

inline

convert to dgrmatrix

Definition at line 40 of file dgsmatrix-cast.hpp.

References dgrmatrix::a, data, i(), dgrmatrix::ia, dgrmatrix::ja, dgrmatrix::m, m, dgrmatrix::n, n, and rows.

 {CPPL_VERBOSE_REPORT;
   //////// resize ////////
   dgrmatrix newmat;
   newmat.m =m;
   newmat.n =n;
   newmat.a.resize(data.size());
   newmat.ia.resize(m+1);
   newmat.ja.resize(data.size());
   
   //////// copy ////////
   newmat.ia[0] =1;//one-based
   CPPL_INT k=0;
   for(CPPL_INT i=0; i<m; i++){
     //// make map ////
     const std::vector<CPPL_INT>::const_iterator rows_i_end =rows[i].end();
     std::map<CPPL_INT,CPPL_INT> jc;
     for(std::vector<CPPL_INT>::const_iterator rit=rows[i].begin(); rit!=rows_i_end; rit++){
       jc.insert( std::make_pair(data[*rit].j, *rit) );
     }
     //// assign ////
     const std::map<CPPL_INT,CPPL_INT>::const_iterator jc_end =jc.end();
     for(std::map<CPPL_INT,CPPL_INT>::const_iterator jcit=jc.begin(); jcit!=jc_end; jcit++){
       newmat.a[k] =data[(*jcit).second].v;
       newmat.ja[k] =CPPL_INT((*jcit).first)+1;//one-based
       k++;
     }
     newmat.ia[i+1] =k+1;//one-based
   }
   
   return newmat;
 }

double dgsmatrix::operator()	(	const CPPL_INT &	i,
		const CPPL_INT &	j
	)		const

inline

operator() for const object

Definition at line 3 of file dgsmatrix-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>::const_iterator rows_i_end =rows[i].end();
   for(std::vector<CPPL_INT>::const_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 0.0;
 }

double & dgsmatrix::operator()	(	const CPPL_INT &	i,
		const CPPL_INT &	j
	)

inline

operator() for const object

Definition at line 26 of file dgsmatrix-io.hpp.

References cols, 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 not found ////////
   rows[i].push_back(CPPL_INT(data.size()));
   cols[j].push_back(CPPL_INT(data.size()));
   data.push_back(dcomponent(i,j,0.));
   return data.back().v;
 }

dgsmatrix & dgsmatrix::put	(	const CPPL_INT &	i,
		const CPPL_INT &	j,
		const double &	v
	)

inline

put value with volume cheack without isListed check

Definition at line 56 of file dgsmatrix-io.hpp.

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

Referenced by identity(), read(), and _dssmatrix::to_dgsmatrix().

 {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);
   }
   const std::vector<dcomponent>::const_iterator data_end =data.end();
   for(std::vector<dcomponent>::const_iterator it=data.begin(); it!=data_end; it++){
     if( it->i==i && it->j==j ){
       ERROR_REPORT;
       std::cerr << "The required component is already listed." << std::endl
                 << "Your input was (" << i << "," << j << "," << v << ")." << std::endl;
       exit(1);
     }
   }
 #endif//CPPL_DEBUG
   
   //// push ////
   rows[i].push_back(CPPL_INT(data.size()));
   cols[j].push_back(CPPL_INT(data.size()));
   data.push_back(dcomponent(i,j,v));
   
   return *this;
 }

dgsmatrix & dgsmatrix::del	(	const CPPL_INT	i,
		const CPPL_INT	j
	)

inline

delete the entry of a component

Definition at line 90 of file dgsmatrix-io.hpp.

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

Referenced by diet(), and stretch().

 {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){//exists
       //// save position ////
       CPPL_INT c =*p;
       CPPL_INT C =CPPL_INT(data.size()-1);
       
       //// data translation ////
       data[c]=data.back();
       data.pop_back();
       
       //// remove from List ////
       rows[i].erase(p);
       const std::vector<CPPL_INT>::iterator cols_j_end =cols[j].end();
       for(std::vector<CPPL_INT>::iterator q=cols[j].begin(); q!=cols_j_end; q++){
         if(*q==c){ cols[j].erase(q); break; }
       }
       
       //// modify the entry of translated component ////
       CPPL_INT I(data[c].i), J(data[c].j);
       const std::vector<CPPL_INT>::iterator rows_I_end =rows[I].end();
       for(std::vector<CPPL_INT>::iterator q=rows[I].begin(); q!=rows_I_end; q++){
         if(*q==C){ *q=c; break; }
       }
       const std::vector<CPPL_INT>::iterator cols_J_end =cols[J].end();
       for(std::vector<CPPL_INT>::iterator q=cols[J].begin(); q!=cols_J_end; q++){
         if(*q==C){ *q=c; break; }
       }
       return *this;
     }
   }
   
 #ifdef  CPPL_DEBUG
   std::cerr << "# [NOTE]@dgsmatrix::del(CPPL_INT&, CPPL_INT&): The required component was not listed. Your input was (" << i << "," << j << ")." << std::endl;
 #endif//CPPL_DEBUG
   
   return *this;
 }

dgsmatrix & dgsmatrix::del ( const CPPL_INT c )

inline

delete the entry of an element

Definition at line 143 of file dgsmatrix-io.hpp.

References cols, data, i(), and rows.

 {CPPL_VERBOSE_REPORT;
   if( c==CPPL_INT(data.size()-1) ){//if c is the last element
     CPPL_INT i(data[c].i), j(data[c].j);
     const std::vector<CPPL_INT>::iterator rows_i_end =rows[i].end();
     for(std::vector<CPPL_INT>::iterator q=rows[i].begin(); q!=rows_i_end; q++){
       if(*q==c){ rows[i].erase(q); break; }
     }
     const std::vector<CPPL_INT>::iterator cols_j_end =cols[j].end();
     for(std::vector<CPPL_INT>::iterator q=cols[j].begin(); q!=cols_j_end; q++){
       if(*q==c){ cols[j].erase(q); break; }
     }
     data.pop_back();
   }
   
   else{//if c is NOT the last element
     //// data translation ////
     CPPL_INT C =CPPL_INT(data.size()-1);
     CPPL_INT i(data[c].i), j(data[c].j), I(data.back().i), J(data.back().j);
     data[c]=data.back();
     //// remove entry of component ////
     const std::vector<CPPL_INT>::iterator rows_i_end =rows[i].end();
     for(std::vector<CPPL_INT>::iterator q=rows[i].begin(); q!=rows_i_end; q++){
       if(*q==c){ rows[i].erase(q); break; }
     }
     const std::vector<CPPL_INT>::iterator cols_j_end =cols[j].end();
     for(std::vector<CPPL_INT>::iterator q=cols[j].begin(); q!=cols_j_end; q++){
       if(*q==c){ cols[j].erase(q); break; }
     }
     //// modify the entry of translated component ////
     const std::vector<CPPL_INT>::iterator rows_I_end =rows[I].end();
     for(std::vector<CPPL_INT>::iterator q=rows[I].begin(); q!=rows_I_end; q++){
       if(*q==C){ *q=c; break; }
     }
     const std::vector<CPPL_INT>::iterator cols_J_end =cols[J].end();
     for(std::vector<CPPL_INT>::iterator q=cols[J].begin(); q!=cols_J_end; q++){
       if(*q==C){ *q=c; break; }
     }
     //// pop_back ////
     data.pop_back();
   }
   
   return *this;
 }

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

inline

Definition at line 216 of file dgsmatrix-io.hpp.

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

void dgsmatrix::read ( const char * filename )

inline

Definition at line 235 of file dgsmatrix-io.hpp.

References data, i(), m, n, put(), and resize().

Referenced by dgsmatrix().

 {CPPL_VERBOSE_REPORT;
   std::ifstream s( filename );
   if(!s){
     ERROR_REPORT;
     std::cerr << "The file \"" << filename << "\" can not be opened." << std::endl;
     exit(1);
   }
   
   //////// id ////////
   std::string id;
   s >> id;
   if( id != "dgsmatrix" && id != "#dgsmatrix" ){
     ERROR_REPORT;
     std::cerr << "The type name of the file \"" << filename << "\" is not dgsmatrix." << std::endl
               << "Its type name was " << id << " ." << std::endl;
     exit(1);
   }
   
   //////// m, n, size ////////
   size_t size;
   s >> m >> n >> size;
   resize(m, n);
   data.resize(size);
   
   //////// i, j, v ////////
   CPPL_INT i, j;
   double v;
   for(size_t k=0; k<size; k++){
     s >> i >> j >> v;
     put(i,j, v);
   }
   
   //////// check ////////
   s >> i;
   if(!s.eof()){
     ERROR_REPORT;
     std::cerr << "There is something is wrong with the file \"" << filename << " ." << std::endl
               << "Most likely, there are too many data components over the context." << std::endl;
     exit(1);
   }
   s.close();
 }

void dgsmatrix::clear ( )

inline

clear all the matrix data and set the sizes 0

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

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

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

dgsmatrix & dgsmatrix::zero ( )

inline

change the matrix into a zero matrix

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

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

Referenced by identity(), operator*=(), _dssmatrix::to_dgsmatrix(), and dssmatrix::to_dgsmatrix().

 {CPPL_VERBOSE_REPORT;
   data.resize(0);
   for(CPPL_INT i=0; i<m; i++){ rows[i].resize(0); }
   for(CPPL_INT j=0; j<n; j++){ cols[j].resize(0); }
   return *this;
 }

dgsmatrix & dgsmatrix::identity ( )

inline

change the matrix into an identity matrix

Definition at line 24 of file dgsmatrix-misc.hpp.

References i(), m, n, put(), and zero().

 {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
   
   zero();
   for(CPPL_INT i=0; i<m; i++){
     put(i,i,1.);
   }
   return *this;
 }

void dgsmatrix::chsign ( )

inline

change sign(+/-) of the matrix

Definition at line 44 of file dgsmatrix-misc.hpp.

References data.

Referenced by operator-().

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

void dgsmatrix::copy ( const dgsmatrix & mat )

inline

make a deep copy of the matrix

Definition at line 54 of file dgsmatrix-misc.hpp.

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

Referenced by dgsmatrix(), and operator=().

 {CPPL_VERBOSE_REPORT;
   m =mat.m;
   n =mat.n;
   data =mat.data;
   rows =mat.rows;
   cols =mat.cols;
 }

void dgsmatrix::shallow_copy ( const _dgsmatrix & mat )

inline

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

Definition at line 66 of file dgsmatrix-misc.hpp.

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

Referenced by operator=().

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

dgsmatrix & dgsmatrix::resize	(	const CPPL_INT &	_m,
		const CPPL_INT &	_n,
		const CPPL_INT	_c = `0`,
		const CPPL_INT	_l = `0`
	)

inline

resize the matrix

Definition at line 83 of file dgsmatrix-misc.hpp.

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

Referenced by read().

 {CPPL_VERBOSE_REPORT;
 #ifdef  CPPL_DEBUG
   if( _m<0 || _n<0 || _c<0 ){
     ERROR_REPORT;
     std::cerr << "Matrix sizes and the length of arrays must be positive integers. " << std::endl
               << "Your input was (" << _m << "," << _n << "," << _c << "," << _l << ")." << std::endl;
     exit(1);
   }
 #endif//CPPL_DEBUG
   
   m =_m;
   n =_n;
   data.resize(0);
   data.reserve(_c);
   rows.resize(m);
   for(CPPL_INT i=0; i<m; i++){
     rows[i].resize(0);
     rows[i].reserve(_l);
   }
   cols.resize(n);
   for(CPPL_INT i=0; i<n; i++){
     cols[i].resize(0);
     cols[i].reserve(_l);
   }
   
   return *this;
 }

void dgsmatrix::stretch	(	const CPPL_INT &	dm,
		const CPPL_INT &	dn
	)

inline

stretch the matrix size

Definition at line 114 of file dgsmatrix-misc.hpp.

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

 {CPPL_VERBOSE_REPORT;
 #ifdef  CPPL_DEBUG
   if( m+dm<0 || n+dn<0 ){
     ERROR_REPORT;
     std::cerr << "The new matrix size must be larger than zero. " << std::endl
               << "Your input was (" << dm << ", " << dn << ")." << std::endl;
     exit(1);
   }
 #endif//CPPL_DEBUG
   
   //////// zero ////////
   if(dm==0 && dn==0){ return; }
   
   //////// non-zero ////////
   m +=dm;
   n +=dn;
   
   //// for rows ////
   if(dm<0){
     //// delete components over the new size ////
     const std::vector<dcomponent>::reverse_iterator data_rend =data.rend();
     for(std::vector<dcomponent>::reverse_iterator it=data.rbegin(); it!=data_rend; it++){
       if( it->i>=m ){ del( CPPL_INT(data_rend-it-1) ); }
     }
     //// shrink rows ////
     for(CPPL_INT i=0; i<-dm; i++){
       rows.pop_back();
     }
   }
   else{//dm>0
     //// expand rows ////
     for(CPPL_INT i=0; i<dm; i++){
       rows.push_back( std::vector<CPPL_INT>(0) );
     }
   }
   
   //// for cols ////
   if(dn<0){
     //// delete components over the new size ////
     const std::vector<dcomponent>::reverse_iterator data_rend =data.rend();
     for(std::vector<dcomponent>::reverse_iterator it=data.rbegin(); it!=data_rend; it++){
       if( it->j>=n ){ del( CPPL_INT(data_rend-it-1) ); }
     }
     for(CPPL_INT j=0; j<-dn; j++){
       cols.pop_back();
     }
   }
   else{//dn>0
     //// expand cols ////
     for(CPPL_INT j=0; j<dn; j++){
       cols.push_back( std::vector<CPPL_INT>(0) );
     }
   }
 }

bool dgsmatrix::isListed	(	const CPPL_INT &	i,
		const CPPL_INT &	j
	)		const

inline

check if the component is listed

Definition at line 172 of file dgsmatrix-misc.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
   const std::vector<CPPL_INT>::const_iterator rows_i_end =rows[i].end();
   for(std::vector<CPPL_INT>::const_iterator p=rows[i].begin(); p!=rows_i_end; p++){
     if(data[*p].j==j){ return 1; }
   }
   
   return 0;
 }

CPPL_INT dgsmatrix::number	(	const CPPL_INT &	i,
		const CPPL_INT &	j
	)

inline

return the element number of the component

Definition at line 193 of file dgsmatrix-misc.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
   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 *p; }
   }
   
   return -1;
 }

void dgsmatrix::diet ( const double eps = DBL_MIN )

inline

erase components less than DBL_MIN

Definition at line 265 of file dgsmatrix-misc.hpp.

References data, and del().

 {CPPL_VERBOSE_REPORT;
   const std::vector<dcomponent>::reverse_iterator data_rend =data.rend();
   for(std::vector<dcomponent>::reverse_iterator it=data.rbegin(); it!=data_rend; it++){
     if( fabs(it->v)<eps ){ del( CPPL_INT(data_rend-it-1) ); }
   }
 }

void dgsmatrix::checkup ( )

inline

health checkup

Definition at line 279 of file dgsmatrix-misc.hpp.

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

 {CPPL_VERBOSE_REPORT;
   //////// write ////////
   const std::vector<dcomponent>::const_iterator data_end =data.end();
   for(std::vector<dcomponent>::const_iterator it=data.begin(); it!=data_end; it++){
     std::cerr << "array[" << it-data.begin() << "] = (" << it->i << "," << it->j << ") = " << it->v << std::endl;
   }
   std::cerr << std::endl;
   
   for(CPPL_INT i=0; i<m; i++){
     std::cerr << "rows[" << i << "] =" << std::flush;
     const size_t rows_i_size =rows[i].size();
     for(size_t k=0; k<rows_i_size; k++){
       std::cerr << " " << rows[i][k] << std::flush;
     }
     std::cerr << std::endl;
   }
   std::cerr << std::endl;
   
   for(CPPL_INT j=0; j<n; j++){
     std::cerr << "cols[" << j << "] =" << std::flush;
     const size_t cols_j_size =cols[j].size();
     for(size_t k=0; k<cols_j_size; k++){
       std::cerr << " " << cols[j][k] << std::flush;
     }
     std::cerr << std::endl;
   }
   
   //////// Elements ////////
   for(std::vector<dcomponent>::const_iterator it=data.begin(); it!=data_end; it++){
     //// m bound ////
     if(it->i>=m){
       ERROR_REPORT;
       std::cerr << "The indx of the " << it-data.begin() << "th element is out of the matrix size." << std::endl
                 << "Its i index was " << it->i << "." << std::endl;
       exit(1);
     }
     
     //// n bound ////
     if(it->j>=n){
       ERROR_REPORT;
       std::cerr << "The indx of the " << it-data.begin() << "th element is out of the matrix size." << std::endl
                 << "Its j index was " << it->j << "." << std::endl;
       exit(1);
     }
     
     //// double-listed ////
     for(std::vector<dcomponent>::const_iterator IT=it+1; IT!=data_end; IT++){
       if( it->i==IT->i && it->j==IT->j ){
         ERROR_REPORT;
         std::cerr << "The (" << it->i << ", " << it->j << ") component is double-listed at the " << it-data.begin() << "th and the" << IT-data.begin() << "the elements."<< std::endl;
         exit(1);
       }
     }
   }
   
   //////// ijc consistence ////////
   
   
   //////// NOTE ////////
   std::cerr << "# [NOTE]@dgsmatrix::checkup(): This sparse matrix is fine." << std::endl;
 }

_drovector dgsmatrix::row ( const CPPL_INT & _m ) const

inline

get row of the matrix

Definition at line 217 of file dgsmatrix-misc.hpp.

References _, data, m, n, rows, and drovector::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
   
   drovector vec(n);
   vec.zero();
   
   const std::vector<CPPL_INT>::const_iterator rows__m_end =rows[_m].end();
   for(std::vector<CPPL_INT>::const_iterator p=rows[_m].begin(); p!=rows__m_end; p++){
     vec(data[*p].j) =data[*p].v;
   }
   
   return _(vec);
 }

_dcovector dgsmatrix::col ( const CPPL_INT & _n ) const

inline

get column of the matrix

Definition at line 241 of file dgsmatrix-misc.hpp.

References _, cols, data, i(), m, n, and dcovector::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
   
   dcovector vec(m);
   vec.zero();
   
   const std::vector<CPPL_INT>::const_iterator cols__n_end =cols[_n].end();
   for(std::vector<CPPL_INT>::const_iterator p=cols[_n].begin(); p!=cols__n_end; p++){
     vec(data[*p].i) =data[*p].v;
   }
   
   return _(vec);
 }

CPPL_INT dgsmatrix::pardiso ( dcovector & b ) const

inline

solve A*x=b for real and unsymmetric matrix using Intel PARDISO.
The argument is dcovector b. b is overwritten and become the solution x. A is not overwritten.

Definition at line 7 of file dgsmatrix-pardiso.hpp.

References dcovector::array, data, i(), dcovector::l, m, n, rows, and swap.

 {CPPL_VERBOSE_REPORT;
 #ifndef  __INTEL_COMPILER
   ERROR_REPORT;
   std::cerr << "dgsmatrix::pardiso is only for intel c++ compiler (icpc)." << std::endl;
   std::cerr << "Recompile your code with icpc to use pardiso." << std::endl;
   (void)b;
   exit(1);
 #else  //__INTEL_COMPILER
   
   
   //#ifdef  CPPL_DEBUG
   if(m!=n || m!=b.l){
     ERROR_REPORT;
     std::cerr << "These matrix and vector cannot be solved." << std::endl
               << "Your input was (" << m << "x" << n << ") and (" << b.l << ")." << std::endl;
     exit(1);
   }
   //#endif//CPPL_DEBUG 
   
   //////// convert matrix storage into compressed sparse row format ////////
   //std::cerr << "converting" << std::endl;
   std::vector<double> a(data.size());
   std::vector<MKL_INT> ja(data.size());
   std::vector<MKL_INT> ia(m+1);
   ia[0] =0;
   MKL_INT k=0;
   for(CPPL_INT i=0; i<m; i++){
     //// make map ////
     const std::vector<CPPL_INT>::const_iterator rows_i_end =rows[i].end();
     std::map<CPPL_INT,CPPL_INT> jc;
     for(std::vector<CPPL_INT>::const_iterator rit=rows[i].begin(); rit!=rows_i_end; rit++){
       jc.insert( std::make_pair(data[*rit].j, *rit) );
     }
     //// assign ////
     const std::map<CPPL_INT,CPPL_INT>::const_iterator jc_end =jc.end();
     for(std::map<CPPL_INT,CPPL_INT>::const_iterator jcit=jc.begin(); jcit!=jc_end; jcit++){
       a[k] =data[(*jcit).second].v;
       ja[k] =MKL_INT((*jcit).first);
       k++;
     }
     ia[i+1] =k;
   }
   
   //////// pardisoinit ////////
   //std::cerr << "initializing" << std::endl;
   _MKL_DSS_HANDLE_t pt[64];
   MKL_INT mtype =11;//real unsymmetric
   MKL_INT iparm[64];
   PARDISOINIT(pt, &mtype, iparm);
   iparm[1] =3;//parallel fill-in reducing ordering
   iparm[23] =1;//use two-level scheduling factorization algorithm
   iparm[26] =0;//disable matrix checker
   iparm[34] =-1;//use zero-base array index
   
   //////// pardiso ////////
   //std::cerr << "solving" << std::endl;
   MKL_INT maxfct =1;
   MKL_INT mnum =1;
   MKL_INT phase =13;
   MKL_INT MKL_INT_n =MKL_INT(n);
   std::vector<MKL_INT> perm(n);
   MKL_INT nrhs =1;
   MKL_INT msglvl =0;
   dcovector x(b.l);
   MKL_INT error =1;
   PARDISO(pt, &maxfct, &mnum, &mtype, &phase, &MKL_INT_n, &a[0], &ia[0], &ja[0], &perm[0], &nrhs, iparm, &msglvl, b.array, x.array, &error);
   swap(b,x);//set b as x
   if(error!=0){
     WARNING_REPORT;
     std::cerr << "Serious trouble happend. error = " << error << "." << std::endl;
   }
   
   //////// release memory ////////
   phase =-1;
   MKL_INT error2 =1;
   PARDISO(pt, &maxfct, &mnum, &mtype, &phase, &MKL_INT_n, &a[0], &ia[0], &ja[0], &perm[0], &nrhs, iparm, &msglvl, b.array, x.array, &error2);
   
   return error;
 #endif //__INTEL_COMPILER
 }

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

inline

dgsmatrix=dgsmatrix operator

Definition at line 3 of file dgsmatrix-dgsmatrix.hpp.

References copy(), and data.

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

dgsmatrix & dgsmatrix::operator= ( const _dgsmatrix & mat )

inline

dgsmatrix=_dgsmatrix operator

Definition at line 3 of file dgsmatrix-_dgsmatrix.hpp.

References shallow_copy().

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

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

inline

dgsmatrix+=dgsmatrix operator

Definition at line 17 of file dgsmatrix-dgsmatrix.hpp.

References data, m, and n.

 {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 << ") += (" << mat.m << "x" << mat.n << ")." << std::endl;
     exit(1);
   }
 #endif//CPPL_DEBUG
   
   const std::vector<dcomponent>::const_iterator mat_data_end =mat.data.end();
   for(std::vector<dcomponent>::const_iterator it=mat.data.begin(); it!=mat_data_end; it++){
     (*this)(it->i,it->j) +=it->v;
   }
   
   return *this;
 }

dgsmatrix & dgsmatrix::operator+= ( const _dgsmatrix & mat )

inline

dgsmatrix+=_dgsmatrix operator

Definition at line 15 of file dgsmatrix-_dgsmatrix.hpp.

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

 {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 << ") += (" << mat.m << "x" << mat.n << ")." << std::endl;
     exit(1);
   }
 #endif//CPPL_DEBUG
   
   const std::vector<dcomponent>::const_iterator mat_data_end =mat.data.end();
   for(std::vector<dcomponent>::const_iterator it=mat.data.begin(); it!=mat_data_end; it++){
     (*this)(it->i,it->j) += it->v;
   }
   
   mat.destroy();
   return *this;
 }

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

inline

dgsmatrix-=dgsmatrix operator

Definition at line 38 of file dgsmatrix-dgsmatrix.hpp.

References data, m, and n.

 {CPPL_VERBOSE_REPORT;
 #ifdef  CPPL_DEBUG
   if(n!=mat.n || m!=mat.m){
     ERROR_REPORT;
     std::cerr << "These two matrises can not make a sutraction." << std::endl
               << "Your input was (" << m << "x" << n << ") -= (" << mat.m << "x" << mat.n << ")." << std::endl;
     exit(1);
   }
 #endif//CPPL_DEBUG
   
   const std::vector<dcomponent>::const_iterator mat_data_end =mat.data.end();
   for(std::vector<dcomponent>::const_iterator it=mat.data.begin(); it!=mat_data_end; it++){
     (*this)(it->i,it->j) -=it->v;
   }
   return *this;
 }

dgsmatrix & dgsmatrix::operator-= ( const _dgsmatrix & mat )

inline

dgsmatrix-=_dgsmatrix operator

Definition at line 37 of file dgsmatrix-_dgsmatrix.hpp.

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

 {CPPL_VERBOSE_REPORT;
 #ifdef  CPPL_DEBUG
   if(n!=mat.n || m!=mat.m){
     ERROR_REPORT;
     std::cerr << "These two matrises can not make a sutraction." << std::endl
               << "Your input was (" << m << "x" << n << ") -= (" << mat.m << "x" << mat.n << ")." << std::endl;
     exit(1);
   }
 #endif//CPPL_DEBUG
   
   const std::vector<dcomponent>::const_iterator mat_data_end =mat.data.end();
   for(std::vector<dcomponent>::const_iterator it=mat.data.begin(); it!=mat_data_end; it++){
     (*this)(it->i,it->j) -= it->v;
   }
   
   mat.destroy();
   return *this;
 }

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

inline

dgsmatrix*=dgsmatrix operator

Definition at line 58 of file dgsmatrix-dgsmatrix.hpp.

References data, m, n, rows, 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
   
   dgsmatrix newmat(m, mat.n);
   newmat.zero();
   
   const std::vector<dcomponent>::const_iterator data_end =data.end();
   for(std::vector<dcomponent>::const_iterator it=data.begin(); it!=data_end; it++){
     CPPL_INT k =it->j;
     const std::vector<CPPL_INT>::const_iterator mat_rows_k_end =mat.rows[k].end();
     for(std::vector<CPPL_INT>::const_iterator p=mat.rows[k].begin(); p!=mat_rows_k_end; p++){
       newmat(it->i,mat.data[*p].j) +=it->v*mat.data[*p].v;
     }
   }
   
   swap(*this,newmat);
   return *this;
 }

dgsmatrix & dgsmatrix::operator*= ( const _dgsmatrix & mat )

inline

dgsmatrix*=_dgsmatrix operator

Definition at line 59 of file dgsmatrix-_dgsmatrix.hpp.

References data, _dgsmatrix::data, _dgsmatrix::destroy(), _dgsmatrix::m, m, n, _dgsmatrix::n, _dgsmatrix::rows, and swap.

 {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
   
   dgsmatrix newmat(m, mat.n);
   
   const std::vector<dcomponent>::const_iterator data_end =data.end();
   for(std::vector<dcomponent>::const_iterator it=data.begin(); it!=data_end; it++){
     CPPL_INT k =it->j;
     const std::vector<CPPL_INT>::const_iterator mat_rows_k_end =mat.rows[k].end();
     for(std::vector<CPPL_INT>::const_iterator p=mat.rows[k].begin(); p!=mat_rows_k_end; p++){
       newmat(it->i,mat.data[*p].j) += it->v*mat.data[*p].v;
     }
   }
   
   swap(*this,newmat);
   mat.destroy();
   return *this;
 }

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

inline

dgsmatrix*=double operator

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

References data.

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

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

inline

dgsmatrix/=double operator

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

References data.

 {CPPL_VERBOSE_REPORT;
   const std::vector<dcomponent>::iterator data_end =data.end();
   for(std::vector<dcomponent>::iterator it=data.begin(); it!=data_end; it++){
     it->v /=d;
   }
   
   return *this;
 }

Friends And Related Function Documentation

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

friend

Definition at line 193 of file dgsmatrix-io.hpp.

 {CPPL_VERBOSE_REPORT;
   for(CPPL_INT i=0; i<mat.m; i++){
     const std::vector<CPPL_INT>::const_iterator mat_rows_i_end =mat.rows[i].end();
     for(CPPL_INT j=0; j<mat.n; j++){
       std::vector<CPPL_INT>::const_iterator q;
       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;
   }
   
   return s;
 }

void swap	(	dgsmatrix &	A,
		dgsmatrix &	B
	)

friend

swap two matrices

Definition at line 348 of file dgsmatrix-misc.hpp.

Referenced by operator*=(), and pardiso().

 {CPPL_VERBOSE_REPORT;
   std::swap(A.n,B.n);
   std::swap(A.m,B.m);
   std::swap(A.data,B.data);
   std::swap(A.rows,B.rows);
   std::swap(A.cols,B.cols);
 }

_dgsmatrix _ ( dgsmatrix & mat )

friend

convert user object to smart-temporary object

Definition at line 359 of file dgsmatrix-misc.hpp.

Referenced by col(), row(), to_dgematrix(), and to_zgsmatrix().

 {CPPL_VERBOSE_REPORT;
   _dgsmatrix newmat;
   
   //////// shallow copy ////////
   newmat.n =mat.n;
   newmat.m =mat.m;
   std::swap(newmat.data,mat.data);
   std::swap(newmat.rows,mat.rows);
   std::swap(newmat.cols,mat.cols);
   
   //////// nullify ////////
   mat.m =0;
   mat.n =0;
   
   return newmat;
 }

_dgsmatrix t ( const dgsmatrix & mat )

friend

return transposed dgsmatrix

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

 {CPPL_VERBOSE_REPORT;
   dgsmatrix newmat =mat;
   
   std::swap(newmat.m,newmat.n);
   std::swap(newmat.rows,newmat.cols);
   const std::vector<dcomponent>::iterator newmat_data_end =newmat.data.end();
   for(std::vector<dcomponent>::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 dgsmatrix &	mat
	)

friend

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

Definition at line 23 of file dgsmatrix-calc.hpp.

 {CPPL_VERBOSE_REPORT;
   //////// exception ////////
   if(mat.data.size()==0){
     WARNING_REPORT;
     std::cerr << "The dgsmatrix is a zero matrix." << std::endl;
     return;
   }
   
   //////// find ////////
   std::vector<dcomponent>::const_iterator itx(mat.data.begin());
   double vmax =0.;
   
   const std::vector<dcomponent>::const_iterator mat_data_end =mat.data.end();
   for(std::vector<dcomponent>::const_iterator it=mat.data.begin(); it!=mat_data_end; it++){
     if( vmax < fabs(it->v) ){
       vmax =fabs(it->v);
       itx =it;
     }
   }
   
   i =itx->i;
   j =itx->j;
 }

double damax ( const dgsmatrix & mat )

friend

return its largest absolute value

Definition at line 50 of file dgsmatrix-calc.hpp.

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

const dgsmatrix& operator+ ( const dgsmatrix & mat )

friend

+dgsmatrix operator

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

 {CPPL_VERBOSE_REPORT;
   return mat;
 }

_dgsmatrix operator- ( const dgsmatrix & mat )

friend

-dgsmatrix operator

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

 {CPPL_VERBOSE_REPORT;
   dgsmatrix newmat(mat);
   
   const std::vector<dcomponent>::iterator newmat_data_end =newmat.data.end();
   for(std::vector<dcomponent>::iterator it=newmat.data.begin(); it!=newmat_data_end; it++){
     it->v =-it->v;
   }
   
   return _(newmat);
 }

_dgematrix operator+	(	const dgsmatrix &	matA,
		const dgematrix &	matB
	)

friend

dgsmatrix+dgematrix operator

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

_dgematrix operator+	(	const dgsmatrix &	matA,
		const _dgematrix &	matB
	)

friend

dgsmatrix+_dgematrix operator

Definition at line 3 of file dgsmatrix-_dgematrix.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<dcomponent>::const_iterator matA_data_end =matA.data.end();
   for(std::vector<dcomponent>::const_iterator it=matA.data.begin(); it!=matA_data_end; it++){
     matB(it->i,it->j) += it->v;
   }
   
   return matB;
 }

_dgematrix operator+	(	const dgsmatrix &	matA,
		const dsymatrix &	matB
	)

friend

dgsmatrix+dsymatrix operator

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

_dgematrix operator+	(	const dgsmatrix &	matA,
		const _dsymatrix &	matB
	)

friend

dgsmatrix+_dsymatrix operator

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

_dgematrix operator+	(	const dgsmatrix &	matA,
		const dgbmatrix &	matB
	)

friend

dgsmatrix+dgbmatrix operator

Definition at line 3 of file dgsmatrix-dgbmatrix.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
   
   dgematrix newmat( matA.to_dgematrix() );
   
   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);
     }
   }
   
   return _(newmat);
 }

_dgematrix operator+	(	const dgsmatrix &	matA,
		const _dgbmatrix &	matB
	)

friend

dgsmatrix+_dgbmatrix operator

Definition at line 3 of file dgsmatrix-_dgbmatrix.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
   
   dgematrix newmat( matA.to_dgematrix() );
   
   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);
     }
   }
   
   matB.destroy();
   return _(newmat);
 }

_dgsmatrix operator+	(	const dgsmatrix &	matA,
		const dgsmatrix &	matB
	)

friend

dgsmatrix+dgsmatrix operator

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

_dgsmatrix operator+	(	const dgsmatrix &	matA,
		const _dgsmatrix &	matB
	)

friend

dgsmatrix+_dgsmatrix operator

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

_dgsmatrix operator+	(	const dgsmatrix &	,
		const dssmatrix &
	)

friend

_dgsmatrix operator+	(	const dgsmatrix &	,
		const _dssmatrix &
	)

friend

_dgematrix operator-	(	const dgsmatrix &	matA,
		const dgematrix &	matB
	)

friend

dgsmatrix-dgematrix operator

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

_dgematrix operator-	(	const dgsmatrix &	matA,
		const _dgematrix &	matB
	)

friend

dgsmatrix-_dgematrix operator

Definition at line 24 of file dgsmatrix-_dgematrix.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.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 ////
   const std::vector<dcomponent>::const_iterator matA_data_end =matA.data.end();
   for(std::vector<dcomponent>::const_iterator it=matA.data.begin(); it!=matA_data_end; it++){
     matB(it->i,it->j) += it->v;
   }
   
   return matB;
 }

_dgematrix operator-	(	const dgsmatrix &	matA,
		const dsymatrix &	matB
	)

friend

dgsmatrix-dsymatrix operator

Definition at line 26 of file dgsmatrix-dsymatrix.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 dgematrix ////
   dgematrix newmat( (-matB).to_dgematrix() );
   
   //// add ////
   const std::vector<dcomponent>::const_iterator matA_data_end =matA.data.end();
   for(std::vector<dcomponent>::const_iterator it=matA.data.begin(); it!=matA_data_end; it++){
     newmat(it->i,it->j) += it->v;
   }
   
   return _(newmat);
 }

_dgematrix operator-	(	const dgsmatrix &	matA,
		const _dsymatrix &	matB
	)

friend

dgsmatrix-_dsymatrix operator

Definition at line 27 of file dgsmatrix-_dsymatrix.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.m << "x" << matB.n << ")." << std::endl;
     exit(1);
   }
 #endif//CPPL_DEBUG
   
   dgematrix newmat( (-matB).to_dgematrix() );
   
   const std::vector<dcomponent>::const_iterator matA_data_end =matA.data.end();
   for(std::vector<dcomponent>::const_iterator it=matA.data.begin(); it!=matA_data_end; it++){
     newmat(it->i,it->j) += it->v;
   }
   
   matB.destroy();
   return _(newmat);
 }

_dgematrix operator-	(	const dgsmatrix &	matA,
		const dgbmatrix &	matB
	)

friend

dgsmatrix-dgbmatrix operator

Definition at line 28 of file dgsmatrix-dgbmatrix.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
   
   dgematrix newmat( matA.to_dgematrix() );
   
   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);
     }
   }
   
   return _(newmat);
 }

_dgematrix operator-	(	const dgsmatrix &	matA,
		const _dgbmatrix &	matB
	)

friend

dgsmatrix-_dgbmatrix operator

Definition at line 29 of file dgsmatrix-_dgbmatrix.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
   
   dgematrix newmat( matA.to_dgematrix() );
   
   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);
     }
   }
   
   matB.destroy();
   return _(newmat);
 }

_dgsmatrix operator-	(	const dgsmatrix &	matA,
		const dgsmatrix &	matB
	)

friend

dgsmatrix-dgsmatrix operator

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

_dgsmatrix operator-	(	const dgsmatrix &	matA,
		const _dgsmatrix &	matB
	)

friend

dgsmatrix-_dgsmatrix operator

Definition at line 115 of file dgsmatrix-_dgsmatrix.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
   
   dgsmatrix newmat(matB);
   newmat.chsign();
   
   const std::vector<dcomponent>::const_iterator matA_data_end =matA.data.end();
   for(std::vector<dcomponent>::const_iterator it=matA.data.begin(); it!=matA_data_end; it++){
     newmat(it->i,it->j) += it->v;
   }
   
   return _(newmat);
 }

_dgsmatrix operator-	(	const dgsmatrix &	,
		const dssmatrix &
	)

friend

_dgsmatrix operator-	(	const dgsmatrix &	,
		const _dssmatrix &
	)

friend

_dcovector operator*	(	const dgsmatrix &	mat,
		const dcovector &	vec
	)

friend

dgsmatrix*dcovector operator

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

_dcovector operator*	(	const dgsmatrix &	mat,
		const _dcovector &	vec
	)

friend

dgsmatrix*_dcovector operator

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

_dgematrix operator*	(	const dgsmatrix &	matA,
		const dgematrix &	matB
	)

friend

dgsmatrix*dgematrix operator

Definition at line 49 of file dgsmatrix-dgematrix.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
   
   dgematrix newmat(matA.m, matB.n);
   newmat.zero();
   
   const std::vector<dcomponent>::const_iterator matA_data_end =matA.data.end();
   for(std::vector<dcomponent>::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);
     }
   }
   
   return _(newmat);
 }

_dgematrix operator*	(	const dgsmatrix &	matA,
		const _dgematrix &	matB
	)

friend

dgsmatrix*_dgematrix operator

Definition at line 51 of file dgsmatrix-_dgematrix.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
   
   dgematrix newmat(matA.m, matB.n);
   newmat.zero();
   
   const std::vector<dcomponent>::const_iterator matA_data_end =matA.data.end();
   for(std::vector<dcomponent>::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);
     }
   }
   
   matB.destroy();
   return _(newmat);
 }

_dgematrix operator*	(	const dgsmatrix &	matA,
		const dsymatrix &	matB
	)

friend

dgsmatrix*dsymatrix operator

Definition at line 51 of file dgsmatrix-dsymatrix.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
   
   dgematrix newmat(matA.m, matB.n);
   newmat.zero();
   
   const std::vector<dcomponent>::const_iterator matA_data_end =matA.data.end();
   for(std::vector<dcomponent>::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);
     }
   }
   
   return _(newmat);
 }

_dgematrix operator*	(	const dgsmatrix &	matA,
		const _dsymatrix &	matB
	)

friend

dgsmatrix*_dsymatrix operator

Definition at line 51 of file dgsmatrix-_dsymatrix.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
   
   dgematrix newmat(matA.m, matB.n);
   newmat.zero();
   
   const std::vector<dcomponent>::const_iterator matA_data_end =matA.data.end();
   for(std::vector<dcomponent>::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);
     }
   }
   
   matB.destroy();
   return _(newmat);
 }

_dgematrix operator*	(	const dgsmatrix &	matA,
		const dgbmatrix &	matB
	)

friend

dgsmatrix*dgbmatrix operator

Definition at line 53 of file dgsmatrix-dgbmatrix.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
   
   dgematrix newmat( matA.m, matB.n );
   newmat.zero();
   
   const std::vector<dcomponent>::const_iterator matA_data_end =matA.data.end();
   for(std::vector<dcomponent>::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);
     }
   }
   
   return _(newmat);
 }

_dgematrix operator*	(	const dgsmatrix &	matA,
		const _dgbmatrix &	matB
	)

friend

dgsmatrix*_dgbmatrix operator

Definition at line 55 of file dgsmatrix-_dgbmatrix.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
   
   dgematrix newmat( matA.m, matB.n );
   newmat.zero();
   
   const std::vector<dcomponent>::const_iterator matA_data_end =matA.data.end();
   for(std::vector<dcomponent>::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);
     }
   }
   
   matB.destroy();
   return _(newmat);
 }

_dgsmatrix operator*	(	const dgsmatrix &	matA,
		const dgsmatrix &	matB
	)

friend

dgsmatrix*dgsmatrix operator

Definition at line 137 of file dgsmatrix-dgsmatrix.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
   
   dgsmatrix newmat( matA.m, matB.n );
   
   const std::vector<dcomponent>::const_iterator matA_data_end =matA.data.end();
   for(std::vector<dcomponent>::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;
     }
   }
   
   return _(newmat);
 }

_dgsmatrix operator*	(	const dgsmatrix &	matA,
		const _dgsmatrix &	matB
	)

friend

dgsmatrix*_dgsmatrix operator

Definition at line 139 of file dgsmatrix-_dgsmatrix.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
   
   dgsmatrix newmat(matA.m, matB.n);
 
   const std::vector<dcomponent>::const_iterator matA_data_end =matA.data.end();
   for(std::vector<dcomponent>::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;
     }
   }
   
   matB.destroy();
   return _(newmat);
 }

_dgsmatrix operator*	(	const dgsmatrix &	,
		const dssmatrix &
	)

friend

_dgsmatrix operator*	(	const dgsmatrix &	,
		const _dssmatrix &
	)

friend

_dgsmatrix operator*	(	const dgsmatrix &	mat,
		const double &	d
	)

friend

dgsmatrix*double operator

Definition at line 31 of file dgsmatrix-double.hpp.

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

_dgsmatrix operator/	(	const dgsmatrix &	mat,
		const double &	d
	)

friend

dgsmatrix/double operator

Definition at line 45 of file dgsmatrix-double.hpp.

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

_dgsmatrix operator*	(	const double &	d,
		const dgsmatrix &	mat
	)

friend

double*dgsmatrix operator

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

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