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

Comparing trunk/OOPSE-3.0/src/math/Vector.hpp (file contents):
Revision 1569 by tim, Thu Oct 14 23:28:09 2004 UTC vs.
Revision 1603 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 85 | Line 86 | namespace oopse {
86                  
87                  return *this;
88              }
89 +
90 +            template<typename T>
91 +            inline Vector(const T& s){
92 +                for (unsigned int i = 0; i < Dim; i++)
93 +                    data_[i] = s;
94 +            }
95              
96              /** Constructs and initializes a Vector from an array */            
97 <            inline Vector( double* v) {
98 <                for (unsigned int i = 0; i < Dim; i++)
99 <                    data_[i] = v[i];
97 >            inline Vector( Real* v) {
98 >                for (unsigned int i = 0; i < Dim; i++)
99 >                    data_[i] = v[i];
100              }
101  
102              /**
# Line 97 | 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 107 | 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 117 | 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 127 | 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 159 | Line 166 | namespace oopse {
166              
167              /** Negates the value of this vector in place. */          
168              inline void negate() {
169 <                data_[0] = -data_[0];
170 <                data_[1] = -data_[1];
164 <                data_[2] = -data_[2];
169 >                for (unsigned int i = 0; i < Dim; i++)
170 >                    data_[i] = -data_[i];
171              }
172  
173              /**
# Line 179 | 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 189 | Line 195 | namespace oopse {
195              * @param v2 the second vector
196              */
197              inline void add( const Vector<Real, Dim>& v1, const Vector<Real, Dim>& v2 ) {
198 <                for (unsigned int i = 0; i < Dim; i++)
199 <                    data_[i] = v1.data_[i] + v2.data_[i];
198 >                for (unsigned int i = 0; i < Dim; i++)
199 >                    data_[i] = v1.data_[i] + v2.data_[i];
200              }
201  
202              /**
# Line 216 | 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 ) {
226 <                for (unsigned int i = 0; i < Dim; i++)
225 >            inline void mul( Real s ) {
226 >                for (unsigned int i = 0; i < Dim; i++)
227                     data_[i] *= s;
228              }
229  
230              /**
231              * Sets the value of this vector to the scalar multiplication of vector v1  
232              * (*this = s * v1).
233 +            * @param v1 the vector            
234              * @param s the scalar value
228 –            * @param v1 the vector
235              */
236 <            inline void mul( double s, const Vector<Real, Dim>& v1 ) {
237 <                for (unsigned int i = 0; i < Dim; i++)
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              }
240  
# Line 236 | 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) {
246 <                for (unsigned int i = 0; i < Dim; i++)            
245 >            inline void div( Real s) {
246 >                for (unsigned int i = 0; i < Dim; i++)            
247                      data_[i] /= s;
248              }
249  
# Line 246 | 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 ) {
256 <                for (unsigned int i = 0; i < Dim; i++)
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              }
259  
# Line 264 | 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 279 | 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 lengthSquared() {
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 +
312 +            /**
313 +             * Tests if this vector is normalized
314 +             * @return true if this vector is normalized, otherwise return false
315 +             */
316 +            inline bool isNormalized() {
317 +                return equal(lengthSquare(), 1.0);
318 +            }          
319              
320          protected:
321 <            double data_[3];
321 >            Real data_[Dim];
322          
323      };
324  
325      /** unary minus*/
326      template<typename Real, unsigned int Dim>    
327      inline Vector<Real, Dim> operator -(const Vector<Real, Dim>& v1){
328 <        Vector tmp(v1);
329 <        return tmp.negate();
328 >        Vector<Real, Dim> tmp(v1);
329 >        tmp.negate();
330 >        return tmp;
331      }
332  
333      /**
# Line 345 | 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(s, v1);
369 >        result.mul(v1,s);
370          return result;          
371      }
372      
# Line 358 | 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(s, v1);
382 >        result.mul(v1, s);
383          return result;          
384      }
385  
# Line 371 | 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      
399      /**
381 –     * Returns the  value of division of a vector by a scalar.
382 –     * @return  the vaule of scalar division of this vector
383 –     * @param s the scalar value
384 –     * @param v1 the source vector
385 –     */
386 –    template<typename Real, unsigned int Dim>        
387 –    inline Vector<Real, Dim> operator /( double s, const Vector<Real, Dim>& v1 ) {
388 –        Vector<Real, Dim> result;
389 –        result.div( v1,s);
390 –        return result;          
391 –    }
392 –
393 –    /** fuzzy comparson */
394 –    template<typename Real, unsigned int Dim>        
395 –    inline bool epsilonEqual( const Vector<Real, Dim>& v1, const Vector<Real, Dim>& v2 ) {
396 –
397 –    }
398 –
399 –    
400 –    /**
400       * Returns the dot product of two Vectors
401       * @param v1 first vector
402       * @param v2 second vector
# Line 405 | Line 404 | namespace oopse {
404       */
405      template<typename Real, unsigned int Dim>    
406      inline Real dot( const Vector<Real, Dim>& v1, const Vector<Real, Dim>& v2 ) {
407 <                Real tmp;
408 <                tmp = 0;
407 >        Real tmp;
408 >        tmp = 0;
409  
410 <                for (unsigned int i = 0; i < Dim; i++)
411 <                        tmp += v1[i] + v2[i];
412 <                
413 <                return tmp;
410 >        for (unsigned int i = 0; i < Dim; i++)
411 >            tmp += v1[i] * v2[i];
412 >
413 >        return tmp;
414      }
415  
416      /**
# Line 442 | Line 441 | namespace oopse {
441       * Write to an output stream
442       */
443      template<typename Real, unsigned int Dim>
444 <    std::ostream &operator<< ( std::ostream& o, const Vector<Real, Dim>& v1 ) {
444 >    std::ostream &operator<< ( std::ostream& o, const Vector<Real, Dim>& v) {
445 >
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