VERB_code_2.3
zgematrix-misc.hpp
1 //=============================================================================
3 inline void zgematrix::clear()
4 {
5 #ifdef CPPL_VERBOSE
6  std::cerr << "# [MARK] zgematrix::clear()"
7  << std::endl;
8 #endif//CPPL_VERBOSE
9 
10 #ifdef CPPL_DEBUG
11  std::cerr << "# [NOTE] zgematrix::clear() "
12  << " An array at " << Array
13  << " is going to be cleared." << std::endl;
14 #endif//CPPL_DEBUG
15 
16  M =0;
17  N =0;
18  delete [] Array;
19  Array =NULL;
20  delete [] Darray;
21  Darray =NULL;
22 }
23 
24 //=============================================================================
26 inline void zgematrix::zero()
27 {
28 #ifdef CPPL_VERBOSE
29  std::cerr << "# [MARK] zgematrix::zero()"
30  << std::endl;
31 #endif//CPPL_VERBOSE
32 
33  for(long i=0; i<M*N; i++){ Array[i] =std::complex<double>(0.0,0.0); }
34 }
35 
36 //=============================================================================
38 inline void zgematrix::identity()
39 {
40 #ifdef CPPL_VERBOSE
41  std::cerr << "# [MARK] zgematrix::identity()"
42  << std::endl;
43 #endif//CPPL_VERBOSE
44 
45 #ifdef CPPL_DEBUG
46  if(M!=N){
47  std::cerr << "[ERROR] zgematrix::identity()" << std::endl
48  << "Only square matrix can be a identity matrix." << std::endl
49  << "The matrix size was " << M << "x" << N << "." << std::endl;
50  exit(1);
51  }
52 #endif//CPPL_DEBUG
53 
54  for(long i=0; i<M*N; i++){ Array[i] =std::complex<double>(0.0,0.0); }
55  for(long i=0; i<M; i++){ operator()(i,i) =std::complex<double>(1.0,0.0); }
56 }
57 
58 //=============================================================================
60 inline void zgematrix::chsign()
61 {
62 #ifdef CPPL_VERBOSE
63  std::cerr << "# [MARK] zgematrix::chsign()"
64  << std::endl;
65 #endif//CPPL_VERBOSE
66 
67  for(long i=0; i<M*N; i++){ Array[i] =-Array[i]; }
68 }
69 
70 //=============================================================================
72 inline void zgematrix::copy(const zgematrix& mat)
73 {
74 #ifdef CPPL_VERBOSE
75  std::cerr << "# [MARK] zgematrix::copy(const zgematrix&)"
76  << std::endl;
77 #endif//CPPL_VERBOSE
78 
79 #ifdef CPPL_DEBUG
80  std::cerr << "# [NOTE] zgematrix::copy(const zgematrix&) "
81  << "A zgematrix at " << Array << " is going to be deleted.";
82 #endif//CPPL_DEBUG
83 
84  M =mat.M;
85  N =mat.N;
86  delete [] Array;
87  Array =new std::complex<double>[M*N];
88  delete [] Darray;
89  Darray =new std::complex<double>*[N];
90  for(int i=0; i<N; i++){ Darray[i] =&Array[i*M]; }
91 
92  zcopy_(mat.M*mat.N, mat.Array, 1, Array, 1);
93 
94 #ifdef CPPL_DEBUG
95  std::cerr << " Then, a COPY of a zgematrix has been cleated at "
96  << Array << "." << std::endl;
97 #endif//CPPL_DEBUG
98 }
99 
100 //=============================================================================
103 inline void zgematrix::shallow_copy(const _zgematrix& mat)
104 {
105 #ifdef CPPL_VERBOSE
106  std::cerr << "# [MARK] zgematrix::shallow_copy(const _zgematrix&)"
107  << std::endl;
108 #endif//CPPL_VERBOSE
109 
110 #ifdef CPPL_DEBUG
111  std::cerr << "# [NOTE] zgematrix:shallow_copy(const _zgematrix&) "
112  << "A zgematrix at " << Array << " is going to be deleted, "
113  << "and point at " << mat.Array << " instead." << std::endl;
114 #endif//CPPL_DEBUG
115 
116  M =mat.M;
117  N =mat.N;
118  delete [] Array;
119  Array =mat.Array;
120  delete [] Darray;
121  Darray =mat.Darray;
122 }
123 
124 //=============================================================================
126 inline void zgematrix::resize(const long& _m, const long& _n)
127 {
128 #ifdef CPPL_VERBOSE
129  std::cerr << "# [MARK] zgematrix::resize(const long&, const long&)"
130  << std::endl;
131 #endif//CPPL_VERBOSE
132 
133 #ifdef CPPL_DEBUG
134  if( _m<0 || _n<0 ){
135  std::cerr << "[ERROR] zgematrix::resize(const long&, const long&)"
136  << std::endl
137  << "Matrix sizes must be positive integers." << std::endl
138  << "Your input was (" << _m << "," << _n << ")." << std::endl;
139  exit(1);
140  }
141 #endif//CPPL_DEBUG
142 
143  M =_m;
144  N =_n;
145  delete [] Array;
146  Array =new std::complex<double>[M*N];
147  delete [] Darray;
148  Darray =new std::complex<double>*[N];
149  for(int i=0; i<N; i++){ Darray[i] =&Array[i*M]; }
150 }
151 
152 //=============================================================================
154 inline void swap(zgematrix& A, zgematrix& B)
155 {
156 #ifdef CPPL_VERBOSE
157  std::cerr << "# [MARK] swap(zgematrix&, zgematrix&)"
158  << std::endl;
159 #endif//CPPL_VERBOSE
160 
161  long A_m(A.M), A_n(A.N);
162  std::complex<double>* A_array(A.Array);
163  std::complex<double>** A_darray = A.Darray; //std::complex<double>** A_darray(A.Darray);
164  A.M=B.M; A.N=B.N; A.Array=B.Array; A.Darray=B.Darray;
165  B.M=A_m; B.N=A_n; B.Array=A_array; B.Darray=A_darray;
166 }
167 
168 //=============================================================================
170 inline _zgematrix _(zgematrix& mat)
171 {
172 #ifdef CPPL_VERBOSE
173  std::cerr << "# [MARK] _(zgematrix&)"
174  << std::endl;
175 #endif//CPPL_VERBOSE
176 
177  _zgematrix newmat;
178 
179  newmat.M =mat.M;
180  newmat.N =mat.N;
181  newmat.Array =mat.Array;
182  newmat.Darray =mat.Darray;
183 
184  mat.M =0;
185  mat.N =0;
186  mat.Array =NULL;
187  mat.Darray =NULL;
188 
189  return newmat;
190 }
void resize(const long &, const long &)
Definition: zgematrix-misc.hpp:126
void shallow_copy(const _zgematrix &)
Definition: zgematrix-misc.hpp:103
void identity()
Definition: zgematrix-misc.hpp:38
long N
matrix column size
Definition: _zgematrix.hpp:8
void copy(const zgematrix &)
Definition: zgematrix-misc.hpp:72
std::complex< double > * Array
1D Array to store matrix data
Definition: _zgematrix.hpp:9
std::complex< double > ** Darray
array of pointers of column head addresses
Definition: _zgematrix.hpp:10
friend _zgematrix i(const zgematrix &)
Definition: zgematrix-calc.hpp:21
Complex Double-precision General Dence Matrix Class.
Definition: zgematrix.hpp:3
void chsign()
Definition: zgematrix-misc.hpp:60
(DO NOT USE) Smart-temporary Complex Double-precision General Dence Matrix Class
Definition: _zgematrix.hpp:3
void clear()
Definition: zgematrix-misc.hpp:3
void zero()
Definition: zgematrix-misc.hpp:26
std::complex< double > & operator()(const long &, const long &)
Definition: zgematrix-io.hpp:3
std::complex< double > * Array
1D Array to store vector data
Definition: _zrovector.hpp:8
long M
matrix row size
Definition: _zgematrix.hpp:7