DSQSS
1.1
|
00001 00002 //============================================================================ 00003 // Exact Calculation of Finite Size Spin Systems 00004 //============================================================================ 00005 00006 #include <cpplapack.h> 00007 #include <blaswrap.h> 00008 #include <cstdlib> 00009 #include <complex> 00010 //#include <ctime> 00011 //#include <blaswrap.h> 00012 //#include <cpplapack.h> 00013 using namespace std; 00014 using namespace CPPL; 00015 00016 //============================================================================ 00017 // 00018 //============================================================================ 00019 00020 complex<double> IUNIT(0.0,1.0); 00021 00022 //============================================================================ 00023 // Display 00024 //============================================================================ 00025 00026 void dump(const vector<double>& V) { 00027 printf("\n"); 00028 for (int i=0; i<V.size(); i++) { 00029 printf(" %8.3f", V[i]); 00030 } 00031 printf("\n"); 00032 } 00033 00034 //---------------------------------------------------------------------------- 00035 00036 void dump(char* s, const vector<double>& V) { 00037 printf("\n"); 00038 printf("%s\n",s); 00039 dump(V); 00040 } 00041 00042 //---------------------------------------------------------------------------- 00043 00044 void dump(const dgematrix& A, int Mmax = 10) { 00045 int M = A.m; 00046 if ( M > Mmax ) M = Mmax; 00047 int N = A.n; 00048 if ( N > Mmax ) N = Mmax; 00049 printf("\n"); 00050 for (int i=0; i<M; i++) { 00051 for (int j=0; j<N; j++) { 00052 printf(" %8.3f", A(i,j)); 00053 // printf(" %2d", (int)(A(i,j)+0.1)); 00054 } 00055 printf("\n"); 00056 } 00057 } 00058 00059 //---------------------------------------------------------------------------- 00060 00061 void dump01(const dgematrix& A, int Mmax = 64) { 00062 int M = A.m; 00063 if ( M > Mmax ) M = Mmax; 00064 int N = A.n; 00065 if ( N > Mmax ) N = Mmax; 00066 printf("\n"); 00067 for (int i=0; i<M; i++) { 00068 for (int j=0; j<N; j++) { 00069 char x = '.'; 00070 if ( abs(A(i,j)) > 1.0e-8 ) x = 'X'; 00071 printf("%1c", x); 00072 } 00073 printf("\n"); 00074 } 00075 } 00076 00077 //---------------------------------------------------------------------------- 00078 00079 void dump(char* s, const dgematrix& A) { 00080 printf("\n"); 00081 printf("%s\n",s); 00082 dump(A); 00083 } 00084 00085 //============================================================================ 00086 // Diagonalization 00087 //============================================================================ 00088 00089 void diagonalize(dsymatrix& A, vector<double>& E, dgematrix& U) { 00090 dsymatrix A0 = A; 00091 vector<dcovector> V; 00092 A0.dsyev(E,V); 00093 for (int i=0; i<A.n; i++) { 00094 for (int j=0; j<A.n; j++) { 00095 U(i,j) = V[j](i); 00096 } 00097 } 00098 return; 00099 } 00100 00101 //---------------------------------------------------------------------------- 00102 00103 void diagonalize(dgematrix& A, vector<double>& E, dgematrix& U) { 00104 dsymatrix A0(A.n); 00105 for (int i=0; i<A.n; i++) { 00106 for (int j=0; j<=i; j++) { 00107 A0(i,j) = A(i,j); 00108 } 00109 } 00110 diagonalize( A0, E, U); 00111 } 00112 00113 //============================================================================ 00114 // Tensor Product 00115 //============================================================================ 00116 00117 dgematrix operator^(const dgematrix& A, const dgematrix& B) { 00118 int m = A.m * B.m; 00119 int n = A.n * B.n; 00120 dgematrix C(m,n); 00121 for (int i0=0; i0<A.m; i0++) { 00122 for (int i1=0; i1<B.m; i1++) { 00123 int i = i0 + A.m * i1; 00124 for (int j0=0; j0<A.n; j0++) { 00125 for (int j1=0; j1<B.n; j1++) { 00126 int j = j0 + A.n * j1; 00127 C(i,j) = A(i0,j0) * B(i1,j1); 00128 } 00129 } 00130 } 00131 } 00132 return C; 00133 } 00134 00135 //============================================================================ 00136 // Complex Matrix 00137 //============================================================================ 00138 00139 class cmatrix { 00140 public: 00141 long m; 00142 long n; 00143 CPPL::dgematrix re; 00144 CPPL::dgematrix im; 00145 00146 void resize(const long m0, const long n0) { 00147 m = m0; 00148 n = n0; 00149 re.resize(m,n); 00150 im.resize(m,n); 00151 }; 00152 00153 void resize(const long n0) { resize(n0,n0); } 00154 00155 cmatrix() {}; 00156 cmatrix(const long n0) { resize(n0,n0); }; 00157 cmatrix(const long m0, const long n0) { resize(m0,n0); }; 00158 cmatrix(const cmatrix& X) { resize(X.m,X.n); }; 00159 00160 cmatrix& operator+=(const cmatrix& A) { 00161 if ( m != A.m ) { printf("cmatrix::operator+= >> ERROR;"); exit(0); } 00162 if ( n != A.n ) { printf("cmatrix::operator+= >> ERROR;"); exit(0); } 00163 re += A.re; 00164 im += A.im; 00165 }; 00166 00167 cmatrix& operator-=(const cmatrix& A) { 00168 if ( m != A.m ) { printf("cmatrix::operator+= >> ERROR;"); exit(0); } 00169 if ( n != A.n ) { printf("cmatrix::operator+= >> ERROR;"); exit(0); } 00170 re -= A.re; 00171 im -= A.im; 00172 }; 00173 00174 cmatrix& operator=(const cmatrix& A) { 00175 m = A.m; 00176 n = A.n; 00177 re = A.re; 00178 im = A.im; 00179 }; 00180 00181 void clear() { re.clear(); im.clear(); }; 00182 00183 void zero(); 00184 00185 void unity() { 00186 resize(1,1); 00187 re(0,0) = 1.0; 00188 im(0,0) = 0.0; 00189 }; 00190 00191 void identity() { 00192 re.identity(); 00193 im.identity(); 00194 } 00195 00196 const void dump(int Mmax); 00197 const void dump(char*); 00198 const void dump01(int Mmax); 00199 00200 }; 00201 00202 //---------------------------------------------------------------------------- 00203 00204 void cmatrix::zero() { 00205 for (int i=0; i<m; i++) { 00206 for (int j=0; j<n; j++) { 00207 re(i,j) = 0.0; 00208 im(i,j) = 0.0; 00209 } 00210 } 00211 } 00212 00213 //---------------------------------------------------------------------------- 00214 00215 const void cmatrix::dump(int Mmax = 10) { 00216 int M = m; 00217 if ( M > Mmax ) M = Mmax; 00218 int N = n; 00219 if ( N > Mmax ) N = Mmax; 00220 printf("\n"); 00221 for (int i=0; i<M; i++) { 00222 for (int j=0; j<N; j++) { 00223 // if ( j!= 0) printf(" |"); 00224 printf(" %6.3f", re(i,j) ); 00225 // printf(" %4.1f %4.1f", re(i,j), im(i,j)); 00226 } 00227 printf("\n"); 00228 } 00229 } 00230 00231 //---------------------------------------------------------------------------- 00232 00233 const void cmatrix::dump01(int Mmax = 64) { 00234 int M = m; 00235 if ( M > Mmax ) M = Mmax; 00236 int N = n; 00237 if ( N > Mmax ) N = Mmax; 00238 printf("\n"); 00239 for (int i=0; i<M; i++) { 00240 for (int j=0; j<N; j++) { 00241 char x = '.'; 00242 if ( re(i,j)*re(i,j)+im(i,j)*im(i,j) > 1.0e-16 ) x = 'X'; 00243 printf("%1c", x); 00244 } 00245 printf("\n"); 00246 } 00247 } 00248 00249 //---------------------------------------------------------------------------- 00250 00251 const void cmatrix::dump(char* s) { 00252 printf("%s\n",s); 00253 dump(); 00254 } 00255 00256 //---------------------------------------------------------------------------- 00257 00258 cmatrix operator+(const cmatrix& A, const cmatrix& B) { 00259 cmatrix C(A.m,B.n); 00260 C.re = A.re + B.re; 00261 C.im = A.im + B.im; 00262 return C; 00263 } 00264 00265 //---------------------------------------------------------------------------- 00266 00267 cmatrix operator-(const cmatrix& A, const cmatrix& B) { 00268 cmatrix C(A.m,B.n); 00269 C.re = A.re - B.re; 00270 C.im = A.im - B.im; 00271 return C; 00272 } 00273 00274 //---------------------------------------------------------------------------- 00275 00276 cmatrix operator*(const cmatrix& A, const cmatrix& B) { 00277 cmatrix C(A.m,B.n); 00278 C.re = A.re * B.re - A.im * B.im; 00279 C.im = A.re * B.im + A.im * B.re; 00280 return C; 00281 } 00282 00283 //---------------------------------------------------------------------------- 00284 00285 cmatrix operator*(const double a, const cmatrix& A) { 00286 cmatrix C(A.m,A.n); 00287 C.re = a * A.re; 00288 C.im = a * A.im; 00289 return C; 00290 } 00291 00292 //---------------------------------------------------------------------------- 00293 00294 cmatrix operator*(const complex<double> c, const cmatrix& A) { 00295 cmatrix C(A.m,A.n); 00296 C.re = c.real() * A.re - c.imag() * A.im; 00297 C.im = c.real() * A.im + c.imag() * A.re; 00298 return C; 00299 } 00300 00301 //---------------------------------------------------------------------------- 00302 00303 cmatrix t(const cmatrix& A) { 00304 cmatrix C(A.n,A.m); 00305 C.re = t(A.re); 00306 C.im = t(A.im); 00307 return C; 00308 } 00309 00310 //---------------------------------------------------------------------------- 00311 00312 cmatrix operator^(cmatrix& A, cmatrix& B) { 00313 int m = A.m * B.m; 00314 int n = A.n * B.n; 00315 cmatrix C(m,n); 00316 C.re = ((A.re)^(B.re)) - ((A.im)^(B.im)); 00317 C.im = ((A.re)^(B.im)) + ((A.im)^(B.re)); 00318 return C; 00319 }