00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
00020
00021
00022 #ifndef TNT_ARRAY1D_H
00023 #define TNT_ARRAY1D_H
00024
00025
00026 #include <iostream>
00027
00028 #ifdef TNT_BOUNDS_CHECK
00029 #include <assert.h>
00030 #endif
00031
00032
00033 #include "tnt_i_refvec.h"
00034
00035 namespace TNT
00036 {
00037
00038 template <class T>
00039 class Array1D
00040 {
00041
00042 private:
00043
00044
00045 i_refvec<T> v_;
00046 int n_;
00047 T* data_;
00048
00049
00050
00051
00052 void copy_(T* p, const T* q, int len) const;
00053 void set_(T* begin, T* end, const T& val);
00054
00055
00056 public:
00057
00058 typedef T value_type;
00059
00060
00061 Array1D();
00062 explicit Array1D(int n);
00063 Array1D(int n, const T &a);
00064 Array1D(int n, T *a);
00065 inline Array1D(const Array1D &A);
00066 inline operator T*();
00067 inline operator const T*();
00068 inline Array1D & operator=(const T &a);
00069 inline Array1D & operator=(const Array1D &A);
00070 inline Array1D & ref(const Array1D &A);
00071 Array1D copy() const;
00072 Array1D & inject(const Array1D & A);
00073 inline T& operator[](int i);
00074 inline const T& operator[](int i) const;
00075 inline int dim1() const;
00076 inline int dim() const;
00077 ~Array1D();
00078
00079
00080
00081
00082 inline int ref_count() const;
00083 inline Array1D<T> subarray(int i0, int i1);
00084
00085 };
00086
00087
00088
00089
00090 template <class T>
00091 Array1D<T>::Array1D() : v_(), n_(0), data_(0) {}
00092
00093 template <class T>
00094 Array1D<T>::Array1D(const Array1D<T> &A) : v_(A.v_), n_(A.n_),
00095 data_(A.data_)
00096 {
00097 #ifdef TNT_DEBUG
00098 std::cout << "Created Array1D(const Array1D<T> &A) \n";
00099 #endif
00100
00101 }
00102
00103
00104 template <class T>
00105 Array1D<T>::Array1D(int n) : v_(n), n_(n), data_(v_.begin())
00106 {
00107 #ifdef TNT_DEBUG
00108 std::cout << "Created Array1D(int n) \n";
00109 #endif
00110 }
00111
00112 template <class T>
00113 Array1D<T>::Array1D(int n, const T &val) : v_(n), n_(n), data_(v_.begin())
00114 {
00115 #ifdef TNT_DEBUG
00116 std::cout << "Created Array1D(int n, const T& val) \n";
00117 #endif
00118 set_(data_, data_+ n, val);
00119
00120 }
00121
00122 template <class T>
00123 Array1D<T>::Array1D(int n, T *a) : v_(a), n_(n) , data_(v_.begin())
00124 {
00125 #ifdef TNT_DEBUG
00126 std::cout << "Created Array1D(int n, T* a) \n";
00127 #endif
00128 }
00129
00130 template <class T>
00131 inline Array1D<T>::operator T*()
00132 {
00133 return &(v_[0]);
00134 }
00135
00136
00137 template <class T>
00138 inline Array1D<T>::operator const T*()
00139 {
00140 return &(v_[0]);
00141 }
00142
00143
00144
00145 template <class T>
00146 inline T& Array1D<T>::operator[](int i)
00147 {
00148 #ifdef TNT_BOUNDS_CHECK
00149 assert(i>= 0);
00150 assert(i < n_);
00151 #endif
00152 return data_[i];
00153 }
00154
00155 template <class T>
00156 inline const T& Array1D<T>::operator[](int i) const
00157 {
00158 #ifdef TNT_BOUNDS_CHECK
00159 assert(i>= 0);
00160 assert(i < n_);
00161 #endif
00162 return data_[i];
00163 }
00164
00165
00166
00167
00168 template <class T>
00169 Array1D<T> & Array1D<T>::operator=(const T &a)
00170 {
00171 set_(data_, data_+n_, a);
00172 return *this;
00173 }
00174
00175 template <class T>
00176 Array1D<T> Array1D<T>::copy() const
00177 {
00178 Array1D A( n_);
00179 copy_(A.data_, data_, n_);
00180
00181 return A;
00182 }
00183
00184
00185 template <class T>
00186 Array1D<T> & Array1D<T>::inject(const Array1D &A)
00187 {
00188 if (A.n_ == n_)
00189 copy_(data_, A.data_, n_);
00190
00191 return *this;
00192 }
00193
00194
00195
00196
00197
00198 template <class T>
00199 Array1D<T> & Array1D<T>::ref(const Array1D<T> &A)
00200 {
00201 if (this != &A)
00202 {
00203 v_ = A.v_;
00204 n_ = A.n_;
00205 data_ = A.data_;
00206
00207 }
00208 return *this;
00209 }
00210
00211 template <class T>
00212 Array1D<T> & Array1D<T>::operator=(const Array1D<T> &A)
00213 {
00214 return ref(A);
00215 }
00216
00217 template <class T>
00218 inline int Array1D<T>::dim1() const { return n_; }
00219
00220 template <class T>
00221 inline int Array1D<T>::dim() const { return n_; }
00222
00223 template <class T>
00224 Array1D<T>::~Array1D() {}
00225
00226
00227
00228
00229 template <class T>
00230 inline int Array1D<T>::ref_count() const
00231 {
00232 return v_.ref_count();
00233 }
00234
00235 template <class T>
00236 inline Array1D<T> Array1D<T>::subarray(int i0, int i1)
00237 {
00238 if ((i0 > 0) && (i1 < n_) || (i0 <= i1))
00239 {
00240 Array1D<T> X(*this);
00241 X.n_ = i1-i0+1;
00242 X.data_ += i0;
00243
00244 return X;
00245 }
00246 else
00247 {
00248 return Array1D<T>();
00249 }
00250 }
00251
00252
00253
00254
00255
00256 template <class T>
00257 void Array1D<T>::set_(T* begin, T* end, const T& a)
00258 {
00259 for (T* p=begin; p<end; p++)
00260 *p = a;
00261
00262 }
00263
00264 template <class T>
00265 void Array1D<T>::copy_(T* p, const T* q, int len) const
00266 {
00267 T *end = p + len;
00268 while (p<end )
00269 *p++ = *q++;
00270
00271 }
00272
00273
00274 }
00275
00276 #endif
00277
00278