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 1586 by tim, Sun Oct 17 01:19:11 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) {
97 >            inline Vector( Real* v) {
98                  for (unsigned int i = 0; i < Dim; i++)
99                      data_[i] = v[i];
100              }
# 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 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 ) {
225 >            inline void mul( Real s ) {
226                  for (unsigned int i = 0; i < Dim; i++)
227                     data_[i] *= s;
228              }
# Line 224 | Line 230 | namespace oopse {
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 ) {
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 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) {
245 >            inline void div( Real s) {
246                  for (unsigned int i = 0; i < Dim; i++)            
247                      data_[i] /= s;
248              }
# 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 ) {
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 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 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 303 | 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 <            {
308 <                return lengthSquare() == 1.0;
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 354 | 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 367 | 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 380 | 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      /**
390 –     * Returns the  value of division of a vector by a scalar.
391 –     * @return  the vaule of scalar division of this vector
392 –     * @param s the scalar value
393 –     * @param v1 the source vector
394 –     */
395 –    template<typename Real, unsigned int Dim>        
396 –    inline Vector<Real, Dim> operator /( double s, const Vector<Real, Dim>& v1 ) {
397 –        Vector<Real, Dim> result;
398 –        result.div( v1,s);
399 –        return result;          
400 –    }
401 –
402 –    /** fuzzy comparson */
403 –    template<typename Real, unsigned int Dim>        
404 –    inline bool epsilonEqual( const Vector<Real, Dim>& v1, const Vector<Real, Dim>& v2 ) {
405 –
406 –    }
407 –
408 –    
409 –    /**
400       * Returns the dot product of two Vectors
401       * @param v1 first vector
402       * @param v2 second vector
# Line 418 | 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 453 | 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