//
// SPDX-License-Identifier: BSD-3-Clause
// Copyright Contributors to the OpenEXR Project.
//

//
// 2D, 3D and 4D point/vector class templates
//

#ifndef INCLUDED_IMATHVEC_H
#define INCLUDED_IMATHVEC_H

#ifdef __has_include
#    if __has_include(<version>)
#        include <version>
#    endif
#endif

#include "ImathExport.h"
#include "ImathNamespace.h"
#include "ImathTypeTraits.h"

#include "ImathMath.h"
#include "half.h"

#include <iostream>
#include <limits>
#include <cstdint>
#include <stdexcept>

#if (defined _WIN32 || defined _WIN64) && defined _MSC_VER
// suppress exception specification warnings
#    pragma warning(push)
#    pragma warning(disable : 4290)
#endif

IMATH_INTERNAL_NAMESPACE_HEADER_ENTER

template <class T> class Vec2;
template <class T> class Vec3;
template <class T> class Vec4;

/// Enum for the Vec4 to Vec3 conversion constructor
enum IMATH_EXPORT_ENUM InfException
{
    INF_EXCEPTION
};

///
/// 2-element vector
///

template <class T> class IMATH_EXPORT_TEMPLATE_TYPE Vec2
{
public:
    /// @{
    /// @name Direct access to elements

    T x, y;

    /// @}

    /// Element access by index.
    ///
    /// NB: This method of access may use dynamic array accesses which
    /// can prevent compiler optimizations and force temporaries to be
    /// stored to the stack and other missed vectorization
    /// opportunities. Use of direct access to x, y when
    /// possible should be preferred.
    IMATH_HOSTDEVICE IMATH_CONSTEXPR14 T& operator[] (int i) IMATH_NOEXCEPT;

    /// Element access by index.
    ///
    /// NB: This method of access may use dynamic array accesses which
    /// can prevent compiler optimizations and force temporaries to be
    /// stored to the stack and other missed vectorization
    /// opportunities. Use of direct access to x, y when
    /// possible should be preferred.
    IMATH_HOSTDEVICE constexpr const T& operator[] (int i) const IMATH_NOEXCEPT;

    /// @{
    ///	@name Constructors and Assignment

    /// Uninitialized by default
    IMATH_HOSTDEVICE Vec2 () IMATH_NOEXCEPT;

    /// Initialize to a scalar `(a,a)`
    IMATH_HOSTDEVICE constexpr explicit Vec2 (T a) IMATH_NOEXCEPT;

    /// Initialize to given elements `(a,b)`
    IMATH_HOSTDEVICE constexpr Vec2 (T a, T b) IMATH_NOEXCEPT;

    /// Copy constructor
    IMATH_HOSTDEVICE constexpr Vec2 (const Vec2& v) IMATH_NOEXCEPT;

    /// Construct from Vec2 of another base type
    template <class S>
    IMATH_HOSTDEVICE constexpr Vec2 (const Vec2<S>& v) IMATH_NOEXCEPT;

    /// Assignment
    IMATH_HOSTDEVICE IMATH_CONSTEXPR14 const Vec2&
    operator= (const Vec2& v) IMATH_NOEXCEPT;

    /// Destructor
    ~Vec2 () IMATH_NOEXCEPT = default;

    /// @}

#if IMATH_FOREIGN_VECTOR_INTEROP
    /// @{
    /// @name Interoperability with other vector types
    ///
    /// Construction and assignment are allowed from other classes that
    /// appear to be equivalent vector types, provided that they have either
    /// a subscripting operator, or data members .x and .y, that are of the
    /// same type as the elements of this vector, and their size appears to
    /// be the right number of elements.
    ///
    /// This functionality is disabled for gcc 4.x, which seems to have a
    /// compiler bug that results in spurious errors. It can also be
    /// disabled by defining IMATH_FOREIGN_VECTOR_INTEROP to be 0 prior to
    /// including any Imath header files.
    ///

    template <typename V, IMATH_ENABLE_IF (has_xy<V, T>::value)>
    IMATH_HOSTDEVICE explicit constexpr Vec2 (const V& v) IMATH_NOEXCEPT
        : Vec2 (T (v.x), T (v.y))
    {}

    template <
        typename V,
        IMATH_ENABLE_IF (has_subscript<V, T, 2>::value && !has_xy<V, T>::value)>
    IMATH_HOSTDEVICE explicit Vec2 (const V& v) : Vec2 (T (v[0]), T (v[1]))
    {}

    template <typename V, IMATH_ENABLE_IF (has_xy<V, T>::value)>
    IMATH_HOSTDEVICE IMATH_CONSTEXPR14 const Vec2&
    operator= (const V& v) IMATH_NOEXCEPT
    {
        x = T (v.x);
        y = T (v.y);
        return *this;
    }

    template <
        typename V,
        IMATH_ENABLE_IF (has_subscript<V, T, 2>::value && !has_xy<V, T>::value)>
    IMATH_HOSTDEVICE const Vec2& operator= (const V& v)
    {
        x = T (v[0]);
        y = T (v[1]);
        return *this;
    }
#endif

    /// @{
    /// @name Compatibility with Sb

    /// Set the value
    template <class S> IMATH_HOSTDEVICE void setValue (S a, S b) IMATH_NOEXCEPT;

    /// Set the value
    template <class S>
    IMATH_HOSTDEVICE void setValue (const Vec2<S>& v) IMATH_NOEXCEPT;

    /// Return the value in `a` and `b`
    template <class S>
    IMATH_HOSTDEVICE void getValue (S& a, S& b) const IMATH_NOEXCEPT;

    /// Return the value in `v`
    template <class S>
    IMATH_HOSTDEVICE void getValue (Vec2<S>& v) const IMATH_NOEXCEPT;

    /// Return a raw pointer to the array of values
    IMATH_HOSTDEVICE T* getValue () IMATH_NOEXCEPT;

    /// Return a raw pointer to the array of values
    IMATH_HOSTDEVICE const T* getValue () const IMATH_NOEXCEPT;

    /// @}

    /// @{
    /// @name Arithmetic and Comparison

    /// Equality
    template <class S>
    IMATH_HOSTDEVICE constexpr bool
    operator== (const Vec2<S>& v) const IMATH_NOEXCEPT;

    /// Inequality
    template <class S>
    IMATH_HOSTDEVICE constexpr bool
    operator!= (const Vec2<S>& v) const IMATH_NOEXCEPT;

    /// Compare two vectors and test if they are "approximately equal":
    /// @return True if the components of this and `v` are the same
    /// with an absolute error of no more than e, i.e., for all i:
    ///
    ///     abs (this[i] - v[i]) <= e
    IMATH_HOSTDEVICE IMATH_CONSTEXPR14 bool
    equalWithAbsError (const Vec2<T>& v, T e) const IMATH_NOEXCEPT;

    /// Compare two vectors and test if they are "approximately equal":
    /// @return True if the components of this and `v` are the same with
    /// a relative error of no more than e, i.e., for all i:
    ///
    ///     abs (this[i] - v[i]) <= e * abs (this[i])
    IMATH_HOSTDEVICE IMATH_CONSTEXPR14 bool
    equalWithRelError (const Vec2<T>& v, T e) const IMATH_NOEXCEPT;

    /// Dot product
    IMATH_HOSTDEVICE constexpr T dot (const Vec2& v) const IMATH_NOEXCEPT;

    /// Dot product
    IMATH_HOSTDEVICE constexpr T operator^ (const Vec2& v) const IMATH_NOEXCEPT;

    /// Right-handed cross product, i.e. z component of
    /// Vec3 (this->x, this->y, 0) % Vec3 (v.x, v.y, 0)
    IMATH_HOSTDEVICE constexpr T cross (const Vec2& v) const IMATH_NOEXCEPT;

    /// Right-handed cross product, i.e. z component of
    /// Vec3 (this->x, this->y, 0) % Vec3 (v.x, v.y, 0)
    IMATH_HOSTDEVICE constexpr T operator% (const Vec2& v) const IMATH_NOEXCEPT;

    /// Component-wise addition
    IMATH_HOSTDEVICE IMATH_CONSTEXPR14 const Vec2&
    operator+= (const Vec2& v) IMATH_NOEXCEPT;

    /// Component-wise addition
    IMATH_HOSTDEVICE constexpr Vec2
    operator+ (const Vec2& v) const IMATH_NOEXCEPT;

    /// Component-wise subtraction
    IMATH_HOSTDEVICE IMATH_CONSTEXPR14 const Vec2&
    operator-= (const Vec2& v) IMATH_NOEXCEPT;

    /// Component-wise subtraction
    IMATH_HOSTDEVICE constexpr Vec2
    operator- (const Vec2& v) const IMATH_NOEXCEPT;

    /// Component-wise multiplication by -1
    IMATH_HOSTDEVICE constexpr Vec2 operator- () const IMATH_NOEXCEPT;

    /// Component-wise multiplication by -1
    IMATH_HOSTDEVICE IMATH_CONSTEXPR14 const Vec2& negate () IMATH_NOEXCEPT;

    /// Component-wise multiplication
    IMATH_HOSTDEVICE IMATH_CONSTEXPR14 const Vec2&
    operator*= (const Vec2& v) IMATH_NOEXCEPT;

    /// Component-wise multiplication
    IMATH_HOSTDEVICE IMATH_CONSTEXPR14 const Vec2&
    operator*= (T a) IMATH_NOEXCEPT;

    /// Component-wise multiplication
    IMATH_HOSTDEVICE constexpr Vec2
    operator* (const Vec2& v) const IMATH_NOEXCEPT;

    /// Component-wise multiplication
    IMATH_HOSTDEVICE constexpr Vec2 operator* (T a) const IMATH_NOEXCEPT;

    /// Component-wise division
    IMATH_HOSTDEVICE IMATH_CONSTEXPR14 const Vec2&
    operator/= (const Vec2& v) IMATH_NOEXCEPT;

    /// Component-wise division
    IMATH_HOSTDEVICE IMATH_CONSTEXPR14 const Vec2&
    operator/= (T a) IMATH_NOEXCEPT;

    /// Component-wise division
    IMATH_HOSTDEVICE constexpr Vec2
    operator/ (const Vec2& v) const IMATH_NOEXCEPT;

    /// Component-wise division
    IMATH_HOSTDEVICE constexpr Vec2 operator/ (T a) const IMATH_NOEXCEPT;

    /// @}

    /// @{
    /// @name Query and Manipulation

    /// Return the Euclidean norm
    IMATH_HOSTDEVICE T length () const IMATH_NOEXCEPT;

    /// Return the square of the Euclidean norm, i.e. the dot product
    /// with itself.
    IMATH_HOSTDEVICE constexpr T length2 () const IMATH_NOEXCEPT;

    /// Normalize in place. If length()==0, return a null vector.
    IMATH_HOSTDEVICE const Vec2& normalize () IMATH_NOEXCEPT;

    /// Normalize in place. If length()==0, throw an exception.
    const Vec2& normalizeExc ();

    /// Normalize without any checks for length()==0. Slightly faster
    /// than the other normalization routines, but if v.length() is
    /// 0.0, the result is undefined.
    IMATH_HOSTDEVICE const Vec2& normalizeNonNull () IMATH_NOEXCEPT;

    /// Return a normalized vector. Does not modify *this.
    IMATH_HOSTDEVICE Vec2<T> normalized () const IMATH_NOEXCEPT;

    /// Return a normalized vector. Does not modify *this. Throw an
    /// exception if length()==0.
    Vec2<T> normalizedExc () const;

    /// Return a normalized vector. Does not modify *this, and does
    /// not check for length()==0. Slightly faster than the other
    /// normalization routines, but if v.length() is 0.0, the result
    /// is undefined.
    IMATH_HOSTDEVICE Vec2<T> normalizedNonNull () const IMATH_NOEXCEPT;

    /// @}

    /// @{
    /// @name Numeric Limits

    /// Largest possible negative value
    IMATH_HOSTDEVICE constexpr static T baseTypeLowest () IMATH_NOEXCEPT
    {
        return std::numeric_limits<T>::lowest ();
    }

    /// Largest possible positive value
    IMATH_HOSTDEVICE constexpr static T baseTypeMax () IMATH_NOEXCEPT
    {
        return std::numeric_limits<T>::max ();
    }

    /// Smallest possible positive value
    IMATH_HOSTDEVICE constexpr static T baseTypeSmallest () IMATH_NOEXCEPT
    {
        return std::numeric_limits<T>::min ();
    }

    /// Smallest possible e for which 1+e != 1
    IMATH_HOSTDEVICE constexpr static T baseTypeEpsilon () IMATH_NOEXCEPT
    {
        return std::numeric_limits<T>::epsilon ();
    }

    /// @}

    /// Return the number of dimensions, i.e. 2
    IMATH_HOSTDEVICE constexpr static unsigned int dimensions () IMATH_NOEXCEPT
    {
        return 2;
    }

    /// The base type: In templates that accept a parameter `V`, you
    /// can refer to `T` as `V::BaseType`
    typedef T BaseType;

private:
    IMATH_HOSTDEVICE IMATH_CONSTEXPR14 T lengthTiny () const IMATH_NOEXCEPT;
};

