00001 #pragma ident "$Id: Vector.hpp 3320 2012-09-20 00:41:47Z yanweignss $"
00002
00003
00004
00010 #ifndef GPSTK_VECTOR_HPP
00011 #define GPSTK_VECTOR_HPP
00012
00013
00014
00015
00016
00017
00018
00019
00020
00021
00022
00023
00024
00025
00026
00027
00028
00029
00030
00031
00032
00033
00034
00035 #include <limits>
00036 #include <vector>
00037 #include "VectorBase.hpp"
00038
00039 namespace gpstk
00040 {
00043
00044
00045 template <class T> class VectorSlice;
00046
00054 template <class T>
00055 class Vector : public RefVectorBase<T, Vector<T> >
00056 {
00057 public:
00059 typedef T value_type;
00061 typedef T& reference;
00063 typedef const T& const_reference;
00065 typedef T* iterator;
00067 typedef const T* const_iterator;
00068
00070 Vector() : v(NULL), s(0) {}
00072 Vector(size_t siz) : s(siz)
00073
00074 {
00075 v = new T[siz];
00076 if(!v) {
00077 VectorException e("Vector(size_t) failed to allocate");
00078 GPSTK_THROW(e);
00079 }
00080 }
00084 Vector(size_t siz, const T defaultValue) : s(siz)
00085
00086 {
00087 v = new T[siz];
00088 if(!v) {
00089 VectorException e("Vector<T>(size_t, const T) failed to allocate");
00090 GPSTK_THROW(e);
00091 }
00092 this->assignFrom(defaultValue);
00093 }
00097 template <class E>
00098 Vector(const ConstVectorBase<T, E>& r) : s(r.size())
00099
00100 {
00101 v = new T[r.size()];
00102 if(!v) {
00103 VectorException e("Vector<T>(ConstVectorBase) failed to allocate");
00104 GPSTK_THROW(e);
00105 }
00106 this->assignFrom(r);
00107 }
00111 Vector(const Vector& r) : s(r.s)
00112
00113 {
00114 v = new T[r.s];
00115 if(!v) {
00116 VectorException e("Vector(Vector) failed to allocate");
00117 GPSTK_THROW(e);
00118 }
00119 this->assignFrom(r);
00120 }
00124 Vector(const std::valarray<T>& r) : s(r.size())
00125
00126 {
00127 v = new T[r.size()];
00128 if(!v) {
00129 VectorException e("Vector(valarray) failed to allocate");
00130 GPSTK_THROW(e);
00131 }
00132 this->assignFrom(r);
00133 }
00134
00136 template <class E>
00137 Vector(const ConstVectorBase<T, E>& vec,
00138 size_t top,
00139 size_t num) : v(size_t(0)),s(0)
00140 {
00141
00142 if ( top >= vec.size() ||
00143 top + num > vec.size())
00144 {
00145 VectorException e("Invalid dimensions or size for Vector(VectorBase)");
00146 GPSTK_THROW(e);
00147 }
00148
00149 v = new T[num];
00150 if(!v) {
00151 VectorException e("Vector(subvector) failed to allocate");
00152 GPSTK_THROW(e);
00153 }
00154 size_t i;
00155 for(i = 0; i < num; i++)
00156 v[i] = vec(top+i);
00157 s = num;
00158 }
00159
00161 ~Vector()
00162 { if (v) delete [] v; }
00163
00165 iterator begin() { return v; }
00167 const_iterator begin() const { return v; }
00169 iterator end() { return v + s; }
00171 const_iterator end() const { return v + s; }
00173 value_type front() { return v[s-1]; }
00175 const_reference front() const { return v[s-1];}
00177 bool empty() const { return size() == 0; }
00179 size_t size() const {return s; }
00181 size_t max_size() const { return std::numeric_limits<size_t>().max(); }
00182
00184 T& operator[] (size_t i)
00185 { return v[i]; }
00187 T operator[] (size_t i) const
00188 { return v[i]; }
00190 T& operator() (size_t i)
00191 { return v[i]; }
00193 T operator() (size_t i) const
00194 { return v[i]; }
00195
00197 VectorSlice<T> operator[] (const std::slice& sli)
00198 { return VectorSlice<T>(*this, sli); }
00199
00201 Vector& operator=(const Vector& x)
00202 { resize(x.s); return this->assignFrom(x); }
00203
00205 template <class E>
00206 Vector& operator=(const ConstVectorBase<T, E>& x)
00207 { resize(x.size()); return this->assignFrom(x); }
00208
00210 Vector& operator=(const std::valarray<T>& x)
00211 { resize(x.size()); return this->assignFrom(x); }
00213 Vector& operator=(const T x)
00214 { return this->assignFrom(x); }
00216 Vector& operator=(const T* x)
00217 { return this->assignFrom(x); }
00218
00220 inline Vector& operator=(const std::vector<T>& x)
00221 {
00222 size_t i;
00223 size_t vs = x.size();
00224 (*this).resize(vs);
00225
00226 for (i = 0; i < vs; i++)
00227 (*this)[i] = x[i];
00228
00229 return (*this);
00230 }
00231
00234 Vector& resize(const size_t index)
00235 {
00236 if (index > s)
00237 {
00238 if (v)
00239 delete [] v;
00240 v = new T[index];
00241 if(!v) {
00242 VectorException e("Vector.resize(size_t) failed to allocate");
00243 GPSTK_THROW(e);
00244 }
00245 }
00246 s = index;
00247 return *this;
00248 }
00249
00251 Vector& resize(const size_t index, const T defaultValue)
00252 {
00253 resize(index);
00254 size_t i;
00255 for(i = 0; i < s; i++)
00256 v[i] = defaultValue;
00257 return *this;
00258 }
00259
00260
00261 std::vector<T> toStdVector()
00262 {
00263 std::vector<T> v;
00264 for(size_t i = 0; i < s; i++)
00265 v.push_back(v[i] );
00266 return v;
00267 }
00268
00269 inline Vector& operator<<(const Vector& b)
00270 {
00271 size_t i;
00272 size_t vs = this->size();
00273 size_t bs = b.size();
00274 size_t rows = vs + bs;
00275 Vector<T> toReturn(rows);
00276
00277 for (i = 0; i < vs; i++)
00278 toReturn[i] = (*this)[i];
00279
00280 for (i = 0; i < bs; i++)
00281 toReturn[i+vs] = b[i];
00282
00283 (*this) = toReturn;
00284
00285 return (*this);
00286 }
00287
00289 inline Vector& operator<<(const T &b)
00290 {
00291 return (*this) << Vector(1,b);
00292 }
00293
00295 inline Vector operator&&(const Vector &b)
00296 {
00297 size_t i;
00298 size_t vs = this->size();
00299 size_t bs = b.size();
00300 size_t rows = vs + bs;
00301 Vector<T> toReturn(rows);
00302
00303 for (i = 0; i < vs; i++)
00304 toReturn[i] = (*this)[i];
00305
00306 for (i = 0; i < bs; i++)
00307 toReturn[i+vs] = b[i];
00308
00309 return toReturn;
00310 }
00311
00313 inline Vector operator&&(const T &b)
00314 {
00315 size_t i;
00316 size_t vs = this->size();
00317 size_t rows = vs + 1;
00318 Vector<T> toReturn(rows);
00319
00320 for (i = 0; i < vs; i++)
00321 toReturn[i] = (*this)[i];
00322
00323 toReturn[rows - 1] = b;
00324
00325 return toReturn;
00326 }
00327
00328 private:
00329
00330
00331
00332
00333 inline bool rangeCheck(const size_t index) const
00334 {
00335 #ifdef RANGECHECK
00336 return (index < s);
00337 #else
00338 return true;
00339 #endif
00340 }
00341
00343 T* v;
00345 size_t s;
00346 };
00347
00348
00354 template <class T>
00355 class VectorSlice : public RefVectorSliceBase<T, VectorSlice<T> >
00356 {
00357 public:
00359 VectorSlice()
00360 : v(NULL), s(std::slice(0,0,0))
00361 { }
00362
00364 VectorSlice(Vector<T>& vv)
00365 : v(&vv), s(std::slice(0,vv.size(),1))
00366 { }
00367
00369 VectorSlice(Vector<T>& vv, const std::slice& ss)
00370 : v(&vv), s(ss)
00371 { vecSliceCheck(vv.size()); }
00372
00374 template <class V>
00375 VectorSlice& operator=(const ConstVectorBase<T, V>& x)
00376 { return this->assignFrom(x); }
00377
00379 VectorSlice& operator=(const std::valarray<T>& x)
00380 { return this->assignFrom(x); }
00381
00383 VectorSlice& operator=(const T x)
00384 { return this->assignFrom(x); }
00385
00387 VectorSlice& operator=(const T* x)
00388 { return this->assignFrom(x); }
00389
00391 T& operator[] (size_t i)
00392 { return (*v)[start() + i * stride()]; }
00394 T operator[] (size_t i) const
00395 { return (*v)[start() + i * stride()]; }
00397 T& operator() (size_t i)
00398 { return (*v)[start() + i * stride()]; }
00400 T operator() (size_t i) const
00401 { return (*v)[start() + i * stride()]; }
00402
00404 inline size_t size() const { return s.size(); }
00406 inline size_t start() const { return s.start(); }
00409 inline size_t stride() const { return s.stride(); }
00410 private:
00412 Vector<T>* v;
00414 std::slice s;
00415 };
00416
00420 template <class T>
00421 class ConstVectorSlice : public ConstVectorSliceBase<T, ConstVectorSlice<T> >
00422 {
00423 public:
00425 ConstVectorSlice()
00426 : v(NULL), s(std::slice(0,0,0))
00427 { }
00428
00430 ConstVectorSlice(const Vector<T>& vv)
00431 : v(&vv), s(std::slice(0,vv.size(),1))
00432 { }
00433
00435 ConstVectorSlice(const Vector<T>& vv, const std::slice& ss)
00436 : v(&vv), s(ss)
00437 { vecSliceCheck(vv.size()); }
00438
00440 T operator[] (size_t i) const
00441 { return (*v)[start() + i * stride()]; }
00443 T operator() (size_t i) const
00444 { return (*v)[start() + i * stride()]; }
00445
00447 inline size_t size() const { return s.size(); }
00449 inline size_t start() const { return s.start(); }
00452 inline size_t stride() const { return s.stride(); }
00453
00454 private:
00456 const Vector<T>* v;
00458 std::slice s;
00459 };
00460
00462
00463 }
00464
00465 #include "VectorOperators.hpp"
00466
00467 #endif