CPPLapack
 All Classes Files Functions Variables Friends
dsymatrix-lapack.hpp
Go to the documentation of this file.
00001 //=============================================================================
00002 /*! solve A*X=Y using dsysv\n
00003   The argument is dmatrix Y. Y is overwritten and become the solution X.
00004   A is also overwritten. 
00005 */
00006 inline long dsymatrix::dsysv(dgematrix& mat)
00007 {VERBOSE_REPORT;
00008 #ifdef  CPPL_DEBUG
00009   if(n!=mat.n){
00010     ERROR_REPORT;
00011     std::cerr << "These two matrices cannot be solved." << std::endl
00012               << "Your input was (" << n << "x" << n << ") and (" << mat.n << "x" << mat.n << ")." << std::endl;
00013     exit(1);
00014   }
00015 #endif//CPPL_DEBUG
00016   
00017   char UPLO('l');
00018   long NRHS(mat.n), LDA(n), *IPIV(new long[n]), LDB(mat.m), LWORK(-1), INFO(1);
00019   double *WORK( new double[1] );
00020   dsysv_(UPLO, n, NRHS, array, LDA, IPIV, mat.array, LDB, WORK, LWORK, INFO);
00021   
00022   INFO=1; 
00023   LWORK = long(WORK[0]);
00024   delete [] WORK;  WORK = new double[LWORK];
00025   dsysv_(UPLO, n, NRHS, array, LDA, IPIV, mat.array, LDB, WORK, LWORK, INFO);
00026   delete [] WORK; delete [] IPIV;
00027   
00028   if(INFO!=0){
00029     WARNING_REPORT;
00030     std::cerr << "Serious trouble happend. INFO = " << INFO << "." << std::endl;
00031   }
00032   return INFO;
00033 }
00034 
00035 //=============================================================================
00036 /*! solve A*x=y using dsysv\n
00037   The argument is dcovector y. y is overwritten and become the solution x.
00038   A is also overwritten.
00039 */
00040 inline long dsymatrix::dsysv(dcovector& vec)
00041 {VERBOSE_REPORT;
00042 #ifdef  CPPL_DEBUG
00043   if(n!=vec.l){
00044     ERROR_REPORT;
00045     std::cerr << "These matrix and vector cannot be solved." << std::endl
00046               << "Your input was (" << n << "x" << n << ") and (" << vec.l << ")." << std::endl;
00047     exit(1);
00048   }
00049 #endif//CPPL_DEBUG 
00050   
00051   char UPLO('l');
00052   long NRHS(1), LDA(n), *IPIV(new long[n]), LDB(vec.l), LWORK(-1), INFO(1);
00053   double *WORK( new double[1] );
00054   dsysv_(UPLO, n, NRHS, array, LDA, IPIV, vec.array, LDB, WORK, LWORK, INFO);
00055   
00056   INFO=1;
00057   LWORK = long(WORK[0]);
00058   delete [] WORK;
00059   WORK = new double[LWORK];
00060   dsysv_(UPLO, n, NRHS, array, LDA, IPIV, vec.array, LDB, WORK, LWORK, INFO);
00061   delete [] WORK;
00062   delete [] IPIV;
00063 
00064   if(INFO!=0){
00065     WARNING_REPORT;
00066     std::cerr << "Serious trouble happend. INFO = " << INFO << "." << std::endl;
00067   }
00068   return INFO;
00069 }
00070 
00071 ///////////////////////////////////////////////////////////////////////////////
00072 ///////////////////////////////////////////////////////////////////////////////
00073 ///////////////////////////////////////////////////////////////////////////////
00074 
00075 //=============================================================================
00076 /*! calculate eigenvalues and eigenvectors.\n
00077   All of the arguments need not to be initialized.
00078   w is overwitten and become eigenvalues.
00079   This matrix is also overwritten. 
00080   if jobz=1, this matrix becomes eigenvectors.
00081 */
00082 inline long dsymatrix::dsyev(std::vector<double>& w, const bool& jobz=0)
00083 {VERBOSE_REPORT;
00084   w.resize(n);
00085   char JOBZ, UPLO('l');
00086   if(jobz==0){ JOBZ='n'; } else{ JOBZ='V'; }
00087   long LDA(n), INFO(1), LWORK(-1);
00088   double *WORK(new double[1]);
00089   dsyev_(JOBZ, UPLO, n, array, LDA, &w[0], WORK, LWORK, INFO);
00090   
00091   INFO=1;
00092   LWORK = long(WORK[0]);
00093   delete [] WORK;  WORK = new double[LWORK];
00094   dsyev_(JOBZ, UPLO, n, array, LDA, &w[0], WORK, LWORK, INFO);
00095   delete [] WORK;
00096   
00097   if(INFO!=0){
00098     WARNING_REPORT;
00099     std::cerr << "Serious trouble happend. INFO = " << INFO << "." << std::endl;
00100   }
00101   return INFO;
00102 }
00103 
00104 //=============================================================================
00105 /*! calculate eigenvalues and eigenvectors.\n
00106   All of the arguments need not to be initialized.
00107   w and v are overwitten and become 
00108   eigenvalues and eigenvectors, respectively.
00109   This matrix is also overwritten. 
00110 */
00111 inline long dsymatrix::dsyev(std::vector<double>& w, std::vector<dcovector>& v)
00112 {VERBOSE_REPORT;
00113   w.resize(n);  v.resize(n);
00114   for(long i=0; i<n; i++){ v[i].resize(n); }
00115   char JOBZ('V'), UPLO('l');
00116   long LDA(n), INFO(1), LWORK(-1);
00117   double *WORK(new double[1]);
00118   dsyev_(JOBZ, UPLO, n, array, LDA, &w[0], WORK, LWORK, INFO);
00119   
00120   INFO=1;
00121   LWORK = long(WORK[0]);
00122   delete [] WORK;  WORK = new double[LWORK];
00123   dsyev_(JOBZ, UPLO, n, array, LDA, &w[0], WORK, LWORK, INFO);
00124   delete [] WORK;
00125   
00126   //// forming ////
00127   for(long i=0; i<n; i++){ for(long j=0; j<n; j++){
00128     v[j](i) = array[i+n*j];
00129   }}
00130   
00131   if(INFO!=0){
00132     WARNING_REPORT;
00133     std::cerr << "Serious trouble happend. INFO = " << INFO << "." << std::endl;
00134   }
00135   return INFO;
00136 }
00137 
00138 //=============================================================================
00139 /*! calculate eigenvalues and eigenvectors.\n
00140   All of the arguments need not to be initialized.
00141   w and v are overwitten and become 
00142   eigenvalues and eigenvectors, respectively.
00143   This matrix is also overwritten. 
00144 */
00145 inline long dsymatrix::dsyev(std::vector<double>& w, std::vector<drovector>& v)
00146 {VERBOSE_REPORT;
00147   w.resize(n);  v.resize(n);
00148   for(long i=0; i<n; i++){ v[i].resize(n); }
00149   char JOBZ('V'), UPLO('l');
00150   long LDA(n), INFO(1), LWORK(-1);
00151   double *WORK(new double[1]);
00152   dsyev_(JOBZ, UPLO, n, array, LDA, &w[0], WORK, LWORK, INFO);
00153   
00154   INFO=1;
00155   LWORK = long(WORK[0]);
00156   delete [] WORK;  WORK = new double[LWORK];
00157   dsyev_(JOBZ, UPLO, n, array, LDA, &w[0], WORK, LWORK, INFO);
00158   delete [] WORK;
00159   
00160   //// forming ////
00161   for(long i=0; i<n; i++){ for(long j=0; j<n; j++){
00162     v[j](i) = array[i+n*j];
00163   }}
00164   
00165   if(INFO!=0){
00166     WARNING_REPORT;
00167     std::cerr << "Serious trouble happend. INFO = " << INFO << "." << std::endl;
00168   }
00169   return INFO;
00170 }
00171 
00172 ///////////////////////////////////////////////////////////////////////////////
00173 ///////////////////////////////////////////////////////////////////////////////
00174 ///////////////////////////////////////////////////////////////////////////////
00175 
00176 //=============================================================================
00177 /*! calculate generalized eigenvalues\n
00178   w is overwitten and become generalized eigenvalues.
00179   This matrix and matB are also overwritten. 
00180 */
00181 inline long dsymatrix::dsygv(dsymatrix& matB, std::vector<double>& w)
00182 {VERBOSE_REPORT;
00183 #ifdef  CPPL_DEBUG
00184   if(matB.n!=n){
00185     ERROR_REPORT;
00186     std::cerr << "The matrix B is not a matrix having the same size as \"this\" matrix." << std::endl
00187               << "The B matrix is (" << matB.n << "x" << matB.n << ")." << std::endl;
00188     exit(1);
00189   }
00190 #endif//CPPL_DEBUG
00191   
00192   w.resize(n);
00193   char JOBZ('n'), UPLO('l');
00194   long ITYPE(1), LDA(n), LDB(n), LWORK(-1), INFO(1);
00195   double *WORK(new double[1]);
00196   dsygv_(ITYPE, JOBZ, UPLO, n, array, LDA, matB.array, LDB, &w[0],
00197          WORK, LWORK, INFO);
00198   INFO=1;
00199   LWORK = long(WORK[0]);
00200   delete [] WORK;  WORK = new double[LWORK];
00201   dsygv_(ITYPE, JOBZ, UPLO, n, array, LDA, matB.array, LDB, &w[0],
00202          WORK, LWORK, INFO);
00203   delete [] WORK;
00204   
00205   if(INFO!=0){
00206     WARNING_REPORT;
00207     std::cerr << "Serious trouble happend. INFO = " << INFO << "." << std::endl;
00208   }
00209   return INFO;
00210 }
00211 
00212 //=============================================================================
00213 /*! calculate generalized eigenvalues\n
00214   w is overwitten and become generalized eigenvalues.
00215   This matrix and matB are also overwritten. 
00216 */
00217 inline long dsymatrix::dsygv(dsymatrix& matB, std::vector<double>& w,
00218                              std::vector<dcovector>& v)
00219 {VERBOSE_REPORT;
00220 #ifdef  CPPL_DEBUG
00221   if(matB.n!=n){
00222     ERROR_REPORT;
00223     std::cerr << "The matrix B is not a matrix having the same size as \"this\" matrix." << std::endl
00224               << "The B matrix is (" << matB.n << "x" << matB.n << ")." << std::endl;
00225     exit(1);
00226   }
00227 #endif//CPPL_DEBUG
00228   
00229   w.resize(n);
00230   v.resize(n);
00231   char JOBZ('V'), UPLO('l');
00232   long ITYPE(1), LDA(n), LDB(n), LWORK(-1), INFO(1);
00233   double *WORK(new double[1]);
00234   dsygv_(ITYPE, JOBZ, UPLO, n, array, LDA, matB.array, LDB, &w[0],
00235          WORK, LWORK, INFO);
00236   INFO=1;
00237   LWORK = long(WORK[0]);
00238   std::cout << " LWORK = "  << LWORK  <<std::endl;
00239   delete [] WORK;  WORK = new double[LWORK];
00240   dsygv_(ITYPE, JOBZ, UPLO, n, array, LDA, matB.array, LDB, &w[0],
00241          WORK, LWORK, INFO);
00242   delete [] WORK;
00243   
00244   //// reforming ////
00245   for(int i=0; i<n; i++){
00246     v[i].resize(n);
00247     for(int j=0; j<n; j++){
00248       v[i](j) =darray[i][j];
00249     }
00250   }
00251   
00252   if(INFO!=0){
00253     WARNING_REPORT;
00254     std::cerr << "Serious trouble happend. INFO = " << INFO << "." << std::endl;
00255   }
00256   return INFO;
00257 }
 All Classes Files Functions Variables Friends