///
/// 3-element vector
///

template <class T> class IMATH_EXPORT_TEMPLATE_TYPE Vec3
{
public:
    /// @{
    /// @name Direct access to elements

    T x, y, z;

    /// @}

    /// Element access by index.
    ///
    /// NB: This method of access uses dynamic array accesses which
    /// can prevent compiler optimizations and force temporaries to be
    /// stored to the stack and other missed vectorization
    /// opportunities. Use of direct access to x, y, z when
    /// possible should be preferred.
    IMATH_HOSTDEVICE IMATH_CONSTEXPR14 T& operator[] (int i) IMATH_NOEXCEPT;

    /// Element access by index.
    ///
    /// NB: This method of access uses dynamic array accesses which
    /// can prevent compiler optimizations and force temporaries to be
    /// stored to the stack and other missed vectorization
    /// opportunities. Use of direct access to x, y, z when
    /// possible should be preferred.
    IMATH_HOSTDEVICE constexpr const T& operator[] (int i) const IMATH_NOEXCEPT;

    /// @{
    ///	@name Constructors and Assignment

    /// Uninitialized by default
    IMATH_HOSTDEVICE Vec3 () IMATH_NOEXCEPT;

    /// Initialize to a scalar `(a,a,a)`
    IMATH_HOSTDEVICE constexpr explicit Vec3 (T a) IMATH_NOEXCEPT;

    /// Initialize to given elements `(a,b,c)`
    IMATH_HOSTDEVICE constexpr Vec3 (T a, T b, T c) IMATH_NOEXCEPT;

    /// Copy constructor
    IMATH_HOSTDEVICE constexpr Vec3 (const Vec3& v) IMATH_NOEXCEPT;

    /// Construct from Vec3 of another base type
    template <class S>
    IMATH_HOSTDEVICE constexpr Vec3 (const Vec3<S>& v) IMATH_NOEXCEPT;

    /// Vec4 to Vec3 conversion: divide x, y and z by w, even if w is
    /// 0.  The result depends on how the environment handles
    /// floating-point exceptions.
    template <class S>
    IMATH_HOSTDEVICE explicit constexpr Vec3 (const Vec4<S>& v) IMATH_NOEXCEPT;

    /// Vec4 to Vec3 conversion: divide x, y and z by w.  Throws an
    /// exception if w is zero or if division by w would overflow.
    template <class S>
    explicit IMATH_HOSTDEVICE IMATH_CONSTEXPR14
    Vec3 (const Vec4<S>& v, InfException);

    /// Assignment
    IMATH_HOSTDEVICE IMATH_CONSTEXPR14 const Vec3&
    operator= (const Vec3& v) IMATH_NOEXCEPT;

    /// Destructor
    ~Vec3 () IMATH_NOEXCEPT = default;

    /// @}

#if IMATH_FOREIGN_VECTOR_INTEROP
    /// @{
    /// @name Interoperability with other vector types
    ///
    /// Construction and assignment are allowed from other classes that
    /// appear to be equivalent vector types, provided that they have either
    /// a subscripting operator, or data members .x, .y, .z, that are of the
    /// same type as the elements of this vector, and their size appears to
    /// be the right number of elements.
    ///
    /// This functionality is disabled for gcc 4.x, which seems to have a
    /// compiler bug that results in spurious errors. It can also be
    /// disabled by defining IMATH_FOREIGN_VECTOR_INTEROP to be 0 prior to
    /// including any Imath header files.
    ///

    template <typename V, IMATH_ENABLE_IF (has_xyz<V, T>::value)>
    IMATH_HOSTDEVICE explicit constexpr Vec3 (const V& v) IMATH_NOEXCEPT
        : Vec3 (T (v.x), T (v.y), T (v.z))
    {}

    template <
        typename V,
        IMATH_ENABLE_IF (
            has_subscript<V, T, 3>::value && !has_xyz<V, T>::value)>
    IMATH_HOSTDEVICE explicit Vec3 (const V& v)
        : Vec3 (T (v[0]), T (v[1]), T (v[2]))
    {}

    /// Interoperability assignment from another type that behaves as if it
    /// were an equivalent vector.
    template <typename V, IMATH_ENABLE_IF (has_xyz<V, T>::value)>
    IMATH_HOSTDEVICE const Vec3& operator= (const V& v) IMATH_NOEXCEPT
    {
        x = T (v.x);
        y = T (v.y);
        z = T (v.z);
        return *this;
    }

    template <
        typename V,
        IMATH_ENABLE_IF (
            has_subscript<V, T, 3>::value && !has_xyz<V, T>::value)>
    IMATH_HOSTDEVICE IMATH_CONSTEXPR14 const Vec3& operator= (const V& v)
    {
        x = T (v[0]);
        y = T (v[1]);
        z = T (v[2]);
        return *this;
    }
    /// @}
#endif

    /// @{
    /// @name Compatibility with Sb

    /// Set the value
    template <class S>
    IMATH_HOSTDEVICE void setValue (S a, S b, S c) IMATH_NOEXCEPT;

    /// Set the value
    template <class S>
    IMATH_HOSTDEVICE void setValue (const Vec3<S>& v) IMATH_NOEXCEPT;

    /// Return the value in `a`, `b`, and `c`
    template <class S>
    IMATH_HOSTDEVICE void getValue (S& a, S& b, S& c) const IMATH_NOEXCEPT;

    /// Return the value in `v`
    template <class S>
    IMATH_HOSTDEVICE void getValue (Vec3<S>& v) const IMATH_NOEXCEPT;

    /// Return a raw pointer to the array of values
    IMATH_HOSTDEVICE T* getValue () IMATH_NOEXCEPT;

    /// Return a raw pointer to the array of values
    IMATH_HOSTDEVICE const T* getValue () const IMATH_NOEXCEPT;

    /// @}

    /// @{
    /// @name Arithmetic and Comparison

    /// Equality
    template <class S>
    IMATH_HOSTDEVICE constexpr bool
    operator== (const Vec3<S>& v) const IMATH_NOEXCEPT;

    /// Inequality
    template <class S>
    IMATH_HOSTDEVICE constexpr bool
    operator!= (const Vec3<S>& v) const IMATH_NOEXCEPT;

    /// Compare two vectors and test if they are "approximately equal":
    /// @return True if the components of this and `v` are the same
    /// with an absolute error of no more than e, i.e., for all i:
    ///
    ///     abs (this[i] - v[i]) <= e
    IMATH_HOSTDEVICE IMATH_CONSTEXPR14 bool
    equalWithAbsError (const Vec3<T>& v, T e) const IMATH_NOEXCEPT;

    /// Compare two vectors and test if they are "approximately equal":
    /// @return True if the components of this and `v` are the same with
    /// a relative error of no more than e, i.e., for all i:
    ///
    ///     abs (this[i] - v[i]) <= e * abs (this[i])
    IMATH_HOSTDEVICE IMATH_CONSTEXPR14 bool
    equalWithRelError (const Vec3<T>& v, T e) const IMATH_NOEXCEPT;

    /// Dot product
    IMATH_HOSTDEVICE constexpr T dot (const Vec3& v) const IMATH_NOEXCEPT;

    /// Dot product
    IMATH_HOSTDEVICE constexpr T operator^ (const Vec3& v) const IMATH_NOEXCEPT;

    /// Right-handed cross product
    IMATH_HOSTDEVICE constexpr Vec3 cross (const Vec3& v) const IMATH_NOEXCEPT;

    /// Right-handed cross product
    IMATH_HOSTDEVICE IMATH_CONSTEXPR14 const Vec3&
    operator%= (const Vec3& v) IMATH_NOEXCEPT;

    /// Right-handed cross product
    IMATH_HOSTDEVICE constexpr Vec3
    operator% (const Vec3& v) const IMATH_NOEXCEPT;

    /// Component-wise addition
    IMATH_HOSTDEVICE IMATH_CONSTEXPR14 const Vec3&
    operator+= (const Vec3& v) IMATH_NOEXCEPT;

    /// Component-wise addition
    IMATH_HOSTDEVICE constexpr Vec3
    operator+ (const Vec3& v) const IMATH_NOEXCEPT;

    /// Component-wise subtraction
    IMATH_HOSTDEVICE IMATH_CONSTEXPR14 const Vec3&
    operator-= (const Vec3& v) IMATH_NOEXCEPT;

    /// Component-wise subtraction
    IMATH_HOSTDEVICE constexpr Vec3
    operator- (const Vec3& v) const IMATH_NOEXCEPT;

    /// Component-wise multiplication by -1
    IMATH_HOSTDEVICE constexpr Vec3 operator- () const IMATH_NOEXCEPT;

    /// Component-wise multiplication by -1
    IMATH_HOSTDEVICE IMATH_CONSTEXPR14 const Vec3& negate () IMATH_NOEXCEPT;

    /// Component-wise multiplication
    IMATH_HOSTDEVICE IMATH_CONSTEXPR14 const Vec3&
    operator*= (const Vec3& v) IMATH_NOEXCEPT;

    /// Component-wise multiplication
    IMATH_HOSTDEVICE IMATH_CONSTEXPR14 const Vec3&
    operator*= (T a) IMATH_NOEXCEPT;

    /// Component-wise multiplication
    IMATH_HOSTDEVICE constexpr Vec3
    operator* (const Vec3& v) const IMATH_NOEXCEPT;

    /// Component-wise multiplication
    IMATH_HOSTDEVICE constexpr Vec3 operator* (T a) const IMATH_NOEXCEPT;

    /// Component-wise division
    IMATH_HOSTDEVICE IMATH_CONSTEXPR14 const Vec3&
    operator/= (const Vec3& v) IMATH_NOEXCEPT;

    /// Component-wise division
    IMATH_HOSTDEVICE IMATH_CONSTEXPR14 const Vec3&
    operator/= (T a) IMATH_NOEXCEPT;

    /// Component-wise division
    IMATH_HOSTDEVICE constexpr Vec3
    operator/ (const Vec3& v) const IMATH_NOEXCEPT;

    /// Component-wise division
    IMATH_HOSTDEVICE constexpr Vec3 operator/ (T a) const IMATH_NOEXCEPT;

    /// @}

    /// @{
    /// @name Query and Manipulation

    /// Return the Euclidean norm
    IMATH_HOSTDEVICE T length () const IMATH_NOEXCEPT;

    /// Return the square of the Euclidean norm, i.e. the dot product
    /// with itself.
    IMATH_HOSTDEVICE constexpr T length2 () const IMATH_NOEXCEPT;

    /// Normalize in place. If length()==0, return a null vector.
    IMATH_HOSTDEVICE const Vec3& normalize () IMATH_NOEXCEPT;

    /// Normalize in place. If length()==0, throw an exception.
    const Vec3& normalizeExc ();

    /// Normalize without any checks for length()==0. Slightly faster
    /// than the other normalization routines, but if v.length() is
    /// 0.0, the result is undefined.
    IMATH_HOSTDEVICE const Vec3& normalizeNonNull () IMATH_NOEXCEPT;

    /// Return a normalized vector. Does not modify *this.
    IMATH_HOSTDEVICE Vec3<T>
    normalized () const IMATH_NOEXCEPT; // does not modify *this

    /// Return a normalized vector. Does not modify *this. Throw an
    /// exception if length()==0.
    Vec3<T> normalizedExc () const;

    /// Return a normalized vector. Does not modify *this, and does
    /// not check for length()==0. Slightly faster than the other
    /// normalization routines, but if v.length() is 0.0, the result
    /// is undefined.
    IMATH_HOSTDEVICE Vec3<T> normalizedNonNull () const IMATH_NOEXCEPT;

    /// @}

    /// @{
    /// @name Numeric Limits

    /// Largest possible negative value
    IMATH_HOSTDEVICE constexpr static T baseTypeLowest () IMATH_NOEXCEPT
    {
        return std::numeric_limits<T>::lowest ();
    }

    /// Largest possible positive value
    IMATH_HOSTDEVICE constexpr static T baseTypeMax () IMATH_NOEXCEPT
    {
        return std::numeric_limits<T>::max ();
    }

    /// Smallest possible positive value
    IMATH_HOSTDEVICE constexpr static T baseTypeSmallest () IMATH_NOEXCEPT
    {
        return std::numeric_limits<T>::min ();
    }

    /// Smallest possible e for which 1+e != 1
    IMATH_HOSTDEVICE constexpr static T baseTypeEpsilon () IMATH_NOEXCEPT
    {
        return std::numeric_limits<T>::epsilon ();
    }

    /// @}

    /// Return the number of dimensions, i.e. 3
    IMATH_HOSTDEVICE constexpr static unsigned int dimensions () IMATH_NOEXCEPT
    {
        return 3;
    }

    /// The base type: In templates that accept a parameter `V`, you
    /// can refer to `T` as `V::BaseType`
    typedef T BaseType;

private:
    IMATH_HOSTDEVICE IMATH_CONSTEXPR14 T lengthTiny () const IMATH_NOEXCEPT;
};

