vector.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 vector_h
00023 #define vector_h
00024 
00025 #include "general_matrix.h"
00026 #include <vector>
00027 #include <cstring>
00028 
00029 namespace fmatvec {
00030 
00039   template <class AT> class Vector<Ref,AT> : public Matrix<General,Ref,Ref,AT> {
00040     using Matrix<General,Ref,Ref,AT>::m;
00041     using Matrix<General,Ref,Ref,AT>::n;
00042     using Matrix<General,Ref,Ref,AT>::lda;
00043     using Matrix<General,Ref,Ref,AT>::ele;
00044     using Matrix<General,Ref,Ref,AT>::tp;
00045     using Matrix<General,Ref,Ref,AT>::memory;
00046     using Matrix<General,Ref,Ref,AT>::elePtr;
00047 
00048     public:
00049 
00051 
00052     template <class T> friend RowVector<Ref,T> trans(const Vector<Ref,T> &x); 
00053     template <class T> friend Vector<Ref,T> trans(const RowVector<Ref,T> &x);     
00054     
00055     friend class RowVector<Ref,AT>;
00056 
00057     friend Vector<Ref,AT> Matrix<General,Ref,Ref,AT>::col(int i);
00058     friend const Vector<Ref,AT> Matrix<General,Ref,Ref,AT>::col(int i) const;
00059 
00060     protected:
00061 
00062     inline void deepCopy(const Vector<Ref,AT> &x);
00063     template<class Row> inline void deepCopy(const Vector<Row,AT> &x);
00064 
00065     AT* elePtr(int i) {
00066       return tp ? ele+lda*i : ele+i;
00067     };
00068 
00069     const AT* elePtr(int i) const {
00070       return tp ? ele+lda*i : ele+i;
00071     };
00072 
00073     Vector(int n_, int lda_, bool tp, Memory<AT> memory, const AT* ele_) : Matrix<General,Ref,Ref,AT>(n_, 1, lda_, tp, memory, ele_) { }
00074 
00076     
00077     public:
00078 
00083       Vector() : Matrix<General,Ref,Ref,AT>() { n=1; }
00084 
00085 //      template<class Ini=All<AT> >
00086 //        Vector(int m, Ini ini=All<AT>()) : Matrix<General,Ref,Ref,AT>(m,1,ini) { } 
00087 
00088       Vector(int m, Noinit ini) : Matrix<General,Ref,Ref,AT>(m,1,ini) { } 
00089       Vector(int m, Init ini=INIT, const AT &a=0) : Matrix<General,Ref,Ref,AT>(m,1,ini,a) { } 
00090 
00097       Vector(int m, AT* ele) : Matrix<General,Ref,Ref,AT>(m,1,ele) { 
00098       }
00099 
00112       Vector(const char *str) : Matrix<General,Ref,Ref,AT>(str) {
00113 #ifndef FMATVEC_NO_SIZE_CHECK
00114         assert(n==1);
00115 #endif
00116       }
00117 
00125       Vector(const Vector<Ref,AT> &x) : Matrix<General,Ref,Ref,AT>(x) {
00126       }
00127 
00128       template<class Row>
00129       Vector(const Vector<Row,AT> &x) : Matrix<General,Ref,Ref,AT>(x) {
00130       }
00131 
00132       template<class Type, class Row, class Col>
00133       explicit Vector(const Matrix<Type,Row,Col,AT> &x) : Matrix<General,Ref,Ref,AT>(x) {
00134 
00135 #ifndef FMATVEC_NO_SIZE_CHECK
00136         assert(x.cols()==1);
00137 #endif
00138       }
00139 
00140       Vector<Ref,AT>& resize() {
00141         Matrix<General,Ref,Ref,AT>::resize();
00142         return *this;
00143       }
00144 
00145       Vector<Ref,AT>& resize(int m, Noinit) {
00146         Matrix<General,Ref,Ref,AT>::resize(m,1,Noinit());
00147         return *this;
00148       }
00149 
00150       Vector<Ref,AT>& resize(int m, Init ini=INIT, const AT &a=0) {
00151         Matrix<General,Ref,Ref,AT>::resize(m,1,ini,a);
00152         return *this;
00153       }
00154       
00161       template <class Row>
00162         inline Vector<Ref,AT>& operator<<(const Vector<Row,AT> &x);
00163 
00170       inline Vector<Ref,AT>& operator>>(const Vector<Ref,AT> &x);
00171 
00172       inline Vector<Ref,AT>& operator>>(const Matrix<General,Ref,Ref,AT> &A);
00173 
00182       inline Vector<Ref,AT>& operator=(const Vector<Ref,AT> &x);
00183 
00184       template <class Row>
00185       inline Vector<Ref,AT>& operator=(const Vector<Row,AT> &x);
00186 
00197       AT& operator()(int i) {
00198 
00199 #ifndef FMATVEC_NO_BOUNDS_CHECK
00200         assert(i>=0);
00201         assert(i<m);
00202 #endif
00203 
00204         return e(i);
00205       };
00206 
00211       const AT& operator()(int i) const {
00212 
00213 #ifndef FMATVEC_NO_BOUNDS_CHECK
00214         assert(i>=0);
00215         assert(i<m);
00216 #endif
00217 
00218         return e(i);
00219       };
00220 
00221       AT& er(int i) {
00222         return ele[i];
00223       };
00224 
00225       const AT& er(int i) const {
00226         return ele[i];
00227       };
00228 
00229       AT& et(int i) {
00230         return ele[i*lda];
00231       };
00232 
00233       const AT& et(int i) const {
00234         return ele[i*lda];
00235       };
00236 
00237        AT& e(int i) {
00238         return tp ? et(i) : er(i);
00239       };
00240 
00241       const AT& e(int i) const {
00242         return tp ? et(i) : er(i);
00243       };
00244 
00252       inline Vector<Ref,AT>& init(const AT& a=0); 
00253       inline Vector<Ref,AT>& init(Init, const AT& a=0) { return init(a); }
00254       inline Vector<Ref,AT>& init(Noinit, const AT& a=0) { return *this; }
00255 
00260       int size() const {return m;};
00261 
00268       int inc() const {return tp?lda:1;};
00269 
00275       inline Vector<Ref,AT> copy() const;
00276 
00286       inline Vector<Ref,AT> operator()(int i1, int i2);
00287 
00292       inline const Vector<Ref,AT> operator()(int i1, int i2) const;
00293 
00302       inline Vector<Ref,AT> operator()(const Index &I);
00303 
00308       inline const Vector<Ref,AT> operator()(const Index &I) const;
00309 
00310       using Matrix<General,Ref,Ref,AT>::operator();
00311 
00316       inline operator std::vector<AT>();
00317 
00322       inline Vector(std::vector<AT> v);
00323 
00324       RowVector<Ref,AT> T() {
00325         return RowVector<Ref,AT>(m,lda,tp?false:true,memory,ele);
00326       };
00327 
00328       const RowVector<Ref,AT> T() const {
00329         return RowVector<Ref,AT>(m,lda,tp?false:true,memory,ele);
00330       }
00331 
00332   };
00333 
00334   template <class AT>
00335     inline Vector<Ref,AT>& Vector<Ref,AT>::init(const AT &val) {
00336       if(tp) 
00337         for(int i=0; i<m; i++) 
00338           et(i) = val;
00339       else 
00340         for(int i=0; i<m; i++) 
00341           er(i) = val;
00342       return *this;
00343     }
00344 
00345   template <class AT>
00346     inline Vector<Ref,AT>& Vector<Ref,AT>::operator=(const Vector<Ref,AT> &x) { 
00347 
00348       if(!ele) {
00349         m = x.size(); 
00350         n = 1;
00351         lda = m;
00352         tp = false;
00353         memory.resize(m);
00354         ele = (AT*)memory.get();
00355       } else {
00356 #ifndef FMATVEC_NO_SIZE_CHECK
00357         assert(m == x.size());
00358 #endif
00359       }
00360 
00361       deepCopy(x);
00362 
00363       return *this;
00364     }
00365 
00366   template <class AT> template<class Row>
00367     inline Vector<Ref,AT>& Vector<Ref,AT>::operator=(const Vector<Row,AT> &x) { 
00368 
00369       if(!ele) {
00370         m = x.size(); 
00371         n = 1;
00372         lda = m;
00373         tp = false;
00374         memory.resize(m);
00375         ele = (AT*)memory.get();
00376       } else {
00377 #ifndef FMATVEC_NO_SIZE_CHECK
00378         assert(m == x.size());
00379 #endif
00380       }
00381 
00382       deepCopy(x);
00383 
00384       return *this;
00385     }
00386 
00387   template <class AT> template<class Row>
00388     inline Vector<Ref,AT>& Vector<Ref,AT>::operator<<(const Vector<Row,AT> &x) { 
00389 
00390       if(m!=x.size()) {
00391         m = x.size(); 
00392         n = 1;
00393         lda = m;
00394         tp = false;
00395         memory.resize(m);
00396         ele = (AT*)memory.get();
00397       }
00398 
00399       deepCopy(x);
00400 
00401       return *this;
00402     }
00403 
00404   template <class AT>
00405     inline Vector<Ref,AT>& Vector<Ref,AT>::operator>>(const Vector<Ref,AT> &x) { 
00406 
00407       m = x.m; 
00408       n = 1;
00409       memory = x.memory;
00410       ele = x.ele;
00411       lda = x.lda;
00412       tp = x.tp; 
00413 
00414       return *this;
00415     }
00416 
00417   template <class AT>
00418     inline Vector<Ref,AT>& Vector<Ref,AT>::operator>>(const Matrix<General,Ref,Ref,AT> &A) { 
00419 
00420 #ifndef FMATVEC_NO_SIZE_CHECK
00421       assert(A.cols() == 1);
00422 #endif
00423       m = A.rows(); 
00424       n = 1;
00425       memory = A.memory;
00426       ele = A.ele;
00427       lda = A.lda;
00428       tp = A.tp; 
00429 
00430       return *this;
00431     }
00432 
00433   template <class AT>
00434     inline Vector<Ref,AT> Vector<Ref,AT>::copy() const {
00435 
00436       Vector<Ref,AT> x(m,NONINIT);
00437       x.deepCopy(*this);
00438 
00439       return x;
00440     }
00441 
00442   template <class AT> 
00443     inline Vector<Ref,AT> Vector<Ref,AT>::operator()(int i1, int i2) {
00444     return operator()(Index(i1,i2));
00445   }
00446 
00447   template <class AT> 
00448     inline const Vector<Ref,AT> Vector<Ref,AT>::operator()(int i1, int i2) const {
00449     return operator()(Index(i1,i2));
00450   }
00451 
00452   template <class AT>
00453     inline const Vector<Ref,AT> Vector<Ref,AT>::operator()(const Index &I) const {
00454 
00455 #ifndef FMATVEC_NO_BOUNDS_CHECK
00456       assert(I.end()<m);
00457 #endif
00458 
00459       return Vector<Ref,AT>(I.end()-I.start()+1,lda,tp,memory,elePtr(I.start()));
00460     }
00461 
00462   template <class AT>
00463     inline Vector<Ref,AT> Vector<Ref,AT>::operator()(const Index &I) {
00464 
00465 #ifndef FMATVEC_NO_BOUNDS_CHECK
00466       assert(I.end()<m);
00467 #endif
00468 
00469       return Vector<Ref,AT>(I.end()-I.start()+1,lda,tp,memory,elePtr(I.start()));
00470     }
00471 
00472   template <class AT>
00473     inline Vector<Ref,AT>::operator std::vector<AT>() {
00474       std::vector<AT> ret(size());
00475       if(size()>0) memcpy(&ret[0], &operator()(0), sizeof(AT)*size());
00476       return ret;
00477     }
00478 
00479   template <class AT>
00480     inline Vector<Ref,AT>::Vector(std::vector<AT> v) : Matrix<General,Ref,Ref,AT>(v.size(),1) {
00481       if(size()>0) memcpy(&operator()(0), &v[0], sizeof(AT)*size());
00482     }
00483 
00485 
00486   template <class AT>
00487     inline void Vector<Ref,AT>::deepCopy(const Vector<Ref,AT> &x) {
00488       if(tp) {
00489         if(x.tp) 
00490           for(int i=0; i<size(); i++)
00491             et(i) = x.et(i); 
00492         else 
00493           for(int i=0; i<size(); i++)
00494             et(i) = x.er(i);
00495       }
00496       else {
00497         if(x.tp)
00498           for(int i=0; i<size(); i++)
00499             er(i) = x.et(i); 
00500         else 
00501           for(int i=0; i<size(); i++)
00502             er(i) = x.er(i);
00503       }
00504     }
00505 
00506   template <class AT> template <class Row>
00507     inline void Vector<Ref,AT>::deepCopy(const Vector<Row,AT> &x) {
00508       if(tp) 
00509         for(int i=0; i<size(); i++)
00510           et(i) = x.e(i);
00511       else 
00512         for(int i=0; i<size(); i++)
00513           er(i) = x.e(i);
00514     }
00515 
00517 
00518 }
00519 
00520 #endif