ViewVC Help
View File | Revision Log | Show Annotations | View Changeset | Root Listing
root/group/branches/new_design/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 1597 by tim, Tue Oct 19 04:34:35 2004 UTC

# Line 85 | Line 85 | namespace oopse {
85                  
86                  return *this;
87              }
88 +
89 +            template<typename T>
90 +            inline Vector(const T& s){
91 +                for (unsigned int i = 0; i < Dim; i++)
92 +                    data_[i] = s;
93 +            }
94              
95              /** Constructs and initializes a Vector from an array */            
96              inline Vector( double* v) {
97 <                for (unsigned int i = 0; i < Dim; i++)
98 <                    data_[i] = v[i];
97 >                for (unsigned int i = 0; i < Dim; i++)
98 >                    data_[i] = v[i];
99              }
100  
101              /**
# Line 159 | Line 165 | namespace oopse {
165              
166              /** Negates the value of this vector in place. */          
167              inline void negate() {
168 <                data_[0] = -data_[0];
169 <                data_[1] = -data_[1];
164 <                data_[2] = -data_[2];
168 >                for (unsigned int i = 0; i < Dim; i++)
169 >                    data_[i] = -data_[i];
170              }
171  
172              /**
# Line 179 | Line 184 | namespace oopse {
184              * @param v1 the other vector
185              */
186              inline void add( const Vector<Real, Dim>& v1 ) {
187 <                for (unsigned int i = 0; i < Dim; i++)
188 <                    data_[i] += v1.data_[i];
187 >            for (unsigned int i = 0; i < Dim; i++)
188 >                data_[i] += v1.data_[i];
189                  }
190  
191              /**
# Line 189 | Line 194 | namespace oopse {
194              * @param v2 the second vector
195              */
196              inline void add( const Vector<Real, Dim>& v1, const Vector<Real, Dim>& v2 ) {
197 <                for (unsigned int i = 0; i < Dim; i++)
198 <                    data_[i] = v1.data_[i] + v2.data_[i];
197 >                for (unsigned int i = 0; i < Dim; i++)
198 >                    data_[i] = v1.data_[i] + v2.data_[i];
199              }
200  
201              /**
# Line 217 | Line 222 | namespace oopse {
222              * @param s the scalar value
223              */
224              inline void mul( double s ) {
225 <                for (unsigned int i = 0; i < Dim; i++)
225 >                for (unsigned int i = 0; i < Dim; i++)
226                     data_[i] *= s;
227              }
228  
229              /**
230              * Sets the value of this vector to the scalar multiplication of vector v1  
231              * (*this = s * v1).
232 <            * @param s the scalar value
233 <            * @param v1 the vector
232 >            * @param v1 the vector            
233 >            * @param s the scalar value
234              */
235 <            inline void mul( double s, const Vector<Real, Dim>& v1 ) {
236 <                for (unsigned int i = 0; i < Dim; i++)
235 >            inline void mul( const Vector<Real, Dim>& v1, double s) {
236 >                for (unsigned int i = 0; i < Dim; i++)
237                      data_[i] = s * v1.data_[i];
238              }
239  
# Line 237 | Line 242 | namespace oopse {
242              * @param s the scalar value
243              */            
244              inline void div( double s) {
245 <                for (unsigned int i = 0; i < Dim; i++)            
245 >                for (unsigned int i = 0; i < Dim; i++)            
246                      data_[i] /= s;
247              }
248  
# Line 247 | Line 252 | namespace oopse {
252              * @param s the scalar value
253              */                        
254              inline void div( const Vector<Real, Dim>& v1, double s ) {
255 <                for (unsigned int i = 0; i < Dim; i++)
255 >                for (unsigned int i = 0; i < Dim; i++)
256                      data_[i] = v1.data_[i] / s;
257              }
258  
# Line 280 | Line 285 | namespace oopse {
285               * @return the length of this vector
286               */
287               inline double length() {
288 <                return sqrt(lengthSquared());  
288 >                return sqrt(lengthSquare());  
289              }
290              
291              /**
292               * Returns the squared length of this vector.
293               * @return the squared length of this vector
294               */
295 <             inline double lengthSquared() {
295 >             inline double lengthSquare() {
296                  return dot(*this, *this);
297              }
298              
# Line 296 | Line 301 | namespace oopse {
301                  double len;
302  
303                  len = length();
304 +                
305 +                //if (len < oopse:epsilon)
306 +                //  throw();
307 +                
308                  *this /= len;
309              }
310 +
311 +            /**
312 +             * Tests if this vector is normalized
313 +             * @return true if this vector is normalized, otherwise return false
314 +             */
315 +            inline bool isNormalized() {
316 +                return equal(lengthSquare(), 1.0);
317 +            }          
318              
319          protected:
320 <            double data_[3];
320 >            double data_[Dim];
321          
322      };
323  
324      /** unary minus*/
325      template<typename Real, unsigned int Dim>    
326      inline Vector<Real, Dim> operator -(const Vector<Real, Dim>& v1){
327 <        Vector tmp(v1);
328 <        return tmp.negate();
327 >        Vector<Real, Dim> tmp(v1);
328 >        tmp.negate();
329 >        return tmp;
330      }
331  
332      /**
# Line 347 | Line 365 | namespace oopse {
365      template<typename Real, unsigned int Dim>                
366      Vector<Real, Dim> operator * ( const Vector<Real, Dim>& v1, double s) {      
367          Vector<Real, Dim> result;
368 <        result.mul(s, v1);
368 >        result.mul(v1,s);
369          return result;          
370      }
371      
# Line 360 | Line 378 | namespace oopse {
378      template<typename Real, unsigned int Dim>
379      Vector<Real, Dim> operator * ( double s, const Vector<Real, Dim>& v1 ) {
380          Vector<Real, Dim> result;
381 <        result.mul(s, v1);
381 >        result.mul(v1, s);
382          return result;          
383      }
384  
# Line 378 | Line 396 | namespace oopse {
396      }
397      
398      /**
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 –    /**
399       * Returns the dot product of two Vectors
400       * @param v1 first vector
401       * @param v2 second vector
# Line 405 | Line 403 | namespace oopse {
403       */
404      template<typename Real, unsigned int Dim>    
405      inline Real dot( const Vector<Real, Dim>& v1, const Vector<Real, Dim>& v2 ) {
406 <                Real tmp;
407 <                tmp = 0;
406 >        Real tmp;
407 >        tmp = 0;
408  
409 <                for (unsigned int i = 0; i < Dim; i++)
410 <                        tmp += v1[i] + v2[i];
411 <                
412 <                return tmp;
409 >        for (unsigned int i = 0; i < Dim; i++)
410 >            tmp += v1[i] + v2[i];
411 >
412 >        return tmp;
413      }
414  
415      /**
# Line 442 | Line 440 | namespace oopse {
440       * Write to an output stream
441       */
442      template<typename Real, unsigned int Dim>
443 <    std::ostream &operator<< ( std::ostream& o, const Vector<Real, Dim>& v1 ) {
444 <        
443 >    std::ostream &operator<< ( std::ostream& o, const Vector<Real, Dim>& v) {
444 >
445 >        o << "[" << v[0] << ", " << v[1] << ", " << v[2] << "]" << endl;
446          return o;        
447      }
448      

Diff Legend

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