///
/// 4-element vector
///

template <class T> class IMATH_EXPORT_TEMPLATE_TYPE Vec4
{
public:
    /// @{
    /// @name Direct access to elements

    T x, y, z, w;

    /// @}

    /// Element access by index.
    ///
    /// NB: This method of access uses dynamic array accesses which
    /// can prevent compiler optimizations and force temporaries to be
    /// stored to the stack and other missed vectorization
    /// opportunities. Use of direct access to x, y, z, w when
    /// possible should be preferred.
    IMATH_HOSTDEVICE IMATH_CONSTEXPR14 T& operator[] (int i) IMATH_NOEXCEPT;

    /// Element access by index.
    ///
    /// NB: This method of access uses dynamic array accesses which
    /// can prevent compiler optimizations and force temporaries to be
    /// stored to the stack and other missed vectorization
    /// opportunities. Use of direct access to x, y, z, w when
    /// possible should be preferred.
    IMATH_HOSTDEVICE constexpr const T& operator[] (int i) const IMATH_NOEXCEPT;

    /// @{
    ///	@name Constructors and Assignment

    /// Uninitialized by default
    IMATH_HOSTDEVICE Vec4 () IMATH_NOEXCEPT; // no initialization

    /// Initialize to a scalar `(a,a,a,a)`
    IMATH_HOSTDEVICE constexpr explicit Vec4 (T a) IMATH_NOEXCEPT;

    /// Initialize to given elements `(a,b,c,d)`
    IMATH_HOSTDEVICE constexpr Vec4 (T a, T b, T c, T d) IMATH_NOEXCEPT;

    /// Copy constructor
    IMATH_HOSTDEVICE constexpr Vec4 (const Vec4& v) IMATH_NOEXCEPT;

    /// Construct from Vec4 of another base type
    template <class S>
    IMATH_HOSTDEVICE constexpr Vec4 (const Vec4<S>& v) IMATH_NOEXCEPT;

    /// Vec3 to Vec4 conversion, sets w to 1.
    template <class S>
    IMATH_HOSTDEVICE explicit constexpr Vec4 (const Vec3<S>& v) IMATH_NOEXCEPT;

    /// Assignment
    IMATH_HOSTDEVICE IMATH_CONSTEXPR14 const Vec4&
    operator= (const Vec4& v) IMATH_NOEXCEPT;

    /// Destructor
    ~Vec4 () IMATH_NOEXCEPT = default;

    /// @}

#if IMATH_FOREIGN_VECTOR_INTEROP
    /// @{
    /// @name Interoperability with other vector types
    ///
    /// Construction and assignment are allowed from other classes that
    /// appear to be equivalent vector types, provided that they have either
    /// a subscripting operator, or data members .x, .y, .z, .w that are of
    /// the same type as the elements of this vector, and their size appears
    /// to be the right number of elements.
    ///
    /// This functionality is disabled for gcc 4.x, which seems to have a
    /// compiler bug that results in spurious errors. It can also be
    /// disabled by defining IMATH_FOREIGN_VECTOR_INTEROP to be 0 prior to
    /// including any Imath header files.
    ///

    template <typename V, IMATH_ENABLE_IF (has_xyzw<V, T>::value)>
    IMATH_HOSTDEVICE explicit constexpr Vec4 (const V& v) IMATH_NOEXCEPT
        : Vec4 (T (v.x), T (v.y), T (v.z), T (v.w))
    {}

    template <
        typename V,
        IMATH_ENABLE_IF (
            has_subscript<V, T, 4>::value && !has_xyzw<V, T>::value)>
    IMATH_HOSTDEVICE explicit Vec4 (const V& v)
        : Vec4 (T (v[0]), T (v[1]), T (v[2]), T (v[3]))
    {}

    template <typename V, IMATH_ENABLE_IF (has_xyzw<V, T>::value)>
    IMATH_HOSTDEVICE IMATH_CONSTEXPR14 const Vec4&
    operator= (const V& v) IMATH_NOEXCEPT
    {
        x = T (v.x);
        y = T (v.y);
        z = T (v.z);
        w = T (v.w);
        return *this;
    }

    template <
        typename V,
        IMATH_ENABLE_IF (
            has_subscript<V, T, 4>::value && !has_xyzw<V, T>::value)>
    IMATH_HOSTDEVICE const Vec4& operator= (const V& v)
    {
        x = T (v[0]);
        y = T (v[1]);
        z = T (v[2]);
        w = T (v[3]);
        return *this;
    }
    /// @}
#endif

    /// @{
    /// @name Compatibility with Sb

    /// Set the value
    template <class S> IMATH_HOSTDEVICE void setValue (S a, S b, S c, S d) IMATH_NOEXCEPT;

    /// Set the value
    template <class S>
    IMATH_HOSTDEVICE void setValue (const Vec4<S>& v) IMATH_NOEXCEPT;

    /// Return the value in `a` and `b`
    template <class S>
    IMATH_HOSTDEVICE void getValue (S& a, S& b, S& c, S& d) const IMATH_NOEXCEPT;

    /// Return the value in `v`
    template <class S>
    IMATH_HOSTDEVICE void getValue (Vec4<S>& v) const IMATH_NOEXCEPT;

    /// Return a raw pointer to the array of values
    IMATH_HOSTDEVICE T* getValue () IMATH_NOEXCEPT;

    /// Return a raw pointer to the array of values
    IMATH_HOSTDEVICE const T* getValue () const IMATH_NOEXCEPT;

    /// @}

    /// @{
    /// @name Arithmetic and Comparison

    /// Equality
    template <class S>
    IMATH_HOSTDEVICE constexpr bool
    operator== (const Vec4<S>& v) const IMATH_NOEXCEPT;

    /// Inequality
    template <class S>
    IMATH_HOSTDEVICE constexpr bool
    operator!= (const Vec4<S>& v) const IMATH_NOEXCEPT;

    /// Compare two vectors and test if they are "approximately equal":
    /// @return True if the components of this and `v` are the same
    /// with an absolute error of no more than e, i.e., for all i:
    ///
    ///     abs (this[i] - v[i]) <= e
    IMATH_HOSTDEVICE IMATH_CONSTEXPR14 bool
    equalWithAbsError (const Vec4<T>& v, T e) const IMATH_NOEXCEPT;

    /// Compare two vectors and test if they are "approximately equal":
    /// @return True if the components of this and `v` are the same with
    /// a relative error of no more than e, i.e., for all i:
    ///
    ///     abs (this[i] - v[i]) <= e * abs (this[i])
    IMATH_HOSTDEVICE IMATH_CONSTEXPR14 bool
    equalWithRelError (const Vec4<T>& v, T e) const IMATH_NOEXCEPT;

    /// Dot product
    IMATH_HOSTDEVICE constexpr T dot (const Vec4& v) const IMATH_NOEXCEPT;

    /// Dot product
    IMATH_HOSTDEVICE constexpr T operator^ (const Vec4& v) const IMATH_NOEXCEPT;

    /// Component-wise addition
    IMATH_HOSTDEVICE IMATH_CONSTEXPR14 const Vec4&
    operator+= (const Vec4& v) IMATH_NOEXCEPT;

    /// Component-wise addition
    IMATH_HOSTDEVICE constexpr Vec4
    operator+ (const Vec4& v) const IMATH_NOEXCEPT;

    /// Component-wise subtraction
    IMATH_HOSTDEVICE IMATH_CONSTEXPR14 const Vec4&
    operator-= (const Vec4& v) IMATH_NOEXCEPT;

    /// Component-wise subtraction
    IMATH_HOSTDEVICE constexpr Vec4
    operator- (const Vec4& v) const IMATH_NOEXCEPT;

    /// Component-wise multiplication by -1
    IMATH_HOSTDEVICE constexpr Vec4 operator- () const IMATH_NOEXCEPT;

    /// Component-wise multiplication by -1
    IMATH_HOSTDEVICE IMATH_CONSTEXPR14 const Vec4& negate () IMATH_NOEXCEPT;

    /// Component-wise multiplication
    IMATH_HOSTDEVICE IMATH_CONSTEXPR14 const Vec4&
    operator*= (const Vec4& v) IMATH_NOEXCEPT;

    /// Component-wise multiplication
    IMATH_HOSTDEVICE IMATH_CONSTEXPR14 const Vec4&
    operator*= (T a) IMATH_NOEXCEPT;

    /// Component-wise multiplication
    IMATH_HOSTDEVICE constexpr Vec4
    operator* (const Vec4& v) const IMATH_NOEXCEPT;

    /// Component-wise multiplication
    IMATH_HOSTDEVICE constexpr Vec4 operator* (T a) const IMATH_NOEXCEPT;

    /// Component-wise division
    IMATH_HOSTDEVICE IMATH_CONSTEXPR14 const Vec4&
    operator/= (const Vec4& v) IMATH_NOEXCEPT;

    /// Component-wise division
    IMATH_HOSTDEVICE IMATH_CONSTEXPR14 const Vec4&
    operator/= (T a) IMATH_NOEXCEPT;

    /// Component-wise division
    IMATH_HOSTDEVICE constexpr Vec4
    operator/ (const Vec4& v) const IMATH_NOEXCEPT;

    /// Component-wise division
    IMATH_HOSTDEVICE constexpr Vec4 operator/ (T a) const IMATH_NOEXCEPT;

    /// @}

    /// @{
    /// @name Query and Manipulation

    /// Return the Euclidean norm
    IMATH_HOSTDEVICE T length () const IMATH_NOEXCEPT;

    /// Return the square of the Euclidean norm, i.e. the dot product
    /// with itself.
    IMATH_HOSTDEVICE constexpr T length2 () const IMATH_NOEXCEPT;

    /// Normalize in place. If length()==0, return a null vector.
    IMATH_HOSTDEVICE const Vec4& normalize () IMATH_NOEXCEPT; // modifies *this

    /// Normalize in place. If length()==0, throw an exception.
    const Vec4& normalizeExc ();

    /// Normalize without any checks for length()==0. Slightly faster
    /// than the other normalization routines, but if v.length() is
    /// 0.0, the result is undefined.
    IMATH_HOSTDEVICE const Vec4& normalizeNonNull () IMATH_NOEXCEPT;

    /// Return a normalized vector. Does not modify *this.
    IMATH_HOSTDEVICE Vec4<T>
    normalized () const IMATH_NOEXCEPT; // does not modify *this

    /// Return a normalized vector. Does not modify *this. Throw an
    /// exception if length()==0.
    Vec4<T> normalizedExc () const;

    /// Return a normalized vector. Does not modify *this, and does
    /// not check for length()==0. Slightly faster than the other
    /// normalization routines, but if v.length() is 0.0, the result
    /// is undefined.
    IMATH_HOSTDEVICE Vec4<T> normalizedNonNull () const IMATH_NOEXCEPT;

    /// @}

    /// @{
    /// @name Numeric Limits

    /// Largest possible negative value
    IMATH_HOSTDEVICE constexpr static T baseTypeLowest () IMATH_NOEXCEPT
    {
        return std::numeric_limits<T>::lowest ();
    }

    /// Largest possible positive value
    IMATH_HOSTDEVICE constexpr static T baseTypeMax () IMATH_NOEXCEPT
    {
        return std::numeric_limits<T>::max ();
    }

    /// Smallest possible positive value
    IMATH_HOSTDEVICE constexpr static T baseTypeSmallest () IMATH_NOEXCEPT
    {
        return std::numeric_limits<T>::min ();
    }

    /// Smallest possible e for which 1+e != 1
    IMATH_HOSTDEVICE constexpr static T baseTypeEpsilon () IMATH_NOEXCEPT
    {
        return std::numeric_limits<T>::epsilon ();
    }

    /// @}

    /// Return the number of dimensions, i.e. 4
    IMATH_HOSTDEVICE constexpr static unsigned int dimensions () IMATH_NOEXCEPT
    {
        return 4;
    }

    /// The base type: In templates that accept a parameter `V`, you
    /// can refer to `T` as `V::BaseType`
    typedef T BaseType;

private:
    IMATH_HOSTDEVICE IMATH_CONSTEXPR14 T lengthTiny () const IMATH_NOEXCEPT;
};

