src/Imath/ImathVec.h

   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