00001 #pragma ident "$Id: Vector.hpp 2910 2011-09-28 06:24:33Z 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 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 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 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 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 assignFrom(x); }
00203
00205 template <class E>
00206 Vector& operator=(const ConstVectorBase<T, E>& x)
00207 { resize(x.size()); return assignFrom(x); }
00208
00210 Vector& operator=(const std::valarray<T>& x)
00211 { resize(x.size()); return assignFrom(x); }
00213 Vector& operator=(const T x)
00214 { return assignFrom(x); }
00216 Vector& operator=(const T* x)
00217 { return 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
00270 inline Vector operator&&(const Vector &b)
00271 {
00272 size_t i;
00273 size_t vs = this->size();
00274 size_t bs = b.size();
00275 size_t rows = vs + bs;
00276 Vector<T> toReturn(rows);
00277
00278 for (i = 0; i < vs; i++)
00279 toReturn[i] = (*this)[i];
00280
00281 for (i = 0; i < bs; i++)
00282 toReturn[i+vs] = b[i];
00283
00284 return toReturn;
00285 }
00286
00288 inline Vector operator&&(const T &b)
00289 {
00290 size_t i;
00291 size_t vs = this->size();
00292 size_t rows = vs + 1;
00293 Vector<T> toReturn(rows);
00294
00295 for (i = 0; i < vs; i++)
00296 toReturn[i] = (*this)[i];
00297
00298 toReturn[rows - 1] = b;
00299
00300 return toReturn;
00301 }
00302
00303 private:
00304
00305
00306
00307
00308 inline bool rangeCheck(const size_t index) const
00309 {
00310 #ifdef RANGECHECK
00311 return (index < s);
00312 #else
00313 return true;
00314 #endif
00315 }
00316
00318 T* v;
00320 size_t s;
00321 };
00322
00323
00329 template <class T>
00330 class VectorSlice : public RefVectorSliceBase<T, VectorSlice<T> >
00331 {
00332 public:
00334 VectorSlice()
00335 : v(NULL), s(std::slice(0,0,0))
00336 { }
00337
00339 VectorSlice(Vector<T>& vv)
00340 : v(&vv), s(std::slice(0,vv.size(),1))
00341 { }
00342
00344 VectorSlice(Vector<T>& vv, const std::slice& ss)
00345 : v(&vv), s(ss)
00346 { vecSliceCheck(vv.size()); }
00347
00349 template <class V>
00350 VectorSlice& operator=(const ConstVectorBase<T, V>& x)
00351 { return assignFrom(x); }
00352
00354 VectorSlice& operator=(const std::valarray<T>& x)
00355 { return assignFrom(x); }
00356
00358 VectorSlice& operator=(const T x)
00359 { return assignFrom(x); }
00360
00362 VectorSlice& operator=(const T* x)
00363 { return assignFrom(x); }
00364
00366 T& operator[] (size_t i)
00367 { return (*v)[start() + i * stride()]; }
00369 T operator[] (size_t i) const
00370 { return (*v)[start() + i * stride()]; }
00372 T& operator() (size_t i)
00373 { return (*v)[start() + i * stride()]; }
00375 T operator() (size_t i) const
00376 { return (*v)[start() + i * stride()]; }
00377
00379 inline size_t size() const { return s.size(); }
00381 inline size_t start() const { return s.start(); }
00384 inline size_t stride() const { return s.stride(); }
00385 private:
00387 Vector<T>* v;
00389 std::slice s;
00390 };
00391
00395 template <class T>
00396 class ConstVectorSlice : public ConstVectorSliceBase<T, ConstVectorSlice<T> >
00397 {
00398 public:
00400 ConstVectorSlice()
00401 : v(NULL), s(std::slice(0,0,0))
00402 { }
00403
00405 ConstVectorSlice(const Vector<T>& vv)
00406 : v(&vv), s(std::slice(0,vv.size(),1))
00407 { }
00408
00410 ConstVectorSlice(const Vector<T>& vv, const std::slice& ss)
00411 : v(&vv), s(ss)
00412 { vecSliceCheck(vv.size()); }
00413
00415 T operator[] (size_t i) const
00416 { return (*v)[start() + i * stride()]; }
00418 T operator() (size_t i) const
00419 { return (*v)[start() + i * stride()]; }
00420
00422 inline size_t size() const { return s.size(); }
00424 inline size_t start() const { return s.start(); }
00427 inline size_t stride() const { return s.stride(); }
00428
00429 private:
00431 const Vector<T>* v;
00433 std::slice s;
00434 };
00435
00437
00438 }
00439
00440 #include "VectorOperators.hpp"
00441
00442 #endif