My Project
dgematrix-constructor.hpp
1 //============================================================================
4  : m(M), n(N), array(Array), darray(Darray)
5 {
6 #ifdef CPPL_VERBOSE
7  std::cerr << "# [MARK] dgematrix::dgematrix()"
8  << std::endl;
9 #endif//CPPL_VERBOSE
10 
12  M =0;
13  N =0;
14  Array =NULL;
15  Darray =NULL;
16 
17 #ifdef CPPL_DEBUG
18  std::cerr << "# [NOTE] dgematrix::dgematrix() "
19  << "A new 0x0 matrix at " << Array
20  << " has been made." << std::endl;
21 #endif//CPPL_DEBUG
22 }
23 
27 
28 //============================================================================
30 inline dgematrix::dgematrix(const dgematrix& mat)
31  : m(M), n(N), array(Array), darray(Darray)
32 {
33 #ifdef CPPL_VERBOSE
34  std::cerr << "# [MARK] dgematrix::dgematrix(const dgematrix&)"
35  << std::endl;
36 #endif//CPPL_VERBOSE
37 
39  M =mat.M;
40  N =mat.N;
41  Array =new double[M*N];
42  Darray =new double*[N];
43  for(int i=0; i<N; i++){ Darray[i] =&Array[i*M]; }
44 
46  dcopy_(M*N, mat.Array, 1, Array, 1);
47 
48 #ifdef CPPL_DEBUG
49  std::cerr << "# [NOTE] dgematrix::dgematrix(const dgematrix&) "
50  << "A new matrix at " << Array << " has been made." << std::endl;
51 #endif//CPPL_DEBUG
52 }
53 
54 //============================================================================
56 inline dgematrix::dgematrix(const _dgematrix& mat)
57  : m(M), n(N), array(Array), darray(Darray)
58 {
59 #ifdef CPPL_VERBOSE
60  std::cerr << "# [MARK] dgematrix::dgematrix(const _dgematrix&)"
61  << std::endl;
62 #endif//CPPL_VERBOSE
63 
64  M =mat.M;
65  N =mat.N;
66  Array =mat.Array;
67  Darray =mat.Darray;
68 
69 #ifdef CPPL_DEBUG
70  std::cerr << "# [NOTE] dgematrix::dgematrix(const _dgematrix&) "
71  << "A new matrix pointing at " << Array << " has been made."
72  << std::endl;
73 #endif//CPPL_DEBUG
74 }
75 
79 
80 //============================================================================
82 inline dgematrix::dgematrix(const dgbmatrix& mat)
83  : m(M), n(N), array(Array), darray(Darray)
84 {
85 #ifdef CPPL_VERBOSE
86  std::cerr << "# [MARK] dgematrix::dgematrix(const dgbmatrix&)"
87  << std::endl;
88 #endif//CPPL_VERBOSE
89 
91  M =mat.M;
92  N =mat.N;
93  Array =new double[M*N];
94  Darray =new double*[N];
95  for(int i=0; i<N; i++){ Darray[i] =&Array[i*M]; }
96 
98  zero();
99  for(long i=0; i<mat.M; i++){
100  for(long j=max(0,i-mat.KL); j<min(N,i+mat.KU+1); j++){
101  operator()(i,j) =mat(i,j);
102  }
103  }
104 #ifdef CPPL_DEBUG
105  std::cerr << "# [NOTE] dgematrix::dgematrix(const dgbmatrix&) "
106  << "A new matrix at " << Array << " has been made." << std::endl;
107 #endif//CPPL_DEBUG
108 }
109 
110 //============================================================================
112 inline dgematrix::dgematrix(const _dgbmatrix& mat)
113  : m(M), n(N), array(Array), darray(Darray)
114 {
115 #ifdef CPPL_VERBOSE
116  std::cerr << "# [MARK] dgematrix::dgematrix(const _dgbmatrix&)"
117  << std::endl;
118 #endif//CPPL_VERBOSE
119 
121  M =mat.M;
122  N =mat.N;
123  Array =new double[M*N];
124  Darray =new double*[N];
125  for(int i=0; i<N; i++){ Darray[i] =&Array[i*M]; }
126 
128  zero();
129  for(long i=0; i<mat.M; i++){
130  for(long j=max(0,i-mat.KL); j<min(N,i+mat.KU+1); j++){
131  operator()(i,j) =mat(i,j);
132  }
133  }
134 
135  mat.destroy();
136 
137 #ifdef CPPL_DEBUG
138  std::cerr << "# [NOTE] dgematrix::dgematrix(const dgbmatrix&) "
139  << "A new matrix at " << Array << " has been made." << std::endl;
140 #endif//CPPL_DEBUG
141 }
142 
146 
147 //============================================================================
149 inline dgematrix::dgematrix(const dsymatrix& mat)
150  : m(M), n(N), array(Array), darray(Darray)
151 {
152 #ifdef CPPL_VERBOSE
153  std::cerr << "# [MARK] dgematrix::dgematrix(const dsymatrix&)"
154  << std::endl;
155 #endif//CPPL_VERBOSE
156 
158  M =mat.N;
159  N =mat.N;
160  Array =new double[N*N];
161  Darray =new double*[N];
162  for(int i=0; i<N; i++){ Darray[i] =&Array[i*M]; }
163 
165  zero();
166  for(long i=0; i<mat.N; i++) {
167  for(long j=0; j<mat.N; j++ ) {
168  operator()(i,j) =mat(i,j);
169  }
170  }
171 #ifdef CPPL_DEBUG
172  std::cerr << "# [NOTE] dgematrix::dgematrix(const dsymatrix&) "
173  << "A new matrix at " << Array << " has been made." << std::endl;
174 #endif//CPPL_DEBUG
175 }
176 
177 //============================================================================
179 inline dgematrix::dgematrix(const _dsymatrix& mat)
180  : m(M), n(N), array(Array), darray(Darray)
181 {
182 #ifdef CPPL_VERBOSE
183  std::cerr << "# [MARK] dgematrix::dgematrix(const _dsymatrix&)"
184  << std::endl;
185 #endif//CPPL_VERBOSE
186 
188  M =mat.N;
189  N =mat.N;
190  Array =mat.Array;
191  Darray =mat.Darray;
192  //Darray =new double*[N];
193  //for(int i=0; i<N; i++){ Darray[i] =&Array[i*M]; }
194 
196  for(long i=0; i<mat.N; i++){ for(long j=0; j<i; j++){
197  operator()(j,i) =operator()(i,j);
198  }}
199 
200 #ifdef CPPL_DEBUG
201  std::cerr << "# [NOTE] dgematrix::dgematrix(const _dsymatrix&) "
202  << "A matrix at " << Array << " has been transformed into "
203  << "dgematrix." << std::endl;
204 #endif//CPPL_DEBUG
205 }
206 
210 
211 //============================================================================
213 inline dgematrix::dgematrix(const dssmatrix& mat)
214  : m(M), n(N), array(Array), darray(Darray)
215 {
216 #ifdef CPPL_VERBOSE
217  std::cerr << "# [MARK] dgematrix::dgematrix(const dssmatrix&)"
218  << std::endl;
219 #endif//CPPL_VERBOSE
220 
222  M =mat.M;
223  N =mat.N;
224  Array =new double[M*N];
225  Darray =new double*[N];
226  for(int i=0; i<N; i++){ Darray[i] =&Array[i*M]; }
227 
229  zero();
230  for(long c=0; c<mat.VOL; c++) {
231  operator()(mat.Indx[c],mat.Jndx[c]) =mat.Array[c];
232  }
233 
234 #ifdef CPPL_DEBUG
235  std::cerr << "# [NOTE] dgematrix::dgematrix(const dssmatrix&) "
236  << "A new matrix at " << Array << " has been made." << std::endl;
237 #endif//CPPL_DEBUG
238 }
239 
240 //============================================================================
242 inline dgematrix::dgematrix(const _dssmatrix& mat)
243  : m(M), n(N), array(Array), darray(Darray)
244 {
245 #ifdef CPPL_VERBOSE
246  std::cerr << "# [MARK] dgematrix::dgematrix(const _dssmatrix&)"
247  << std::endl;
248 #endif//CPPL_VERBOSE
249 
251  M =mat.M;
252  N =mat.N;
253  Array =new double[M*N];
254  Darray =new double*[N];
255  for(int i=0; i<N; i++){ Darray[i] =&Array[i*M]; }
256 
258  zero();
259  for(long c=0; c<mat.VOL; c++){
260  operator()(mat.Indx[c],mat.Jndx[c]) =mat.Array[c];
261  }
262 
263  mat.destroy();
264 
265 #ifdef CPPL_DEBUG
266  std::cerr << "# [NOTE] dgematrix::dgematrix(const _dssmatrix&) "
267  << "A new matrix at " << Array << " has been made." << std::endl;
268 #endif//CPPL_DEBUG
269 }
270 
274 
275 //============================================================================
277 inline dgematrix::dgematrix(const long& _m, const long& _n)
278  : m(M), n(N), array(Array), darray(Darray)
279 {
280 #ifdef CPPL_VERBOSE
281  std::cerr << "# [MARK] dgematrix::dgematrix(const long&, const long&)"
282  << std::endl;
283 #endif//CPPL_VERBOSE
284 
285 #ifdef CPPL_DEBUG
286  if( _m<0 || _n<0 ){
287  std::cerr << "[ERROR] dgematrix::dgematrix(const long, const long)"
288  << std::endl
289  << "Matrix sizes must be positive integers. " << std::endl
290  << "Your input was (" << _m << "," << _n << ")." << std::endl;
291  exit(1);
292  }
293 #endif//CPPL_DEBUG
294 
296  M =_m;
297  N =_n;
298  Array =new double[M*N];
299  Darray =new double*[N];
300  for(int i=0; i<N; i++){ Darray[i] =&Array[i*M]; }
301 
302 #ifdef CPPL_DEBUG
303  std::cerr << "# [NOTE] dgematrix(long,long) "
304  << "A new matrix at " << Array << " has been made." << std::endl;
305 #endif//CPPL_DEBUG
306 }
307 
308 //============================================================================
310 inline dgematrix::dgematrix(const char* filename)
311  : m(M), n(N), array(Array), darray(Darray)
312 {
313 #ifdef CPPL_VERBOSE
314  std::cerr << "# [MARK] dgematrix::dgematrix(const char*)"
315  << std::endl;
316 #endif//CPPL_VERBOSE
317 
318  Array =NULL;
319  Darray =NULL;
320 
322  read(filename);
323 
324 #ifdef CPPL_DEBUG
325  std::cerr << "# [NOTE] dgematrix::dgematrix(const char*) "
326  << "A new matrix at " << Array << " has been made." << std::endl;
327 #endif//CPPL_DEBUG
328 }
329 
333 
334 //============================================================================
336 inline dgematrix::~dgematrix()
337 {
338 #ifdef CPPL_VERBOSE
339  std::cerr << "# [MARK] dgematrix::~dgematrix()"
340  << std::endl;
341 #endif//CPPL_VERBOSE
342 
343 #ifdef CPPL_DEBUG
344  std::cerr << "# [NOTE] dgematrix::~dgematrix() "
345  << "A matrix at " << Array << " is going to be deleted." << std::endl;
346 #endif//CPPL_DEBUG
347  delete [] Darray;
349  delete [] Array;
350 }
double * Array
1D array to store non-zero matrix data
Definition: _dssmatrix.hpp:11
~dgematrix()
Definition: dgematrix-constructor.hpp:336
void zero()
Definition: dgematrix-misc.hpp:26
long KL
lower band width
Definition: _dgbmatrix.hpp:9
(DO NOT USE) Smart-temporary Real Double-precision Sparse Matrix Class
Definition: _dssmatrix.hpp:3
long M
matrix row size
Definition: _dgbmatrix.hpp:7
void destroy() const
Definition: _dgbmatrix-misc.hpp:3
double * Array
1D Array to store vector data
Definition: _drovector.hpp:8
long M
matrix row size
Definition: _dssmatrix.hpp:7
double ** Darray
array of pointers of column head addresses
Definition: _dgematrix.hpp:10
Real Double-precision General Dence Matrix Class.
Definition: dgematrix.hpp:3
long N
matrix column size
Definition: _dgbmatrix.hpp:8
double * Array
1D Array to store matrix data
Definition: _dsymatrix.hpp:8
Real Double-precision Symmetric Matrix Class [L-type (UPLO=L) Strage].
Definition: dsymatrix.hpp:3
double ** Darray
array of pointers of column head addresses
Definition: _dsymatrix.hpp:9
long * Jndx
1D array to store the j-index of non-zero matrix components
Definition: _dssmatrix.hpp:13
(DO NOT USE) Smart-temporary Real Double-precision General Dence Matrix Class
Definition: _dgematrix.hpp:3
long N
matrix column size
Definition: _dgematrix.hpp:8
Real Double-precision General Band Matrix Class.
Definition: dgbmatrix.hpp:3
long VOL
the number of non-zero components
Definition: _dssmatrix.hpp:10
double * Array
1D array to store matrix data
Definition: _dgematrix.hpp:9
long N
matrix column or row size
Definition: _dsymatrix.hpp:7
(DO NOT USE) Smart-temporary Real Double-precision General Band Matrix Class
Definition: _dgbmatrix.hpp:3
long N
matrix column size
Definition: _dssmatrix.hpp:8
(DO NOT USE) Smart-temporary Real Double-precision Symmetric Matrix Class
Definition: _dsymatrix.hpp:3
Real Double-precision Sparse Matrix Class.
Definition: dssmatrix.hpp:3
friend _dgematrix i(const dgematrix &)
Definition: dgematrix-calc.hpp:21
long * Indx
1D array to store the i-index of non-zero matrix components
Definition: _dssmatrix.hpp:12
void destroy() const
Definition: _dssmatrix-misc.hpp:3
long KU
upper band width
Definition: _dgbmatrix.hpp:10
dgematrix()
Definition: dgematrix-constructor.hpp:3
long M
matrix row size
Definition: _dgematrix.hpp:7
double & operator()(const long &, const long &)
Definition: dgematrix-io.hpp:3