/// Stream output, as "(x y)"
template <class T> std::ostream& operator<< (std::ostream& s, const Vec2<T>& v);

/// Stream output, as "(x y z)"
template <class T> std::ostream& operator<< (std::ostream& s, const Vec3<T>& v);

/// Stream output, as "(x y z w)"
template <class T> std::ostream& operator<< (std::ostream& s, const Vec4<T>& v);

/// Reverse multiplication: S * Vec2<T>
template <class T>
IMATH_HOSTDEVICE constexpr Vec2<T>
operator* (T a, const Vec2<T>& v) IMATH_NOEXCEPT;

/// Reverse multiplication: S * Vec3<T>
template <class T>
IMATH_HOSTDEVICE constexpr Vec3<T>
operator* (T a, const Vec3<T>& v) IMATH_NOEXCEPT;

/// Reverse multiplication: S * Vec4<T>
template <class T>
IMATH_HOSTDEVICE constexpr Vec4<T>
operator* (T a, const Vec4<T>& v) IMATH_NOEXCEPT;

//-------------------------
// Typedefs for convenience
//-------------------------

/// Vec2 of half
typedef Vec2<half> V2h;

/// Vec2 of short
typedef Vec2<short> V2s;

/// Vec2 of integer
typedef Vec2<int> V2i;

/// Vec2 of int64_t
typedef Vec2<int64_t> V2i64;

/// Vec2 of float
typedef Vec2<float> V2f;

/// Vec2 of double
typedef Vec2<double> V2d;

/// Vec3 of half
typedef Vec3<half> V3h;

/// Vec3 of short
typedef Vec3<short> V3s;

/// Vec3 of integer
typedef Vec3<int> V3i;

/// Vec3 of int64_t
typedef Vec3<int64_t> V3i64;

/// Vec3 of float
typedef Vec3<float> V3f;

/// Vec3 of double
typedef Vec3<double> V3d;

/// Vec4 of half
typedef Vec4<half> V4h;

/// Vec4 of short
typedef Vec4<short> V4s;

/// Vec4 of integer
typedef Vec4<int> V4i;

/// Vec4 of int64_t
typedef Vec4<int64_t> V4i64;

/// Vec4 of float
typedef Vec4<float> V4f;

/// Vec4 of double
typedef Vec4<double> V4d;

//----------------------------------------------------------------------------
// Specializations for VecN<short>, VecN<int>
//
// Normalize and length don't make sense for integer vectors, so disable them.
//----------------------------------------------------------------------------

/// @cond Doxygen_Suppress

// Vec2<short>
template <>
IMATH_HOSTDEVICE short Vec2<short>::length () const IMATH_NOEXCEPT = delete;
template <>
IMATH_HOSTDEVICE const Vec2<short>&
                       Vec2<short>::normalize () IMATH_NOEXCEPT = delete;
template <> const Vec2<short>& Vec2<short>::normalizeExc ()     = delete;
template <>
IMATH_HOSTDEVICE const Vec2<short>&
                       Vec2<short>::normalizeNonNull () IMATH_NOEXCEPT = delete;
template <>
IMATH_HOSTDEVICE Vec2<short>
                 Vec2<short>::normalized () const IMATH_NOEXCEPT = delete;
template <> Vec2<short> Vec2<short>::normalizedExc () const      = delete;
template <>
IMATH_HOSTDEVICE Vec2<short>
Vec2<short>::normalizedNonNull () const IMATH_NOEXCEPT = delete;

// Vec2<int>
template <>
IMATH_HOSTDEVICE int Vec2<int>::length () const IMATH_NOEXCEPT = delete;
template <>
IMATH_HOSTDEVICE const       Vec2<int>&
                             Vec2<int>::normalize () IMATH_NOEXCEPT = delete;
template <> const Vec2<int>& Vec2<int>::normalizeExc ()             = delete;
template <>
IMATH_HOSTDEVICE const Vec2<int>&
                       Vec2<int>::normalizeNonNull () IMATH_NOEXCEPT = delete;
template <>
IMATH_HOSTDEVICE      Vec2<int>
                      Vec2<int>::normalized () const IMATH_NOEXCEPT = delete;
template <> Vec2<int> Vec2<int>::normalizedExc () const             = delete;
template <>
IMATH_HOSTDEVICE Vec2<int>
                 Vec2<int>::normalizedNonNull () const IMATH_NOEXCEPT = delete;

// Vec2<int64_t>
template <>
IMATH_HOSTDEVICE int64_t Vec2<int64_t>::length () const IMATH_NOEXCEPT = delete;
template <>
IMATH_HOSTDEVICE const Vec2<int64_t>&
                       Vec2<int64_t>::normalize () IMATH_NOEXCEPT = delete;
template <> const Vec2<int64_t>& Vec2<int64_t>::normalizeExc ()   = delete;
template <>
IMATH_HOSTDEVICE const Vec2<int64_t>&
Vec2<int64_t>::normalizeNonNull () IMATH_NOEXCEPT = delete;
template <>
IMATH_HOSTDEVICE Vec2<int64_t>
                 Vec2<int64_t>::normalized () const IMATH_NOEXCEPT = delete;
template <> Vec2<int64_t> Vec2<int64_t>::normalizedExc () const    = delete;
template <>
IMATH_HOSTDEVICE Vec2<int64_t>
Vec2<int64_t>::normalizedNonNull () const IMATH_NOEXCEPT = delete;

// Vec3<short>
template <>
IMATH_HOSTDEVICE short Vec3<short>::length () const IMATH_NOEXCEPT = delete;
template <>
IMATH_HOSTDEVICE const Vec3<short>&
                       Vec3<short>::normalize () IMATH_NOEXCEPT = delete;
template <> const Vec3<short>& Vec3<short>::normalizeExc ()     = delete;
template <>
IMATH_HOSTDEVICE const Vec3<short>&
                       Vec3<short>::normalizeNonNull () IMATH_NOEXCEPT = delete;
template <>
IMATH_HOSTDEVICE Vec3<short>
                 Vec3<short>::normalized () const IMATH_NOEXCEPT = delete;
template <> Vec3<short> Vec3<short>::normalizedExc () const      = delete;
template <>
IMATH_HOSTDEVICE Vec3<short>
Vec3<short>::normalizedNonNull () const IMATH_NOEXCEPT = delete;

// Vec3<int>
template <>
IMATH_HOSTDEVICE int Vec3<int>::length () const IMATH_NOEXCEPT = delete;
template <>
IMATH_HOSTDEVICE const       Vec3<int>&
                             Vec3<int>::normalize () IMATH_NOEXCEPT = delete;
