CPPLapack
 All Classes Files Functions Variables Friends Pages
dgbmatrix-misc.hpp
Go to the documentation of this file.
1 //=============================================================================
2 /*! clear all the matrix data and set the sizes 0 */
3 inline void dgbmatrix::clear()
4 {CPPL_VERBOSE_REPORT;
5  m =0;
6  n =0;
7  kl =0;
8  ku =0;
9  delete [] array;
10  array=NULL;
11  delete [] darray;
12  darray=NULL;
13 }
14 
15 
16 //=============================================================================
17 /*! change the matrix into a zero matrix */
19 {CPPL_VERBOSE_REPORT;
20  const CPPL_INT size =(kl+ku+1)*n;
21  for(CPPL_INT i=0; i<size; i++){
22  array[i] =0.0;
23  }
24  return *this;
25 }
26 
27 //=============================================================================
28 /*! change the matrix into an identity matrix */
30 {CPPL_VERBOSE_REPORT;
31 #ifdef CPPL_DEBUG
32  if(m!=n){
33  ERROR_REPORT;
34  std::cerr << "Only square matrix can be a identity matrix." << std::endl
35  << "The matrix size was " << m << "x" << n << "." << std::endl;
36  exit(1);
37  }
38 #endif//CPPL_DEBUG
39 
40  const CPPL_INT size =(kl+ku+1)*n;
41  for(CPPL_INT i=0; i<size; i++){
42  array[i] =0.0;
43  }
44  for(CPPL_INT i=0; i<m; i++){
45  operator()(i,i) =1.0;
46  }
47  return *this;
48 }
49 
50 //=============================================================================
51 /*! change sign(+/-) of the matrix */
52 inline void dgbmatrix::chsign()
53 {CPPL_VERBOSE_REPORT;
54  const CPPL_INT size =(kl+ku+1)*n;
55  for(CPPL_INT i=0; i<size; i++){
56  array[i] =-array[i];
57  }
58 }
59 //=============================================================================
60 /*! make a deep copy of the matrix */
61 inline void dgbmatrix::copy(const dgbmatrix& mat)
62 {CPPL_VERBOSE_REPORT;
63  m =mat.m;
64  n =mat.n;
65  kl =mat.kl;
66  ku =mat.ku;
67  delete [] array;
68  array =new double[(mat.kl+mat.ku+1)*mat.n];
69  delete [] darray;
70  darray =new double*[n];
71  for(int i=0; i<n; i++){
72  darray[i] =&array[i*(kl+ku+1)];
73  }
74 
75  CPPL_INT size =(mat.kl+mat.ku+1)*mat.n;
76  CPPL_INT inc =1;
77  dcopy_(&size, mat.array, &inc, array, &inc);
78 }
79 
80 //=============================================================================
81 /*! make a shallow copy of the matrix\n
82  This function is not designed to be used in project codes. */
83 inline void dgbmatrix::shallow_copy(const _dgbmatrix& mat)
84 {CPPL_VERBOSE_REPORT;
85  m =mat.m;
86  n =mat.n;
87  kl =mat.kl;
88  ku =mat.ku;
89  delete [] array;
90  array =mat.array;
91  delete [] darray;
92  darray =mat.darray;
93 
94  mat.nullify();
95 }
96 
97 //=============================================================================
98 /*! resize the matrix */
99 inline dgbmatrix& dgbmatrix::resize(const CPPL_INT& _m, const CPPL_INT& _n,
100  const CPPL_INT& _kl, const CPPL_INT& _ku)
101 {CPPL_VERBOSE_REPORT;
102 #ifdef CPPL_DEBUG
103  if( _m<0 || _n<0 || _kl<0 || _ku<0 || _m<_kl || _n<_ku ){
104  ERROR_REPORT;
105  std::cerr << "It is impossible to make a matrix you ordered. " << std::endl
106  << "Your input was (" << _m << "," << _n << ","<< _ku << "," << _kl << ")." << std::endl;
107  exit(1);
108  }
109 #endif//CPPL_DEBUG
110 
111  m =_m;
112  n =_n;
113  kl =_kl;
114  ku =_ku;
115  delete [] array;
116  array =new double[(kl+ku+1)*n];
117  delete [] darray;
118  darray =new double*[n];
119  for(int i=0; i<n; i++){ darray[i] =&array[i*(kl+ku+1)]; }
120 
121  return *this;
122 }
123 
124 ///////////////////////////////////////////////////////////////////////////////
125 ///////////////////////////////////////////////////////////////////////////////
126 ///////////////////////////////////////////////////////////////////////////////
127 
128 //=============================================================================
129 /*! get row of the matrix */
130 inline _drovector dgbmatrix::row(const CPPL_INT& _m) const
131 {CPPL_VERBOSE_REPORT;
132 #ifdef CPPL_DEBUG
133  if( _m<0 || _m>m ){
134  ERROR_REPORT;
135  std::cerr << "Input row number must be between 0 and " << m << "." << std::endl
136  << "Your input was " << _m << "." << std::endl;
137  exit(1);
138  }
139 #endif//CPPL_DEBUG
140 
141  drovector v( drovector(n).zero() );
142 
143  const CPPL_INT jmax =std::min(n,_m+ku+1);
144  for(CPPL_INT j=std::max(CPPL_INT(0),_m-kl); j<jmax; j++){
145  v(j)=(*this)(_m,j);
146  }
147 
148  return _(v);
149 }
150 
151 //=============================================================================
152 /*! get column of the matrix */
153 inline _dcovector dgbmatrix::col(const CPPL_INT& _n) const
154 {CPPL_VERBOSE_REPORT;
155 #ifdef CPPL_DEBUG
156  if( _n<0 || _n>n ){
157  ERROR_REPORT;
158  std::cerr << "Input row number must be between 0 and " << n << "." << std::endl
159  << "Your input was " << _n << "." << std::endl;
160  exit(1);
161  }
162 #endif//CPPL_DEBUG
163 
164  dcovector v( dcovector(m).zero() );
165 
166  const CPPL_INT imax =std::min(m,_n+kl+1);
167  for(CPPL_INT i=std::max(CPPL_INT(0),_n-ku); i<imax; i++){
168  v(i)=(*this)(i,_n);
169  }
170 
171  return _(v);
172 }
173 
174 ///////////////////////////////////////////////////////////////////////////////
175 ///////////////////////////////////////////////////////////////////////////////
176 ///////////////////////////////////////////////////////////////////////////////
177 
178 //=============================================================================
179 /*! swap two matrices */
180 inline void swap(dgbmatrix& A, dgbmatrix& B)
181 {CPPL_VERBOSE_REPORT;
182  CPPL_INT A_m =A.m, A_n =A.n, A_kl =A.kl, A_ku =A.ku;
183  double* A_array =A.array;
184  double** A_darray=A.darray;
185  A.m=B.m; A.n=B.n; A.kl=B.kl; A.ku=B.ku; A.array=B.array; A.darray=B.darray;
186  B.m=A_m; B.n=A_n; B.kl=A_kl; B.ku=A_ku; B.array=A_array; B.darray=A_darray;
187 }
188 
189 //=============================================================================
190 /*! convert user object to smart-temporary object */
191 inline _dgbmatrix _(dgbmatrix& mat)
192 {CPPL_VERBOSE_REPORT;
193  _dgbmatrix newmat;
194 
195  //////// shallow copy ////////
196  newmat.m =mat.m;
197  newmat.n =mat.n;
198  newmat.kl =mat.kl;
199  newmat.ku =mat.ku;
200  newmat.array =mat.array;
201  newmat.darray =mat.darray;
202 
203  //////// nullify ////////
204  mat.m =0;
205  mat.n =0;
206  mat.kl =0;
207  mat.ku =0;
208  mat.array =NULL;
209  mat.darray =NULL;
210 
211  return newmat;
212 }
friend _dgematrix i(const dgbmatrix &)
CPPL_INT m
matrix row size
Definition: dgbmatrix.hpp:9
friend _dgbmatrix _(dgbmatrix &)
double ** darray
array of pointers of column head addresses
Definition: _dgbmatrix.hpp:14
void nullify() const
_dgbmatrix _(dgbmatrix &mat)
CPPL_INT ku
upper band width
Definition: _dgbmatrix.hpp:12
double ** darray
array of pointers of column head addresses
Definition: dgbmatrix.hpp:14
void shallow_copy(const _dgbmatrix &)
dgbmatrix & identity()
CPPL_INT kl
lower band width
Definition: dgbmatrix.hpp:11
CPPL_INT kl
lower band width
Definition: _dgbmatrix.hpp:11
CPPL_INT ku
upper band width
Definition: dgbmatrix.hpp:12
double * array
1D array to store matrix data
Definition: dgbmatrix.hpp:13
_dcovector col(const CPPL_INT &) const
CPPL_INT n
matrix column size
Definition: _dgbmatrix.hpp:10
Real Double-precision Row Vector Class.
Definition: drovector.hpp:3
(DO NOT USE) Smart-temporary Real Double-precision Row Vector Class
Definition: _drovector.hpp:3
dgbmatrix & resize(const CPPL_INT &, const CPPL_INT &, const CPPL_INT &, const CPPL_INT &)
Real Double-precision General Band Matrix Class.
Definition: dgbmatrix.hpp:3
_drovector row(const CPPL_INT &) const
void clear()
double * array
1D array to store matrix data
Definition: _dgbmatrix.hpp:13
void swap(dgbmatrix &A, dgbmatrix &B)
void copy(const dgbmatrix &)
(DO NOT USE) Smart-temporary Real Double-precision General Band Matrix Class
Definition: _dgbmatrix.hpp:3
Real Double-precision Column Vector Class.
Definition: dcovector.hpp:3
dgbmatrix & zero()
double & operator()(const CPPL_INT &, const CPPL_INT &)
Definition: dgbmatrix-io.hpp:3
CPPL_INT n
matrix column size
Definition: dgbmatrix.hpp:10
(DO NOT USE) Smart-temporary Real Double-precision Column Vector Class
Definition: _dcovector.hpp:3
CPPL_INT m
matrix row size
Definition: _dgbmatrix.hpp:9