SpherePackingScenarioGenerator: algorithms/ls2/Vector.h Source File

Go to the documentation of this file.
00001 //#ifndef LS2_Vector_H
00002 //#define LS2_Vector_H
00003 //
00004 //#include <iostream>
00005 //#include <fstream>
00006 //namespace algorithms{
00007 //namespace ls2{
00008 //#define DIM 3
00009 //
00011 // * Class Vector: the position of sphere
00012 // */
00013 //template <int D, typename T=double>
00014 //class Vector {
00015 //
00016 //public:
00017 //      T x[D];
00018 //
00019 //public:
00020 //      /**
00021 //       * Constructor
00022 //       */
00023 //      Vector();
00024 //      /**
00025 //       * Constructor
00026 //       */
00027 //      Vector(const T[D]);
00028 //      /**
00029 //       * Constructor
00030 //       */
00031 //      Vector(const Vector&);
00032 //      /**
00033 //       * Destructor
00034 //       */
00035 //      ~Vector();
00036 //      /**
00037 //       * Define operator +=
00038 //       */
00039 //      Vector<D, T>& operator+=(const Vector<D, T>&);
00040 //      /**
00041 //       * Define operator -=
00042 //       */
00043 //      Vector<D, T>& operator-=(const Vector<D, T>&);
00044 //      /**
00045 //       * Define operator *=
00046 //       */
00047 //      Vector<D, T>& operator*=(const T);
00048 //      /**
00049 //       * Define operator /=
00050 //       */
00051 //      Vector<D, T>& operator/=(const T);
00052 //      /**
00053 //       * Define operator +
00054 //       */
00055 //      Vector<D, T> operator+(const Vector<D, T>&) const;
00056 //      /**
00057 //       * Define operator -=
00058 //       */
00059 //      Vector<D, T> operator-(const Vector<D, T>&) const;
00060 //      /**
00061 //       * Define operator *
00062 //       */
00063 //      Vector<D, T> operator*(const T) const;
00064 //      /**
00065 //       * Define operator /
00066 //       */
00067 //      Vector<D, T> operator/(const T) const;
00068 //      /**
00069 //       * Define operator %
00070 //       */
00071 //      Vector<D, T> operator%(const T) const;
00072 //      /**
00073 //       * Define operator ==
00074 //       */
00075 //      bool operator==(const Vector<D, T> &a) const;
00076 //      /**
00077 //       * Integer
00078 //       */
00079 //      Vector<D, int> integer() const;
00080 //      /**
00081 //       * Double
00082 //       */
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);
00088 //      /**
00089 //       * Dot
00090 //       */
00091 //      double dot(const Vector<D, T>&) const;
00092 //      static double dot(const Vector<D, T>&, const Vector<D, T>&);
00093 //      /**
00094 //       * Norm_squared
00095 //       */
00096 //      double norm_squared() const;
00097 //      static double norm_squared(const Vector<D, T>&);
00098 //      /**
00099 //       * Read
00100 //       */
00101 //      void read(std::ifstream&);
00102 //      /**
00103 //       * Write
00104 //       */
00105 //      void write(std::ofstream&) const;
00106 //};
00108 // *
00109 // Insertion
00110 //
00111 // */
00112 //
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 ls2 */
00355 //}/* close namespace algorithms */
00356 //#endif