SpherePackingScenarioGenerator: algorithms/ls/Vector.h Source File

Go to the documentation of this file.
00001 #ifndef Vector_H
00002 #define Vector_H
00003 
00004 #include <iostream>
00005 #include <fstream>
00006 namespace algorithms{
00007 namespace ls{
00008 #define DIM 3
00009 
00013 template <int D, typename T=double>
00014 class Vector {
00015 
00016 public:
00017         T x[D];
00018 
00019 public:
00023         Vector();
00027         Vector(const T[D]);
00031         Vector(const Vector&);
00035         ~Vector();
00039         Vector<D, T>& operator+=(const Vector<D, T>&);
00043         Vector<D, T>& operator-=(const Vector<D, T>&);
00047         Vector<D, T>& operator*=(const T);
00051         Vector<D, T>& operator/=(const T);
00055         Vector<D, T> operator+(const Vector<D, T>&) const;
00059         Vector<D, T> operator-(const Vector<D, T>&) const;
00063         Vector<D, T> operator*(const T) const;
00067         Vector<D, T> operator/(const T) const;
00071         Vector<D, T> operator%(const T) const;
00075         bool operator==(const Vector<D, T> &a) const;
00079         Vector<D, int> integer() const;
00083         Vector<D, double> Double() const;
00084         static Vector<D, int> integer(const Vector<D, T>&);
00085         static Vector<D, double> Double(const Vector<D, T>&);
00086 
00087         T& operator[](const unsigned int);
00091         double dot(const Vector<D, T>&) const;
00092         static double dot(const Vector<D, T>&, const Vector<D, T>&);
00096         double norm_squared() const;
00097         static double norm_squared(const Vector<D, T>&);
00101         void read(std::ifstream&);
00105         void write(std::ofstream&) const;
00106 };
00113 template <int D, typename T>
00114 std::ostream& operator<<(std::ostream&, const Vector<D, T>&);
00115 
00116 
00117 template <int D, typename T>
00118 Vector<D, T>::Vector()
00119 {
00120         for(int k=0; k<D; k++)
00121                 x[k] = 0;
00122 }
00123 
00124 template <int D, typename T>
00125 Vector<D, T>::Vector(const T x_i[D])
00126 {
00127         for(int k=0; k<D; k++)
00128                 x[k] = x_i[k];
00129 }
00130 
00131 template <int D, typename T>
00132 Vector<D, T>::Vector(const Vector<D, T> &v)
00133 {
00134         for(int k=0; k<D; k++)
00135                 x[k] = v.x[k];
00136 }
00137 
00138 template <int D, typename T>
00139 Vector<D, T>::~Vector()
00140 {
00141 }
00142 
00143 
00144 template <int D, typename T>
00145 inline Vector<D, T>& Vector<D, T>::operator+=(const Vector<D, T> &v)
00146 {
00147         for(int k=0; k<D; k++)
00148                 x[k] += v.x[k];
00149 
00150         return *this;
00151 }
00152 
00153 
00154 template <int D, typename T>
00155 inline Vector<D, T>& Vector<D, T>::operator-=(const Vector<D, T> &v)
00156 {
00157         for(int k=0; k<D; k++)
00158                 x[k] -= v.x[k];
00159 
00160         return *this;
00161 }
00162 
00163 
00164 template <int D, typename T>
00165 inline Vector<D, T>& Vector<D, T>::operator*=(const T s)
00166 {
00167         for(int k=0; k<D; k++)
00168                 x[k] *= s;
00169 
00170         return *this;
00171 }
00172 
00173 template <int D, typename T>
00174 inline Vector<D, T>& Vector<D, T>::operator/=(const T s)
00175 {
00176         for(int k=0; k<D; k++)
00177                 x[k] /= s;
00178 
00179         return *this;
00180 }
00181 
00182 
00183 template <int D, typename T>
00184 inline Vector<D, T> Vector<D, T>::operator+(const Vector<D, T> &a) const
00185 {
00186         Vector<D, T> c;
00187 
00188         for(int k=0; k<D; k++)
00189                 c.x[k] = x[k] + a.x[k];
00190 
00191         return c;
00192 }
00193 
00194 
00195 template <int D, typename T>
00196 inline Vector<D, T> Vector<D, T>::operator-(const Vector<D, T> &a) const
00197 {
00198         Vector<D, T> c;
00199 
00200         for(int k=0; k<D; k++)
00201                 c[k] = x[k] - a.x[k];
00202 
00203         return c;
00204 }
00205 
00206 
00207 template <int D, typename T>
00208 inline Vector<D, T> Vector<D, T>::operator*(const T s) const
00209 {
00210         Vector<D, T> c;
00211 
00212         for(int k=0; k<D; k++)
00213                 c[k] = x[k] * s;
00214 
00215         return c;
00216 }
00217 
00218 
00219 template <int D, typename T>
00220 inline Vector<D, T> Vector<D, T>::operator/(const T s) const
00221 {
00222         Vector<D, T> c;
00223 
00224         for(int k=0; k<D; k++)
00225                 c[k] = x[k] / s;
00226 
00227         return c;
00228 }
00229 
00230 
00231 template <int D, typename T>
00232 inline bool Vector<D, T>::operator==(const Vector<D, T> &a) const
00233 {
00234         for(int k=0; k<D; k++)
00235         {
00236                 if (!(x[k]==a.x[k]))
00237                         return false;
00238         }
00239         return true;
00240 }
00241 
00242 
00243 template <int D, typename T>
00244 inline Vector<D, T> Vector<D, T>::operator%(const T s) const
00245 {
00246         Vector<D, T> c;
00247 
00248         for(int k=0; k<D; k++)
00249                 c[k] = x[k] % s;
00250 
00251         return c;
00252 }
00253 
00254 
00255 template <int D, typename T>
00256 inline Vector<D, int> Vector<D, T>::integer() const
00257 {
00258         Vector<D, int> c;
00259 
00260         for(int k=0; k<D; k++)
00261                 c[k] = (int)x[k];
00262 
00263         return c;
00264 }
00265 
00266 template <int D, typename T>
00267 inline Vector<D, int> Vector<D, T>::integer(const Vector<D, T>& v)
00268 {
00269         return v.integer();
00270 }
00271 
00272 template <int D, typename T>
00273 inline Vector<D, double> Vector<D, T>::Double() const
00274 {
00275         Vector<D, double> c;
00276 
00277         for(int k=0; k<D; k++)
00278                 c[k] = (double)x[k];
00279 
00280         return c;
00281 }
00282 
00283 template <int D, typename T>
00284 inline Vector<D, double> Vector<D, T>::Double(const Vector<D, T>& v)
00285 {
00286         return v.Double();
00287 }
00288 
00289 
00290 
00291 template <int D, typename T>
00292 inline T& Vector<D, T>::operator[](const unsigned int i)
00293 {
00294         return x[i];
00295 }
00296 
00297 
00298 template <int D, typename T>
00299 inline double Vector<D, T>::dot(const Vector<D, T> &a) const
00300 {
00301         double d=0;
00302 
00303         for(int k=0; k<D; k++)
00304                 d += x[k] * a.x[k];
00305 
00306         return d;
00307 }
00308 
00309 template <int D, typename T>
00310 inline double Vector<D, T>::dot(const Vector<D, T> &a, const Vector<D, T> &b)
00311 {
00312         return a.dot(b);
00313 }
00314 
00315 
00316 template <int D, typename T>
00317 inline double Vector<D, T>::norm_squared() const
00318 {
00319         return dot(*this, *this);
00320 }
00321 
00322 template <int D, typename T>
00323 inline double Vector<D, T>::norm_squared(const Vector<D, T>& v)
00324 {
00325         return v.norm_squared();
00326 }
00327 
00328 template <int D, typename T>
00329 void Vector<D, T>::read(std::ifstream& in)
00330 {
00331         in.read((char*)x, sizeof(T)*D);
00332 }
00333 
00334 template <int D, typename T>
00335 void Vector<D, T>::write(std::ofstream& out) const
00336 {
00337         out.write((const char*)x, sizeof(T)*D);
00338 }
00339 
00340 
00341 template <int D, typename T>
00342 std::ostream& operator<<(std::ostream& os, const Vector<D, T>& v)
00343 {
00344         os << "(";
00345 
00346         for(int k=0; k<D-1; k++)
00347                 os << v.x[k] << ", ";
00348 
00349         os << v.x[D-1] << ")";
00350 
00351         return os;
00352 }
00353 
00354 }/* close namespace ls */
00355 }/* close namespace algorithms */
00356 #endif