template <> const Vec3<int>& Vec3<int>::normalizeExc ()             = delete;
template <>
IMATH_HOSTDEVICE const Vec3<int>&
                       Vec3<int>::normalizeNonNull () IMATH_NOEXCEPT = delete;
template <>
IMATH_HOSTDEVICE      Vec3<int>
                      Vec3<int>::normalized () const IMATH_NOEXCEPT = delete;
template <> Vec3<int> Vec3<int>::normalizedExc () const             = delete;
template <>
IMATH_HOSTDEVICE Vec3<int>
                 Vec3<int>::normalizedNonNull () const IMATH_NOEXCEPT = delete;

// Vec3<int64_t>
template <>
IMATH_HOSTDEVICE int64_t Vec3<int64_t>::length () const IMATH_NOEXCEPT = delete;
template <>
IMATH_HOSTDEVICE const Vec3<int64_t>&
                       Vec3<int64_t>::normalize () IMATH_NOEXCEPT = delete;
template <> const Vec3<int64_t>& Vec3<int64_t>::normalizeExc ()   = delete;
template <>
IMATH_HOSTDEVICE const Vec3<int64_t>&
Vec3<int64_t>::normalizeNonNull () IMATH_NOEXCEPT = delete;
template <>
IMATH_HOSTDEVICE Vec3<int64_t>
                 Vec3<int64_t>::normalized () const IMATH_NOEXCEPT = delete;
template <> Vec3<int64_t> Vec3<int64_t>::normalizedExc () const    = delete;
template <>
IMATH_HOSTDEVICE Vec3<int64_t>
Vec3<int64_t>::normalizedNonNull () const IMATH_NOEXCEPT = delete;

// Vec4<short>
template <>
IMATH_HOSTDEVICE short Vec4<short>::length () const IMATH_NOEXCEPT = delete;
template <>
IMATH_HOSTDEVICE const Vec4<short>&
                       Vec4<short>::normalize () IMATH_NOEXCEPT = delete;
template <> const Vec4<short>& Vec4<short>::normalizeExc ()     = delete;
template <>
IMATH_HOSTDEVICE const Vec4<short>&
                       Vec4<short>::normalizeNonNull () IMATH_NOEXCEPT = delete;
template <>
IMATH_HOSTDEVICE Vec4<short>
                 Vec4<short>::normalized () const IMATH_NOEXCEPT = delete;
template <> Vec4<short> Vec4<short>::normalizedExc () const      = delete;
template <>
IMATH_HOSTDEVICE Vec4<short>
Vec4<short>::normalizedNonNull () const IMATH_NOEXCEPT = delete;

// Vec4<int>
template <>
IMATH_HOSTDEVICE int Vec4<int>::length () const IMATH_NOEXCEPT = delete;
template <>
IMATH_HOSTDEVICE const       Vec4<int>&
                             Vec4<int>::normalize () IMATH_NOEXCEPT = delete;
template <> const Vec4<int>& Vec4<int>::normalizeExc ()             = delete;
template <>
IMATH_HOSTDEVICE const Vec4<int>&
                       Vec4<int>::normalizeNonNull () IMATH_NOEXCEPT = delete;
template <>
IMATH_HOSTDEVICE      Vec4<int>
                      Vec4<int>::normalized () const IMATH_NOEXCEPT = delete;
template <> Vec4<int> Vec4<int>::normalizedExc () const             = delete;
template <>
IMATH_HOSTDEVICE Vec4<int>
                 Vec4<int>::normalizedNonNull () const IMATH_NOEXCEPT = delete;

// Vec4<int64_t>
template <>
IMATH_HOSTDEVICE int64_t Vec4<int64_t>::length () const IMATH_NOEXCEPT = delete;
template <>
IMATH_HOSTDEVICE const Vec4<int64_t>&
                       Vec4<int64_t>::normalize () IMATH_NOEXCEPT = delete;
template <> const Vec4<int64_t>& Vec4<int64_t>::normalizeExc ()   = delete;
template <>
IMATH_HOSTDEVICE const Vec4<int64_t>&
Vec4<int64_t>::normalizeNonNull () IMATH_NOEXCEPT = delete;
template <>
IMATH_HOSTDEVICE Vec4<int64_t>
                 Vec4<int64_t>::normalized () const IMATH_NOEXCEPT = delete;
template <> Vec4<int64_t> Vec4<int64_t>::normalizedExc () const    = delete;
template <>
IMATH_HOSTDEVICE Vec4<int64_t>
Vec4<int64_t>::normalizedNonNull () const IMATH_NOEXCEPT = delete;

/// @endcond Doxygen_Suppress

//------------------------
// Implementation of Vec2:
//------------------------

template <class T>
IMATH_CONSTEXPR14 IMATH_HOSTDEVICE inline T&
Vec2<T>::operator[] (int i) IMATH_NOEXCEPT
{
    return reinterpret_cast<T*> (this)[i];
}

template <class T>
constexpr IMATH_HOSTDEVICE inline const T&
Vec2<T>::operator[] (int i) const IMATH_NOEXCEPT
{
#ifdef __cpp_if_consteval
    if consteval
    {
        return (i == 0) ? x : y;
    }
    else
    {
        return reinterpret_cast<const T*> (this)[i];
    }
#else
    return reinterpret_cast<const T*> (this)[i];
#endif
}

template <class T> IMATH_HOSTDEVICE inline Vec2<T>::Vec2 () IMATH_NOEXCEPT
{
    // empty, and not constexpr because data is uninitialized.
}

template <class T>
IMATH_HOSTDEVICE constexpr inline Vec2<T>::Vec2 (T a) IMATH_NOEXCEPT : x (a),
                                                                       y (a)
{}

template <class T>
IMATH_HOSTDEVICE constexpr inline Vec2<T>::Vec2 (T a, T b) IMATH_NOEXCEPT
    : x (a),
      y (b)
{}

template <class T>
IMATH_HOSTDEVICE constexpr inline Vec2<T>::Vec2 (const Vec2& v) IMATH_NOEXCEPT
    : x (v.x),
      y (v.y)
{}

template <class T>
template <class S>
IMATH_HOSTDEVICE constexpr inline Vec2<T>::Vec2 (const Vec2<S>& v)
    IMATH_NOEXCEPT : x (T (v.x)),
                     y (T (v.y))
{}

template <class T>
IMATH_CONSTEXPR14 IMATH_HOSTDEVICE inline const Vec2<T>&
Vec2<T>::operator= (const Vec2& v) IMATH_NOEXCEPT
{
    x = v.x;
    y = v.y;
    return *this;
}

template <class T>
template <class S>
IMATH_HOSTDEVICE inline void
Vec2<T>::setValue (S a, S b) IMATH_NOEXCEPT
{
    x = T (a);
    y = T (b);
}

template <class T>
template <class S>
IMATH_HOSTDEVICE inline void
Vec2<T>::setValue (const Vec2<S>& v) IMATH_NOEXCEPT
{
    x = T (v.x);
    y = T (v.y);
}

template <class T>
template <class S>
IMATH_HOSTDEVICE inline void
Vec2<T>::getValue (S& a, S& b) const IMATH_NOEXCEPT
{
    a = S (x);
    b = S (y);
}

template <class T>
template <class S>
IMATH_HOSTDEVICE inline void
Vec2<T>::getValue (Vec2<S>& v) const IMATH_NOEXCEPT
{
    v.x = S (x);
    v.y = S (y);
}

template <class T>
IMATH_HOSTDEVICE inline T*
Vec2<T>::getValue () IMATH_NOEXCEPT
{
    return reinterpret_cast<T*> (this);
}

template <class T>
IMATH_HOSTDEVICE inline const T*
Vec2<T>::getValue () const IMATH_NOEXCEPT
{
    return reinterpret_cast<const T*> (this);
}

template <class T>
template <class S>
IMATH_HOSTDEVICE constexpr inline bool
Vec2<T>::operator== (const Vec2<S>& v) const IMATH_NOEXCEPT
{
    return x == v.x && y == v.y;
}

template <class T>
template <class S>
IMATH_HOSTDEVICE constexpr inline bool
Vec2<T>::operator!= (const Vec2<S>& v) const IMATH_NOEXCEPT
{
    return x != v.x || y != v.y;
}

template <class T>
IMATH_HOSTDEVICE IMATH_CONSTEXPR14 inline bool
Vec2<T>::equalWithAbsError (const Vec2<T>& v, T e) const IMATH_NOEXCEPT
{
    if (!IMATH_INTERNAL_NAMESPACE::equalWithAbsError (x, v.x, e))
            return false;
    if (!IMATH_INTERNAL_NAMESPACE::equalWithAbsError (y, v.y, e))
            return false;

    return true;
}

template <class T>
IMATH_HOSTDEVICE IMATH_CONSTEXPR14 inline bool
Vec2<T>::equalWithRelError (const Vec2<T>& v, T e) const IMATH_NOEXCEPT
{
    if (!IMATH_INTERNAL_NAMESPACE::equalWithRelError (x, v.x, e))
        return false;
    if (!IMATH_INTERNAL_NAMESPACE::equalWithRelError (y, v.y, e))
        return false;

    return true;
}

template <class T>
IMATH_HOSTDEVICE constexpr inline T
Vec2<T>::dot (const Vec2& v) const IMATH_NOEXCEPT
{
    return x * v.x + y * v.y;
}

template <class T>
IMATH_HOSTDEVICE constexpr inline T
Vec2<T>::operator^ (const Vec2& v) const IMATH_NOEXCEPT
{
    return dot (v);
}

template <class T>
IMATH_HOSTDEVICE constexpr inline T
Vec2<T>::cross (const Vec2& v) const IMATH_NOEXCEPT
{
    return x * v.y - y * v.x;
}

template <class T>
IMATH_HOSTDEVICE constexpr inline T
Vec2<T>::operator% (const Vec2& v) const IMATH_NOEXCEPT
{
    return x * v.y - y * v.x;
}

template <class T>
IMATH_HOSTDEVICE IMATH_CONSTEXPR14 inline const Vec2<T>&
Vec2<T>::operator+= (const Vec2& v) IMATH_NOEXCEPT
{
    x += v.x;
    y += v.y;
    return *this;
}

template <class T>
IMATH_HOSTDEVICE constexpr inline Vec2<T>
Vec2<T>::operator+ (const Vec2& v) const IMATH_NOEXCEPT
{
    return Vec2 (x + v.x, y + v.y);
}

template <class T>
IMATH_HOSTDEVICE IMATH_CONSTEXPR14 inline const Vec2<T>&
Vec2<T>::operator-= (const Vec2& v) IMATH_NOEXCEPT
{
    x -= v.x;
    y -= v.y;
    return *this;
}

template <class T>
IMATH_HOSTDEVICE constexpr inline Vec2<T>
Vec2<T>::operator- (const Vec2& v) const IMATH_NOEXCEPT
{
    return Vec2 (x - v.x, y - v.y);
}

template <class T>
IMATH_HOSTDEVICE constexpr inline Vec2<T>
Vec2<T>::operator- () const IMATH_NOEXCEPT
{
    return Vec2 (-x, -y);
}

