My Project
zgematrix-constructor.hpp
1 //============================================================================
4  : m(M), n(N), array(Array), darray(Darray)
5 {
6 #ifdef CPPL_VERBOSE
7  std::cerr << "# [MARK] zgematrix::zgematrix()"
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] zgematrix::zgematrix() "
19  << "A new 0x0 matrix at " << Array
20  << " has been made." << std::endl;
21 #endif//CPPL_DEBUG
22 }
23 
24 //============================================================================
26 inline zgematrix::zgematrix(const zgematrix& mat)
27  : m(M), n(N), array(Array), darray(Darray)
28 {
29 #ifdef CPPL_VERBOSE
30  std::cerr << "# [MARK] zgematrix::zgematrix(const zgematrix&)"
31  << std::endl;
32 #endif//CPPL_VERBOSE
33 
35  M =mat.M;
36  N =mat.N;
37  Array =new std::complex<double>[M*N];
38  Darray =new std::complex<double>*[N];
39  for(int i=0; i<N; i++){ Darray[i] =&Array[i*M]; }
40 
42  zcopy_(M*N, mat.Array, 1, Array, 1);
43 
44 #ifdef CPPL_DEBUG
45  std::cerr << "# [NOTE] zgematrix::zgematrix(const zgematrix&) "
46  << "A new matrix at " << Array << " has been made." << std::endl;
47 #endif//CPPL_DEBUG
48 }
49 
50 //============================================================================
52 inline zgematrix::zgematrix(const _zgematrix& mat)
53  : m(M), n(N), array(Array), darray(Darray)
54 {
55 #ifdef CPPL_VERBOSE
56  std::cerr << "# [MARK] zgematrix::zgematrix(const _zgematrix&)"
57  << std::endl;
58 #endif//CPPL_VERBOSE
59 
60  M =mat.M;
61  N =mat.N;
62  Array =mat.Array;
63  Darray =mat.Darray;
64 
65 #ifdef CPPL_DEBUG
66  std::cerr << "# [NOTE] zgematrix::zgematrix(const _zgematrix&) "
67  << "A new matrix pointing at " << Array << " has been made."
68  << std::endl;
69 #endif//CPPL_DEBUG
70 }
71 
72 //============================================================================
74 inline zgematrix::zgematrix(const zgbmatrix& mat)
75  : m(M), n(N), array(Array), darray(Darray)
76 {
77 #ifdef CPPL_VERBOSE
78  std::cerr << "# [MARK] zgematrix::zgematrix(const zgbmatrix&)"
79  << std::endl;
80 #endif//CPPL_VERBOSE
81 
83  M =mat.M;
84  N =mat.N;
85  Array =new std::complex<double>[M*N];
86  Darray =new std::complex<double>*[N];
87  for(int i=0; i<N; i++){ Darray[i] =&Array[i*M]; }
88 
90  zero();
91  for(long i=0; i<mat.M; i++){
92  for(long j=max(0,i-mat.KL); j<min(N,i+mat.KU+1); j++){
93  operator()(i,j) =mat(i,j);
94  }
95  }
96 #ifdef CPPL_DEBUG
97  std::cerr << "# [NOTE] zgematrix::zgematrix(const zgbmatrix&) "
98  << "A new matrix at " << Array << " has been made." << std::endl;
99 #endif//CPPL_DEBUG
100 }
101 
102 //============================================================================
104 inline zgematrix::zgematrix(const _zgbmatrix& mat)
105  : m(M), n(N), array(Array), darray(Darray)
106 {
107 #ifdef CPPL_VERBOSE
108  std::cerr << "# [MARK] zgematrix::zgematrix(const _zgbmatrix&)"
109  << std::endl;
110 #endif//CPPL_VERBOSE
111 
113  M =mat.M;
114  N =mat.N;
115  Array =new std::complex<double>[M*N];
116  Darray =new std::complex<double>*[N];
117  for(int i=0; i<N; i++){ Darray[i] =&Array[i*M]; }
118 
120  zero();
121  for(long i=0; i<mat.M; i++){
122  for(long j=max(0,i-mat.KL); j<min(N,i+mat.KU+1); j++){
123  operator()(i,j) =mat(i,j);
124  }
125  }
126 
127  mat.destroy();
128 
129 #ifdef CPPL_DEBUG
130  std::cerr << "# [NOTE] zgematrix::zgematrix(const zgbmatrix&) "
131  << "A new matrix at " << Array << " has been made." << std::endl;
132 #endif//CPPL_DEBUG
133 }
134 
135 //============================================================================
137 inline zgematrix::zgematrix(const zhematrix& mat)
138  : m(M), n(N), array(Array), darray(Darray)
139 {
140 #ifdef CPPL_VERBOSE
141  std::cerr << "# [MARK] zgematrix::zgematrix(const zhematrix&)"
142  << std::endl;
143 #endif//CPPL_VERBOSE
144 
146  M =mat.N;
147  N =mat.N;
148  Array =new std::complex<double>[N*N];
149  Darray =new std::complex<double>*[N];
150  for(int i=0; i<N; i++){ Darray[i] =&Array[i*M]; }
151 
153  zero();
154  for(long i=0; i<mat.N; i++){
155  for(long j=0; j<mat.N; j++ ){
156  operator()(i,j) =mat(i,j);
157  }
158  }
159 #ifdef CPPL_DEBUG
160  std::cerr << "# [NOTE] zgematrix::zgematrix(const zhematrix&) "
161  << "A new matrix at " << Array << " has been made." << std::endl;
162 #endif//CPPL_DEBUG
163 }
164 
165 //============================================================================
167 inline zgematrix::zgematrix(const _zhematrix& mat)
168  : m(M), n(N), array(Array), darray(Darray)
169 {
170 #ifdef CPPL_VERBOSE
171  std::cerr << "# [MARK] zgematrix::zgematrix(const _zhematrix&)"
172  << std::endl;
173 #endif//CPPL_VERBOSE
174 
176  M =mat.N;
177  N =mat.N;
178  Array =mat.Array;
179  Darray =mat.Darray;
180  //Darray =new std::complex<double>*[N];
181  //for(int i=0; i<N; i++){ Darray[i] =&Array[i*M]; }
182 
184  for(long i=0; i<mat.N; i++){ for(long j=0; j<i; j++){
185  operator()(j,i) =std::conj(operator()(i,j));
186  }}
187 
188 #ifdef CPPL_DEBUG
189  std::cerr << "# [NOTE] zgematrix::zgematrix(const _zhematrix&) "
190  << "A matrix at " << Array << " has been transformed into "
191  << "zgematrix." << std::endl;
192 #endif//CPPL_DEBUG
193 }
194 
195 //============================================================================
197 inline zgematrix::zgematrix(const zssmatrix& mat)
198  : m(M), n(N), array(Array), darray(Darray)
199 {
200 #ifdef CPPL_VERBOSE
201  std::cerr << "# [MARK] zgematrix::zgematrix(const zssmatrix&)"
202  << std::endl;
203 #endif//CPPL_VERBOSE
204 
206  M =mat.M;
207  N =mat.N;
208  Array =new std::complex<double>[M*N];
209  Darray =new std::complex<double>*[N];
210  for(int i=0; i<N; i++){ Darray[i] =&Array[i*M]; }
211 
213  zero();
214  for(long c=0; c<mat.VOL; c++) {
215  operator()(mat.Indx[c],mat.Jndx[c]) =mat.Array[c];
216  }
217 
218 #ifdef CPPL_DEBUG
219  std::cerr << "# [NOTE] zgematrix::zgematrix(const zssmatrix&) "
220  << "A new matrix at " << Array << " has been made." << std::endl;
221 #endif//CPPL_DEBUG
222 }
223 
224 //============================================================================
226 inline zgematrix::zgematrix(const _zssmatrix& mat)
227  : m(M), n(N), array(Array), darray(Darray)
228 {
229 #ifdef CPPL_VERBOSE
230  std::cerr << "# [MARK] zgematrix::zgematrix(const _zssmatrix&)"
231  << std::endl;
232 #endif//CPPL_VERBOSE
233 
235  M =mat.M;
236  N =mat.N;
237  Array =new std::complex<double>[M*N];
238  Darray =new std::complex<double>*[N];
239  for(int i=0; i<N; i++){ Darray[i] =&Array[i*M]; }
240 
242  zero();
243  for(long c=0; c<mat.VOL; c++){
244  operator()(mat.Indx[c],mat.Jndx[c]) =mat.Array[c];
245  }
246 
247  mat.destroy();
248 
249 #ifdef CPPL_DEBUG
250  std::cerr << "# [NOTE] zgematrix::zgematrix(const _zssmatrix&) "
251  << "A new matrix at " << Array << " has been made." << std::endl;
252 #endif//CPPL_DEBUG
253 }
254 
255 //============================================================================
257 inline zgematrix::zgematrix(const long& _m, const long& _n)
258  : m(M), n(N), array(Array), darray(Darray)
259 {
260 #ifdef CPPL_VERBOSE
261  std::cerr << "# [MARK] zgematrix::zgematrix(const long&, const long&)"
262  << std::endl;
263 #endif//CPPL_VERBOSE
264 
265 #ifdef CPPL_DEBUG
266  if( _m<0 || _n<0 ){
267  std::cerr << "[ERROR] zgematrix::zgematrix(const long, const long)"
268  << std::endl
269  << "Matrix sizes must be positive integers. " << std::endl
270  << "Your input was (" << _m << "," << _n << ")." << std::endl;
271  exit(1);
272  }
273 #endif//CPPL_DEBUG
274 
276  M =_m;
277  N =_n;
278  Array =new std::complex<double>[M*N];
279  Darray =new std::complex<double>*[N];
280  for(int i=0; i<N; i++){ Darray[i] =&Array[i*M]; }
281 
282 #ifdef CPPL_DEBUG
283  std::cerr << "# [NOTE] zgematrix(long,long) "
284  << "A new matrix at " << Array << " has been made." << std::endl;
285 #endif//CPPL_DEBUG
286 }
287 
288 //============================================================================
290 inline zgematrix::zgematrix(const char* filename)
291  : m(M), n(N), array(Array), darray(Darray)
292 {
293 #ifdef CPPL_VERBOSE
294  std::cerr << "# [MARK] zgematrix::zgematrix(const char*)"
295  << std::endl;
296 #endif//CPPL_VERBOSE
297 
298  Array =NULL;
299  Darray =NULL;
300 
302  read(filename);
303 
304 #ifdef CPPL_DEBUG
305  std::cerr << "# [NOTE] zgematrix::zgematrix(const char*) "
306  << "A new matrix at " << Array << " has been made." << std::endl;
307 #endif//CPPL_DEBUG
308 }
309 
313 
314 //============================================================================
316 inline zgematrix::~zgematrix()
317 {
318 #ifdef CPPL_VERBOSE
319  std::cerr << "# [MARK] zgematrix::~zgematrix()"
320  << std::endl;
321 #endif//CPPL_VERBOSE
322 
323 #ifdef CPPL_DEBUG
324  std::cerr << "# [NOTE] zgematrix::~zgematrix() "
325  << "A matrix at " << Array << " is going to be deleted." << std::endl;
326 #endif//CPPL_DEBUG
327  delete [] Array;
329  delete [] Darray;
330 }
std::complex< double > ** Darray
array of pointers of column head addresses
Definition: _zhematrix.hpp:9
(DO NOT USE) Smart-temporary Complex Double-precision Hermitian Matrix Class
Definition: _zhematrix.hpp:3
long M
matrix row size
Definition: _zssmatrix.hpp:7
long VOL
the number of non-zero components
Definition: _zssmatrix.hpp:10
(DO NOT USE) Smart-temporary Complex Double-precision Sparse Matrix Class
Definition: _zssmatrix.hpp:3
long N
matrix column size
Definition: _zgematrix.hpp:8
long N
matrix column size
Definition: _zgbmatrix.hpp:8
void destroy() const
Definition: _zgbmatrix-misc.hpp:3
friend _zgematrix i(const zgematrix &)
Definition: zgematrix-calc.hpp:21
~zgematrix()
Definition: zgematrix-constructor.hpp:316
Complex Double-precision General Dence Matrix Class.
Definition: zgematrix.hpp:3
long KU
upper band width
Definition: _zgbmatrix.hpp:10
(DO NOT USE) Smart-temporary Complex Double-precision General Dence Matrix Class
Definition: _zgematrix.hpp:3
zgematrix()
Definition: zgematrix-constructor.hpp:3
void zero()
Definition: zgematrix-misc.hpp:26
std::complex< double > * Array
1D array to store non-zero matrix data
Definition: _zssmatrix.hpp:11
Complex Double-precision General Band Matrix Class.
Definition: zgbmatrix.hpp:3
std::complex< double > * Array
1D Array to store matrix data
Definition: _zgematrix.hpp:9
std::complex< double > * Array
1D Array to store matrix data
Definition: _zhematrix.hpp:8
std::complex< double > & operator()(const long &, const long &)
Definition: zgematrix-io.hpp:3
void destroy() const
Definition: _zssmatrix-misc.hpp:3
long M
matrix row size
Definition: _zgbmatrix.hpp:7
std::complex< double > ** Darray
array of pointers of column head addresses
Definition: _zgematrix.hpp:10
(DO NOT USE) Smart-temporary Complex Double-precision General Band Matrix Class
Definition: _zgbmatrix.hpp:3
long M
matrix row size
Definition: _zgematrix.hpp:7
Complex Double-precision Hermitian Matrix Class [L-type (UPLO=L) Strage].
Definition: zhematrix.hpp:4
long N
matrix column or row size
Definition: _zhematrix.hpp:7
long N
matrix column size
Definition: _zssmatrix.hpp:8
long * Jndx
1D array to store the j-index of non-zero matrix components
Definition: _zssmatrix.hpp:13
Complex Double-precision Sparse Matrix Class.
Definition: zssmatrix.hpp:3
long KL
lower band width
Definition: _zgbmatrix.hpp:9
long * Indx
1D array to store the i-index of non-zero matrix components
Definition: _zssmatrix.hpp:12
std::complex< double > * Array
1D Array to store vector data
Definition: _zrovector.hpp:8