Debian Codegraph @

src/Imath/ImathVec.h

raw
1 //
2 // SPDX-License-Identifier: BSD-3-Clause
3 // Copyright Contributors to the OpenEXR Project.
4 //
5
6 //
7 // 2D, 3D and 4D point/vector class templates
8 //
9
10 #ifndef INCLUDED_IMATHVEC_H
11 #define INCLUDED_IMATHVEC_H
12
13 #include "ImathExport.h"
14 #include "ImathNamespace.h"
15 #include "ImathTypeTraits.h"
16
17 #include "ImathMath.h"
18
19 #include <iostream>
20 #include <limits>
21 #include <cstdint>
22 #include <stdexcept>
23
24 #if (defined _WIN32 || defined _WIN64) && defined _MSC_VER
25 // suppress exception specification warnings
26 # pragma warning(push)
27 # pragma warning(disable : 4290)
28 #endif
29
30 IMATH_INTERNAL_NAMESPACE_HEADER_ENTER
31
32 template <class T> class Vec2;
33 template <class T> class Vec3;
34 template <class T> class Vec4;
35
36 /// Enum for the Vec4 to Vec3 conversion constructor
37 enum IMATH_EXPORT_ENUM InfException
38 {
39 INF_EXCEPTION
40 };
41
42 ///
43 /// 2-element vector
44 ///
45
46 template <class T> class IMATH_EXPORT_TEMPLATE_TYPE Vec2
47 {
48 public:
49
50 /// @{
51 /// @name Direct access to elements
52
53 T x, y;
54
55 /// @}
56
57 /// Element access by index.
58 IMATH_HOSTDEVICE IMATH_CONSTEXPR14 T& operator[] (int i) IMATH_NOEXCEPT;
59
60 /// Element access by index.
61 IMATH_HOSTDEVICE constexpr const T& operator[] (int i) const IMATH_NOEXCEPT;
62
63 /// @{
64 /// @name Constructors and Assignment
65
66 /// Uninitialized by default
67 IMATH_HOSTDEVICE Vec2() IMATH_NOEXCEPT;
68
69 /// Initialize to a scalar `(a,a)`
70 IMATH_HOSTDEVICE constexpr explicit Vec2 (T a) IMATH_NOEXCEPT;
71
72 /// Initialize to given elements `(a,b)`
73 IMATH_HOSTDEVICE constexpr Vec2 (T a, T b) IMATH_NOEXCEPT;
74
75 /// Copy constructor
76 IMATH_HOSTDEVICE constexpr Vec2 (const Vec2& v) IMATH_NOEXCEPT;
77
78 /// Construct from Vec2 of another base type
79 template <class S> IMATH_HOSTDEVICE constexpr Vec2 (const Vec2<S>& v) IMATH_NOEXCEPT;
80
81
82 /// Assignment
83 IMATH_HOSTDEVICE IMATH_CONSTEXPR14 const Vec2& operator= (const Vec2& v) IMATH_NOEXCEPT;
84
85 /// Destructor
86 ~Vec2() IMATH_NOEXCEPT = default;
87
88 /// @}
89
90 #if IMATH_FOREIGN_VECTOR_INTEROP
91 /// @{
92 /// @name Interoperability with other vector types
93 ///
94 /// Construction and assignment are allowed from other classes that
95 /// appear to be equivalent vector types, provided that they have either
96 /// a subscripting operator, or data members .x and .y, that are of the
97 /// same type as the elements of this vector, and their size appears to
98 /// be the right number of elements.
99 ///
100 /// This functionality is disabled for gcc 4.x, which seems to have a
101 /// compiler bug that results in spurious errors. It can also be
102 /// disabled by defining IMATH_FOREIGN_VECTOR_INTEROP to be 0 prior to
103 /// including any Imath header files.
104 ///
105
106 template<typename V, IMATH_ENABLE_IF(has_xy<V,T>::value)>
107 IMATH_HOSTDEVICE explicit constexpr Vec2 (const V& v) IMATH_NOEXCEPT
108 : Vec2(T(v.x), T(v.y)) { }
109
110 template<typename V, IMATH_ENABLE_IF(has_subscript<V,T,2>::value
111 && !has_xy<V,T>::value)>
112 IMATH_HOSTDEVICE explicit Vec2 (const V& v) : Vec2(T(v[0]), T(v[1])) { }
113
114 template<typename V, IMATH_ENABLE_IF(has_xy<V,T>::value)>
115 IMATH_HOSTDEVICE IMATH_CONSTEXPR14 const Vec2& operator= (const V& v) IMATH_NOEXCEPT {
116 x = T(v.x);
117 y = T(v.y);
118 return *this;
119 }
120
121 template<typename V, IMATH_ENABLE_IF(has_subscript<V,T,2>::value
122 && !has_xy<V,T>::value)>
123 IMATH_HOSTDEVICE const Vec2& operator= (const V& v) {
124 x = T(v[0]);
125 y = T(v[1]);
126 return *this;
127 }
128 #endif
129
130 /// @{
131 /// @name Compatibility with Sb
132
133 /// Set the value
134 template <class S> IMATH_HOSTDEVICE void setValue (S a, S b) IMATH_NOEXCEPT;
135
136 /// Set the value
137 template <class S> IMATH_HOSTDEVICE void setValue (const Vec2<S>& v) IMATH_NOEXCEPT;
138
139 /// Return the value in `a` and `b`
140 template <class S> IMATH_HOSTDEVICE void getValue (S& a, S& b) const IMATH_NOEXCEPT;
141
142 /// Return the value in `v`
143 template <class S> IMATH_HOSTDEVICE void getValue (Vec2<S>& v) const IMATH_NOEXCEPT;
144
145 /// Return a raw pointer to the array of values
146 IMATH_HOSTDEVICE T* getValue() IMATH_NOEXCEPT;
147
148 /// Return a raw pointer to the array of values
149 IMATH_HOSTDEVICE const T* getValue() const IMATH_NOEXCEPT;
150
151 /// @}
152
153 /// @{
154 /// @name Arithmetic and Comparison
155
156 /// Equality
157 template <class S> IMATH_HOSTDEVICE constexpr bool operator== (const Vec2<S>& v) const IMATH_NOEXCEPT;
158
159
160 /// Inequality
161 template <class S> IMATH_HOSTDEVICE constexpr bool operator!= (const Vec2<S>& v) const IMATH_NOEXCEPT;
162
163 /// Compare two matrices and test if they are "approximately equal":
164 /// @return True if the coefficients of this and `m` are the same
165 /// with an absolute error of no more than e, i.e., for all i, j:
166 ///
167 /// abs (this[i][j] - m[i][j]) <= e
168 IMATH_HOSTDEVICE IMATH_CONSTEXPR14 bool equalWithAbsError (const Vec2<T>& v, T e) const IMATH_NOEXCEPT;
169
170 /// Compare two matrices and test if they are "approximately equal":
171 /// @return True if the coefficients of this and m are the same with
172 /// a relative error of no more than e, i.e., for all i, j:
173 ///
174 /// abs (this[i] - v[i][j]) <= e * abs (this[i][j])
175 IMATH_HOSTDEVICE IMATH_CONSTEXPR14 bool equalWithRelError (const Vec2<T>& v, T e) const IMATH_NOEXCEPT;
176
177 /// Dot product
178 IMATH_HOSTDEVICE constexpr T dot (const Vec2& v) const IMATH_NOEXCEPT;
179
180 /// Dot product
181 IMATH_HOSTDEVICE constexpr T operator^ (const Vec2& v) const IMATH_NOEXCEPT;
182
183 /// Right-handed cross product, i.e. z component of
184 /// Vec3 (this->x, this->y, 0) % Vec3 (v.x, v.y, 0)
185 IMATH_HOSTDEVICE constexpr T cross (const Vec2& v) const IMATH_NOEXCEPT;
186
187 /// Right-handed cross product, i.e. z component of
188 /// Vec3 (this->x, this->y, 0) % Vec3 (v.x, v.y, 0)
189 IMATH_HOSTDEVICE constexpr T operator% (const Vec2& v) const IMATH_NOEXCEPT;
190
191 /// Component-wise addition
192 IMATH_HOSTDEVICE IMATH_CONSTEXPR14 const Vec2& operator+= (const Vec2& v) IMATH_NOEXCEPT;
193
194 /// Component-wise addition
195 IMATH_HOSTDEVICE constexpr Vec2 operator+ (const Vec2& v) const IMATH_NOEXCEPT;
196
197 /// Component-wise subtraction
198 IMATH_HOSTDEVICE IMATH_CONSTEXPR14 const Vec2& operator-= (const Vec2& v) IMATH_NOEXCEPT;
199
200 /// Component-wise subtraction
201 IMATH_HOSTDEVICE constexpr Vec2 operator- (const Vec2& v) const IMATH_NOEXCEPT;
202
203 /// Component-wise multiplication by -1
204 IMATH_HOSTDEVICE constexpr Vec2 operator-() const IMATH_NOEXCEPT;
205
206 /// Component-wise multiplication by -1
207 IMATH_HOSTDEVICE IMATH_CONSTEXPR14 const Vec2& negate() IMATH_NOEXCEPT;
208
209 /// Component-wise multiplication
210 IMATH_HOSTDEVICE IMATH_CONSTEXPR14 const Vec2& operator*= (const Vec2& v) IMATH_NOEXCEPT;
211
212 /// Component-wise multiplication
213 IMATH_HOSTDEVICE IMATH_CONSTEXPR14 const Vec2& operator*= (T a) IMATH_NOEXCEPT;
214
215 /// Component-wise multiplication
216 IMATH_HOSTDEVICE constexpr Vec2 operator* (const Vec2& v) const IMATH_NOEXCEPT;
217
218 /// Component-wise multiplication
219 IMATH_HOSTDEVICE constexpr Vec2 operator* (T a) const IMATH_NOEXCEPT;
220
221 /// Component-wise division
222 IMATH_HOSTDEVICE IMATH_CONSTEXPR14 const Vec2& operator/= (const Vec2& v) IMATH_NOEXCEPT;
223
224 /// Component-wise division
225 IMATH_HOSTDEVICE IMATH_CONSTEXPR14 const Vec2& operator/= (T a) IMATH_NOEXCEPT;
226
227 /// Component-wise division
228 IMATH_HOSTDEVICE constexpr Vec2 operator/ (const Vec2& v) const IMATH_NOEXCEPT;
229
230 /// Component-wise division
231 IMATH_HOSTDEVICE constexpr Vec2 operator/ (T a) const IMATH_NOEXCEPT;
232
233 /// @}
234
235 /// @{
236 /// @name Query and Manipulation
237
238 /// Return the Euclidean norm
239 IMATH_HOSTDEVICE T length() const IMATH_NOEXCEPT;
240
241 /// Return the square of the Euclidean norm, i.e. the dot product
242 /// with itself.
243 IMATH_HOSTDEVICE constexpr T length2() const IMATH_NOEXCEPT;
244
245 /// Normalize in place. If length()==0, return a null vector.
246 IMATH_HOSTDEVICE const Vec2& normalize() IMATH_NOEXCEPT;
247
248 /// Normalize in place. If length()==0, throw an exception.
249 const Vec2& normalizeExc();
250
251 /// Normalize without any checks for length()==0. Slightly faster
252 /// than the other normalization routines, but if v.length() is
253 /// 0.0, the result is undefined.
254 IMATH_HOSTDEVICE const Vec2& normalizeNonNull() IMATH_NOEXCEPT;
255
256 /// Return a normalized vector. Does not modify *this.
257 IMATH_HOSTDEVICE Vec2<T> normalized() const IMATH_NOEXCEPT;
258
259 /// Return a normalized vector. Does not modify *this. Throw an
260 /// exception if length()==0.
261 Vec2<T> normalizedExc() const;
262
263 /// Return a normalized vector. Does not modify *this, and does
264 /// not check for length()==0. Slightly faster than the other
265 /// normalization routines, but if v.length() is 0.0, the result
266 /// is undefined.
267 IMATH_HOSTDEVICE Vec2<T> normalizedNonNull() const IMATH_NOEXCEPT;
268
269 /// @}
270
271 /// @{
272 /// @name Numeric Limits
273
274 /// Largest possible negative value
275 IMATH_HOSTDEVICE constexpr static T baseTypeLowest() IMATH_NOEXCEPT { return std::numeric_limits<T>::lowest(); }
276
277 /// Largest possible positive value
278 IMATH_HOSTDEVICE constexpr static T baseTypeMax() IMATH_NOEXCEPT { return std::numeric_limits<T>::max(); }
279
280 /// Smallest possible positive value
281 IMATH_HOSTDEVICE constexpr static T baseTypeSmallest() IMATH_NOEXCEPT { return std::numeric_limits<T>::min(); }
282
283 /// Smallest possible e for which 1+e != 1
284 IMATH_HOSTDEVICE constexpr static T baseTypeEpsilon() IMATH_NOEXCEPT { return std::numeric_limits<T>::epsilon(); }
285
286 /// @}
287
288 /// Return the number of dimensions, i.e. 2
289 IMATH_HOSTDEVICE constexpr static unsigned int dimensions() IMATH_NOEXCEPT { return 2; }
290
291 /// The base type: In templates that accept a parameter `V`, you
292 /// can refer to `T` as `V::BaseType`
293 typedef T BaseType;
294
295 private:
296
297 IMATH_HOSTDEVICE IMATH_CONSTEXPR14 T lengthTiny() const IMATH_NOEXCEPT;
298 };
299
300 ///
301 /// 3-element vector
302 ///
303
304 template <class T> class IMATH_EXPORT_TEMPLATE_TYPE Vec3
305 {
306 public:
307
308 /// @{
309 /// @name Direct access to elements
310
311 T x, y, z;
312
313 /// @}
314
315 /// Element access by index.
316 IMATH_HOSTDEVICE IMATH_CONSTEXPR14 T& operator[] (int i) IMATH_NOEXCEPT;
317
318 /// Element access by index.
319 IMATH_HOSTDEVICE constexpr const T& operator[] (int i) const IMATH_NOEXCEPT;
320
321 /// @{
322 /// @name Constructors and Assignment
323
324 /// Uninitialized by default
325 IMATH_HOSTDEVICE Vec3() IMATH_NOEXCEPT;
326
327 /// Initialize to a scalar `(a,a,a)`
328 IMATH_HOSTDEVICE constexpr explicit Vec3 (T a) IMATH_NOEXCEPT;
329
330 /// Initialize to given elements `(a,b,c)`
331 IMATH_HOSTDEVICE constexpr Vec3 (T a, T b, T c) IMATH_NOEXCEPT;
332
333 /// Copy constructor
334 IMATH_HOSTDEVICE constexpr Vec3 (const Vec3& v) IMATH_NOEXCEPT;
335
336 /// Construct from Vec3 of another base type
337 template <class S> IMATH_HOSTDEVICE constexpr Vec3 (const Vec3<S>& v) IMATH_NOEXCEPT;
338
339 /// Vec4 to Vec3 conversion: divide x, y and z by w, even if w is
340 /// 0. The result depends on how the environment handles
341 /// floating-point exceptions.
342 template <class S> IMATH_HOSTDEVICE explicit constexpr Vec3 (const Vec4<S>& v) IMATH_NOEXCEPT;
343
344 /// Vec4 to Vec3 conversion: divide x, y and z by w. Throws an
345 /// exception if w is zero or if division by w would overflow.
346 template <class S>
347 explicit IMATH_HOSTDEVICE IMATH_CONSTEXPR14 Vec3 (const Vec4<S>& v, InfException);
348
349 /// Assignment
350 IMATH_HOSTDEVICE IMATH_CONSTEXPR14 const Vec3& operator= (const Vec3& v) IMATH_NOEXCEPT;
351
352 /// Destructor
353 ~Vec3() IMATH_NOEXCEPT = default;
354
355 /// @}
356
357 #if IMATH_FOREIGN_VECTOR_INTEROP
358 /// @{
359 /// @name Interoperability with other vector types
360 ///
361 /// Construction and assignment are allowed from other classes that
362 /// appear to be equivalent vector types, provided that they have either
363 /// a subscripting operator, or data members .x, .y, .z, that are of the
364 /// same type as the elements of this vector, and their size appears to
365 /// be the right number of elements.
366 ///
367 /// This functionality is disabled for gcc 4.x, which seems to have a
368 /// compiler bug that results in spurious errors. It can also be
369 /// disabled by defining IMATH_FOREIGN_VECTOR_INTEROP to be 0 prior to
370 /// including any Imath header files.
371 ///
372
373 template<typename V, IMATH_ENABLE_IF(has_xyz<V,T>::value)>
374 IMATH_HOSTDEVICE explicit constexpr Vec3 (const V& v) IMATH_NOEXCEPT
375 : Vec3(T(v.x), T(v.y), T(v.z)) { }
376
377 template<typename V, IMATH_ENABLE_IF(has_subscript<V,T,3>::value
378 && !has_xyz<V,T>::value)>
379 IMATH_HOSTDEVICE explicit Vec3 (const V& v) : Vec3(T(v[0]), T(v[1]), T(v[2])) { }
380
381 /// Interoperability assignment from another type that behaves as if it
382 /// were an equivalent vector.
383 template<typename V, IMATH_ENABLE_IF(has_xyz<V,T>::value)>
384 IMATH_HOSTDEVICE const Vec3& operator= (const V& v) IMATH_NOEXCEPT {
385 x = T(v.x);
386 y = T(v.y);
387 z = T(v.z);
388 return *this;
389 }
390
391 template<typename V, IMATH_ENABLE_IF(has_subscript<V,T,3>::value
392 && !has_xyz<V,T>::value)>
393 IMATH_HOSTDEVICE IMATH_CONSTEXPR14 const Vec3& operator= (const V& v) {
394 x = T(v[0]);
395 y = T(v[1]);
396 z = T(v[2]);
397 return *this;
398 }
399 /// @}
400 #endif
401
402 /// @{
403 /// @name Compatibility with Sb
404
405 /// Set the value
406 template <class S> IMATH_HOSTDEVICE void setValue (S a, S b, S c) IMATH_NOEXCEPT;
407
408 /// Set the value
409 template <class S> IMATH_HOSTDEVICE void setValue (const Vec3<S>& v) IMATH_NOEXCEPT;
410
411 /// Return the value in `a`, `b`, and `c`
412 template <class S> IMATH_HOSTDEVICE void getValue (S& a, S& b, S& c) const IMATH_NOEXCEPT;
413
414 /// Return the value in `v`
415 template <class S> IMATH_HOSTDEVICE void getValue (Vec3<S>& v) const IMATH_NOEXCEPT;
416
417 /// Return a raw pointer to the array of values
418 IMATH_HOSTDEVICE T* getValue() IMATH_NOEXCEPT;
419
420 /// Return a raw pointer to the array of values
421 IMATH_HOSTDEVICE const T* getValue() const IMATH_NOEXCEPT;
422
423 /// @}
424
425 /// @{
426 /// @name Arithmetic and Comparison
427
428 /// Equality
429 template <class S> IMATH_HOSTDEVICE constexpr bool operator== (const Vec3<S>& v) const IMATH_NOEXCEPT;
430
431 /// Inequality
432 template <class S> IMATH_HOSTDEVICE constexpr bool operator!= (const Vec3<S>& v) const IMATH_NOEXCEPT;
433
434 /// Compare two matrices and test if they are "approximately equal":
435 /// @return True if the coefficients of this and `m` are the same
436 /// with an absolute error of no more than e, i.e., for all i, j:
437 ///
438 /// abs (this[i][j] - m[i][j]) <= e
439 IMATH_HOSTDEVICE IMATH_CONSTEXPR14 bool equalWithAbsError (const Vec3<T>& v, T e) const IMATH_NOEXCEPT;
440
441 /// Compare two matrices and test if they are "approximately equal":
442 /// @return True if the coefficients of this and m are the same with
443 /// a relative error of no more than e, i.e., for all i, j:
444 ///
445 /// abs (this[i] - v[i][j]) <= e * abs (this[i][j])
446 IMATH_HOSTDEVICE IMATH_CONSTEXPR14 bool equalWithRelError (const Vec3<T>& v, T e) const IMATH_NOEXCEPT;
447
448 /// Dot product
449 IMATH_HOSTDEVICE constexpr T dot (const Vec3& v) const IMATH_NOEXCEPT;
450
451 /// Dot product
452 IMATH_HOSTDEVICE constexpr T operator^ (const Vec3& v) const IMATH_NOEXCEPT;
453
454 /// Right-handed cross product
455 IMATH_HOSTDEVICE constexpr Vec3 cross (const Vec3& v) const IMATH_NOEXCEPT;
456
457 /// Right-handed cross product
458 IMATH_HOSTDEVICE IMATH_CONSTEXPR14 const Vec3& operator%= (const Vec3& v) IMATH_NOEXCEPT;
459
460 /// Right-handed cross product
461 IMATH_HOSTDEVICE constexpr Vec3 operator% (const Vec3& v) const IMATH_NOEXCEPT;
462
463 /// Component-wise addition
464 IMATH_HOSTDEVICE IMATH_CONSTEXPR14 const Vec3& operator+= (const Vec3& v) IMATH_NOEXCEPT;
465
466 /// Component-wise addition
467 IMATH_HOSTDEVICE constexpr Vec3 operator+ (const Vec3& v) const IMATH_NOEXCEPT;
468
469 /// Component-wise subtraction
470 IMATH_HOSTDEVICE IMATH_CONSTEXPR14 const Vec3& operator-= (const Vec3& v) IMATH_NOEXCEPT;
471
472 /// Component-wise subtraction
473 IMATH_HOSTDEVICE constexpr Vec3 operator- (const Vec3& v) const IMATH_NOEXCEPT;
474
475 /// Component-wise multiplication by -1
476 IMATH_HOSTDEVICE constexpr Vec3 operator-() const IMATH_NOEXCEPT;
477
478 /// Component-wise multiplication by -1
479 IMATH_HOSTDEVICE IMATH_CONSTEXPR14 const Vec3& negate() IMATH_NOEXCEPT;
480
481 /// Component-wise multiplication
482 IMATH_HOSTDEVICE IMATH_CONSTEXPR14 const Vec3& operator*= (const Vec3& v) IMATH_NOEXCEPT;
483
484 /// Component-wise multiplication
485 IMATH_HOSTDEVICE IMATH_CONSTEXPR14 const Vec3& operator*= (T a) IMATH_NOEXCEPT;
486
487 /// Component-wise multiplication
488 IMATH_HOSTDEVICE constexpr Vec3 operator* (const Vec3& v) const IMATH_NOEXCEPT;
489
490 /// Component-wise multiplication
491 IMATH_HOSTDEVICE constexpr Vec3 operator* (T a) const IMATH_NOEXCEPT;
492
493 /// Component-wise division
494 IMATH_HOSTDEVICE IMATH_CONSTEXPR14 const Vec3& operator/= (const Vec3& v) IMATH_NOEXCEPT;
495
496 /// Component-wise division
497 IMATH_HOSTDEVICE IMATH_CONSTEXPR14 const Vec3& operator/= (T a) IMATH_NOEXCEPT;
498
499 /// Component-wise division
500 IMATH_HOSTDEVICE constexpr Vec3 operator/ (const Vec3& v) const IMATH_NOEXCEPT;
501
502 /// Component-wise division
503 IMATH_HOSTDEVICE constexpr Vec3 operator/ (T a) const IMATH_NOEXCEPT;
504
505 /// @}
506
507 /// @{
508 /// @name Query and Manipulation
509
510 /// Return the Euclidean norm
511 IMATH_HOSTDEVICE T length() const IMATH_NOEXCEPT;
512
513 /// Return the square of the Euclidean norm, i.e. the dot product
514 /// with itself.
515 IMATH_HOSTDEVICE constexpr T length2() const IMATH_NOEXCEPT;
516
517 /// Normalize in place. If length()==0, return a null vector.
518 IMATH_HOSTDEVICE const Vec3& normalize() IMATH_NOEXCEPT;
519
520 /// Normalize in place. If length()==0, throw an exception.
521 const Vec3& normalizeExc();
522
523 /// Normalize without any checks for length()==0. Slightly faster
524 /// than the other normalization routines, but if v.length() is
525 /// 0.0, the result is undefined.
526 IMATH_HOSTDEVICE const Vec3& normalizeNonNull() IMATH_NOEXCEPT;
527
528 /// Return a normalized vector. Does not modify *this.
529 IMATH_HOSTDEVICE Vec3<T> normalized() const IMATH_NOEXCEPT; // does not modify *this
530
531 /// Return a normalized vector. Does not modify *this. Throw an
532 /// exception if length()==0.
533 Vec3<T> normalizedExc() const;
534
535 /// Return a normalized vector. Does not modify *this, and does
536 /// not check for length()==0. Slightly faster than the other
537 /// normalization routines, but if v.length() is 0.0, the result
538 /// is undefined.
539 IMATH_HOSTDEVICE Vec3<T> normalizedNonNull() const IMATH_NOEXCEPT;
540
541 /// @}
542
543 /// @{
544 /// @name Numeric Limits
545
546 /// Largest possible negative value
547 IMATH_HOSTDEVICE constexpr static T baseTypeLowest() IMATH_NOEXCEPT { return std::numeric_limits<T>::lowest(); }
548
549 /// Largest possible positive value
550 IMATH_HOSTDEVICE constexpr static T baseTypeMax() IMATH_NOEXCEPT { return std::numeric_limits<T>::max(); }
551
552 /// Smallest possible positive value
553 IMATH_HOSTDEVICE constexpr static T baseTypeSmallest() IMATH_NOEXCEPT { return std::numeric_limits<T>::min(); }
554
555 /// Smallest possible e for which 1+e != 1
556 IMATH_HOSTDEVICE constexpr static T baseTypeEpsilon() IMATH_NOEXCEPT { return std::numeric_limits<T>::epsilon(); }
557
558 /// @}
559
560 /// Return the number of dimensions, i.e. 3
561 IMATH_HOSTDEVICE constexpr static unsigned int dimensions() IMATH_NOEXCEPT { return 3; }
562
563 /// The base type: In templates that accept a parameter `V`, you
564 /// can refer to `T` as `V::BaseType`
565 typedef T BaseType;
566
567 private:
568 IMATH_HOSTDEVICE IMATH_CONSTEXPR14 T lengthTiny() const IMATH_NOEXCEPT;
569 };
570
571 ///
572 /// 4-element vector
573 ///
574
575 template <class T> class IMATH_EXPORT_TEMPLATE_TYPE Vec4
576 {
577 public:
578
579 /// @{
580 /// @name Direct access to elements
581
582 T x, y, z, w;
583
584 /// @}
585
586 /// Element access by index.
587 IMATH_HOSTDEVICE IMATH_CONSTEXPR14 T& operator[] (int i) IMATH_NOEXCEPT;
588
589 /// Element access by index.
590 IMATH_HOSTDEVICE constexpr const T& operator[] (int i) const IMATH_NOEXCEPT;
591
592 /// @{
593 /// @name Constructors and Assignment
594
595 /// Uninitialized by default
596 IMATH_HOSTDEVICE Vec4() IMATH_NOEXCEPT; // no initialization
597
598 /// Initialize to a scalar `(a,a,a,a)`
599 IMATH_HOSTDEVICE constexpr explicit Vec4 (T a) IMATH_NOEXCEPT;
600
601 /// Initialize to given elements `(a,b,c,d)`
602 IMATH_HOSTDEVICE constexpr Vec4 (T a, T b, T c, T d) IMATH_NOEXCEPT;
603
604 /// Copy constructor
605 IMATH_HOSTDEVICE constexpr Vec4 (const Vec4& v) IMATH_NOEXCEPT;
606
607 /// Construct from Vec4 of another base type
608 template <class S> IMATH_HOSTDEVICE constexpr Vec4 (const Vec4<S>& v) IMATH_NOEXCEPT;
609
610 /// Vec3 to Vec4 conversion, sets w to 1.
611 template <class S> IMATH_HOSTDEVICE explicit constexpr Vec4 (const Vec3<S>& v) IMATH_NOEXCEPT;
612
613 /// Assignment
614 IMATH_HOSTDEVICE IMATH_CONSTEXPR14 const Vec4& operator= (const Vec4& v) IMATH_NOEXCEPT;
615
616 /// Destructor
617 ~Vec4() IMATH_NOEXCEPT = default;
618
619 /// @}
620
621 #if IMATH_FOREIGN_VECTOR_INTEROP
622 /// @{
623 /// @name Interoperability with other vector types
624 ///
625 /// Construction and assignment are allowed from other classes that
626 /// appear to be equivalent vector types, provided that they have either
627 /// a subscripting operator, or data members .x, .y, .z, .w that are of
628 /// the same type as the elements of this vector, and their size appears
629 /// to be the right number of elements.
630 ///
631 /// This functionality is disabled for gcc 4.x, which seems to have a
632 /// compiler bug that results in spurious errors. It can also be
633 /// disabled by defining IMATH_FOREIGN_VECTOR_INTEROP to be 0 prior to
634 /// including any Imath header files.
635 ///
636
637 template<typename V, IMATH_ENABLE_IF(has_xyzw<V,T>::value)>
638 IMATH_HOSTDEVICE explicit constexpr Vec4 (const V& v) IMATH_NOEXCEPT
639 : Vec4(T(v.x), T(v.y), T(v.z), T(v.w)) { }
640
641 template<typename V, IMATH_ENABLE_IF(has_subscript<V,T,4>::value
642 && !has_xyzw<V,T>::value)>
643 IMATH_HOSTDEVICE explicit Vec4 (const V& v) : Vec4(T(v[0]), T(v[1]), T(v[2]), T(v[3])) { }
644
645 template<typename V, IMATH_ENABLE_IF(has_xyzw<V,T>::value)>
646 IMATH_HOSTDEVICE IMATH_CONSTEXPR14 const Vec4& operator= (const V& v) IMATH_NOEXCEPT {
647 x = T(v.x);
648 y = T(v.y);
649 z = T(v.z);
650 w = T(v.w);
651 return *this;
652 }
653
654 template<typename V, IMATH_ENABLE_IF(has_subscript<V,T,4>::value
655 && !has_xyzw<V,T>::value)>
656 IMATH_HOSTDEVICE const Vec4& operator= (const V& v) {
657 x = T(v[0]);
658 y = T(v[1]);
659 z = T(v[2]);
660 w = T(v[3]);
661 return *this;
662 }
663 /// @}
664 #endif
665
666 /// @{
667 /// @name Arithmetic and Comparison
668
669 /// Equality
670 template <class S> IMATH_HOSTDEVICE constexpr bool operator== (const Vec4<S>& v) const IMATH_NOEXCEPT;
671
672 /// Inequality
673 template <class S> IMATH_HOSTDEVICE constexpr bool operator!= (const Vec4<S>& v) const IMATH_NOEXCEPT;
674
675 /// Compare two matrices and test if they are "approximately equal":
676 /// @return True if the coefficients of this and `m` are the same
677 /// with an absolute error of no more than e, i.e., for all i, j:
678 ///
679 /// abs (this[i][j] - m[i][j]) <= e
680 IMATH_HOSTDEVICE IMATH_CONSTEXPR14 bool equalWithAbsError (const Vec4<T>& v, T e) const IMATH_NOEXCEPT;
681
682 /// Compare two matrices and test if they are "approximately equal":
683 /// @return True if the coefficients of this and m are the same with
684 /// a relative error of no more than e, i.e., for all i, j:
685 ///
686 /// abs (this[i] - v[i][j]) <= e * abs (this[i][j])
687 IMATH_HOSTDEVICE IMATH_CONSTEXPR14 bool equalWithRelError (const Vec4<T>& v, T e) const IMATH_NOEXCEPT;
688
689 /// Dot product
690 IMATH_HOSTDEVICE constexpr T dot (const Vec4& v) const IMATH_NOEXCEPT;
691
692 /// Dot product
693 IMATH_HOSTDEVICE constexpr T operator^ (const Vec4& v) const IMATH_NOEXCEPT;
694
695 /// Component-wise addition
696 IMATH_HOSTDEVICE IMATH_CONSTEXPR14 const Vec4& operator+= (const Vec4& v) IMATH_NOEXCEPT;
697
698 /// Component-wise addition
699 IMATH_HOSTDEVICE constexpr Vec4 operator+ (const Vec4& v) const IMATH_NOEXCEPT;
700
701 /// Component-wise subtraction
702 IMATH_HOSTDEVICE IMATH_CONSTEXPR14 const Vec4& operator-= (const Vec4& v) IMATH_NOEXCEPT;
703
704 /// Component-wise subtraction
705 IMATH_HOSTDEVICE constexpr Vec4 operator- (const Vec4& v) const IMATH_NOEXCEPT;
706
707 /// Component-wise multiplication by -1
708 IMATH_HOSTDEVICE constexpr Vec4 operator-() const IMATH_NOEXCEPT;
709
710 /// Component-wise multiplication by -1
711 IMATH_HOSTDEVICE IMATH_CONSTEXPR14 const Vec4& negate() IMATH_NOEXCEPT;
712
713 /// Component-wise multiplication
714 IMATH_HOSTDEVICE IMATH_CONSTEXPR14 const Vec4& operator*= (const Vec4& v) IMATH_NOEXCEPT;
715
716 /// Component-wise multiplication
717 IMATH_HOSTDEVICE IMATH_CONSTEXPR14 const Vec4& operator*= (T a) IMATH_NOEXCEPT;
718
719 /// Component-wise multiplication
720 IMATH_HOSTDEVICE constexpr Vec4 operator* (const Vec4& v) const IMATH_NOEXCEPT;
721
722 /// Component-wise multiplication
723 IMATH_HOSTDEVICE constexpr Vec4 operator* (T a) const IMATH_NOEXCEPT;
724
725 /// Component-wise division
726 IMATH_HOSTDEVICE IMATH_CONSTEXPR14 const Vec4& operator/= (const Vec4& v) IMATH_NOEXCEPT;
727
728 /// Component-wise division
729 IMATH_HOSTDEVICE IMATH_CONSTEXPR14 const Vec4& operator/= (T a) IMATH_NOEXCEPT;
730
731 /// Component-wise division
732 IMATH_HOSTDEVICE constexpr Vec4 operator/ (const Vec4& v) const IMATH_NOEXCEPT;
733
734 /// Component-wise division
735 IMATH_HOSTDEVICE constexpr Vec4 operator/ (T a) const IMATH_NOEXCEPT;
736
737 /// @}
738
739 /// @{
740 /// @name Query and Manipulation
741
742 /// Return the Euclidean norm
743 IMATH_HOSTDEVICE T length() const IMATH_NOEXCEPT;
744
745 /// Return the square of the Euclidean norm, i.e. the dot product
746 /// with itself.
747 IMATH_HOSTDEVICE constexpr T length2() const IMATH_NOEXCEPT;
748
749 /// Normalize in place. If length()==0, return a null vector.
750 IMATH_HOSTDEVICE const Vec4& normalize() IMATH_NOEXCEPT; // modifies *this
751
752 /// Normalize in place. If length()==0, throw an exception.
753 const Vec4& normalizeExc();
754
755 /// Normalize without any checks for length()==0. Slightly faster
756 /// than the other normalization routines, but if v.length() is
757 /// 0.0, the result is undefined.
758 IMATH_HOSTDEVICE const Vec4& normalizeNonNull() IMATH_NOEXCEPT;
759
760 /// Return a normalized vector. Does not modify *this.
761 IMATH_HOSTDEVICE Vec4<T> normalized() const IMATH_NOEXCEPT; // does not modify *this
762
763 /// Return a normalized vector. Does not modify *this. Throw an
764 /// exception if length()==0.
765 Vec4<T> normalizedExc() const;
766
767 /// Return a normalized vector. Does not modify *this, and does
768 /// not check for length()==0. Slightly faster than the other
769 /// normalization routines, but if v.length() is 0.0, the result
770 /// is undefined.
771 IMATH_HOSTDEVICE Vec4<T> normalizedNonNull() const IMATH_NOEXCEPT;
772
773 /// @}
774
775 /// @{
776 /// @name Numeric Limits
777
778 /// Largest possible negative value
779 IMATH_HOSTDEVICE constexpr static T baseTypeLowest() IMATH_NOEXCEPT { return std::numeric_limits<T>::lowest(); }
780
781 /// Largest possible positive value
782 IMATH_HOSTDEVICE constexpr static T baseTypeMax() IMATH_NOEXCEPT { return std::numeric_limits<T>::max(); }
783
784 /// Smallest possible positive value
785 IMATH_HOSTDEVICE constexpr static T baseTypeSmallest() IMATH_NOEXCEPT { return std::numeric_limits<T>::min(); }
786
787 /// Smallest possible e for which 1+e != 1
788 IMATH_HOSTDEVICE constexpr static T baseTypeEpsilon() IMATH_NOEXCEPT { return std::numeric_limits<T>::epsilon(); }
789
790 /// @}
791
792 /// Return the number of dimensions, i.e. 4
793 IMATH_HOSTDEVICE constexpr static unsigned int dimensions() IMATH_NOEXCEPT { return 4; }
794
795 /// The base type: In templates that accept a parameter `V`, you
796 /// can refer to `T` as `V::BaseType`
797 typedef T BaseType;
798
799 private:
800 IMATH_HOSTDEVICE IMATH_CONSTEXPR14 T lengthTiny() const IMATH_NOEXCEPT;
801 };
802
803 /// Stream output, as "(x y)"
804 template <class T> std::ostream& operator<< (std::ostream& s, const Vec2<T>& v);
805
806 /// Stream output, as "(x y z)"
807 template <class T> std::ostream& operator<< (std::ostream& s, const Vec3<T>& v);
808
809 /// Stream output, as "(x y z w)"
810 template <class T> std::ostream& operator<< (std::ostream& s, const Vec4<T>& v);
811
812 /// Reverse multiplication: S * Vec2<T>
813 template <class T> IMATH_HOSTDEVICE constexpr Vec2<T> operator* (T a, const Vec2<T>& v) IMATH_NOEXCEPT;
814
815 /// Reverse multiplication: S * Vec3<T>
816 template <class T> IMATH_HOSTDEVICE constexpr Vec3<T> operator* (T a, const Vec3<T>& v) IMATH_NOEXCEPT;
817
818 /// Reverse multiplication: S * Vec4<T>
819 template <class T> IMATH_HOSTDEVICE constexpr Vec4<T> operator* (T a, const Vec4<T>& v) IMATH_NOEXCEPT;
820
821 //-------------------------
822 // Typedefs for convenience
823 //-------------------------
824
825 /// Vec2 of short
826 typedef Vec2<short> V2s;
827
828 /// Vec2 of integer
829 typedef Vec2<int> V2i;
830
831 /// Vec2 of int64_t
832 typedef Vec2<int64_t> V2i64;
833
834 /// Vec2 of float
835 typedef Vec2<float> V2f;
836
837 /// Vec2 of double
838 typedef Vec2<double> V2d;
839
840 /// Vec3 of short
841 typedef Vec3<short> V3s;
842
843 /// Vec3 of integer
844 typedef Vec3<int> V3i;
845
846 /// Vec3 of int64_t
847 typedef Vec3<int64_t> V3i64;
848
849 /// Vec3 of float
850 typedef Vec3<float> V3f;
851
852 /// Vec3 of double
853 typedef Vec3<double> V3d;
854
855 /// Vec4 of short
856 typedef Vec4<short> V4s;
857
858 /// Vec4 of integer
859 typedef Vec4<int> V4i;
860
861 /// Vec4 of int64_t
862 typedef Vec4<int64_t> V4i64;
863
864 /// Vec4 of float
865 typedef Vec4<float> V4f;
866
867 /// Vec4 of double
868 typedef Vec4<double> V4d;
869
870 //----------------------------------------------------------------------------
871 // Specializations for VecN<short>, VecN<int>
872 //
873 // Normalize and length don't make sense for integer vectors, so disable them.
874 //----------------------------------------------------------------------------
875
876 /// @cond Doxygen_Suppress
877
878 // Vec2<short>
879 template <> IMATH_HOSTDEVICE short Vec2<short>::length() const IMATH_NOEXCEPT = delete;
880 template <> IMATH_HOSTDEVICE const Vec2<short>& Vec2<short>::normalize() IMATH_NOEXCEPT = delete;
881 template <> const Vec2<short>& Vec2<short>::normalizeExc() = delete;
882 template <> IMATH_HOSTDEVICE const Vec2<short>& Vec2<short>::normalizeNonNull() IMATH_NOEXCEPT = delete;
883 template <> IMATH_HOSTDEVICE Vec2<short> Vec2<short>::normalized() const IMATH_NOEXCEPT = delete;
884 template <> Vec2<short> Vec2<short>::normalizedExc() const = delete;
885 template <> IMATH_HOSTDEVICE Vec2<short> Vec2<short>::normalizedNonNull() const IMATH_NOEXCEPT = delete;
886
887 // Vec2<int>
888 template <> IMATH_HOSTDEVICE int Vec2<int>::length() const IMATH_NOEXCEPT = delete;
889 template <> IMATH_HOSTDEVICE const Vec2<int>& Vec2<int>::normalize() IMATH_NOEXCEPT = delete;
890 template <> const Vec2<int>& Vec2<int>::normalizeExc() = delete;
891 template <> IMATH_HOSTDEVICE const Vec2<int>& Vec2<int>::normalizeNonNull() IMATH_NOEXCEPT = delete;
892 template <> IMATH_HOSTDEVICE Vec2<int> Vec2<int>::normalized() const IMATH_NOEXCEPT = delete;
893 template <> Vec2<int> Vec2<int>::normalizedExc() const = delete;
894 template <> IMATH_HOSTDEVICE Vec2<int> Vec2<int>::normalizedNonNull() const IMATH_NOEXCEPT = delete;
895
896 // Vec2<int64_t>
897 template <> IMATH_HOSTDEVICE int64_t Vec2<int64_t>::length() const IMATH_NOEXCEPT = delete;
898 template <> IMATH_HOSTDEVICE const Vec2<int64_t>& Vec2<int64_t>::normalize() IMATH_NOEXCEPT = delete;
899 template <> const Vec2<int64_t>& Vec2<int64_t>::normalizeExc() = delete;
900 template <> IMATH_HOSTDEVICE const Vec2<int64_t>& Vec2<int64_t>::normalizeNonNull() IMATH_NOEXCEPT = delete;
901 template <> IMATH_HOSTDEVICE Vec2<int64_t> Vec2<int64_t>::normalized() const IMATH_NOEXCEPT = delete;
902 template <> Vec2<int64_t> Vec2<int64_t>::normalizedExc() const = delete;
903 template <> IMATH_HOSTDEVICE Vec2<int64_t> Vec2<int64_t>::normalizedNonNull() const IMATH_NOEXCEPT = delete;
904
905 // Vec3<short>
906 template <> IMATH_HOSTDEVICE short Vec3<short>::length() const IMATH_NOEXCEPT = delete;
907 template <> IMATH_HOSTDEVICE const Vec3<short>& Vec3<short>::normalize() IMATH_NOEXCEPT = delete;
908 template <> const Vec3<short>& Vec3<short>::normalizeExc() = delete;
909 template <> IMATH_HOSTDEVICE const Vec3<short>& Vec3<short>::normalizeNonNull() IMATH_NOEXCEPT = delete;
910 template <> IMATH_HOSTDEVICE Vec3<short> Vec3<short>::normalized() const IMATH_NOEXCEPT = delete;
911 template <> Vec3<short> Vec3<short>::normalizedExc() const = delete;
912 template <> IMATH_HOSTDEVICE Vec3<short> Vec3<short>::normalizedNonNull() const IMATH_NOEXCEPT = delete;
913
914 // Vec3<int>
915 template <> IMATH_HOSTDEVICE int Vec3<int>::length() const IMATH_NOEXCEPT = delete;
916 template <> IMATH_HOSTDEVICE const Vec3<int>& Vec3<int>::normalize() IMATH_NOEXCEPT = delete;
917 template <> const Vec3<int>& Vec3<int>::normalizeExc() = delete;
918 template <> IMATH_HOSTDEVICE const Vec3<int>& Vec3<int>::normalizeNonNull() IMATH_NOEXCEPT = delete;
919 template <> IMATH_HOSTDEVICE Vec3<int> Vec3<int>::normalized() const IMATH_NOEXCEPT = delete;
920 template <> Vec3<int> Vec3<int>::normalizedExc() const = delete;
921 template <> IMATH_HOSTDEVICE Vec3<int> Vec3<int>::normalizedNonNull() const IMATH_NOEXCEPT = delete;
922
923 // Vec3<int64_t>
924 template <> IMATH_HOSTDEVICE int64_t Vec3<int64_t>::length() const IMATH_NOEXCEPT = delete;
925 template <> IMATH_HOSTDEVICE const Vec3<int64_t>& Vec3<int64_t>::normalize() IMATH_NOEXCEPT = delete;
926 template <> const Vec3<int64_t>& Vec3<int64_t>::normalizeExc() = delete;
927 template <> IMATH_HOSTDEVICE const Vec3<int64_t>& Vec3<int64_t>::normalizeNonNull() IMATH_NOEXCEPT = delete;
928 template <> IMATH_HOSTDEVICE Vec3<int64_t> Vec3<int64_t>::normalized() const IMATH_NOEXCEPT = delete;
929 template <> Vec3<int64_t> Vec3<int64_t>::normalizedExc() const = delete;
930 template <> IMATH_HOSTDEVICE Vec3<int64_t> Vec3<int64_t>::normalizedNonNull() const IMATH_NOEXCEPT = delete;
931
932 // Vec4<short>
933 template <> IMATH_HOSTDEVICE short Vec4<short>::length() const IMATH_NOEXCEPT = delete;
934 template <> IMATH_HOSTDEVICE const Vec4<short>& Vec4<short>::normalize() IMATH_NOEXCEPT = delete;
935 template <> const Vec4<short>& Vec4<short>::normalizeExc() = delete;
936 template <> IMATH_HOSTDEVICE const Vec4<short>& Vec4<short>::normalizeNonNull() IMATH_NOEXCEPT = delete;
937 template <> IMATH_HOSTDEVICE Vec4<short> Vec4<short>::normalized() const IMATH_NOEXCEPT = delete;
938 template <> Vec4<short> Vec4<short>::normalizedExc() const = delete;
939 template <> IMATH_HOSTDEVICE Vec4<short> Vec4<short>::normalizedNonNull() const IMATH_NOEXCEPT = delete;
940
941 // Vec4<int>
942 template <> IMATH_HOSTDEVICE int Vec4<int>::length() const IMATH_NOEXCEPT = delete;
943 template <> IMATH_HOSTDEVICE const Vec4<int>& Vec4<int>::normalize() IMATH_NOEXCEPT = delete;
944 template <> const Vec4<int>& Vec4<int>::normalizeExc() = delete;
945 template <> IMATH_HOSTDEVICE const Vec4<int>& Vec4<int>::normalizeNonNull() IMATH_NOEXCEPT = delete;
946 template <> IMATH_HOSTDEVICE Vec4<int> Vec4<int>::normalized() const IMATH_NOEXCEPT = delete;
947 template <> Vec4<int> Vec4<int>::normalizedExc() const = delete;
948 template <> IMATH_HOSTDEVICE Vec4<int> Vec4<int>::normalizedNonNull() const IMATH_NOEXCEPT = delete;
949
950 // Vec4<int64_t>
951 template <> IMATH_HOSTDEVICE int64_t Vec4<int64_t>::length() const IMATH_NOEXCEPT = delete;
952 template <> IMATH_HOSTDEVICE const Vec4<int64_t>& Vec4<int64_t>::normalize() IMATH_NOEXCEPT = delete;
953 template <> const Vec4<int64_t>& Vec4<int64_t>::normalizeExc() = delete;
954 template <> IMATH_HOSTDEVICE const Vec4<int64_t>& Vec4<int64_t>::normalizeNonNull() IMATH_NOEXCEPT = delete;
955 template <> IMATH_HOSTDEVICE Vec4<int64_t> Vec4<int64_t>::normalized() const IMATH_NOEXCEPT = delete;
956 template <> Vec4<int64_t> Vec4<int64_t>::normalizedExc() const = delete;
957 template <> IMATH_HOSTDEVICE Vec4<int64_t> Vec4<int64_t>::normalizedNonNull() const IMATH_NOEXCEPT = delete;
958
959 /// @endcond Doxygen_Suppress
960
961 //------------------------
962 // Implementation of Vec2:
963 //------------------------
964
965 template <class T>
966 IMATH_CONSTEXPR14 IMATH_HOSTDEVICE inline T&
967 Vec2<T>::operator[] (int i) IMATH_NOEXCEPT
968 {
969 return (&x)[i]; // NOSONAR - suppress SonarCloud bug report.
970 }
971
972 template <class T>
973 constexpr IMATH_HOSTDEVICE inline const T&
974 Vec2<T>::operator[] (int i) const IMATH_NOEXCEPT
975 {
976 return (&x)[i]; // NOSONAR - suppress SonarCloud bug report.
977 }
978
979 template <class T> IMATH_HOSTDEVICE inline Vec2<T>::Vec2() IMATH_NOEXCEPT
980 {
981 // empty, and not constexpr because data is uninitialized.
982 }
983
984 template <class T> IMATH_HOSTDEVICE constexpr inline Vec2<T>::Vec2 (T a) IMATH_NOEXCEPT
985 : x(a), y(a)
986 {
987 }
988
989 template <class T> IMATH_HOSTDEVICE constexpr inline Vec2<T>::Vec2 (T a, T b) IMATH_NOEXCEPT
990 : x(a), y(b)
991 {
992 }
993
994 template <class T> IMATH_HOSTDEVICE constexpr inline Vec2<T>::Vec2 (const Vec2& v) IMATH_NOEXCEPT
995 : x(v.x), y(v.y)
996 {
997 }
998
999 template <class T> template <class S> IMATH_HOSTDEVICE constexpr inline Vec2<T>::Vec2 (const Vec2<S>& v) IMATH_NOEXCEPT
1000 : x(T(v.x)), y(T(v.y))
1001 {
1002 }
1003
1004 template <class T>
1005 IMATH_CONSTEXPR14 IMATH_HOSTDEVICE inline const Vec2<T>&
1006 Vec2<T>::operator= (const Vec2& v) IMATH_NOEXCEPT
1007 {
1008 x = v.x;
1009 y = v.y;
1010 return *this;
1011 }
1012
1013 template <class T>
1014 template <class S>
1015 IMATH_HOSTDEVICE inline void
1016 Vec2<T>::setValue (S a, S b) IMATH_NOEXCEPT
1017 {
1018 x = T (a);
1019 y = T (b);
1020 }
1021
1022 template <class T>
1023 template <class S>
1024 IMATH_HOSTDEVICE inline void
1025 Vec2<T>::setValue (const Vec2<S>& v) IMATH_NOEXCEPT
1026 {
1027 x = T (v.x);
1028 y = T (v.y);
1029 }
1030
1031 template <class T>
1032 template <class S>
1033 IMATH_HOSTDEVICE inline void
1034 Vec2<T>::getValue (S& a, S& b) const IMATH_NOEXCEPT
1035 {
1036 a = S (x);
1037 b = S (y);
1038 }
1039
1040 template <class T>
1041 template <class S>
1042 IMATH_HOSTDEVICE inline void
1043 Vec2<T>::getValue (Vec2<S>& v) const IMATH_NOEXCEPT
1044 {
1045 v.x = S (x);
1046 v.y = S (y);
1047 }
1048
1049 template <class T>
1050 IMATH_HOSTDEVICE inline T*
1051 Vec2<T>::getValue() IMATH_NOEXCEPT
1052 {
1053 return (T*) &x;
1054 }
1055
1056 template <class T>
1057 IMATH_HOSTDEVICE inline const T*
1058 Vec2<T>::getValue() const IMATH_NOEXCEPT
1059 {
1060 return (const T*) &x;
1061 }
1062
1063 template <class T>
1064 template <class S>
1065 IMATH_HOSTDEVICE constexpr inline bool
1066 Vec2<T>::operator== (const Vec2<S>& v) const IMATH_NOEXCEPT
1067 {
1068 return x == v.x && y == v.y;
1069 }
1070
1071 template <class T>
1072 template <class S>
1073 IMATH_HOSTDEVICE constexpr inline bool
1074 Vec2<T>::operator!= (const Vec2<S>& v) const IMATH_NOEXCEPT
1075 {
1076 return x != v.x || y != v.y;
1077 }
1078
1079 template <class T>
1080 IMATH_HOSTDEVICE IMATH_CONSTEXPR14 inline bool
1081 Vec2<T>::equalWithAbsError (const Vec2<T>& v, T e) const IMATH_NOEXCEPT
1082 {
1083 for (int i = 0; i < 2; i++)
1084 if (!IMATH_INTERNAL_NAMESPACE::equalWithAbsError ((*this)[i], v[i], e))
1085 return false;
1086
1087 return true;
1088 }
1089
1090 template <class T>
1091 IMATH_HOSTDEVICE IMATH_CONSTEXPR14 inline bool
1092 Vec2<T>::equalWithRelError (const Vec2<T>& v, T e) const IMATH_NOEXCEPT
1093 {
1094 for (int i = 0; i < 2; i++)
1095 if (!IMATH_INTERNAL_NAMESPACE::equalWithRelError ((*this)[i], v[i], e))
1096 return false;
1097
1098 return true;
1099 }
1100
1101 template <class T>
1102 IMATH_HOSTDEVICE constexpr inline T
1103 Vec2<T>::dot (const Vec2& v) const IMATH_NOEXCEPT
1104 {
1105 return x * v.x + y * v.y;
1106 }
1107
1108 template <class T>
1109 IMATH_HOSTDEVICE constexpr inline T
1110 Vec2<T>::operator^ (const Vec2& v) const IMATH_NOEXCEPT
1111 {
1112 return dot (v);
1113 }
1114
1115 template <class T>
1116 IMATH_HOSTDEVICE constexpr inline T
1117 Vec2<T>::cross (const Vec2& v) const IMATH_NOEXCEPT
1118 {
1119 return x * v.y - y * v.x;
1120 }
1121
1122 template <class T>
1123 IMATH_HOSTDEVICE constexpr inline T
1124 Vec2<T>::operator% (const Vec2& v) const IMATH_NOEXCEPT
1125 {
1126 return x * v.y - y * v.x;
1127 }
1128
1129 template <class T>
1130 IMATH_HOSTDEVICE IMATH_CONSTEXPR14 inline const Vec2<T>&
1131 Vec2<T>::operator+= (const Vec2& v) IMATH_NOEXCEPT
1132 {
1133 x += v.x;
1134 y += v.y;
1135 return *this;
1136 }
1137
1138 template <class T>
1139 IMATH_HOSTDEVICE constexpr inline Vec2<T>
1140 Vec2<T>::operator+ (const Vec2& v) const IMATH_NOEXCEPT
1141 {
1142 return Vec2 (x + v.x, y + v.y);
1143 }
1144
1145 template <class T>
1146 IMATH_HOSTDEVICE IMATH_CONSTEXPR14 inline const Vec2<T>&
1147 Vec2<T>::operator-= (const Vec2& v) IMATH_NOEXCEPT
1148 {
1149 x -= v.x;
1150 y -= v.y;
1151 return *this;
1152 }
1153
1154 template <class T>
1155 IMATH_HOSTDEVICE constexpr inline Vec2<T>
1156 Vec2<T>::operator- (const Vec2& v) const IMATH_NOEXCEPT
1157 {
1158 return Vec2 (x - v.x, y - v.y);
1159 }
1160
1161 template <class T>
1162 IMATH_HOSTDEVICE constexpr inline Vec2<T>
1163 Vec2<T>::operator-() const IMATH_NOEXCEPT
1164 {
1165 return Vec2 (-x, -y);
1166 }
1167
1168 template <class T>
1169 IMATH_HOSTDEVICE IMATH_CONSTEXPR14 inline const Vec2<T>&
1170 Vec2<T>::negate() IMATH_NOEXCEPT
1171 {
1172 x = -x;
1173 y = -y;
1174 return *this;
1175 }
1176
1177 template <class T>
1178 IMATH_HOSTDEVICE IMATH_CONSTEXPR14 inline const Vec2<T>&
1179 Vec2<T>::operator*= (const Vec2& v) IMATH_NOEXCEPT
1180 {
1181 x *= v.x;
1182 y *= v.y;
1183 return *this;
1184 }
1185
1186 template <class T>
1187 IMATH_HOSTDEVICE IMATH_CONSTEXPR14 inline const Vec2<T>&
1188 Vec2<T>::operator*= (T a) IMATH_NOEXCEPT
1189 {
1190 x *= a;
1191 y *= a;
1192 return *this;
1193 }
1194
1195 template <class T>
1196 IMATH_HOSTDEVICE constexpr inline Vec2<T>
1197 Vec2<T>::operator* (const Vec2& v) const IMATH_NOEXCEPT
1198 {
1199 return Vec2 (x * v.x, y * v.y);
1200 }
1201
1202 template <class T>
1203 IMATH_HOSTDEVICE constexpr inline Vec2<T>
1204 Vec2<T>::operator* (T a) const IMATH_NOEXCEPT
1205 {
1206 return Vec2 (x * a, y * a);
1207 }
1208
1209 template <class T>
1210 IMATH_HOSTDEVICE IMATH_CONSTEXPR14 inline const Vec2<T>&
1211 Vec2<T>::operator/= (const Vec2& v) IMATH_NOEXCEPT
1212 {
1213 x /= v.x;
1214 y /= v.y;
1215 return *this;
1216 }
1217
1218 template <class T>
1219 IMATH_HOSTDEVICE IMATH_CONSTEXPR14 inline const Vec2<T>&
1220 Vec2<T>::operator/= (T a) IMATH_NOEXCEPT
1221 {
1222 x /= a;
1223 y /= a;
1224 return *this;
1225 }
1226
1227 template <class T>
1228 IMATH_HOSTDEVICE constexpr inline Vec2<T>
1229 Vec2<T>::operator/ (const Vec2& v) const IMATH_NOEXCEPT
1230 {
1231 return Vec2 (x / v.x, y / v.y);
1232 }
1233
1234 template <class T>
1235 IMATH_HOSTDEVICE constexpr inline Vec2<T>
1236 Vec2<T>::operator/ (T a) const IMATH_NOEXCEPT
1237 {
1238 return Vec2 (x / a, y / a);
1239 }
1240
1241 template <class T>
1242 IMATH_HOSTDEVICE IMATH_CONSTEXPR14 inline T
1243 Vec2<T>::lengthTiny() const IMATH_NOEXCEPT
1244 {
1245 T absX = std::abs(x);
1246 T absY = std::abs(y);
1247
1248 T max = absX;
1249
1250 if (max < absY)
1251 max = absY;
1252
1253 if (IMATH_UNLIKELY(max == T (0)))
1254 return T (0);
1255
1256 //
1257 // Do not replace the divisions by max with multiplications by 1/max.
1258 // Computing 1/max can overflow but the divisions below will always
1259 // produce results less than or equal to 1.
1260 //
1261
1262 absX /= max;
1263 absY /= max;
1264
1265 return max * std::sqrt (absX * absX + absY * absY);
1266 }
1267
1268 template <class T>
1269 IMATH_HOSTDEVICE inline T
1270 Vec2<T>::length() const IMATH_NOEXCEPT
1271 {
1272 T length2 = dot (*this);
1273
1274 if (IMATH_UNLIKELY(length2 < T (2) * std::numeric_limits<T>::min()))
1275 return lengthTiny();
1276
1277 return std::sqrt (length2);
1278 }
1279
1280 template <class T>
1281 IMATH_HOSTDEVICE constexpr inline T
1282 Vec2<T>::length2() const IMATH_NOEXCEPT
1283 {
1284 return dot (*this);
1285 }
1286
1287 template <class T>
1288 IMATH_HOSTDEVICE inline const Vec2<T>&
1289 Vec2<T>::normalize() IMATH_NOEXCEPT
1290 {
1291 T l = length();
1292
1293 if (IMATH_LIKELY(l != T (0)))
1294 {
1295 //
1296 // Do not replace the divisions by l with multiplications by 1/l.
1297 // Computing 1/l can overflow but the divisions below will always
1298 // produce results less than or equal to 1.
1299 //
1300
1301 x /= l;
1302 y /= l;
1303 }
1304
1305 return *this;
1306 }
1307
1308 template <class T>
1309 inline const Vec2<T>&
1310 Vec2<T>::normalizeExc()
1311 {
1312 T l = length();
1313
1314 if (IMATH_UNLIKELY(l == T (0)))
1315 throw std::domain_error ("Cannot normalize null vector.");
1316
1317 x /= l;
1318 y /= l;
1319 return *this;
1320 }
1321
1322 template <class T>
1323 IMATH_HOSTDEVICE inline const Vec2<T>&
1324 Vec2<T>::normalizeNonNull() IMATH_NOEXCEPT
1325 {
1326 T l = length();
1327 x /= l;
1328 y /= l;
1329 return *this;
1330 }
1331
1332 template <class T>
1333 IMATH_HOSTDEVICE inline Vec2<T>
1334 Vec2<T>::normalized() const IMATH_NOEXCEPT
1335 {
1336 T l = length();
1337
1338 if (IMATH_UNLIKELY(l == T (0)))
1339 return Vec2 (T (0));
1340
1341 return Vec2 (x / l, y / l);
1342 }
1343
1344 template <class T>
1345 inline Vec2<T>
1346 Vec2<T>::normalizedExc() const
1347 {
1348 T l = length();
1349
1350 if (IMATH_UNLIKELY(l == T (0)))
1351 throw std::domain_error ("Cannot normalize null vector.");
1352
1353 return Vec2 (x / l, y / l);
1354 }
1355
1356 template <class T>
1357 IMATH_HOSTDEVICE inline Vec2<T>
1358 Vec2<T>::normalizedNonNull() const IMATH_NOEXCEPT
1359 {
1360 T l = length();
1361 return Vec2 (x / l, y / l);
1362 }
1363
1364 //-----------------------
1365 // Implementation of Vec3
1366 //-----------------------
1367
1368 template <class T>
1369 IMATH_HOSTDEVICE
1370 IMATH_CONSTEXPR14 inline T&
1371 Vec3<T>::operator[] (int i) IMATH_NOEXCEPT
1372 {
1373 return (&x)[i]; // NOSONAR - suppress SonarCloud bug report.
1374 }
1375
1376 template <class T>
1377 IMATH_HOSTDEVICE constexpr inline const T&
1378 Vec3<T>::operator[] (int i) const IMATH_NOEXCEPT
1379 {
1380 return (&x)[i]; // NOSONAR - suppress SonarCloud bug report.
1381 }
1382
1383 template <class T> IMATH_HOSTDEVICE inline Vec3<T>::Vec3() IMATH_NOEXCEPT
1384 {
1385 // empty, and not constexpr because data is uninitialized.
1386 }
1387
1388 template <class T> IMATH_HOSTDEVICE constexpr inline Vec3<T>::Vec3 (T a) IMATH_NOEXCEPT
1389 : x(a), y(a), z(a)
1390 {
1391 }
1392
1393 template <class T> IMATH_HOSTDEVICE constexpr inline Vec3<T>::Vec3 (T a, T b, T c) IMATH_NOEXCEPT
1394 : x(a), y(b), z(c)
1395 {
1396 }
1397
1398 template <class T> IMATH_HOSTDEVICE constexpr inline Vec3<T>::Vec3 (const Vec3& v) IMATH_NOEXCEPT
1399 : x(v.x), y(v.y), z(v.z)
1400 {
1401 }
1402
1403 template <class T> template <class S>
1404 IMATH_HOSTDEVICE constexpr inline Vec3<T>::Vec3 (const Vec3<S>& v) IMATH_NOEXCEPT
1405 : x(T(v.x)), y(T(v.y)), z(T(v.z))
1406 {
1407 }
1408
1409 template <class T>
1410 IMATH_HOSTDEVICE IMATH_CONSTEXPR14 inline const Vec3<T>&
1411 Vec3<T>::operator= (const Vec3& v) IMATH_NOEXCEPT
1412 {
1413 x = v.x;
1414 y = v.y;
1415 z = v.z;
1416 return *this;
1417 }
1418
1419 template <class T> template <class S>
1420 IMATH_HOSTDEVICE constexpr inline Vec3<T>::Vec3 (const Vec4<S>& v) IMATH_NOEXCEPT
1421 : x(T(v.x/v.w)), y(T(v.y/v.w)), z(T(v.z/v.w))
1422 {
1423 }
1424
1425 template <class T>
1426 template <class S>
1427 IMATH_HOSTDEVICE IMATH_CONSTEXPR14 inline Vec3<T>::Vec3 (const Vec4<S>& v, InfException)
1428 {
1429 T vx = T (v.x);
1430 T vy = T (v.y);
1431 T vz = T (v.z);
1432 T vw = T (v.w);
1433
1434 T absW = (vw >= T (0)) ? vw : -vw;
1435
1436 if (absW < 1)
1437 {
1438 T m = baseTypeMax() * absW;
1439
1440 if (vx <= -m || vx >= m || vy <= -m || vy >= m || vz <= -m || vz >= m)
1441 throw std::domain_error ("Cannot normalize point at infinity.");
1442 }
1443
1444 x = vx / vw;
1445 y = vy / vw;
1446 z = vz / vw;
1447 }
1448
1449 template <class T>
1450 template <class S>
1451 IMATH_HOSTDEVICE inline void
1452 Vec3<T>::setValue (S a, S b, S c) IMATH_NOEXCEPT
1453 {
1454 x = T (a);
1455 y = T (b);
1456 z = T (c);
1457 }
1458
1459 template <class T>
1460 template <class S>
1461 IMATH_HOSTDEVICE inline void
1462 Vec3<T>::setValue (const Vec3<S>& v) IMATH_NOEXCEPT
1463 {
1464 x = T (v.x);
1465 y = T (v.y);
1466 z = T (v.z);
1467 }
1468
1469 template <class T>
1470 template <class S>
1471 IMATH_HOSTDEVICE inline void
1472 Vec3<T>::getValue (S& a, S& b, S& c) const IMATH_NOEXCEPT
1473 {
1474 a = S (x);
1475 b = S (y);
1476 c = S (z);
1477 }
1478
1479 template <class T>
1480 template <class S>
1481 IMATH_HOSTDEVICE inline void
1482 Vec3<T>::getValue (Vec3<S>& v) const IMATH_NOEXCEPT
1483 {
1484 v.x = S (x);
1485 v.y = S (y);
1486 v.z = S (z);
1487 }
1488
1489 template <class T>
1490 IMATH_HOSTDEVICE inline T*
1491 Vec3<T>::getValue() IMATH_NOEXCEPT
1492 {
1493 return (T*) &x;
1494 }
1495
1496 template <class T>
1497 IMATH_HOSTDEVICE inline const T*
1498 Vec3<T>::getValue() const IMATH_NOEXCEPT
1499 {
1500 return (const T*) &x;
1501 }
1502
1503 template <class T>
1504 template <class S>
1505 IMATH_HOSTDEVICE constexpr inline bool
1506 Vec3<T>::operator== (const Vec3<S>& v) const IMATH_NOEXCEPT
1507 {
1508 return x == v.x && y == v.y && z == v.z;
1509 }
1510
1511 template <class T>
1512 template <class S>
1513 IMATH_HOSTDEVICE constexpr inline bool
1514 Vec3<T>::operator!= (const Vec3<S>& v) const IMATH_NOEXCEPT
1515 {
1516 return x != v.x || y != v.y || z != v.z;
1517 }
1518
1519 template <class T>
1520 IMATH_HOSTDEVICE IMATH_CONSTEXPR14 inline bool
1521 Vec3<T>::equalWithAbsError (const Vec3<T>& v, T e) const IMATH_NOEXCEPT
1522 {
1523 for (int i = 0; i < 3; i++)
1524 if (!IMATH_INTERNAL_NAMESPACE::equalWithAbsError ((*this)[i], v[i], e))
1525 return false;
1526
1527 return true;
1528 }
1529
1530 template <class T>
1531 IMATH_HOSTDEVICE IMATH_CONSTEXPR14 inline bool
1532 Vec3<T>::equalWithRelError (const Vec3<T>& v, T e) const IMATH_NOEXCEPT
1533 {
1534 for (int i = 0; i < 3; i++)
1535 if (!IMATH_INTERNAL_NAMESPACE::equalWithRelError ((*this)[i], v[i], e))
1536 return false;
1537
1538 return true;
1539 }
1540
1541 template <class T>
1542 IMATH_HOSTDEVICE constexpr inline T
1543 Vec3<T>::dot (const Vec3& v) const IMATH_NOEXCEPT
1544 {
1545 return x * v.x + y * v.y + z * v.z;
1546 }
1547
1548 template <class T>
1549 IMATH_HOSTDEVICE constexpr inline T
1550 Vec3<T>::operator^ (const Vec3& v) const IMATH_NOEXCEPT
1551 {
1552 return dot (v);
1553 }
1554
1555 template <class T>
1556 IMATH_HOSTDEVICE constexpr inline Vec3<T>
1557 Vec3<T>::cross (const Vec3& v) const IMATH_NOEXCEPT
1558 {
1559 return Vec3 (y * v.z - z * v.y, z * v.x - x * v.z, x * v.y - y * v.x);
1560 }
1561
1562 template <class T>
1563 IMATH_HOSTDEVICE IMATH_CONSTEXPR14 inline const Vec3<T>&
1564 Vec3<T>::operator%= (const Vec3& v) IMATH_NOEXCEPT
1565 {
1566 T a = y * v.z - z * v.y;
1567 T b = z * v.x - x * v.z;
1568 T c = x * v.y - y * v.x;
1569 x = a;
1570 y = b;
1571 z = c;
1572 return *this;
1573 }
1574
1575 template <class T>
1576 IMATH_HOSTDEVICE constexpr inline Vec3<T>
1577 Vec3<T>::operator% (const Vec3& v) const IMATH_NOEXCEPT
1578 {
1579 return Vec3 (y * v.z - z * v.y, z * v.x - x * v.z, x * v.y - y * v.x);
1580 }
1581
1582 template <class T>
1583 IMATH_HOSTDEVICE IMATH_CONSTEXPR14 inline const Vec3<T>&
1584 Vec3<T>::operator+= (const Vec3& v) IMATH_NOEXCEPT
1585 {
1586 x += v.x;
1587 y += v.y;
1588 z += v.z;
1589 return *this;
1590 }
1591
1592 template <class T>
1593 IMATH_HOSTDEVICE constexpr inline Vec3<T>
1594 Vec3<T>::operator+ (const Vec3& v) const IMATH_NOEXCEPT
1595 {
1596 return Vec3 (x + v.x, y + v.y, z + v.z);
1597 }
1598
1599 template <class T>
1600 IMATH_HOSTDEVICE IMATH_CONSTEXPR14 inline const Vec3<T>&
1601 Vec3<T>::operator-= (const Vec3& v) IMATH_NOEXCEPT
1602 {
1603 x -= v.x;
1604 y -= v.y;
1605 z -= v.z;
1606 return *this;
1607 }
1608
1609 template <class T>
1610 IMATH_HOSTDEVICE constexpr inline Vec3<T>
1611 Vec3<T>::operator- (const Vec3& v) const IMATH_NOEXCEPT
1612 {
1613 return Vec3 (x - v.x, y - v.y, z - v.z);
1614 }
1615
1616 template <class T>
1617 IMATH_HOSTDEVICE constexpr inline Vec3<T>
1618 Vec3<T>::operator-() const IMATH_NOEXCEPT
1619 {
1620 return Vec3 (-x, -y, -z);
1621 }
1622
1623 template <class T>
1624 IMATH_HOSTDEVICE IMATH_CONSTEXPR14 inline const Vec3<T>&
1625 Vec3<T>::negate() IMATH_NOEXCEPT
1626 {
1627 x = -x;
1628 y = -y;
1629 z = -z;
1630 return *this;
1631 }
1632
1633 template <class T>
1634 IMATH_HOSTDEVICE IMATH_CONSTEXPR14 inline const Vec3<T>&
1635 Vec3<T>::operator*= (const Vec3& v) IMATH_NOEXCEPT
1636 {
1637 x *= v.x;
1638 y *= v.y;
1639 z *= v.z;
1640 return *this;
1641 }
1642
1643 template <class T>
1644 IMATH_HOSTDEVICE IMATH_CONSTEXPR14 inline const Vec3<T>&
1645 Vec3<T>::operator*= (T a) IMATH_NOEXCEPT
1646 {
1647 x *= a;
1648 y *= a;
1649 z *= a;
1650 return *this;
1651 }
1652
1653 template <class T>
1654 IMATH_HOSTDEVICE constexpr inline Vec3<T>
1655 Vec3<T>::operator* (const Vec3& v) const IMATH_NOEXCEPT
1656 {
1657 return Vec3 (x * v.x, y * v.y, z * v.z);
1658 }
1659
1660 template <class T>
1661 IMATH_HOSTDEVICE constexpr inline Vec3<T>
1662 Vec3<T>::operator* (T a) const IMATH_NOEXCEPT
1663 {
1664 return Vec3 (x * a, y * a, z * a);
1665 }
1666
1667 template <class T>
1668 IMATH_HOSTDEVICE IMATH_CONSTEXPR14 inline const Vec3<T>&
1669 Vec3<T>::operator/= (const Vec3& v) IMATH_NOEXCEPT
1670 {
1671 x /= v.x;
1672 y /= v.y;
1673 z /= v.z;
1674 return *this;
1675 }
1676
1677 template <class T>
1678 IMATH_HOSTDEVICE IMATH_CONSTEXPR14 inline const Vec3<T>&
1679 Vec3<T>::operator/= (T a) IMATH_NOEXCEPT
1680 {
1681 x /= a;
1682 y /= a;
1683 z /= a;
1684 return *this;
1685 }
1686
1687 template <class T>
1688 IMATH_HOSTDEVICE constexpr inline Vec3<T>
1689 Vec3<T>::operator/ (const Vec3& v) const IMATH_NOEXCEPT
1690 {
1691 return Vec3 (x / v.x, y / v.y, z / v.z);
1692 }
1693
1694 template <class T>
1695 IMATH_HOSTDEVICE constexpr inline Vec3<T>
1696 Vec3<T>::operator/ (T a) const IMATH_NOEXCEPT
1697 {
1698 return Vec3 (x / a, y / a, z / a);
1699 }
1700
1701 template <class T>
1702 IMATH_HOSTDEVICE IMATH_CONSTEXPR14 inline T
1703 Vec3<T>::lengthTiny() const IMATH_NOEXCEPT
1704 {
1705 T absX = (x >= T (0)) ? x : -x;
1706 T absY = (y >= T (0)) ? y : -y;
1707 T absZ = (z >= T (0)) ? z : -z;
1708
1709 T max = absX;
1710
1711 if (max < absY)
1712 max = absY;
1713
1714 if (max < absZ)
1715 max = absZ;
1716
1717 if (IMATH_UNLIKELY(max == T (0)))
1718 return T (0);
1719
1720 //
1721 // Do not replace the divisions by max with multiplications by 1/max.
1722 // Computing 1/max can overflow but the divisions below will always
1723 // produce results less than or equal to 1.
1724 //
1725
1726 absX /= max;
1727 absY /= max;
1728 absZ /= max;
1729
1730 return max * std::sqrt (absX * absX + absY * absY + absZ * absZ);
1731 }
1732
1733 template <class T>
1734 IMATH_HOSTDEVICE inline T
1735 Vec3<T>::length() const IMATH_NOEXCEPT
1736 {
1737 T length2 = dot (*this);
1738
1739 if (IMATH_UNLIKELY(length2 < T (2) * std::numeric_limits<T>::min()))
1740 return lengthTiny();
1741
1742 return std::sqrt (length2);
1743 }
1744
1745 template <class T>
1746 IMATH_HOSTDEVICE constexpr inline T
1747 Vec3<T>::length2() const IMATH_NOEXCEPT
1748 {
1749 return dot (*this);
1750 }
1751
1752 template <class T>
1753 IMATH_HOSTDEVICE inline const Vec3<T>&
1754 Vec3<T>::normalize() IMATH_NOEXCEPT
1755 {
1756 T l = length();
1757
1758 if (IMATH_LIKELY(l != T (0)))
1759 {
1760 //
1761 // Do not replace the divisions by l with multiplications by 1/l.
1762 // Computing 1/l can overflow but the divisions below will always
1763 // produce results less than or equal to 1.
1764 //
1765
1766 x /= l;
1767 y /= l;
1768 z /= l;
1769 }
1770
1771 return *this;
1772 }
1773
1774 template <class T>
1775 inline const Vec3<T>&
1776 Vec3<T>::normalizeExc()
1777 {
1778 T l = length();
1779
1780 if (IMATH_UNLIKELY(l == T (0)))
1781 throw std::domain_error ("Cannot normalize null vector.");
1782
1783 x /= l;
1784 y /= l;
1785 z /= l;
1786 return *this;
1787 }
1788
1789 template <class T>
1790 IMATH_HOSTDEVICE inline const Vec3<T>&
1791 Vec3<T>::normalizeNonNull() IMATH_NOEXCEPT
1792 {
1793 T l = length();
1794 x /= l;
1795 y /= l;
1796 z /= l;
1797 return *this;
1798 }
1799
1800 template <class T>
1801 IMATH_HOSTDEVICE inline Vec3<T>
1802 Vec3<T>::normalized() const IMATH_NOEXCEPT
1803 {
1804 T l = length();
1805
1806 if (IMATH_UNLIKELY((l == T (0))))
1807 return Vec3 (T (0));
1808
1809 return Vec3 (x / l, y / l, z / l);
1810 }
1811
1812 template <class T>
1813 inline Vec3<T>
1814 Vec3<T>::normalizedExc() const
1815 {
1816 T l = length();
1817
1818 if (IMATH_UNLIKELY(l == T (0)))
1819 throw std::domain_error ("Cannot normalize null vector.");
1820
1821 return Vec3 (x / l, y / l, z / l);
1822 }
1823
1824 template <class T>
1825 IMATH_HOSTDEVICE inline Vec3<T>
1826 Vec3<T>::normalizedNonNull() const IMATH_NOEXCEPT
1827 {
1828 T l = length();
1829 return Vec3 (x / l, y / l, z / l);
1830 }
1831
1832 //-----------------------
1833 // Implementation of Vec4
1834 //-----------------------
1835
1836 template <class T>
1837 IMATH_HOSTDEVICE
1838 IMATH_CONSTEXPR14 inline T&
1839 Vec4<T>::operator[] (int i) IMATH_NOEXCEPT
1840 {
1841 return (&x)[i]; // NOSONAR - suppress SonarCloud bug report.
1842 }
1843
1844 template <class T>
1845 IMATH_HOSTDEVICE constexpr inline const T&
1846 Vec4<T>::operator[] (int i) const IMATH_NOEXCEPT
1847 {
1848 return (&x)[i]; // NOSONAR - suppress SonarCloud bug report.
1849 }
1850
1851 template <class T> IMATH_HOSTDEVICE inline Vec4<T>::Vec4() IMATH_NOEXCEPT
1852 {
1853 // empty, and not constexpr because data is uninitialized.
1854 }
1855
1856 template <class T> IMATH_HOSTDEVICE constexpr inline Vec4<T>::Vec4 (T a) IMATH_NOEXCEPT
1857 : x(a), y(a), z(a), w(a)
1858 {
1859 }
1860
1861 template <class T> IMATH_HOSTDEVICE constexpr inline Vec4<T>::Vec4 (T a, T b, T c, T d) IMATH_NOEXCEPT
1862 : x(a), y(b), z(c), w(d)
1863 {
1864 }
1865
1866 template <class T> IMATH_HOSTDEVICE constexpr inline Vec4<T>::Vec4 (const Vec4& v) IMATH_NOEXCEPT
1867 : x(v.x), y(v.y), z(v.z), w(v.w)
1868 {
1869 }
1870
1871 template <class T> template <class S>
1872 IMATH_HOSTDEVICE constexpr inline Vec4<T>::Vec4 (const Vec4<S>& v) IMATH_NOEXCEPT
1873 : x(T(v.x)), y(T(v.y)), z(T(v.z)), w(T(v.w))
1874 {
1875 }
1876
1877 template <class T>
1878 IMATH_HOSTDEVICE IMATH_CONSTEXPR14 inline const Vec4<T>&
1879 Vec4<T>::operator= (const Vec4& v) IMATH_NOEXCEPT
1880 {
1881 x = v.x;
1882 y = v.y;
1883 z = v.z;
1884 w = v.w;
1885 return *this;
1886 }
1887
1888 template <class T> template <class S>
1889 IMATH_HOSTDEVICE constexpr inline Vec4<T>::Vec4 (const Vec3<S>& v) IMATH_NOEXCEPT
1890 : x(T(v.x)), y(T(v.y)), z(T(v.z)), w(T(1))
1891 {
1892 }
1893
1894 template <class T>
1895 template <class S>
1896 IMATH_HOSTDEVICE constexpr inline bool
1897 Vec4<T>::operator== (const Vec4<S>& v) const IMATH_NOEXCEPT
1898 {
1899 return x == v.x && y == v.y && z == v.z && w == v.w;
1900 }
1901
1902 template <class T>
1903 template <class S>
1904 IMATH_HOSTDEVICE constexpr inline bool
1905 Vec4<T>::operator!= (const Vec4<S>& v) const IMATH_NOEXCEPT
1906 {
1907 return x != v.x || y != v.y || z != v.z || w != v.w;
1908 }
1909
1910 template <class T>
1911 IMATH_HOSTDEVICE IMATH_CONSTEXPR14 inline bool
1912 Vec4<T>::equalWithAbsError (const Vec4<T>& v, T e) const IMATH_NOEXCEPT
1913 {
1914 for (int i = 0; i < 4; i++)
1915 if (!IMATH_INTERNAL_NAMESPACE::equalWithAbsError ((*this)[i], v[i], e))
1916 return false;
1917
1918 return true;
1919 }
1920
1921 template <class T>
1922 IMATH_HOSTDEVICE IMATH_CONSTEXPR14 inline bool
1923 Vec4<T>::equalWithRelError (const Vec4<T>& v, T e) const IMATH_NOEXCEPT
1924 {
1925 for (int i = 0; i < 4; i++)
1926 if (!IMATH_INTERNAL_NAMESPACE::equalWithRelError ((*this)[i], v[i], e))
1927 return false;
1928
1929 return true;
1930 }
1931
1932 template <class T>
1933 IMATH_HOSTDEVICE constexpr inline T
1934 Vec4<T>::dot (const Vec4& v) const IMATH_NOEXCEPT
1935 {
1936 return x * v.x + y * v.y + z * v.z + w * v.w;
1937 }
1938
1939 template <class T>
1940 IMATH_HOSTDEVICE constexpr inline T
1941 Vec4<T>::operator^ (const Vec4& v) const IMATH_NOEXCEPT
1942 {
1943 return dot (v);
1944 }
1945
1946 template <class T>
1947 IMATH_HOSTDEVICE IMATH_CONSTEXPR14 inline const Vec4<T>&
1948 Vec4<T>::operator+= (const Vec4& v) IMATH_NOEXCEPT
1949 {
1950 x += v.x;
1951 y += v.y;
1952 z += v.z;
1953 w += v.w;
1954 return *this;
1955 }
1956
1957 template <class T>
1958 IMATH_HOSTDEVICE constexpr inline Vec4<T>
1959 Vec4<T>::operator+ (const Vec4& v) const IMATH_NOEXCEPT
1960 {
1961 return Vec4 (x + v.x, y + v.y, z + v.z, w + v.w);
1962 }
1963
1964 template <class T>
1965 IMATH_HOSTDEVICE IMATH_CONSTEXPR14 inline const Vec4<T>&
1966 Vec4<T>::operator-= (const Vec4& v) IMATH_NOEXCEPT
1967 {
1968 x -= v.x;
1969 y -= v.y;
1970 z -= v.z;
1971 w -= v.w;
1972 return *this;
1973 }
1974
1975 template <class T>
1976 IMATH_HOSTDEVICE constexpr inline Vec4<T>
1977 Vec4<T>::operator- (const Vec4& v) const IMATH_NOEXCEPT
1978 {
1979 return Vec4 (x - v.x, y - v.y, z - v.z, w - v.w);
1980 }
1981
1982 template <class T>
1983 IMATH_HOSTDEVICE constexpr inline Vec4<T>
1984 Vec4<T>::operator-() const IMATH_NOEXCEPT
1985 {
1986 return Vec4 (-x, -y, -z, -w);
1987 }
1988
1989 template <class T>
1990 IMATH_HOSTDEVICE IMATH_CONSTEXPR14 inline const Vec4<T>&
1991 Vec4<T>::negate() IMATH_NOEXCEPT
1992 {
1993 x = -x;
1994 y = -y;
1995 z = -z;
1996 w = -w;
1997 return *this;
1998 }
1999
2000 template <class T>
2001 IMATH_HOSTDEVICE IMATH_CONSTEXPR14 inline const Vec4<T>&
2002 Vec4<T>::operator*= (const Vec4& v) IMATH_NOEXCEPT
2003 {
2004 x *= v.x;
2005 y *= v.y;
2006 z *= v.z;
2007 w *= v.w;
2008 return *this;
2009 }
2010
2011 template <class T>
2012 IMATH_HOSTDEVICE IMATH_CONSTEXPR14 inline const Vec4<T>&
2013 Vec4<T>::operator*= (T a) IMATH_NOEXCEPT
2014 {
2015 x *= a;
2016 y *= a;
2017 z *= a;
2018 w *= a;
2019 return *this;
2020 }
2021
2022 template <class T>
2023 IMATH_HOSTDEVICE constexpr inline Vec4<T>
2024 Vec4<T>::operator* (const Vec4& v) const IMATH_NOEXCEPT
2025 {
2026 return Vec4 (x * v.x, y * v.y, z * v.z, w * v.w);
2027 }
2028
2029 template <class T>
2030 IMATH_HOSTDEVICE constexpr inline Vec4<T>
2031 Vec4<T>::operator* (T a) const IMATH_NOEXCEPT
2032 {
2033 return Vec4 (x * a, y * a, z * a, w * a);
2034 }
2035
2036 template <class T>
2037 IMATH_HOSTDEVICE IMATH_CONSTEXPR14 inline const Vec4<T>&
2038 Vec4<T>::operator/= (const Vec4& v) IMATH_NOEXCEPT
2039 {
2040 x /= v.x;
2041 y /= v.y;
2042 z /= v.z;
2043 w /= v.w;
2044 return *this;
2045 }
2046
2047 template <class T>
2048 IMATH_HOSTDEVICE IMATH_CONSTEXPR14 inline const Vec4<T>&
2049 Vec4<T>::operator/= (T a) IMATH_NOEXCEPT
2050 {
2051 x /= a;
2052 y /= a;
2053 z /= a;
2054 w /= a;
2055 return *this;
2056 }
2057
2058 template <class T>
2059 IMATH_HOSTDEVICE constexpr inline Vec4<T>
2060 Vec4<T>::operator/ (const Vec4& v) const IMATH_NOEXCEPT
2061 {
2062 return Vec4 (x / v.x, y / v.y, z / v.z, w / v.w);
2063 }
2064
2065 template <class T>
2066 IMATH_HOSTDEVICE constexpr inline Vec4<T>
2067 Vec4<T>::operator/ (T a) const IMATH_NOEXCEPT
2068 {
2069 return Vec4 (x / a, y / a, z / a, w / a);
2070 }
2071
2072 template <class T>
2073 IMATH_HOSTDEVICE IMATH_CONSTEXPR14 inline T
2074 Vec4<T>::lengthTiny() const IMATH_NOEXCEPT
2075 {
2076 T absX = (x >= T (0)) ? x : -x;
2077 T absY = (y >= T (0)) ? y : -y;
2078 T absZ = (z >= T (0)) ? z : -z;
2079 T absW = (w >= T (0)) ? w : -w;
2080
2081 T max = absX;
2082
2083 if (max < absY)
2084 max = absY;
2085
2086 if (max < absZ)
2087 max = absZ;
2088
2089 if (max < absW)
2090 max = absW;
2091
2092 if (IMATH_UNLIKELY(max == T (0)))
2093 return T (0);
2094
2095 //
2096 // Do not replace the divisions by max with multiplications by 1/max.
2097 // Computing 1/max can overflow but the divisions below will always
2098 // produce results less than or equal to 1.
2099 //
2100
2101 absX /= max;
2102 absY /= max;
2103 absZ /= max;
2104 absW /= max;
2105
2106 return max * std::sqrt (absX * absX + absY * absY + absZ * absZ + absW * absW);
2107 }
2108
2109 template <class T>
2110 IMATH_HOSTDEVICE inline T
2111 Vec4<T>::length() const IMATH_NOEXCEPT
2112 {
2113 T length2 = dot (*this);
2114
2115 if (IMATH_UNLIKELY(length2 < T (2) * std::numeric_limits<T>::min()))
2116 return lengthTiny();
2117
2118 return std::sqrt (length2);
2119 }
2120
2121 template <class T>
2122 IMATH_HOSTDEVICE constexpr inline T
2123 Vec4<T>::length2() const IMATH_NOEXCEPT
2124 {
2125 return dot (*this);
2126 }
2127
2128 template <class T>
2129 IMATH_HOSTDEVICE const inline Vec4<T>&
2130 Vec4<T>::normalize() IMATH_NOEXCEPT
2131 {
2132 T l = length();
2133
2134 if (IMATH_LIKELY(l != T (0)))
2135 {
2136 //
2137 // Do not replace the divisions by l with multiplications by 1/l.
2138 // Computing 1/l can overflow but the divisions below will always
2139 // produce results less than or equal to 1.
2140 //
2141
2142 x /= l;
2143 y /= l;
2144 z /= l;
2145 w /= l;
2146 }
2147
2148 return *this;
2149 }
2150
2151 template <class T>
2152 const inline Vec4<T>&
2153 Vec4<T>::normalizeExc()
2154 {
2155 T l = length();
2156
2157 if (IMATH_UNLIKELY(l == T (0)))
2158 throw std::domain_error ("Cannot normalize null vector.");
2159
2160 x /= l;
2161 y /= l;
2162 z /= l;
2163 w /= l;
2164 return *this;
2165 }
2166
2167 template <class T>
2168 IMATH_HOSTDEVICE inline const Vec4<T>&
2169 Vec4<T>::normalizeNonNull() IMATH_NOEXCEPT
2170 {
2171 T l = length();
2172 x /= l;
2173 y /= l;
2174 z /= l;
2175 w /= l;
2176 return *this;
2177 }
2178
2179 template <class T>
2180 IMATH_HOSTDEVICE inline Vec4<T>
2181 Vec4<T>::normalized() const IMATH_NOEXCEPT
2182 {
2183 T l = length();
2184
2185 if (IMATH_UNLIKELY(l == T (0)))
2186 return Vec4 (T (0));
2187
2188 return Vec4 (x / l, y / l, z / l, w / l);
2189 }
2190
2191 template <class T>
2192 inline Vec4<T>
2193 Vec4<T>::normalizedExc() const
2194 {
2195 T l = length();
2196
2197 if (IMATH_UNLIKELY(l == T (0)))
2198 throw std::domain_error ("Cannot normalize null vector.");
2199
2200 return Vec4 (x / l, y / l, z / l, w / l);
2201 }
2202
2203 template <class T>
2204 IMATH_HOSTDEVICE inline Vec4<T>
2205 Vec4<T>::normalizedNonNull() const IMATH_NOEXCEPT
2206 {
2207 T l = length();
2208 return Vec4 (x / l, y / l, z / l, w / l);
2209 }
2210
2211 //-----------------------------
2212 // Stream output implementation
2213 //-----------------------------
2214
2215 template <class T>
2216 std::ostream&
2217 operator<< (std::ostream& s, const Vec2<T>& v)
2218 {
2219 return s << '(' << v.x << ' ' << v.y << ')';
2220 }
2221
2222 template <class T>
2223 std::ostream&
2224 operator<< (std::ostream& s, const Vec3<T>& v)
2225 {
2226 return s << '(' << v.x << ' ' << v.y << ' ' << v.z << ')';
2227 }
2228
2229 template <class T>
2230 std::ostream&
2231 operator<< (std::ostream& s, const Vec4<T>& v)
2232 {
2233 return s << '(' << v.x << ' ' << v.y << ' ' << v.z << ' ' << v.w << ')';
2234 }
2235
2236 //-----------------------------------------
2237 // Implementation of reverse multiplication
2238 //-----------------------------------------
2239
2240 template <class T>
2241 IMATH_HOSTDEVICE constexpr inline Vec2<T>
2242 operator* (T a, const Vec2<T>& v) IMATH_NOEXCEPT
2243 {
2244 return Vec2<T> (a * v.x, a * v.y);
2245 }
2246
2247 template <class T>
2248 IMATH_HOSTDEVICE constexpr inline Vec3<T>
2249 operator* (T a, const Vec3<T>& v) IMATH_NOEXCEPT
2250 {
2251 return Vec3<T> (a * v.x, a * v.y, a * v.z);
2252 }
2253
2254 template <class T>
2255 IMATH_HOSTDEVICE constexpr inline Vec4<T>
2256 operator* (T a, const Vec4<T>& v) IMATH_NOEXCEPT
2257 {
2258 return Vec4<T> (a * v.x, a * v.y, a * v.z, a * v.w);
2259 }
2260
2261 #if (defined _WIN32 || defined _WIN64) && defined _MSC_VER
2262 # pragma warning(pop)
2263 #endif
2264
2265 IMATH_INTERNAL_NAMESPACE_HEADER_EXIT
2266
2267 #endif // INCLUDED_IMATHVEC_H