template <class T>
IMATH_HOSTDEVICE IMATH_CONSTEXPR14 inline const Vec2<T>&
                 Vec2<T>::negate () IMATH_NOEXCEPT
{
    x = -x;
    y = -y;
    return *this;
}

template <class T>
IMATH_HOSTDEVICE IMATH_CONSTEXPR14 inline const Vec2<T>&
Vec2<T>::operator*= (const Vec2& v) IMATH_NOEXCEPT
{
    x *= v.x;
    y *= v.y;
    return *this;
}

template <class T>
IMATH_HOSTDEVICE IMATH_CONSTEXPR14 inline const Vec2<T>&
Vec2<T>::operator*= (T a) IMATH_NOEXCEPT
{
    x *= a;
    y *= a;
    return *this;
}

template <class T>
IMATH_HOSTDEVICE constexpr inline Vec2<T>
Vec2<T>::operator* (const Vec2& v) const IMATH_NOEXCEPT
{
    return Vec2 (x * v.x, y * v.y);
}

template <class T>
IMATH_HOSTDEVICE constexpr inline Vec2<T>
Vec2<T>::operator* (T a) const IMATH_NOEXCEPT
{
    return Vec2 (x * a, y * a);
}

template <class T>
IMATH_HOSTDEVICE IMATH_CONSTEXPR14 inline const Vec2<T>&
Vec2<T>::operator/= (const Vec2& v) IMATH_NOEXCEPT
{
    x /= v.x;
    y /= v.y;
    return *this;
}

template <class T>
IMATH_HOSTDEVICE IMATH_CONSTEXPR14 inline const Vec2<T>&
Vec2<T>::operator/= (T a) IMATH_NOEXCEPT
{
    x /= a;
    y /= a;
    return *this;
}

template <class T>
IMATH_HOSTDEVICE constexpr inline Vec2<T>
Vec2<T>::operator/ (const Vec2& v) const IMATH_NOEXCEPT
{
    return Vec2 (x / v.x, y / v.y);
}

template <class T>
IMATH_HOSTDEVICE constexpr inline Vec2<T>
Vec2<T>::operator/ (T a) const IMATH_NOEXCEPT
{
    return Vec2 (x / a, y / a);
}

template <class T>
IMATH_HOSTDEVICE IMATH_CONSTEXPR14 inline T
Vec2<T>::lengthTiny () const IMATH_NOEXCEPT
{
    T absX = std::abs (x);
    T absY = std::abs (y);

    T max = absX;

    if (max < absY) max = absY;

    if (IMATH_UNLIKELY (max == T (0))) return T (0);

    //
    // Do not replace the divisions by max with multiplications by 1/max.
    // Computing 1/max can overflow but the divisions below will always
    // produce results less than or equal to 1.
    //

    absX /= max;
    absY /= max;

    return max * std::sqrt (absX * absX + absY * absY);
}

template <class T>
IMATH_HOSTDEVICE inline T
Vec2<T>::length () const IMATH_NOEXCEPT
{
    T length2 = dot (*this);

    if (IMATH_UNLIKELY (length2 < T (2) * std::numeric_limits<T>::min ()))
        return lengthTiny ();

    return std::sqrt (length2);
}

template <class T>
IMATH_HOSTDEVICE constexpr inline T
Vec2<T>::length2 () const IMATH_NOEXCEPT
{
    return dot (*this);
}

template <class T>
IMATH_HOSTDEVICE inline const Vec2<T>&
Vec2<T>::normalize () IMATH_NOEXCEPT
{
    T l = length ();

    if (IMATH_LIKELY (l != T (0)))
    {
        //
        // Do not replace the divisions by l with multiplications by 1/l.
        // Computing 1/l can overflow but the divisions below will always
        // produce results less than or equal to 1.
        //

        x /= l;
        y /= l;
    }

    return *this;
}

template <class T>
inline const Vec2<T>&
Vec2<T>::normalizeExc ()
{
    T l = length ();

    if (IMATH_UNLIKELY (l == T (0)))
        throw std::domain_error ("Cannot normalize null vector.");

    x /= l;
    y /= l;
    return *this;
}

template <class T>
IMATH_HOSTDEVICE inline const Vec2<T>&
Vec2<T>::normalizeNonNull () IMATH_NOEXCEPT
{
    T l = length ();
    x /= l;
    y /= l;
    return *this;
}

template <class T>
IMATH_HOSTDEVICE inline Vec2<T>
Vec2<T>::normalized () const IMATH_NOEXCEPT
{
    T l = length ();

    if (IMATH_UNLIKELY (l == T (0))) return Vec2 (T (0));

    return Vec2 (x / l, y / l);
}

template <class T>
inline Vec2<T>
Vec2<T>::normalizedExc () const
{
    T l = length ();

    if (IMATH_UNLIKELY (l == T (0)))
        throw std::domain_error ("Cannot normalize null vector.");

    return Vec2 (x / l, y / l);
}

template <class T>
IMATH_HOSTDEVICE inline Vec2<T>
Vec2<T>::normalizedNonNull () const IMATH_NOEXCEPT
{
    T l = length ();
    return Vec2 (x / l, y / l);
}

//-----------------------
// Implementation of Vec3
//-----------------------

template <class T>
IMATH_HOSTDEVICE IMATH_CONSTEXPR14 inline T&
Vec3<T>::operator[] (int i) IMATH_NOEXCEPT
{
    return reinterpret_cast<T*> (this)[i];
}

template <class T>
constexpr IMATH_HOSTDEVICE inline const T&
Vec3<T>::operator[] (int i) const IMATH_NOEXCEPT
{
#ifdef __cpp_if_consteval
    if consteval
    {
        return (i == 0) ? x : ((i == 1) ? y : z);
    }
    else
    {
        return reinterpret_cast<const T*> (this)[i];
    }
#else
    return reinterpret_cast<const T*> (this)[i];
#endif
}

template <class T> IMATH_HOSTDEVICE inline Vec3<T>::Vec3 () IMATH_NOEXCEPT
{
    // empty, and not constexpr because data is uninitialized.
}

template <class T>
IMATH_HOSTDEVICE constexpr inline Vec3<T>::Vec3 (T a) IMATH_NOEXCEPT : x (a),
                                                                       y (a),
                                                                       z (a)
{}

template <class T>
IMATH_HOSTDEVICE constexpr inline Vec3<T>::Vec3 (T a, T b, T c) IMATH_NOEXCEPT
    : x (a),
      y (b),
      z (c)
{}

template <class T>
IMATH_HOSTDEVICE constexpr inline Vec3<T>::Vec3 (const Vec3& v) IMATH_NOEXCEPT
    : x (v.x),
      y (v.y),
      z (v.z)
{}

template <class T>
template <class S>
IMATH_HOSTDEVICE constexpr inline Vec3<T>::Vec3 (const Vec3<S>& v)
    IMATH_NOEXCEPT : x (T (v.x)),
                     y (T (v.y)),
                     z (T (v.z))
{}

template <class T>
IMATH_HOSTDEVICE IMATH_CONSTEXPR14 inline const Vec3<T>&
Vec3<T>::operator= (const Vec3& v) IMATH_NOEXCEPT
{
    x = v.x;
    y = v.y;
    z = v.z;
    return *this;
}

template <class T>
template <class S>
IMATH_HOSTDEVICE constexpr inline Vec3<T>::Vec3 (const Vec4<S>& v)
    IMATH_NOEXCEPT : x (T (v.x / v.w)),
                     y (T (v.y / v.w)),
                     z (T (v.z / v.w))
{}

template <class T>
template <class S>
IMATH_HOSTDEVICE
    IMATH_CONSTEXPR14 inline Vec3<T>::Vec3 (const Vec4<S>& v, InfException)
{
    T vx = T (v.x);
    T vy = T (v.y);
    T vz = T (v.z);
    T vw = T (v.w);

    T absW = (vw >= T (0)) ? vw : -vw;

    if (absW < 1)
    {
        T m = baseTypeMax () * absW;

        if (vx <= -m || vx >= m || vy <= -m || vy >= m || vz <= -m || vz >= m)
            throw std::domain_error ("Cannot normalize point at infinity.");
    }

    x = vx / vw;
    y = vy / vw;
    z = vz / vw;
}

template <class T>
template <class S>
IMATH_HOSTDEVICE inline void
Vec3<T>::setValue (S a, S b, S c) IMATH_NOEXCEPT
{
    x = T (a);
    y = T (b);
    z = T (c);
}

template <class T>
template <class S>
IMATH_HOSTDEVICE inline void
Vec3<T>::setValue (const Vec3<S>& v) IMATH_NOEXCEPT
{
    x = T (v.x);
    y = T (v.y);
    z = T (v.z);
}

template <class T>
template <class S>
IMATH_HOSTDEVICE inline void
Vec3<T>::getValue (S& a, S& b, S& c) const IMATH_NOEXCEPT
{
    a = S (x);
    b = S (y);
    c = S (z);
}

template <class T>
template <class S>
IMATH_HOSTDEVICE inline void
Vec3<T>::getValue (Vec3<S>& v) const IMATH_NOEXCEPT
{
    v.x = S (x);
    v.y = S (y);
    v.z = S (z);
}

template <class T>
IMATH_HOSTDEVICE inline T*
Vec3<T>::getValue () IMATH_NOEXCEPT
{
    return reinterpret_cast<T*> (this);
}

template <class T>
IMATH_HOSTDEVICE inline const T*
Vec3<T>::getValue () const IMATH_NOEXCEPT
{
    return reinterpret_cast<const T*> (this);
}

template <class T>
template <class S>
IMATH_HOSTDEVICE constexpr inline bool
Vec3<T>::operator== (const Vec3<S>& v) const IMATH_NOEXCEPT
{
    return x == v.x && y == v.y && z == v.z;
}

template <class T>
template <class S>
IMATH_HOSTDEVICE constexpr inline bool
Vec3<T>::operator!= (const Vec3<S>& v) const IMATH_NOEXCEPT
{
    return x != v.x || y != v.y || z != v.z;
}

template <class T>
IMATH_HOSTDEVICE IMATH_CONSTEXPR14 inline bool
Vec3<T>::equalWithAbsError (const Vec3<T>& v, T e) const IMATH_NOEXCEPT
{
    for (int i = 0; i < 3; i++)
        if (!IMATH_INTERNAL_NAMESPACE::equalWithAbsError ((*this)[i], v[i], e))
            return false;

    return true;
}

template <class T>
IMATH_HOSTDEVICE IMATH_CONSTEXPR14 inline bool
Vec3<T>::equalWithRelError (const Vec3<T>& v, T e) const IMATH_NOEXCEPT
{
    for (int i = 0; i < 3; i++)
        if (!IMATH_INTERNAL_NAMESPACE::equalWithRelError ((*this)[i], v[i], e))
            return false;

    return true;
}

template <class T>
IMATH_HOSTDEVICE constexpr inline T
Vec3<T>::dot (const Vec3& v) const IMATH_NOEXCEPT
{
    return x * v.x + y * v.y + z * v.z;
}

template <class T>
IMATH_HOSTDEVICE constexpr inline T
Vec3<T>::operator^ (const Vec3& v) const IMATH_NOEXCEPT
{
    return dot (v);
}

