00001 #ifndef Impala_Core_Vector_VectorTem_h
00002 #define Impala_Core_Vector_VectorTem_h
00003
00004 #include <iostream>
00005 #include "Basis/String.h"
00006
00007 namespace Impala
00008 {
00009 namespace Core
00010 {
00011 namespace Vector
00012 {
00013
00014
00018 template <class ElemT>
00019 class VectorTem
00020 {
00021 public:
00022
00024 VectorTem()
00025 {
00026 mSize = 0;
00027 mData = 0;
00028 mIsWrapper = false;
00029 }
00030
00032 VectorTem(int n)
00033 {
00034 mSize = n;
00035 mData = new ElemT[mSize];
00036 mIsWrapper = false;
00037 }
00038
00040 VectorTem(int n, ElemT* data, bool isWrapper)
00041 {
00042 mSize = n;
00043 mIsWrapper = isWrapper;
00044 mData = (mIsWrapper) ? data : new ElemT[n];
00045 if (!mIsWrapper)
00046 CopyData(n, data);
00047 }
00048
00050 VectorTem(ElemT a0, ElemT a1)
00051 {
00052 mSize = 2;
00053 mData = new ElemT[mSize];
00054 mIsWrapper = false;
00055 mData[0] = a0;
00056 mData[1] = a1;
00057 }
00058
00060 VectorTem(ElemT a0, ElemT a1, ElemT a2)
00061 {
00062 mSize = 3;
00063 mData = new ElemT[mSize];
00064 mIsWrapper = false;
00065 mData[0] = a0;
00066 mData[1] = a1;
00067 mData[2] = a2;
00068 }
00069
00071 VectorTem(const VectorTem& v)
00072 {
00073 mSize = v.mSize;
00074 mIsWrapper = v.mIsWrapper;
00075 mData = (mIsWrapper) ? v.mData : new ElemT[mSize];
00076 if (!mIsWrapper)
00077 CopyData(mSize, v.mData);
00078 }
00079
00081 virtual
00082 ~VectorTem()
00083 {
00084 if (!mIsWrapper)
00085 delete [] mData;
00086 }
00087
00089 int
00090 Size() const
00091 {
00092 return mSize;
00093 }
00094
00096 int
00097 Valid() const
00098 {
00099 return (mSize != 0);
00100 }
00101
00103 VectorTem&
00104 operator=(const VectorTem& v)
00105 {
00106 if (this != &v)
00107 {
00108 if ((mSize != v.mSize) && (!mIsWrapper))
00109 {
00110 delete [] mData;
00111 mSize = v.mSize;
00112 mData = new ElemT[mSize];
00113 }
00114 CopyData(mSize, v.mData);
00115 }
00116 return *this;
00117 }
00118
00120 void
00121 CopyData(int n, const ElemT* data, int begin=0)
00122 {
00123 for (int i=0 ; i<n && i+begin<Size() ; i++)
00124 mData[i+begin] = data[i];
00125 }
00126
00128 VectorTem&
00129 operator=(ElemT a)
00130 {
00131 for (int i=0 ; i<mSize ; i++)
00132 mData[i] = a;
00133 return *this;
00134 }
00135
00136 bool
00137 Equals(const VectorTem& arg) const
00138 {
00139 const int size = Size();
00140
00141 if (size != arg.Size())
00142 return false;
00143
00144 for (int i = 0; i < size; i++)
00145 if (mData[i] != arg[i])
00146 return false;
00147
00148 return true;
00149 }
00150
00152 ElemT&
00153 operator[](int i) const
00154 {
00155 return mData[i];
00156 }
00157
00158 ElemT&
00159 Elem(int i) const
00160 {
00161 return mData[i];
00162 }
00163
00164 ElemT*
00165 GetData()
00166 {
00167 return mData;
00168 }
00169
00170 const ElemT*
00171 GetData() const
00172 {
00173 return mData;
00174 }
00175
00176
00177 String
00178 PrintE(int nrElem) const
00179 {
00180 if (nrElem == -1)
00181 nrElem = Size();
00182 std::ostringstream oss;
00183 oss << "(";
00184 for (int i=0 ; i<Size() ; i++)
00185 {
00186 if ((i < nrElem) || (i >= Size() - nrElem))
00187 {
00188 oss << mData[i];
00189 if (i != Size() - 1)
00190 oss << ",";
00191 }
00192 else
00193 {
00194 if (i == nrElem)
00195 oss << "..., ";
00196 }
00197 }
00198 oss << ")";
00199 return oss.str();
00200 }
00201
00203 template<class ElemTT>
00204 friend ElemTT
00205 operator*(const VectorTem<ElemTT>& a, const VectorTem<ElemTT>& b);
00206
00208 template<class ElemTT>
00209 friend VectorTem<ElemTT>
00210 operator*(const ElemTT a, const VectorTem<ElemTT>& b);
00211
00213 template<class ElemTT>
00214 friend VectorTem<ElemTT>
00215 operator*(const VectorTem<ElemTT>& a, const ElemTT b);
00216
00217 private:
00218
00219 int mSize;
00220 ElemT* mData;
00221 bool mIsWrapper;
00222 };
00223
00224 template <class ElemT>
00225 VectorTem<ElemT> Append(const VectorTem<ElemT>& v1, const VectorTem<ElemT>& v2)
00226 {
00227 VectorTem<ElemT> ret(v1.Size() + v2.Size());
00228 ret.CopyData(v1.Size(), v1.GetData());
00229 ret.CopyData(v2.Size(), v2.GetData(), v1.Size());
00230 return ret;
00231 }
00232
00233 template <class ElemT>
00234 inline std::ostream&
00235 operator<<(std::ostream& os, const VectorTem<ElemT>& v)
00236 {
00237 os << "(";
00238 for (int i=0 ; i<v.Size() ; i++)
00239 {
00240 os << v[i];
00241 if (i != v.Size() - 1)
00242 os << ",";
00243 }
00244 os << ")";
00245 return os;
00246 }
00247
00248 template <class ElemT>
00249 inline VectorTem<ElemT>
00250 operator*(const VectorTem<ElemT>& a, ElemT b)
00251 {
00252 VectorTem<ElemT> r(a);
00253 for (int i=0 ; i<r.mSize ; i++)
00254 r.mData[i] *= b;
00255 return r;
00256 }
00257
00258 template <class ElemT>
00259 inline VectorTem<ElemT>
00260 operator*(ElemT a, const VectorTem<ElemT> &b)
00261 {
00262 VectorTem<ElemT> r(b);
00263 for (int i=0 ; i<r.mSize ; i++)
00264 r.mData[i] *= a;
00265 return r;
00266 }
00267
00268 template <class ElemT>
00269 inline ElemT
00270 operator*(const VectorTem<ElemT> &a, const VectorTem<ElemT> &b)
00271 {
00272 if (a.mSize != b.mSize)
00273 {
00274 std::cerr << "nonconformant VectorTem * VectorTem operands." << std::endl;
00275 return 0;
00276 }
00277 ElemT sum = 0;
00278 int i;
00279 for (i=0 ; i<a.mSize ; i++)
00280 sum += a[i] * b[i];
00281 return sum;
00282 }
00283
00284 }
00285 }
00286 }
00287
00288 #endif