# | 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() { |
288 | > | inline Real length() { |
289 | return sqrt(lengthSquare()); | |
290 | } | |
291 | ||
# | Line 292 | Line 293 | namespace oopse { | |
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 | ||
# | Line 317 | Line 318 | namespace oopse { | |
318 | } | |
319 | ||
320 | protected: | |
321 | < | double data_[Dim]; |
321 | > | Real data_[Dim]; |
322 | ||
323 | }; | |
324 | ||
# | Line 363 | 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 376 | 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 389 | 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; | |
# | Line 407 | 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 442 | 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 |
– | Removed lines |
+ | Added lines |
< | Changed lines |
> | Changed lines |