ViewVC Help
View File | Revision Log | Show Annotations | View Changeset | Root Listing
root/OpenMD/trunk/src/math/Vector.hpp
(Generate patch)

Comparing trunk/src/math/Vector.hpp (file contents):
Revision 101 by tim, Mon Oct 18 23:13:23 2004 UTC vs.
Revision 110 by tim, Tue Oct 19 21:28:55 2004 UTC

# Line 55 | Line 55 | namespace oopse {
55      inline bool equal(double e1, double e2) {
56          return fabs(e1 - e2) < epsilon;
57      }
58 +
59      
60      /**
61       * @class Vector Vector.hpp "math/Vector.hpp"
# Line 93 | Line 94 | namespace oopse {
94              }
95              
96              /** Constructs and initializes a Vector from an array */            
97 <            inline Vector( double* v) {
97 >            inline Vector( Real* v) {
98                  for (unsigned int i = 0; i < Dim; i++)
99                      data_[i] = v[i];
100              }
# Line 103 | Line 104 | namespace oopse {
104               * @return reference of ith element
105               * @param i index
106               */
107 <            inline double& operator[](unsigned int  i) {
107 >            inline Real& operator[](unsigned int  i) {
108                  assert( i < Dim);
109                  return data_[i];
110              }
# Line 113 | Line 114 | namespace oopse {
114               * @return reference of ith element
115               * @param i index
116               */
117 <            inline double& operator()(unsigned int  i) {
117 >            inline Real& operator()(unsigned int  i) {
118                  assert( i < Dim);
119                  return data_[i];
120              }
# Line 123 | Line 124 | namespace oopse {
124               * @return reference of ith element
125               * @param i index
126               */
127 <            inline  const double& operator[](unsigned int i) const {
127 >            inline  const Real& operator[](unsigned int i) const {
128                  assert( i < Dim);
129                  return data_[i];
130              }
# Line 133 | Line 134 | namespace oopse {
134               * @return reference of ith element
135               * @param i index
136               */
137 <            inline  const double& operator()(unsigned int i) const {
137 >            inline  const Real& operator()(unsigned int i) const {
138                  assert( i < Dim);
139                  return data_[i];
140              }
# Line 184 | Line 185 | namespace oopse {
185              * @param v1 the other vector
186              */
187              inline void add( const Vector<Real, Dim>& v1 ) {
188 <            for (unsigned int i = 0; i < Dim; i++)
189 <                data_[i] += v1.data_[i];
190 <                }
188 >                for (unsigned int i = 0; i < Dim; i++)
189 >                    data_[i] += v1.data_[i];
190 >            }
191  
192              /**
193              * Sets the value of this vector to the sum of v1 and v2 (*this = v1 + v2).
# Line 221 | Line 222 | namespace oopse {
222              * Sets the value of this vector to the scalar multiplication of itself (*this *= s).
223              * @param s the scalar value
224              */
225 <            inline void mul( double s ) {
225 >            inline void mul( Real s ) {
226                  for (unsigned int i = 0; i < Dim; i++)
227                     data_[i] *= s;
228              }
# Line 232 | Line 233 | namespace oopse {
233              * @param v1 the vector            
234              * @param s the scalar value
235              */
236 <            inline void mul( const Vector<Real, Dim>& v1, double s) {
236 >            inline void mul( const Vector<Real, Dim>& v1, Real s) {
237                  for (unsigned int i = 0; i < Dim; i++)
238                      data_[i] = s * v1.data_[i];
239              }
# Line 241 | Line 242 | namespace oopse {
242              * Sets the value of this vector to the scalar division of itself  (*this /= s ).
243              * @param s the scalar value
244              */            
245 <            inline void div( double s) {
245 >            inline void div( Real s) {
246                  for (unsigned int i = 0; i < Dim; i++)            
247                      data_[i] /= s;
248              }
# Line 251 | Line 252 | namespace oopse {
252              * @param v1 the source vector
253              * @param s the scalar value
254              */                        
255 <            inline void div( const Vector<Real, Dim>& v1, double s ) {
255 >            inline void div( const Vector<Real, Dim>& v1, Real s ) {
256                  for (unsigned int i = 0; i < Dim; i++)
257                      data_[i] = v1.data_[i] / s;
258              }
# Line 269 | Line 270 | namespace oopse {
270              }
271  
272              /** @see #mul */
273 <            inline Vector<Real, Dim>& operator *=( double s) {
273 >            inline Vector<Real, Dim>& operator *=( Real s) {
274                  mul(s);
275                  return *this;
276              }
277  
278              /** @see #div */
279 <            inline Vector<Real, Dim>& operator /=( double s ) {
279 >            inline Vector<Real, Dim>& operator /=( Real s ) {
280                  div(s);
281                  return *this;
282              }
# Line 284 | Line 285 | namespace oopse {
285               * Returns the length of this vector.
286               * @return the length of this vector
287               */
288 <             inline double length() {
289 <                return sqrt(lengthSquared());  
288 >             inline Real length() {
289 >                return sqrt(lengthSquare());  
290              }
291              
292              /**
293               * Returns the squared length of this vector.
294               * @return the squared length of this vector
295               */
296 <             inline double lengthSquare() {
296 >             inline Real lengthSquare() {
297                  return dot(*this, *this);
298              }
299              
300              /** Normalizes this vector in place */
301              inline void normalize() {
302 <                double len;
302 >                Real len;
303  
304                  len = length();
305 +                
306 +                //if (len < oopse:epsilon)
307 +                //  throw();
308 +                
309                  *this /= len;
310              }
311  
# Line 308 | Line 313 | namespace oopse {
313               * Tests if this vector is normalized
314               * @return true if this vector is normalized, otherwise return false
315               */
316 <            inline bool isNormalized() const
317 <            {
313 <                return lengthSquare() == 1.0;
316 >            inline bool isNormalized() {
317 >                return equal(lengthSquare(), 1.0);
318              }          
319              
320          protected:
321 <            double data_[Dim];
321 >            Real data_[Dim];
322          
323      };
324  
# Line 360 | Line 364 | namespace oopse {
364       * @param s the scalar value
365       */
366      template<typename Real, unsigned int Dim>                
367 <    Vector<Real, Dim> operator * ( const Vector<Real, Dim>& v1, double s) {      
367 >    Vector<Real, Dim> operator * ( const Vector<Real, Dim>& v1, Real s) {      
368          Vector<Real, Dim> result;
369          result.mul(v1,s);
370          return result;          
# Line 373 | Line 377 | namespace oopse {
377       * @param v1 the source vector
378       */  
379      template<typename Real, unsigned int Dim>
380 <    Vector<Real, Dim> operator * ( double s, const Vector<Real, Dim>& v1 ) {
380 >    Vector<Real, Dim> operator * ( Real s, const Vector<Real, Dim>& v1 ) {
381          Vector<Real, Dim> result;
382          result.mul(v1, s);
383          return result;          
# Line 386 | Line 390 | namespace oopse {
390       * @param s the scalar value
391       */
392      template<typename Real, unsigned int Dim>    
393 <    Vector<Real, Dim> operator / ( const Vector<Real, Dim>& v1, double s) {      
393 >    Vector<Real, Dim> operator / ( const Vector<Real, Dim>& v1, Real s) {      
394          Vector<Real, Dim> result;
395          result.div( v1,s);
396          return result;          
397      }
398      
395 –    /** fuzzy comparson */
396 –    template<typename Real, unsigned int Dim>        
397 –    inline bool epsilonEqual( const Vector<Real, Dim>& v1, const Vector<Real, Dim>& v2 ) {
398 –
399 –    }
400 –
401 –    
399      /**
400       * Returns the dot product of two Vectors
401       * @param v1 first vector
# Line 411 | Line 408 | namespace oopse {
408          tmp = 0;
409  
410          for (unsigned int i = 0; i < Dim; i++)
411 <            tmp += v1[i] + v2[i];
411 >            tmp += v1[i] * v2[i];
412  
413          return tmp;
414      }
# Line 446 | Line 443 | namespace oopse {
443      template<typename Real, unsigned int Dim>
444      std::ostream &operator<< ( std::ostream& o, const Vector<Real, Dim>& v) {
445  
446 <        o << "[" << v[0] << ", " << v[1] << ", " << v[2] << "]" << endl;
446 >        o << "[ ";
447 >        
448 >        for (unsigned int i = 0 ; i< Dim; i++) {
449 >            o << v[i];
450 >
451 >            if (i  != Dim -1) {
452 >                o<< ", ";
453 >            }
454 >        }
455 >
456 >        o << " ]";
457          return o;        
458      }
459      

Diff Legend

– Removed lines
+ Added lines
< Changed lines
> Changed lines