template <class T>
IMATH_HOSTDEVICE constexpr inline Vec3<T>
Vec3<T>::cross (const Vec3& v) const IMATH_NOEXCEPT
{
    return Vec3 (y * v.z - z * v.y, z * v.x - x * v.z, x * v.y - y * v.x);
}

template <class T>
IMATH_HOSTDEVICE IMATH_CONSTEXPR14 inline const Vec3<T>&
Vec3<T>::operator%= (const Vec3& v) IMATH_NOEXCEPT
{
    T a = y * v.z - z * v.y;
    T b = z * v.x - x * v.z;
    T c = x * v.y - y * v.x;
    x   = a;
    y   = b;
    z   = c;
    return *this;
}

template <class T>
IMATH_HOSTDEVICE constexpr inline Vec3<T>
Vec3<T>::operator% (const Vec3& v) const IMATH_NOEXCEPT
{
    return Vec3 (y * v.z - z * v.y, z * v.x - x * v.z, x * v.y - y * v.x);
}

template <class T>
IMATH_HOSTDEVICE IMATH_CONSTEXPR14 inline const Vec3<T>&
Vec3<T>::operator+= (const Vec3& v) IMATH_NOEXCEPT
{
    x += v.x;
    y += v.y;
    z += v.z;
    return *this;
}

template <class T>
IMATH_HOSTDEVICE constexpr inline Vec3<T>
Vec3<T>::operator+ (const Vec3& v) const IMATH_NOEXCEPT
{
    return Vec3 (x + v.x, y + v.y, z + v.z);
}

template <class T>
IMATH_HOSTDEVICE IMATH_CONSTEXPR14 inline const Vec3<T>&
Vec3<T>::operator-= (const Vec3& v) IMATH_NOEXCEPT
{
    x -= v.x;
    y -= v.y;
    z -= v.z;
    return *this;
}

template <class T>
IMATH_HOSTDEVICE constexpr inline Vec3<T>
Vec3<T>::operator- (const Vec3& v) const IMATH_NOEXCEPT
{
    return Vec3 (x - v.x, y - v.y, z - v.z);
}

template <class T>
IMATH_HOSTDEVICE constexpr inline Vec3<T>
Vec3<T>::operator- () const IMATH_NOEXCEPT
{
    return Vec3 (-x, -y, -z);
}

template <class T>
IMATH_HOSTDEVICE IMATH_CONSTEXPR14 inline const Vec3<T>&
                 Vec3<T>::negate () IMATH_NOEXCEPT
{
    x = -x;
    y = -y;
    z = -z;
    return *this;
}

template <class T>
IMATH_HOSTDEVICE IMATH_CONSTEXPR14 inline const Vec3<T>&
Vec3<T>::operator*= (const Vec3& v) IMATH_NOEXCEPT
{
    x *= v.x;
    y *= v.y;
    z *= v.z;
    return *this;
}

template <class T>
IMATH_HOSTDEVICE IMATH_CONSTEXPR14 inline const Vec3<T>&
Vec3<T>::operator*= (T a) IMATH_NOEXCEPT
{
    x *= a;
    y *= a;
    z *= a;
    return *this;
}

template <class T>
IMATH_HOSTDEVICE constexpr inline Vec3<T>
Vec3<T>::operator* (const Vec3& v) const IMATH_NOEXCEPT
{
    return Vec3 (x * v.x, y * v.y, z * v.z);
}

template <class T>
IMATH_HOSTDEVICE constexpr inline Vec3<T>
Vec3<T>::operator* (T a) const IMATH_NOEXCEPT
{
    return Vec3 (x * a, y * a, z * a);
}

template <class T>
IMATH_HOSTDEVICE IMATH_CONSTEXPR14 inline const Vec3<T>&
Vec3<T>::operator/= (const Vec3& v) IMATH_NOEXCEPT
{
    x /= v.x;
    y /= v.y;
    z /= v.z;
    return *this;
}

template <class T>
IMATH_HOSTDEVICE IMATH_CONSTEXPR14 inline const Vec3<T>&
Vec3<T>::operator/= (T a) IMATH_NOEXCEPT
{
    x /= a;
    y /= a;
    z /= a;
    return *this;
}

template <class T>
IMATH_HOSTDEVICE constexpr inline Vec3<T>
Vec3<T>::operator/ (const Vec3& v) const IMATH_NOEXCEPT
{
    return Vec3 (x / v.x, y / v.y, z / v.z);
}

template <class T>
IMATH_HOSTDEVICE constexpr inline Vec3<T>
Vec3<T>::operator/ (T a) const IMATH_NOEXCEPT
{
    return Vec3 (x / a, y / a, z / a);
}

template <class T>
IMATH_HOSTDEVICE IMATH_CONSTEXPR14 inline T
Vec3<T>::lengthTiny () const IMATH_NOEXCEPT
{
    T absX = (x >= T (0)) ? x : -x;
    T absY = (y >= T (0)) ? y : -y;
    T absZ = (z >= T (0)) ? z : -z;

    T max = absX;

    if (max < absY) max = absY;

    if (max < absZ) max = absZ;

    if (IMATH_UNLIKELY (max == T (0))) return T (0);

    //
    // Do not replace the divisions by max with multiplications by 1/max.
    // Computing 1/max can overflow but the divisions below will always
    // produce results less than or equal to 1.
    //

    absX /= max;
    absY /= max;
    absZ /= max;

    return max * std::sqrt (absX * absX + absY * absY + absZ * absZ);
}

template <class T>
IMATH_HOSTDEVICE inline T
Vec3<T>::length () const IMATH_NOEXCEPT
{
    T length2 = dot (*this);

    if (IMATH_UNLIKELY (length2 < T (2) * std::numeric_limits<T>::min ()))
        return lengthTiny ();

    return std::sqrt (length2);
}

template <class T>
IMATH_HOSTDEVICE constexpr inline T
Vec3<T>::length2 () const IMATH_NOEXCEPT
{
    return dot (*this);
}

template <class T>
IMATH_HOSTDEVICE inline const Vec3<T>&
Vec3<T>::normalize () IMATH_NOEXCEPT
{
    T l = length ();

    if (IMATH_LIKELY (l != T (0)))
    {
        //
        // Do not replace the divisions by l with multiplications by 1/l.
        // Computing 1/l can overflow but the divisions below will always
        // produce results less than or equal to 1.
        //

        x /= l;
        y /= l;
        z /= l;
    }

    return *this;
}

template <class T>
inline const Vec3<T>&
Vec3<T>::normalizeExc ()
{
    T l = length ();

    if (IMATH_UNLIKELY (l == T (0)))
        throw std::domain_error ("Cannot normalize null vector.");

    x /= l;
    y /= l;
    z /= l;
    return *this;
}

template <class T>
IMATH_HOSTDEVICE inline const Vec3<T>&
Vec3<T>::normalizeNonNull () IMATH_NOEXCEPT
{
    T l = length ();
    x /= l;
    y /= l;
    z /= l;
    return *this;
}

template <class T>
IMATH_HOSTDEVICE inline Vec3<T>
Vec3<T>::normalized () const IMATH_NOEXCEPT
{
    T l = length ();

    if (IMATH_UNLIKELY ((l == T (0)))) return Vec3 (T (0));

    return Vec3 (x / l, y / l, z / l);
}

template <class T>
inline Vec3<T>
Vec3<T>::normalizedExc () const
{
    T l = length ();

    if (IMATH_UNLIKELY (l == T (0)))
        throw std::domain_error ("Cannot normalize null vector.");

    return Vec3 (x / l, y / l, z / l);
}

template <class T>
IMATH_HOSTDEVICE inline Vec3<T>
Vec3<T>::normalizedNonNull () const IMATH_NOEXCEPT
{
    T l = length ();
    return Vec3 (x / l, y / l, z / l);
}

//-----------------------
// Implementation of Vec4
//-----------------------

template <class T>
IMATH_HOSTDEVICE IMATH_CONSTEXPR14 inline T&
Vec4<T>::operator[] (int i) IMATH_NOEXCEPT
{
    return reinterpret_cast<T*> (this)[i];
}

template <class T>
IMATH_HOSTDEVICE constexpr inline const T&
Vec4<T>::operator[] (int i) const IMATH_NOEXCEPT
{
#ifdef __cpp_if_consteval
    if consteval
    {
        return (i == 0) ? x : ((i == 1) ? y : ((i == 2) ? z : w));
    }
    else
    {
        return reinterpret_cast<const T*> (this)[i];
    }
#else
    return reinterpret_cast<const T*> (this)[i];
#endif
}

template <class T> IMATH_HOSTDEVICE inline Vec4<T>::Vec4 () IMATH_NOEXCEPT
{
    // empty, and not constexpr because data is uninitialized.
}

template <class T>
IMATH_HOSTDEVICE constexpr inline Vec4<T>::Vec4 (T a) IMATH_NOEXCEPT : x (a),
                                                                       y (a),
                                                                       z (a),
                                                                       w (a)
{}

template <class T>
IMATH_HOSTDEVICE constexpr inline Vec4<T>::Vec4 (T a, T b, T c, T d)
    IMATH_NOEXCEPT : x (a),
                     y (b),
                     z (c),
                     w (d)
{}

template <class T>
IMATH_HOSTDEVICE constexpr inline Vec4<T>::Vec4 (const Vec4& v) IMATH_NOEXCEPT
    : x (v.x),
      y (v.y),
      z (v.z),
      w (v.w)
{}

template <class T>
template <class S>
IMATH_HOSTDEVICE constexpr inline Vec4<T>::Vec4 (const Vec4<S>& v)
    IMATH_NOEXCEPT : x (T (v.x)),
                     y (T (v.y)),
                     z (T (v.z)),
                     w (T (v.w))
{}

template <class T>
IMATH_HOSTDEVICE IMATH_CONSTEXPR14 inline const Vec4<T>&
Vec4<T>::operator= (const Vec4& v) IMATH_NOEXCEPT
{
    x = v.x;
    y = v.y;
    z = v.z;
    w = v.w;
    return *this;
}

template <class T>
template <class S>
IMATH_HOSTDEVICE constexpr inline Vec4<T>::Vec4 (const Vec3<S>& v)
    IMATH_NOEXCEPT : x (T (v.x)),
                     y (T (v.y)),
                     z (T (v.z)),
                     w (T (1))
{}

template <class T>
template <class S>
IMATH_HOSTDEVICE inline void
Vec4<T>::setValue (S a, S b, S c, S d) IMATH_NOEXCEPT
{
    x = T (a);
    y = T (b);
    z = T (c);
    w = T (d);
}

template <class T>
template <class S>
IMATH_HOSTDEVICE inline void
Vec4<T>::setValue (const Vec4<S>& v) IMATH_NOEXCEPT
{
    x = T (v.x);
    y = T (v.y);
    z = T (v.z);
    w = T (v.w);
}

template <class T>
template <class S>
IMATH_HOSTDEVICE inline void
Vec4<T>::getValue (S& a, S& b, S& c, S& d) const IMATH_NOEXCEPT
{
    a = S (x);
    b = S (y);
    c = S (z);
    d = S (w);
}

