sparse_matrix.h
00001 /* Copyright (C) 2003-2005  Martin Förg
00002 
00003  * This library is free software; you can redistribute it and/or
00004  * modify it under the terms of the GNU Lesser General Public
00005  * License as published by the Free Software Foundation; either
00006  * version 2.1 of the License, or (at your option) any later version.
00007  * 
00008  * This library is distributed in the hope that it will be useful,
00009  * but WITHOUT ANY WARRANTY; without even the implied warranty of
00010  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
00011  * Lesser General Public License for more details.
00012  * 
00013  * You should have received a copy of the GNU Lesser General Public
00014  * License along with this library; if not, write to the Free Software
00015  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
00016  *
00017  * Contact:
00018  *   martin.o.foerg@googlemail.com
00019  *
00020  */
00021 
00022 #ifndef sparse_matrix_h
00023 #define sparse_matrix_h
00024 
00025 #include "matrix.h"
00026 #include "square_matrix.h"
00027 #include "types.h"
00028 #include "_memory.h"
00029 
00030 namespace fmatvec {
00031 
00043   template <class AT>
00044     class Matrix<Sparse,Ref,Ref,AT> {
00045 
00046       protected:
00047 
00049     
00050         Memory<AT> memEle;
00051         Memory<int> memI, memJ;
00052         AT *ele;
00053         int *I, *J;
00054         int m, n, k;
00055 
00056         void deepCopy(const Matrix<Sparse,Ref,Ref,AT> &x);
00057 
00058         void deepCopy(const SquareMatrix<Ref,AT> &A);
00059 
00061 
00062 
00063       public:
00064 
00069         Matrix() : memEle(), memI(), memJ(), ele(0), I(0), J(0), m(0), n(0), k(0) { }
00070 
00071 //        template<class Ini=All<AT> >
00072 //          Matrix(int n_, Ini ini=All<AT>()) : memEle(n_*n_), memI(n_+1), memJ(n_*n_), ele((AT*)memEle.get()), I((int*)memI.get()), J((int*)memJ.get()), m(n_), n(n_), k(n_*n_) {
00073 //            init(ini);
00074 //          }
00075 //        template<class Ini=All<AT> >
00076 //          Matrix(int m_, int n_, Ini ini) : memEle(n_*n_), memI(n_+1), memJ(n_*n_), ele((AT*)memEle.get()), I((int*)memI.get()), J((int*)memJ.get()), m(n_), n(n_), k(n_*n_) {  
00077 //            init(ini);
00078 //          }
00079 
00080         Matrix(int m_, int n_, int k_, Noinit) : memEle(k_), memI(n_+1), memJ(k_), ele((AT*)memEle.get()), I((int*)memI.get()), J((int*)memJ.get()), m(n_), n(n_), k(k_) { }
00081         Matrix(int m_, int n_, int k_, Init ini=INIT, const AT &a=0) : memEle(k_), memI(n_+1), memJ(k_), ele((AT*)memEle.get()), I((int*)memI.get()), J((int*)memJ.get()), m(n_), n(n_), k(k_) {  init(a); }
00082 
00083         Matrix(int n_, Noinit) : memEle(n_*n_), memI(n_+1), memJ(n_*n_), ele((AT*)memEle.get()), I((int*)memI.get()), J((int*)memJ.get()), m(n_), n(n_), k(n_*n_) { }
00084         Matrix(int n_, Init ini=INIT, const AT &a=0) : memEle(n_*n_), memI(n_+1), memJ(n_*n_), ele((AT*)memEle.get()), I((int*)memI.get()), J((int*)memJ.get()), m(n_), n(n_), k(n_*n_) { init(a); }
00085 
00086         Matrix(int m_, int n_, Noinit) : memEle(n_*n_), memI(n_+1), memJ(n_*n_), ele((AT*)memEle.get()), I((int*)memI.get()), J((int*)memJ.get()), m(n_), n(n_), k(n_*n_) { }
00087         Matrix(int m_, int n_, Init ini=INIT, const AT &a=0) : memEle(n_*n_), memI(n_+1), memJ(n_*n_), ele((AT*)memEle.get()), I((int*)memI.get()), J((int*)memJ.get()), m(n_), n(n_), k(n_*n_) { init(a); }
00088 
00089 
00097         Matrix(const Matrix<Sparse,Ref,Ref,AT> &A) : memEle(A.memEle), memI(A.memI), memJ(A.memJ), ele(A.ele), I(A.I), J(A.J), m(A.m), n(A.n), k(A.k) {
00098         }
00099 
00102         ~Matrix() {
00103         }
00104 
00105         Matrix<Sparse,Ref,Ref,AT>& resize() {
00106             m = n = k = 0;
00107             memEle.resize(0);
00108             memI.resize(0);
00109             memJ.resize(0);
00110             ele = 0;
00111             I = J = 0;
00112             return *this;
00113         }
00114 
00115         Matrix<Sparse,Ref,Ref,AT>& resize(int n_, int k_, Noinit) {
00116             m = n_; n = n_; k = k_;
00117             memEle.resize(k);
00118             memI.resize(m+1);
00119             memJ.resize(k);
00120             ele = (AT*)memEle.get();
00121             I = (int*)memI.get();
00122             J = (int*)memJ.get();
00123             return *this;
00124         }
00125 
00126         Matrix<Sparse,Ref,Ref,AT>& resize(int n, int k, Init ini=INIT, const AT &a=0) { return resize(m,k,Noinit()).init(a); }
00127 
00134         inline Matrix<Sparse,Ref,Ref,AT>& operator<<(const Matrix<Sparse,Ref,Ref,AT> &A);
00135 
00142         inline Matrix<Sparse,Ref,Ref,AT>& operator>>(const Matrix<Sparse,Ref,Ref,AT> &A);
00143 
00148         inline Matrix<Sparse,Ref,Ref,AT>& operator<<(const SquareMatrix<Ref,AT> &A);
00149 
00158         inline Matrix<Sparse,Ref,Ref,AT>& operator=(const Matrix<Sparse,Ref,Ref,AT> &A);
00159 
00164         const AT* operator()() const {
00165           return ele;
00166         };
00167 
00173         AT* operator()() {
00174           return ele;
00175         };
00176 
00181         const int* Ip() const {
00182           return I;
00183         };
00184 
00189         int* Ip() {
00190           return I;
00191         };
00192 
00197         const int* Jp() const {
00198           return J;
00199         };
00200 
00205         int* Jp() {
00206           return J;
00207         };
00208 
00213         int rows() const {return m;};
00214 
00219         int cols() const {return n;};
00220 
00226         Matrix<Sparse,Ref,Ref,AT> copy() const;
00227 
00235         Matrix<Sparse,Ref,Ref,AT>& init(const AT &a);
00236         inline Matrix<Sparse,Ref,Ref,AT>& init(Init, const AT &a=0) { return init(a); }
00237         inline Matrix<Sparse,Ref,Ref,AT>& init(Noinit, const AT &a=0) { return *this; }
00238 
00239     };
00240   // ------------------------- Constructors -------------------------------------
00241   // ----------------------------------------------------------------------------
00242 
00243   template <class AT>
00244     inline Matrix<Sparse,Ref,Ref,AT>& Matrix<Sparse,Ref,Ref,AT>::operator>>(const Matrix<Sparse,Ref,Ref,AT> &A) { 
00245 
00246       m=A.m;
00247       n=A.n;
00248       k=A.k;
00249       memEle = A.memEle;
00250       memI = A.memI;
00251       memJ = A.memJ;
00252       ele = A.ele;
00253       I = A.I;
00254       J = A.J;
00255       k = A.k;
00256 
00257       return *this;
00258     }
00259 
00260   template <class AT>
00261     inline Matrix<Sparse,Ref,Ref,AT>& Matrix<Sparse,Ref,Ref,AT>::operator=(const Matrix<Sparse,Ref,Ref,AT> &A) { 
00262 
00263       if(!ele) {
00264         m = A.m;
00265         n = A.n;
00266         k = A.k;
00267         memEle.resize(k);
00268         memI.resize(m+1);
00269         memJ.resize(k);
00270         ele = (AT*)memEle.get();
00271         I = (int*)memI.get();
00272         J = (int*)memJ.get();
00273       }
00274       else {
00275 #ifndef FMATVEC_NO_SIZE_CHECK
00276         assert(m == A.m);
00277         assert(n == A.n);
00278         assert(k == A.k);
00279 #endif
00280       }
00281 
00282       deepCopy(A);
00283 
00284       return *this;
00285     }
00286 
00287   template <class AT>
00288     inline Matrix<Sparse,Ref,Ref,AT>& Matrix<Sparse,Ref,Ref,AT>::operator<<(const Matrix<Sparse,Ref,Ref,AT> &A) { 
00289 
00290       if(m!=A.m || n!=A.n || k!=A.k) {
00291         m = A.m;
00292         n = A.n;
00293         k = A.k;
00294         memEle.resize(k);
00295         memI.resize(m+1);
00296         memJ.resize(k);
00297         ele = (AT*)memEle.get();
00298         I = (int*)memI.get();
00299         J = (int*)memJ.get();
00300       }
00301 
00302       deepCopy(A);
00303 
00304       return *this;
00305     }
00306 
00307   template <class AT>
00308     inline Matrix<Sparse,Ref,Ref,AT>& Matrix<Sparse,Ref,Ref,AT>::operator<<(const SquareMatrix<Ref,AT> &A) { 
00309 
00310       if(m!=A.rows() || n!=A.cols()) {
00311         m = A.rows();
00312         n = A.cols();
00313         k = countElements(A);
00314         memEle.resize(k);
00315         memI.resize(m+1);
00316         memJ.resize(k);
00317         ele = (AT*)memEle.get();
00318         I = (int*)memI.get();
00319         J = (int*)memJ.get();
00320       } else {
00321         int k_ = countElements(A);
00322         if(k != k_) {
00323           k = k_;
00324           memEle.resize(k);
00325           memJ.resize(k);
00326           ele = (AT*)memEle.get();
00327           J = (int*)memJ.get();
00328         }
00329       }
00330 
00331       deepCopy(A);
00332 
00333       return *this;
00334     }
00335 
00336   template <class AT>
00337     Matrix<Sparse,Ref,Ref,AT> Matrix<Sparse,Ref,Ref,AT>::copy() const {
00338 
00339       Matrix<Sparse,Ref,Ref,AT> A(m,NONINIT);
00340 
00341       A.deepCopy(*this);
00342 
00343       return A;
00344     }
00345 
00346   template <class AT>
00347     void Matrix<Sparse,Ref,Ref,AT>::deepCopy(const Matrix<Sparse,Ref,Ref,AT> &A) { 
00348       for(int i=0; i<=m; i++) {
00349         I[i] = A.I[i];
00350       }
00351       for(int i=0; i<k; i++) {
00352         ele[i] = A.ele[i];
00353         J[i] = A.J[i];
00354       }
00355     }
00356 
00357   template <class AT> void Matrix<Sparse,Ref,Ref,AT>::deepCopy(const SquareMatrix<Ref,AT> &A) { 
00358       int k=0;
00359       int i;
00360       for(i=0; i<A.size(); i++) {
00361         ele[k]=A(i,i);
00362         J[k]=i;
00363         I[i]=k++;
00364         for(int j=0; j<i; j++) {
00365           // TODO eps
00366           if(fabs(A(i,j))>1e-16) {
00367             ele[k]=A(i,j);
00368             J[k++]=j;
00369           }
00370         }
00371         for(int j=i+1; j<A.size(); j++) {
00372           // TODO eps
00373           if(fabs(A(i,j))>1e-16) {
00374             ele[k]=A(i,j);
00375             J[k++]=j;
00376           }
00377         }
00378       }
00379       if(n) I[i]=k;
00380     }
00381 
00382   template <class AT>
00383     Matrix<Sparse,Ref,Ref,AT>&  Matrix<Sparse,Ref,Ref,AT>::init(const AT& val) {
00384       for(int i=0; i<k; i++) {
00385         ele[i] = val;
00386       }
00387       return *this;
00388     }
00389 
00390 /* template <class AT> template <class Type> void Matrix<Sparse,Ref,Ref,AT>::deepCopy(const Matrix<Type, AT> &A) { 
00391       k=0;
00392       AT *eleBuf = new AT[m*n];
00393       int *JBuf = new int[m*n];
00394       int i;
00395       for(i=0; i<A.rows(); i++) {
00396         eleBuf[k]=A(i,i);
00397         JBuf[k]=i;
00398         I[i]=k++;
00399         for(int j=0; j<i; j++) {
00400           // TODO eps
00401           if(fabs(A(i,j))>1e-16) {
00402             eleBuf[k]=A(i,j);
00403             JBuf[k++]=j;
00404           }
00405         }
00406         for(int j=i+1; j<A.cols(); j++) {
00407           // TODO eps
00408           if(fabs(A(i,j))>1e-16) {
00409             eleBuf[k]=A(i,j);
00410             JBuf[k++]=j;
00411           }
00412         }
00413       }
00414       I[i]=k;
00415       memEle.resize(k);
00416       memJ.resize(k);
00417       ele = (AT*)memEle.get();
00418       J = (int*)memJ.get();
00419       for(int i=0; i<k; i++) {
00420         ele[i] = eleBuf[i];
00421         J[i] = JBuf[i];
00422       }
00423 
00424       delete [] eleBuf;
00425       delete [] JBuf;
00426     }
00427 
00428     */
00429 
00430   //template <> extern void Matrix<Sparse,Ref,Ref,double>::deepCopy(const Matrix<Sparse,Ref,Ref,double> &A);
00431 
00432 }
00433 
00434 #endif