# | 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 |
– | Removed lines |
+ | Added lines |
< | Changed lines |
> | Changed lines |