template <class T>
template <class S>
IMATH_HOSTDEVICE inline void
Vec4<T>::getValue (Vec4<S>& v) const IMATH_NOEXCEPT
{
    v.x = S (x);
    v.y = S (y);
    v.z = S (z);
    v.w = S (w);
}

template <class T>
IMATH_HOSTDEVICE inline T*
Vec4<T>::getValue () IMATH_NOEXCEPT
{
    return reinterpret_cast<T*> (this);
}

template <class T>
IMATH_HOSTDEVICE inline const T*
Vec4<T>::getValue () const IMATH_NOEXCEPT
{
    return reinterpret_cast<const T*> (this);
}

template <class T>
template <class S>
IMATH_HOSTDEVICE constexpr inline bool
Vec4<T>::operator== (const Vec4<S>& v) const IMATH_NOEXCEPT
{
    return x == v.x && y == v.y && z == v.z && w == v.w;
}

template <class T>
template <class S>
IMATH_HOSTDEVICE constexpr inline bool
Vec4<T>::operator!= (const Vec4<S>& v) const IMATH_NOEXCEPT
{
    return x != v.x || y != v.y || z != v.z || w != v.w;
}

template <class T>
IMATH_HOSTDEVICE IMATH_CONSTEXPR14 inline bool
Vec4<T>::equalWithAbsError (const Vec4<T>& v, T e) const IMATH_NOEXCEPT
{
    for (int i = 0; i < 4; i++)
        if (!IMATH_INTERNAL_NAMESPACE::equalWithAbsError ((*this)[i], v[i], e))
            return false;

    return true;
}

template <class T>
IMATH_HOSTDEVICE IMATH_CONSTEXPR14 inline bool
Vec4<T>::equalWithRelError (const Vec4<T>& v, T e) const IMATH_NOEXCEPT
{
    for (int i = 0; i < 4; i++)
        if (!IMATH_INTERNAL_NAMESPACE::equalWithRelError ((*this)[i], v[i], e))
            return false;

    return true;
}

template <class T>
IMATH_HOSTDEVICE constexpr inline T
Vec4<T>::dot (const Vec4& v) const IMATH_NOEXCEPT
{
    return x * v.x + y * v.y + z * v.z + w * v.w;
}

template <class T>
IMATH_HOSTDEVICE constexpr inline T
Vec4<T>::operator^ (const Vec4& v) const IMATH_NOEXCEPT
{
    return dot (v);
}

template <class T>
IMATH_HOSTDEVICE IMATH_CONSTEXPR14 inline const Vec4<T>&
Vec4<T>::operator+= (const Vec4& v) IMATH_NOEXCEPT
{
    x += v.x;
    y += v.y;
    z += v.z;
    w += v.w;
    return *this;
}

template <class T>
IMATH_HOSTDEVICE constexpr inline Vec4<T>
Vec4<T>::operator+ (const Vec4& v) const IMATH_NOEXCEPT
{
    return Vec4 (x + v.x, y + v.y, z + v.z, w + v.w);
}

template <class T>
IMATH_HOSTDEVICE IMATH_CONSTEXPR14 inline const Vec4<T>&
Vec4<T>::operator-= (const Vec4& v) IMATH_NOEXCEPT
{
    x -= v.x;
    y -= v.y;
    z -= v.z;
    w -= v.w;
    return *this;
}

template <class T>
IMATH_HOSTDEVICE constexpr inline Vec4<T>
Vec4<T>::operator- (const Vec4& v) const IMATH_NOEXCEPT
{
    return Vec4 (x - v.x, y - v.y, z - v.z, w - v.w);
}

template <class T>
IMATH_HOSTDEVICE constexpr inline Vec4<T>
Vec4<T>::operator- () const IMATH_NOEXCEPT
{
    return Vec4 (-x, -y, -z, -w);
}

template <class T>
IMATH_HOSTDEVICE IMATH_CONSTEXPR14 inline const Vec4<T>&
                 Vec4<T>::negate () IMATH_NOEXCEPT
{
    x = -x;
    y = -y;
    z = -z;
    w = -w;
    return *this;
}

template <class T>
IMATH_HOSTDEVICE IMATH_CONSTEXPR14 inline const Vec4<T>&
Vec4<T>::operator*= (const Vec4& v) IMATH_NOEXCEPT
{
    x *= v.x;
    y *= v.y;
    z *= v.z;
    w *= v.w;
    return *this;
}

template <class T>
IMATH_HOSTDEVICE IMATH_CONSTEXPR14 inline const Vec4<T>&
Vec4<T>::operator*= (T a) IMATH_NOEXCEPT
{
    x *= a;
    y *= a;
    z *= a;
    w *= a;
    return *this;
}

template <class T>
IMATH_HOSTDEVICE constexpr inline Vec4<T>
Vec4<T>::operator* (const Vec4& v) const IMATH_NOEXCEPT
{
    return Vec4 (x * v.x, y * v.y, z * v.z, w * v.w);
}

template <class T>
IMATH_HOSTDEVICE constexpr inline Vec4<T>
Vec4<T>::operator* (T a) const IMATH_NOEXCEPT
{
    return Vec4 (x * a, y * a, z * a, w * a);
}

template <class T>
IMATH_HOSTDEVICE IMATH_CONSTEXPR14 inline const Vec4<T>&
Vec4<T>::operator/= (const Vec4& v) IMATH_NOEXCEPT
{
    x /= v.x;
    y /= v.y;
    z /= v.z;
    w /= v.w;
    return *this;
}

template <class T>
IMATH_HOSTDEVICE IMATH_CONSTEXPR14 inline const Vec4<T>&
Vec4<T>::operator/= (T a) IMATH_NOEXCEPT
{
    x /= a;
    y /= a;
    z /= a;
    w /= a;
    return *this;
}

template <class T>
IMATH_HOSTDEVICE constexpr inline Vec4<T>
Vec4<T>::operator/ (const Vec4& v) const IMATH_NOEXCEPT
{
    return Vec4 (x / v.x, y / v.y, z / v.z, w / v.w);
}

template <class T>
IMATH_HOSTDEVICE constexpr inline Vec4<T>
Vec4<T>::operator/ (T a) const IMATH_NOEXCEPT
{
    return Vec4 (x / a, y / a, z / a, w / a);
}

template <class T>
IMATH_HOSTDEVICE IMATH_CONSTEXPR14 inline T
Vec4<T>::lengthTiny () const IMATH_NOEXCEPT
{
    T absX = (x >= T (0)) ? x : -x;
    T absY = (y >= T (0)) ? y : -y;
    T absZ = (z >= T (0)) ? z : -z;
    T absW = (w >= T (0)) ? w : -w;

    T max = absX;

    if (max < absY) max = absY;

    if (max < absZ) max = absZ;

    if (max < absW) max = absW;

    if (IMATH_UNLIKELY (max == T (0))) return T (0);

    //
    // Do not replace the divisions by max with multiplications by 1/max.
    // Computing 1/max can overflow but the divisions below will always
    // produce results less than or equal to 1.
    //

    absX /= max;
    absY /= max;
    absZ /= max;
    absW /= max;

    return max *
           std::sqrt (absX * absX + absY * absY + absZ * absZ + absW * absW);
}

template <class T>
IMATH_HOSTDEVICE inline T
Vec4<T>::length () const IMATH_NOEXCEPT
{
    T length2 = dot (*this);

    if (IMATH_UNLIKELY (length2 < T (2) * std::numeric_limits<T>::min ()))
        return lengthTiny ();

    return std::sqrt (length2);
}

template <class T>
IMATH_HOSTDEVICE constexpr inline T
Vec4<T>::length2 () const IMATH_NOEXCEPT
{
    return dot (*this);
}

template <class T>
IMATH_HOSTDEVICE const inline Vec4<T>&
Vec4<T>::normalize () IMATH_NOEXCEPT
{
    T l = length ();

    if (IMATH_LIKELY (l != T (0)))
    {
        //
        // Do not replace the divisions by l with multiplications by 1/l.
        // Computing 1/l can overflow but the divisions below will always
        // produce results less than or equal to 1.
        //

        x /= l;
        y /= l;
        z /= l;
        w /= l;
    }

    return *this;
}

template <class T>
const inline Vec4<T>&
Vec4<T>::normalizeExc ()
{
    T l = length ();

    if (IMATH_UNLIKELY (l == T (0)))
        throw std::domain_error ("Cannot normalize null vector.");

    x /= l;
    y /= l;
    z /= l;
    w /= l;
    return *this;
}

template <class T>
IMATH_HOSTDEVICE inline const Vec4<T>&
Vec4<T>::normalizeNonNull () IMATH_NOEXCEPT
{
    T l = length ();
    x /= l;
    y /= l;
    z /= l;
    w /= l;
    return *this;
}

template <class T>
IMATH_HOSTDEVICE inline Vec4<T>
Vec4<T>::normalized () const IMATH_NOEXCEPT
{
    T l = length ();

    if (IMATH_UNLIKELY (l == T (0))) return Vec4 (T (0));

    return Vec4 (x / l, y / l, z / l, w / l);
}

template <class T>
inline Vec4<T>
Vec4<T>::normalizedExc () const
{
    T l = length ();

    if (IMATH_UNLIKELY (l == T (0)))
        throw std::domain_error ("Cannot normalize null vector.");

    return Vec4 (x / l, y / l, z / l, w / l);
}

template <class T>
IMATH_HOSTDEVICE inline Vec4<T>
Vec4<T>::normalizedNonNull () const IMATH_NOEXCEPT
{
    T l = length ();
    return Vec4 (x / l, y / l, z / l, w / l);
}

//-----------------------------
// Stream output implementation
//-----------------------------

template <class T>
std::ostream&
operator<< (std::ostream& s, const Vec2<T>& v)
{
    return s << '(' << v.x << ' ' << v.y << ')';
}

template <class T>
std::ostream&
operator<< (std::ostream& s, const Vec3<T>& v)
{
    return s << '(' << v.x << ' ' << v.y << ' ' << v.z << ')';
}

template <class T>
std::ostream&
operator<< (std::ostream& s, const Vec4<T>& v)
{
    return s << '(' << v.x << ' ' << v.y << ' ' << v.z << ' ' << v.w << ')';
}

//-----------------------------------------
// Implementation of reverse multiplication
//-----------------------------------------

template <class T>
IMATH_HOSTDEVICE constexpr inline Vec2<T>
operator* (T a, const Vec2<T>& v) IMATH_NOEXCEPT
{
    return Vec2<T> (a * v.x, a * v.y);
}

template <class T>
IMATH_HOSTDEVICE constexpr inline Vec3<T>
operator* (T a, const Vec3<T>& v) IMATH_NOEXCEPT
{
    return Vec3<T> (a * v.x, a * v.y, a * v.z);
}

template <class T>
IMATH_HOSTDEVICE constexpr inline Vec4<T>
operator* (T a, const Vec4<T>& v) IMATH_NOEXCEPT
{
    return Vec4<T> (a * v.x, a * v.y, a * v.z, a * v.w);
}

#if (defined _WIN32 || defined _WIN64) && defined _MSC_VER
#    pragma warning(pop)
#endif

IMATH_INTERNAL_NAMESPACE_HEADER_EXIT

#endif // INCLUDED_IMATHVEC_H
