DSQSS  1.1
matrix.h
説明を見る。
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 }
 全て クラス ネームスペース ファイル 関数 変数 型定義 列挙型の値 フレンド マクロ定義