vector.h

Go to the documentation of this file.

/***************************************************************************************************
 * Copyright 2025 NVIDIA Corporation. All rights reserved.
 **************************************************************************************************/
 
#ifndef MI_MATH_VECTOR_H
#define MI_MATH_VECTOR_H
 
#include <mi/base/types.h>
#include <mi/math/assert.h>
#include <mi/math/function.h>
 
namespace mi {
 
namespace math {
 
enum From_iterator_tag {
    FROM_ITERATOR 
};
 
 
// Color and Vector can be converted into each other. To avoid cyclic dependencies among the
// headers, the Color_struct class is already defined here.
 
//------- POD struct that provides storage for color elements --------
 
struct Color_struct
{
    Float32 r;
    Float32 g;
    Float32 b;
    Float32 a;
};
 
 
//------- POD struct that provides storage for vector elements --------
 
template <typename T, Size DIM>
struct Vector_struct
{
    T elements[DIM]; 
};
 
template <typename T> struct Vector_struct<T, 1>
{
    T x;  
};
 
template <typename T> struct Vector_struct<T, 2>
{
    T x;  
    T y;  
};
 
template <typename T> struct Vector_struct<T, 3>
{
    T x;  
    T y;  
    T z;  
};
 
template <typename T> struct Vector_struct<T, 4>
{
    T x;  
    T y;  
    T z;  
    T w;  
};
 
 
//------ Indirect access to vector storage base ptr to keep Vector_struct a POD --
 
template <typename T, Size DIM>
inline T* vector_base_ptr( Vector_struct<T,DIM>& vec)
{
    return vec.elements;
}
 
template <typename T, Size DIM>
inline const T* vector_base_ptr( const Vector_struct<T,DIM>& vec)
{
    return vec.elements;
}
 
template <typename T>
inline T* vector_base_ptr( Vector_struct<T,1>& vec)
{
    return &vec.x;
}
 
template <typename T>
inline const T* vector_base_ptr( const Vector_struct<T,1>& vec)
{
    return &vec.x;
}
 
template <typename T>
inline T* vector_base_ptr( Vector_struct<T,2>& vec)
{
    return &vec.x;
}
 
template <typename T>
inline const T* vector_base_ptr( const Vector_struct<T,2>& vec)
{
    return &vec.x;
}
 
template <typename T>
inline T* vector_base_ptr( Vector_struct<T,3>& vec)
{
    return &vec.x;
}
 
template <typename T>
inline const T* vector_base_ptr( const Vector_struct<T,3>& vec)
{
    return &vec.x;
}
 
template <typename T>
inline T* vector_base_ptr( Vector_struct<T,4>& vec)
{
    return &vec.x;
}
 
template <typename T>
inline const T* vector_base_ptr( const Vector_struct<T,4>& vec)
{
    return &vec.x;
}
 
 // end group mi_math_vector_struct
 
 
//------ Generic Vector Class -------------------------------------------------
 
template < class T, Size DIM>
class Vector : public Vector_struct<T, DIM> //-V690 PVS
{
public:
    using Pod_type        = Vector_struct<T, DIM>;  
    using storage_type    = Vector_struct<T, DIM>;  
 
    using value_type      = T;                      
    using size_type       = Size;                   
    using difference_type = Difference;             
    using pointer         = T*;                     
    using const_pointer   = const T*;               
    using reference       = T&;                     
    using const_reference = const T&;               
 
    static constexpr Size DIMENSION = DIM;          
    static constexpr Size SIZE      = DIM;          
 
    static constexpr inline Size size()     { return SIZE; }
 
    static constexpr inline Size max_size() { return SIZE; }
 
    inline T* begin() { return vector_base_ptr( *this); }
 
    inline const T* begin() const { return vector_base_ptr( *this); }
 
    inline T* end() { return begin() + DIM; }
 
    inline const T* end() const { return begin() + DIM; }
 
    inline Vector()
    {
#ifndef NDEBUG
        // In debug mode, default-constructed vectors are initialized with signaling NaNs or, if not
        // applicable, with a maximum value to increase the chances of diagnosing incorrect use of
        // an uninitialized vector.
        using Traits = mi::base::numeric_traits<T>;
        T v = (Traits::has_signaling_NaN) ? Traits::signaling_NaN()
                                          : Traits::max MI_PREVENT_MACRO_EXPAND ();
        for( Size i(0u); i < DIM; ++i)
            (*this)[i] = v;
#endif
    }
 
    Vector( const Vector<T,DIM>& vec ) = default;
 
    inline Vector( const Vector_struct<T,DIM>& vec )
    {
        for( Size i(0u); i < DIM; ++i)
            begin()[i] = vector_base_ptr(vec)[i];
    }
 
#if (__cplusplus >= 201402L)
private:
    template<Size s>
    constexpr inline void init( std::integral_constant<Size,s>, T v)
    {
        for( Size i = 0; i < DIM; ++i)
            Pod_type::elements[i] = v;
    }
 
    constexpr inline void init( std::integral_constant<Size,1>, T v)
    { Pod_type::x = v; }
 
    constexpr inline void init( std::integral_constant<Size,2>, T v)
    { Pod_type::x = Pod_type::y = v; }
 
    constexpr inline void init( std::integral_constant<Size,3>, T v)
    { Pod_type::x = Pod_type::y = Pod_type::z = v; }
 
    constexpr inline void init( std::integral_constant<Size,4>, T v)
    { Pod_type::x = Pod_type::y = Pod_type::z = Pod_type::w = v; }
 
public:
    constexpr inline explicit Vector(T v)
    {
        init( std::integral_constant<Size,DIM>(), v);
    }
#else
    inline explicit Vector(T v)
    {
        for( Size i(0u); i < DIM; ++i)
            begin()[i] = v;
    }
#endif
 
    template <typename Iterator>
    inline Vector(From_iterator_tag, Iterator p)
    {
        for( Size i(0u); i < DIM; ++i, ++p)
            begin()[i] = *p;
    }
 
    template <typename T2>
    inline explicit Vector( T2 const (& array)[DIM])
    {
        for( Size i(0u); i < DIM; ++i)
            begin()[i] = array[i];
    }
 
    template <typename T2>
    inline explicit Vector( const Vector<T2,DIM>& other)
    {
        for( Size i(0u); i < DIM; ++i)
            begin()[i] = T(other[i]);
    }
 
    template <typename T2>
    inline explicit Vector( const Vector_struct<T2,DIM>& other)
    {
        for( Size i(0u); i < DIM; ++i)
            begin()[i] = T(vector_base_ptr(other)[i]);
    }
 
#if (__cplusplus >= 201402L)
    constexpr
#endif
    inline Vector(T v1, T v2) : Vector_struct<T, DIM>{v1,v2}
    {
        mi_static_assert(DIM == 2);
    }
 
#if (__cplusplus >= 201402L)
    constexpr
#endif
    inline Vector(T v1, T v2, T v3) : Vector_struct<T, DIM>{v1,v2,v3}
    {
        mi_static_assert(DIM == 3);
    }
 
#if (__cplusplus >= 201402L)
    constexpr
#endif
    inline Vector(T v1, const Vector<T,2>& v2) : Vector_struct<T, DIM>{v1,v2.x,v2.y}
    {
        mi_static_assert(DIM == 3);
    }
 
#if (__cplusplus >= 201402L)
    constexpr
#endif
    inline Vector(const Vector<T,2>& v1, T v2) : Vector_struct<T, DIM>{v1.x,v1.y,v2}
    {
        mi_static_assert(DIM == 3);
    }
 
#if (__cplusplus >= 201402L)
    constexpr
#endif
    inline Vector(T v1, T v2, T v3, T v4) : Vector_struct<T, DIM>{v1,v2,v3,v4}
    {
        mi_static_assert(DIM == 4);
    }
 
#if (__cplusplus >= 201402L)
    constexpr
#endif
    inline Vector(T v1, T v2, const Vector<T,2>& v3) : Vector_struct<T, DIM>{v1,v2,v3.x,v3.y}
    {
        mi_static_assert(DIM == 4);
    }
 
#if (__cplusplus >= 201402L)
    constexpr
#endif
    inline Vector(T v1, const Vector<T,2>& v2, T v3) : Vector_struct<T, DIM>{v1,v2.x,v2.y,v3}
    {
        mi_static_assert(DIM == 4);
    }
 
#if (__cplusplus >= 201402L)
    constexpr
#endif
    inline Vector(const Vector<T,2>& v1, T v2, T v3) : Vector_struct<T, DIM>{v1.x,v1.y,v2,v3}
    {
        mi_static_assert(DIM == 4);
    }
 
#if (__cplusplus >= 201402L)
    constexpr
#endif
    inline Vector(const Vector<T,2>& v1, const Vector<T,2>& v2) : Vector_struct<T, DIM>{v1.x,v1.y,v2.x,v2.y}
    {
        mi_static_assert(DIM == 4);
    }
 
#if (__cplusplus >= 201402L)
    constexpr
#endif
    inline Vector(T v1, const Vector<T,3>& v2) : Vector_struct<T, DIM>{v1,v2.x,v2.y,v2.z}
    {
        mi_static_assert(DIM == 4);
    }
 
#if (__cplusplus >= 201402L)
    constexpr
#endif
    inline Vector(const Vector<T,3>& v1, T v2) : Vector_struct<T, DIM>{v1.x,v1.y,v1.z,v2}
    {
        mi_static_assert(DIM == 4);
    }
 
#if (__cplusplus >= 201402L)
    constexpr
#endif
    inline explicit Vector( const Color_struct& color) : Vector_struct<T, DIM>{static_cast<T>(color.r),static_cast<T>(color.g),static_cast<T>(color.b),static_cast<T>(color.a)}
    {
        mi_static_assert(DIM == 4);
    }
 
    Vector& operator=( const Vector& other) = default;
 
#if (__cplusplus >= 201402L)
    constexpr
#endif
    inline Vector& operator=( T s)
    {
#if (__cplusplus >= 201402L)
        init(std::integral_constant<Size,DIM>(), s);
#else
        for( Size i(0u); i < DIM; ++i)
            begin()[i] = s;
#endif
        return *this;
    }
#if (__cplusplus >= 201402L)
    constexpr
#endif
    inline Vector& operator=( const Color_struct& color)
    {
        mi_static_assert(DIM == 4);
        Pod_type::x = color.r;
        Pod_type::y = color.g;
        Pod_type::z = color.b;
        Pod_type::w = color.a;
        return *this;
    }
 
    inline T& operator[](Size i)
    {
        mi_math_assert_msg(i < DIM, "precondition");
        return begin()[i];
    }
 
    inline const T& operator[](Size i) const
    {
        mi_math_assert_msg(i < DIM, "precondition");
        return begin()[i];
    }
 
    inline const T& get(Size i) const
    {
        mi_math_assert_msg(i < DIM, "precondition");
        return begin()[i];
    }
 
    inline void set(Size i, T value)
    {
        mi_math_assert_msg(i < DIM, "precondition");
        begin()[i] = value;
    }
 
 
 
    inline bool normalize()
    {
        const T rec_length = T(1) / length( *this);
        const bool result = isfinite( rec_length); //-V601 PVS
        if( result)
            (*this) *= rec_length;
        return result;
    }
 
 
    //------ Free comparison operators ==, !=, <, <=, >, >= for vectors --------
 
    inline bool operator==( Vector<T,DIM> rhs) const
    {
        return is_equal( *this, rhs);
    }
 
    inline bool operator!=( Vector<T,DIM> rhs) const
    {
        return is_not_equal( *this, rhs);
    }
 
    inline bool operator<( Vector<T,DIM> rhs) const
    {
        return lexicographically_less( *this, rhs);
    }
 
    inline bool operator<=( Vector<T,DIM> rhs) const
    {
        return lexicographically_less_or_equal( *this, rhs);
    }
 
    inline bool operator>( Vector<T,DIM> rhs) const
    {
        return lexicographically_greater( *this, rhs);
    }
 
    inline bool operator>=( Vector<T,DIM> rhs) const
    {
        return lexicographically_greater_or_equal( *this, rhs);
    }
};
 
 
//------ Free operators +=, -=, *=, /=, +, -, *, and / for vectors -------------
 
template <typename T, Size DIM>
inline Vector<T,DIM>& operator+=(
    Vector<T,DIM>&              lhs,
    const Vector_struct<T,DIM>& rhs)
{
    for( Size i(0u); i < DIM; ++i)
        lhs.elements[i] += rhs.elements[i];
    return lhs;
}
template <typename T>
inline Vector<T,1>& operator+=(
    Vector<T,1>&              lhs,
    const Vector_struct<T,1>& rhs)
{
    lhs.x += rhs.x;
    return lhs;
}
template <typename T>
inline Vector<T,2>& operator+=(
    Vector<T,2>&              lhs,
    const Vector_struct<T,2>& rhs)
{
    lhs.x += rhs.x;
    lhs.y += rhs.y;
    return lhs;
}
template <typename T>
inline Vector<T,3>& operator+=(
    Vector<T,3>&              lhs,
    const Vector_struct<T,3>& rhs)
{
    lhs.x += rhs.x;
    lhs.y += rhs.y;
    lhs.z += rhs.z;
    return lhs;
}
template <typename T>
inline Vector<T,4>& operator+=(
    Vector<T,4>&              lhs,
    const Vector_struct<T,4>& rhs)
{
    lhs.x += rhs.x;
    lhs.y += rhs.y;
    lhs.z += rhs.z;
    lhs.w += rhs.w;
    return lhs;
}
 
template <typename T, Size DIM>
inline Vector<T,DIM>& operator-=(
    Vector<T,DIM>&              lhs,
    const Vector_struct<T,DIM>& rhs)
{
    for( Size i(0u); i < DIM; ++i)
        lhs.elements[i] -= rhs.elements[i];
    return lhs;
}
template <typename T>
inline Vector<T,1>& operator-=(
    Vector<T,1>&              lhs,
    const Vector_struct<T,1>& rhs)
{
    lhs.x -= rhs.x;
    return lhs;
}
template <typename T>
inline Vector<T,2>& operator-=(
    Vector<T,2>&              lhs,
    const Vector_struct<T,2>& rhs)
{
    lhs.x -= rhs.x;
    lhs.y -= rhs.y;
    return lhs;
}
template <typename T>
inline Vector<T,3>& operator-=(
    Vector<T,3>&              lhs,
    const Vector_struct<T,3>& rhs)
{
    lhs.x -= rhs.x;
    lhs.y -= rhs.y;
    lhs.z -= rhs.z;
    return lhs;
}
template <typename T>
inline Vector<T,4>& operator-=(
    Vector<T,4>&              lhs,
    const Vector_struct<T,4>& rhs)
{
    lhs.x -= rhs.x;
    lhs.y -= rhs.y;
    lhs.z -= rhs.z;
    lhs.w -= rhs.w;
    return lhs;
}
 
template <typename T, Size DIM>
inline Vector<T,DIM>& operator*=(
    Vector<T,DIM>&              lhs,
    const Vector_struct<T,DIM>& rhs)
{
    for( Size i(0u); i < DIM; ++i)
        lhs.elements[i] *= rhs.elements[i];
    return lhs;
}
template <typename T>
inline Vector<T,1>& operator*=(
    Vector<T,1>&              lhs,
    const Vector_struct<T,1>& rhs)
{
    lhs.x *= rhs.x;
    return lhs;
}
template <typename T>
inline Vector<T,2>& operator*=(
    Vector<T,2>&              lhs,
    const Vector_struct<T,2>& rhs)
{
    lhs.x *= rhs.x;
    lhs.y *= rhs.y;
    return lhs;
}
template <typename T>
inline Vector<T,3>& operator*=(
    Vector<T,3>&              lhs,
    const Vector_struct<T,3>& rhs)
{
    lhs.x *= rhs.x;
    lhs.y *= rhs.y;
    lhs.z *= rhs.z;
    return lhs;
}
template <typename T>
inline Vector<T,4>& operator*=(
    Vector<T,4>&              lhs,
    const Vector_struct<T,4>& rhs)
{
    lhs.x *= rhs.x;
    lhs.y *= rhs.y;
    lhs.z *= rhs.z;
    lhs.w *= rhs.w;
    return lhs;
}
 
template <typename T, Size DIM>
inline Vector<T,DIM>& operator%=(
    Vector<T,DIM>&              lhs,
    const Vector_struct<T,DIM>& rhs)
{
    for( Size i(0u); i < DIM; ++i)
        lhs[i] %= vector_base_ptr(rhs)[i];
    return lhs;
}
 
template <typename T, typename U, Size DIM>
inline Vector<T,DIM>& operator/=(
    Vector<T,DIM>&              lhs,
    const Vector_struct<U,DIM>& rhs)
{
    for( Size i(0u); i < DIM; ++i)
        lhs[i] = T(lhs[i] / vector_base_ptr(rhs)[i]);
    return lhs;
}
 
template <typename T, Size DIM>
inline Vector<T,DIM> operator+(
    const Vector_struct<T,DIM>& lhs,
    const Vector_struct<T,DIM>& rhs)
{
    Vector<T,DIM> tmp( lhs);
    return tmp += rhs;
}
 
template <typename T, Size DIM>
inline Vector<T,DIM> operator-(
    const Vector_struct<T,DIM>& lhs,
    const Vector_struct<T,DIM>& rhs)
{
    Vector<T,DIM> tmp( lhs);
    return tmp -= rhs;
}
 
template <typename T, Size DIM>
inline Vector<T,DIM> operator*(
    const Vector_struct<T,DIM>& lhs,
    const Vector_struct<T,DIM>& rhs)
{
    Vector<T,DIM> tmp( lhs);
    return tmp *= rhs;
}
 
template <typename T, Size DIM>
inline Vector<T,DIM> operator%(
    const Vector_struct<T,DIM>& lhs,
    const Vector_struct<T,DIM>& rhs)
{
    Vector<T,DIM> tmp( lhs);
    return tmp %= rhs;
}
 
template <typename T, typename U, Size DIM>
inline Vector<T,DIM> operator/(
    const Vector_struct<T,DIM>& lhs,
    const Vector_struct<U,DIM>& rhs)
{
    Vector<T,DIM> tmp(lhs);
    return tmp /= rhs;
}
 
template <typename T, Size DIM>
inline Vector<T,DIM> operator-( const Vector_struct<T,DIM>& v)
{
    Vector<T,DIM> tmp;
    for( Size i(0u); i < DIM; ++i)
        tmp.elements[i] = -v.elements[i];
    return tmp;
}
template <typename T>
inline Vector<T,1> operator-( const Vector_struct<T,1>& v)
{
    return Vector<T,1>( -v.x);
}
template <typename T>
inline Vector<T,2> operator-( const Vector_struct<T,2>& v)
{
    return Vector<T,2>( -v.x, -v.y);
}
template <typename T>
inline Vector<T,3> operator-( const Vector_struct<T,3>& v)
{
    return Vector<T,3>( -v.x, -v.y, -v.z);
}
template <typename T>
inline Vector<T,4> operator-( const Vector_struct<T,4>& v)
{
    return Vector<T,4>( -v.x, -v.y, -v.z, -v.w);
}
 
 
//------ Resolve ambiguity with hybrid operators -------------
// (Those operators should really be restricted to scalar types but that requires
// modern C++ which some users of this headers don't enable.)
 
template <typename T, Size DIM>
inline Vector<T,DIM>& operator+=(
    Vector<T,DIM>&       lhs,
    const Vector<T,DIM>& rhs)
{
    return lhs += static_cast<const Vector_struct<T,DIM>&>(rhs);
}
 
template <typename T, Size DIM>
inline Vector<T,DIM>& operator-=(
    Vector<T,DIM>&       lhs,
    const Vector<T,DIM>& rhs)
{
    return lhs -= static_cast<const Vector_struct<T,DIM>&>(rhs);
}
 
template <typename T, Size DIM>
inline Vector<T,DIM>& operator*=(
    Vector<T,DIM>&       lhs,
    const Vector<T,DIM>& rhs)
{
    return lhs *= static_cast<const Vector_struct<T,DIM>&>(rhs);
}
template <typename T>
inline Vector<T,1>& operator*=(
    Vector<T,1>&       lhs,
    const Vector<T,1>& rhs)
{
    return lhs *= static_cast<const Vector_struct<T,1>&>(rhs);
}
template <typename T>
inline Vector<T,2>& operator*=(
    Vector<T,2>&       lhs,
    const Vector<T,2>& rhs)
{
    return lhs *= static_cast<const Vector_struct<T,2>&>(rhs);
}
template <typename T>
inline Vector<T,3>& operator*=(
    Vector<T,3>&       lhs,
    const Vector<T,3>& rhs)
{
    return lhs *= static_cast<const Vector_struct<T,3>&>(rhs);
}
template <typename T>
inline Vector<T,4>& operator*=(
    Vector<T,4>&       lhs,
    const Vector<T,4>& rhs)
{
    return lhs *= static_cast<const Vector_struct<T,4>&>(rhs);
}
 
template <typename T, Size DIM>
inline Vector<T,DIM>& operator%=(
    Vector<T,DIM>&       lhs,
    const Vector<T,DIM>& rhs)
{
    return lhs %= static_cast<const Vector_struct<T,DIM>&>(rhs);
}
 
template <typename T, typename U, Size DIM>
inline Vector<T,DIM>& operator/=(
    Vector<T,DIM>&       lhs,
    const Vector<U,DIM>& rhs)
{
    return lhs /= static_cast<const Vector_struct<U,DIM>&>(rhs);
}
 
template <typename T, Size DIM>
inline Vector<T,DIM> operator+(
    const Vector<T,DIM>& lhs,
    const Vector<T,DIM>& rhs)
{
    return lhs + static_cast<const Vector_struct<T,DIM>&>(rhs);
}
 
template <typename T, Size DIM>
inline Vector<T,DIM> operator-(
    const Vector<T,DIM>& lhs,
    const Vector<T,DIM>& rhs)
{
    return lhs - static_cast<const Vector_struct<T,DIM>&>(rhs);
}
 
template <typename T, Size DIM>
inline Vector<T,DIM> operator*(
    const Vector<T,DIM>& lhs,
    const Vector<T,DIM>& rhs)
{
    return lhs * static_cast<const Vector_struct<T,DIM>&>(rhs);
}
 
template <typename T, Size DIM>
inline Vector<T,DIM> operator%(
    const Vector<T,DIM>& lhs,
    const Vector<T,DIM>& rhs)
{
    return lhs % static_cast<const Vector_struct<T,DIM>&>(rhs);
}
 
template <typename T, typename U, Size DIM>
inline Vector<T,DIM> operator/(
    const Vector<T,DIM>& lhs,
    const Vector<U,DIM>& rhs)
{
    return lhs / static_cast<const Vector_struct<U,DIM>&>(rhs);
}
 
template <typename T, Size DIM>
inline Vector<T,DIM> operator-( const Vector<T,DIM>& v)
{
    return -static_cast<const Vector_struct<T,DIM>&>(v);
}
 
 
//------ Free operator *=, /=, *, and / definitions for scalars ---------------
 
template <typename T, typename TT, Size DIM>
inline Vector<T,DIM>& operator*=(
    Vector<T,DIM>& v,
    TT             s)
{
    for( Size i(0u); i < DIM; ++i)
        v.elements[i] = T(v.elements[i] * s);
    return v;
}
template <typename T, typename TT>
inline Vector<T,1>& operator*=(
    Vector<T,1>& v,
    TT           s)
{
    v.x = T(v.x * s);
    return v;
}
template <typename T, typename TT>
inline Vector<T,2>& operator*=(
    Vector<T,2>& v,
    TT           s)
{
    v.x = T(v.x * s);
    v.y = T(v.y * s);
    return v;
}
template <typename T, typename TT>
inline Vector<T,3>& operator*=(
    Vector<T,3>& v,
    TT           s)
{
    v.x = T(v.x * s);
    v.y = T(v.y * s);
    v.z = T(v.z * s);
    return v;
}
template <typename T, typename TT>
inline Vector<T,4>& operator*=(
    Vector<T,4>& v,
    TT           s)
{
    v.x = T(v.x * s);
    v.y = T(v.y * s);
    v.z = T(v.z * s);
    v.w = T(v.w * s);
    return v;
}
 
template <typename T, typename TT, Size DIM>
inline Vector<T,DIM>& operator%=(
    Vector<T,DIM>& v,
    TT             s)
{
    for( Size i(0u); i < DIM; ++i)
        v[i] = T(v[i] % s);
    return v;
}
 
template <typename T, typename TT, Size DIM>
inline Vector<T,DIM>& operator/=(
    Vector<T,DIM>&  v,
    TT              s)
{
    for( Size i(0u); i < DIM; ++i)
        v[i] = T(v[i] / s);
    return v;
}
 
template <typename T, typename TT, Size DIM>
inline Vector<T,DIM> operator*(
    const Vector_struct<T,DIM>& v,
    TT                          s)
{
    Vector<T,DIM> tmp( v);
    return tmp *= s;
}
 
template <typename T, typename TT, Size DIM>
inline Vector<T,DIM> operator*(
    TT                          s,
    const Vector_struct<T,DIM>& v)
{
    Vector<T,DIM> tmp( v);
    return tmp *= s;
}
 
template <typename T, typename TT, Size DIM>
inline Vector<T,DIM> operator%(
    const Vector_struct<T,DIM>& v,
    TT                          s)
{
    Vector<T,DIM> tmp( v);
    return tmp %= s;
}
 
template <typename T, typename TT, Size DIM>
inline Vector<T,DIM> operator/(
    const Vector_struct<T,DIM>& v,
    TT                          s)
{
    Vector<T,DIM> tmp( v);
    return tmp /= s;
}
 
 
//------ Free operator ++, -- for vectors -------------------------------------
 
template <typename T, Size DIM>
inline Vector<T,DIM>& operator++( Vector<T,DIM>& vec)
{
    general::for_each( vec, functor::Operator_pre_incr());
    return vec;
}
 
template <typename T, Size DIM>
inline Vector<T,DIM>& operator--( Vector<T,DIM>& vec)
{
    general::for_each( vec, functor::Operator_pre_decr());
    return vec;
}
 
 
//------ Free operators !, &&, ||, ^ for bool vectors and bool scalars ---------
 
template <Size DIM>
inline Vector<bool,DIM> operator&&(
    const Vector<bool,DIM>& lhs,
    const Vector<bool,DIM>& rhs)
{
    Vector<bool,DIM> result;
    general::transform( lhs, rhs, result, functor::Operator_and_and());
    return result;
}
 
template <Size DIM>
inline Vector<bool,DIM> operator&&(
    bool                    lhs,
    const Vector<bool,DIM>& rhs)
{
    Vector<bool,DIM> result;
    general::transform_left_scalar( lhs, rhs, result, functor::Operator_and_and());
    return result;
}
 
template <Size DIM>
inline Vector<bool,DIM> operator&&(
    const Vector<bool,DIM>& lhs,
    bool                    rhs)
{
    Vector<bool,DIM> result;
    general::transform_right_scalar( lhs, rhs, result, functor::Operator_and_and());
    return result;
}
 
template <Size DIM>
inline Vector<bool,DIM> operator||(
    const Vector<bool,DIM>& lhs,
    const Vector<bool,DIM>& rhs)
{
    Vector<bool,DIM> result;
    general::transform(lhs, rhs, result, functor::Operator_or_or());
    return result;
}
 
template <Size DIM>
inline Vector<bool,DIM> operator||(
    bool                    lhs,
    const Vector<bool,DIM>& rhs)
{
    Vector<bool,DIM> result;
    general::transform_left_scalar( lhs, rhs, result, functor::Operator_or_or());
    return result;
}
 
template <Size DIM>
inline Vector<bool,DIM> operator||(
    const Vector<bool,DIM>& lhs,
    bool                     rhs)
{
    Vector<bool,DIM> result;
    general::transform_right_scalar( lhs, rhs, result, functor::Operator_or_or());
    return result;
}
 
template <Size DIM>
inline Vector<bool,DIM> operator^(
    const Vector<bool,DIM>& lhs,
    const Vector<bool,DIM>& rhs)
{
    Vector<bool,DIM> result;
    general::transform( lhs, rhs, result, functor::Operator_xor());
    return result;
}
 
template <Size DIM>
inline Vector<bool,DIM> operator^(
    bool                    lhs,
    const Vector<bool,DIM>& rhs)
{
    Vector<bool,DIM> result;
    general::transform_left_scalar( lhs, rhs, result, functor::Operator_xor());
    return result;
}
 
template <Size DIM>
inline Vector<bool,DIM> operator^(
    const Vector<bool,DIM>& lhs,
    bool                    rhs)
{
    Vector<bool,DIM> result;
    general::transform_right_scalar( lhs, rhs, result, functor::Operator_xor());
    return result;
}
 
template <Size DIM>
inline Vector<bool,DIM> operator!(
    const Vector<bool,DIM>& vec)
{
    Vector<bool,DIM> result;
    general::transform( vec, result, functor::Operator_not());
    return result;
}
 
 
//------ Elementwise comparison operators returning a bool vector. ------------
 
template <typename T, Size DIM>
inline Vector<bool,DIM> elementwise_is_equal(
    const Vector<T,DIM>& lhs,
    const Vector<T,DIM>& rhs)
{
    Vector<bool,DIM> result;
    general::transform( lhs, rhs, result,functor::Operator_equal_equal());
    return result;
}
 
template <typename T, Size DIM>
inline Vector<bool,DIM> elementwise_is_not_equal(
    const Vector<T,DIM>& lhs,
    const Vector<T,DIM>& rhs)
{
    Vector<bool,DIM> result;
    general::transform( lhs, rhs, result,functor::Operator_not_equal());
    return result;
}
 
template <typename T, Size DIM>
inline Vector<bool,DIM> elementwise_is_less_than(
    const Vector<T,DIM>& lhs,
    const Vector<T,DIM>& rhs)
{
    Vector<bool,DIM> result;
    general::transform( lhs, rhs, result,functor::Operator_less());
    return result;
}
 
template <typename T, Size DIM>
inline Vector<bool,DIM> elementwise_is_less_than_or_equal(
    const Vector<T,DIM>& lhs,
    const Vector<T,DIM>& rhs)
{
    Vector<bool,DIM> result;
    general::transform( lhs, rhs, result,functor::Operator_less_equal());
    return result;
}
 
template <typename T, Size DIM>
inline Vector<bool,DIM> elementwise_is_greater_than(
    const Vector<T,DIM>& lhs,
    const Vector<T,DIM>& rhs)
{
    Vector<bool,DIM> result;
    general::transform( lhs, rhs, result,functor::Operator_greater());
    return result;
}
 
template <typename T, Size DIM>
inline Vector<bool,DIM> elementwise_is_greater_than_or_equal(
    const Vector<T,DIM>& lhs,
    const Vector<T,DIM>& rhs)
{
    Vector<bool,DIM> result;
    general::transform( lhs, rhs, result,functor::Operator_greater_equal());
    return result;
}
 
 
//------ Function Overloads for Vector Algorithms -----------------------------
 
template <typename T, Size DIM>
inline Vector<T,DIM> abs( const Vector_struct<T,DIM>& v)
{
    Vector<T,DIM> result;
    for( Size i = 0; i != DIM; ++i)
        result[i] = abs( vector_base_ptr(v)[i]);
    return result;
}
 
template <typename T, Size DIM>
inline Vector<T,DIM> acos( const Vector_struct<T,DIM>& v)
{
    Vector<T,DIM> result;
    for( Size i = 0; i != DIM; ++i)
        result[i] = acos( vector_base_ptr(v)[i]);
    return result;
}
 
template <typename T, Size DIM>
inline bool all( const Vector_struct<T,DIM>& v)
{
    for( Size i = 0; i != DIM; ++i)
        if( !all( vector_base_ptr(v)[i]))
            return false;
    return true;
}
 
template <typename T, Size DIM>
inline bool any( const Vector_struct<T,DIM>& v)
{
    for( Size i = 0; i != DIM; ++i)
        if( any( vector_base_ptr(v)[i]))
           return true;
    return false;
}
 
template <typename T, Size DIM>
inline Vector<T,DIM> asin( const Vector_struct<T,DIM>& v)
{
    Vector<T,DIM> result;
    for( Size i = 0; i != DIM; ++i)
        result[i] = asin( vector_base_ptr(v)[i]);
    return result;
}
 
template <typename T, Size DIM>
inline Vector<T,DIM> atan( const Vector_struct<T,DIM>& v)
{
    Vector<T,DIM> result;
    for( Size i = 0; i != DIM; ++i)
        result[i] = atan( vector_base_ptr(v)[i]);
    return result;
}
 
template <typename T, Size DIM>
inline Vector<T,DIM> atan2( const Vector_struct<T,DIM>& v, const Vector_struct<T,DIM>& w)
{
    Vector<T,DIM> result;
    for( Size i = 0; i != DIM; ++i)
        result[i] = atan2( vector_base_ptr(v)[i], vector_base_ptr(w)[i]);
    return result;
}
 
template <typename T, Size DIM>
inline Vector<T,DIM> ceil( const Vector_struct<T,DIM>& v)
{
    Vector<T,DIM> result;
    for( Size i = 0; i != DIM; ++i)
        result[i] = ceil( vector_base_ptr(v)[i]);
    return result;
}
 
template <typename T, Size DIM>
inline Vector<T,DIM> clamp(
    const Vector_struct<T,DIM>&  v,
    const Vector_struct<T,DIM>&  low,
    const Vector_struct<T,DIM>&  high)
{
    Vector<T,DIM> result;
    for( Size i = 0u; i < DIM; ++i)
        result[i] = clamp(
            vector_base_ptr(v)[i], vector_base_ptr(low)[i], vector_base_ptr(high)[i]);
    return result;
}
 
template <typename T, Size DIM>
inline Vector<T,DIM> clamp(
    const Vector_struct<T,DIM>& v,
    const Vector_struct<T,DIM>& low,
    T                    high)
{
    Vector<T,DIM> result;
    for( Size i = 0u; i < DIM; ++i)
        result[i] = clamp( vector_base_ptr(v)[i], vector_base_ptr(low)[i], high);
    return result;
}
 
template <typename T, Size DIM>
inline Vector<T,DIM> clamp(
    const Vector_struct<T,DIM>& v,
    T                    low,
    const Vector_struct<T,DIM>& high)
{
    Vector<T,DIM> result;
    for( Size i = 0u; i < DIM; ++i)
        result[i] = clamp( vector_base_ptr(v)[i], low, vector_base_ptr(high)[i]);
    return result;
}
 
template <typename T, Size DIM>
inline Vector<T,DIM> clamp(
    const Vector_struct<T,DIM>& v,
    T                    low,
    T                    high)
{
    Vector<T,DIM> result;
    for( Size i = 0u; i < DIM; ++i)
        result[i] = clamp( vector_base_ptr(v)[i], low, high);
    return result;
}
 
template <typename T, Size DIM>
inline Vector<T,DIM> cos( const Vector_struct<T,DIM>& v)
{
    Vector<T,DIM> result;
    for( Size i = 0; i != DIM; ++i)
        result[i] = cos( vector_base_ptr(v)[i]);
    return result;
}
 
template <typename T, Size DIM>
inline Vector<T,DIM> degrees( const Vector_struct<T,DIM>& v)
{
    Vector<T,DIM> result;
    for( Size i = 0; i != DIM; ++i)
        result[i] = degrees( vector_base_ptr(v)[i]);
    return result;
}
 
template <typename T, Size DIM>
inline Vector<T,DIM> elementwise_max(
    const Vector_struct<T,DIM>& lhs,
    const Vector_struct<T,DIM>& rhs)
{
    Vector<T,DIM> r;
    for( Size i(0u); i < Vector<T,DIM>::DIMENSION; ++i)
        r[i] = base::max MI_PREVENT_MACRO_EXPAND (
            vector_base_ptr(lhs)[i], vector_base_ptr(rhs)[i] );
    return r;
}
 
template <typename T, Size DIM>
inline Vector<T,DIM> elementwise_min(
    const Vector_struct<T,DIM>& lhs,
    const Vector_struct<T,DIM>& rhs)
{
    Vector<T,DIM> r;
    for( Size i(0u); i < Vector<T,DIM>::DIMENSION; ++i)
        r[i] = base::min MI_PREVENT_MACRO_EXPAND (
            vector_base_ptr(lhs)[i], vector_base_ptr(rhs)[i] );
    return r;
}
 
template <typename T, Size DIM>
inline Vector<T,DIM> exp( const Vector_struct<T,DIM>& v)
{
    Vector<T,DIM> result;
    for( Size i = 0; i != DIM; ++i)
        result[i] = exp( vector_base_ptr(v)[i]);
    return result;
}
 
template <typename T, Size DIM>
inline Vector<T,DIM> exp2( const Vector_struct<T,DIM>& v)
{
    Vector<T,DIM> result;
    for( Size i = 0; i != DIM; ++i)
        result[i] = exp2( vector_base_ptr(v)[i]);
    return result;
}
 
template <typename T, Size DIM>
inline Vector<T,DIM> floor( const Vector_struct<T,DIM>& v)
{
    Vector<T,DIM> result;
    for( Size i = 0; i != DIM; ++i)
        result[i] = floor( vector_base_ptr(v)[i]);
    return result;
}
 
template <typename T, Size DIM>
inline Vector<T,DIM> fmod( const Vector_struct<T,DIM>& a, const Vector_struct<T,DIM>& b)
{
    Vector<T,DIM> result;
    for( Size i = 0; i != DIM; ++i)
        result[i] = fmod( vector_base_ptr(a)[i], vector_base_ptr(b)[i]);
    return result;
}
 
template <typename T, Size DIM>
inline Vector<T,DIM> fmod( const Vector_struct<T,DIM>& a, T b)
{
    Vector<T,DIM> result;
    for( Size i = 0; i != DIM; ++i)
        result[i] = fmod( vector_base_ptr(a)[i], b);
    return result;
}
 
template <typename T, Size DIM>
inline Vector<T,DIM> frac( const Vector_struct<T,DIM>& v)
{
    Vector<T,DIM> result;
    for( Size i = 0; i != DIM; ++i)
        result[i] = frac( vector_base_ptr(v)[i]);
    return result;
}
 
template <typename T, Size DIM>
inline bool is_approx_equal(
    const Vector_struct<T,DIM>& left,
    const Vector_struct<T,DIM>& right,
    T                    e)
{
    for( Size i = 0u; i < DIM; ++i)
        if( !is_approx_equal( vector_base_ptr(left)[i], vector_base_ptr(right)[i], e))
            return false;
    return true;
}
 
template <typename T, Size DIM>
inline Vector<T,DIM> lerp(
    const Vector_struct<T,DIM>& v1,  
    const Vector_struct<T,DIM>& v2,  
    const Vector_struct<T,DIM>& t)   
{
    Vector<T,DIM> result;
    for( Size i = 0; i != DIM; ++i)
        result[i] = vector_base_ptr(v1)[i] * (T(1)-vector_base_ptr(t)[i])
                  + vector_base_ptr(v2)[i] * vector_base_ptr(t)[i];
    return result;
}
 
template <typename T, Size DIM>
inline Vector<T,DIM> lerp(
    const Vector_struct<T,DIM>& v1,  
    const Vector_struct<T,DIM>& v2,  
    T          t)             
{
    // equivalent to: return v1 * (T(1)-t) + v2 * t;
    Vector<T,DIM> result;
    T t2 = T(1) - t;
    for( Size i = 0; i != DIM; ++i)
        result[i] = vector_base_ptr(v1)[i] * t2 + vector_base_ptr(v2)[i] * t;
    return result;
}
 
template <typename T, Size DIM>
inline Vector<T,DIM> log( const Vector_struct<T,DIM>& v)
{
    Vector<T,DIM> result;
    for( Size i = 0; i != DIM; ++i)
        result[i] = log( vector_base_ptr(v)[i]);
    return result;
}
 
template <typename T, Size DIM>
inline Vector<T,DIM> log2 MI_PREVENT_MACRO_EXPAND ( const Vector_struct<T,DIM>& v)
{
    Vector<T,DIM> result;
    for( Size i = 0; i != DIM; ++i)
        result[i] = log2 MI_PREVENT_MACRO_EXPAND ( vector_base_ptr(v)[i]);
    return result;
}
 
template <typename T, Size DIM>
inline Vector<T,DIM> log10( const Vector_struct<T,DIM>& v)
{
    Vector<T,DIM> result;
    for( Size i = 0; i != DIM; ++i)
        result[i] = log10( vector_base_ptr(v)[i]);
    return result;
}
 
template <typename T, Size DIM>
inline Vector<T,DIM> modf( const Vector_struct<T,DIM>& v, Vector<T,DIM>& i)
{
    Vector<T,DIM> result;
    for( Size j = 0; j != DIM; ++j)
        result[j] = modf( vector_base_ptr(v)[j], i[j]);
    return result;
}
 
template <typename T, Size DIM>
inline Vector<T,DIM> pow( const Vector_struct<T,DIM>& a, const Vector_struct<T,DIM>& b)
{
    Vector<T,DIM> result;
    for( Size i = 0; i != DIM; ++i)
        result[i] = pow( vector_base_ptr(a)[i], vector_base_ptr(b)[i]);
    return result;
}
 
template <typename T, Size DIM>
inline Vector<T,DIM> pow( const Vector_struct<T,DIM>& a, T b)
{
    Vector<T,DIM> result;
    for( Size i = 0; i != DIM; ++i)
        result[i] = pow( vector_base_ptr(a)[i], b);
    return result;
}
 
template <typename T, Size DIM>
inline Vector<T,DIM> radians( const Vector_struct<T,DIM>& v)
{
    Vector<T,DIM> result;
    for( Size i = 0; i != DIM; ++i)
        result[i] = radians( vector_base_ptr(v)[i]);
    return result;
}
 
template <typename T, Size DIM>
inline Vector<T,DIM> round( const Vector_struct<T,DIM>& v)
{
    Vector<T,DIM> result;
    for( Size i = 0; i != DIM; ++i)
        result[i] = round( vector_base_ptr(v)[i]);
    return result;
}
 
template <typename T, Size DIM>
inline Vector<T,DIM> rsqrt( const Vector_struct<T,DIM>& v)
{
    Vector<T,DIM> result;
    for( Size i = 0; i != DIM; ++i)
        result[i] = rsqrt( vector_base_ptr(v)[i]);
    return result;
}
 
template <typename T, Size DIM>
inline Vector<T,DIM> saturate( const Vector_struct<T,DIM>& v)
{
    Vector<T,DIM> result;
    for( Size i = 0; i != DIM; ++i)
        result[i] = saturate( vector_base_ptr(v)[i]);
    return result;
}
 
template <typename T, Size DIM>
inline Vector<T,DIM> sign( const Vector_struct<T,DIM>& v)
{
    Vector<T,DIM> result;
    for( Size i = 0; i != DIM; ++i)
        result[i] = sign( vector_base_ptr(v)[i]);
    return result;
}
 
template <typename T, Size DIM>
inline Vector<T,DIM> sin( const Vector_struct<T,DIM>& v)
{
    Vector<T,DIM> result;
    for( Size i = 0; i != DIM; ++i)
        result[i] = sin( vector_base_ptr(v)[i]);
    return result;
}
 
template <typename T, Size DIM>
inline void sincos( const Vector_struct<T,DIM>& a, Vector<T,DIM>& s, Vector<T,DIM>& c)
{
    for( Size i = 0; i != DIM; ++i)
        sincos( vector_base_ptr(a)[i], s[i], c[i]);
}
 
template <typename T, Size DIM>
inline Vector<T,DIM> smoothstep(
    const Vector_struct<T,DIM>& a,
    const Vector_struct<T,DIM>& b,
    const Vector_struct<T,DIM>& v)
{
    Vector<T,DIM> result;
    for( Size i = 0; i != DIM; ++i)
        result[i] = smoothstep(
            vector_base_ptr(a)[i], vector_base_ptr(b)[i], vector_base_ptr(v)[i]);
    return result;
}
 
template <typename T, Size DIM>
inline Vector<T,DIM> smoothstep(
    const Vector_struct<T,DIM>& a,
    const Vector_struct<T,DIM>& b,
    T x)
{
    Vector<T,DIM> result;
    for( Size i = 0; i != DIM; ++i)
        result[i] = smoothstep( vector_base_ptr(a)[i], vector_base_ptr(b)[i], x);
    return result;
}
 
template <typename T, Size DIM>
inline Vector<T,DIM> sqrt( const Vector_struct<T,DIM>& v)
{
    Vector<T,DIM> result;
    for( Size i = 0; i != DIM; ++i)
        result[i] = sqrt( vector_base_ptr(v)[i]);
    return result;
}
 
template <typename T, Size DIM>
inline Vector<T,DIM> step( const Vector_struct<T,DIM>& a, const Vector_struct<T,DIM>& v)
{
    Vector<T,DIM> result;
    for( Size i = 0; i != DIM; ++i)
        result[i] = step( vector_base_ptr(a)[i], vector_base_ptr(v)[i]);
    return result;
}
 
template <typename T, Size DIM>
inline Vector<T,DIM> tan( const Vector_struct<T,DIM>& v)
{
    Vector<T,DIM> result;
    for( Size i = 0; i != DIM; ++i)
        result[i] = tan( vector_base_ptr(v)[i]);
    return result;
}
 
 
//------ Geometric Vector Algorithms ------------------------------------------
 
template <typename T>
inline T cross(
    const Vector_struct<T,2>& lhs,
    const Vector_struct<T,2>& rhs)
{
    return lhs.x * rhs.y - lhs.y * rhs.x;
}
 
template <typename T>
inline Vector<T,3> cross(
    const Vector_struct<T,3>& lhs,
    const Vector_struct<T,3>& rhs)
{
    return Vector<T,3>( lhs.y * rhs.z - lhs.z * rhs.y,
                        lhs.z * rhs.x - lhs.x * rhs.z,
                        lhs.x * rhs.y - lhs.y * rhs.x);
}
 
template <typename T>
inline void make_basis(
    const Vector<T,3>& n,  
    Vector<T,3>* const u,  
    Vector<T,3>* const v)  
{
#ifdef mi_base_assert_enabled
    constexpr T eps = 1e-6f;       // smallest resolvable factor
#endif
 
    mi_math_assert_msg( u != 0, "precondition");
    mi_math_assert_msg( v != 0, "precondition");
    // Sanity check: the normal vector must be unit length.
    mi_math_assert_msg( abs( length(n) - T(1)) < eps, "precondition");
 
    // Compute u.
    if( abs(n.x) < abs(n.y)) {
        // u = cross(x, n), x = (1, 0, 0)
        u->x = T(0);
        u->y = -n.z;
        u->z =  n.y;
    } else {
        // u = cross(y, n), y = (0, 1, 0)
        u->x =  n.z;
        u->y = T(0);
        u->z = -n.x;
    }
    u->normalize();
 
    // Compute v. Since *u and n are orthogonal and unit-length,
    // there is no need to normalize *v.
    *v = cross( *u, n);
 
    // Sanity check: make sure (u, n, v) is an orthogonal basis.
    mi_math_assert_msg( abs( dot( *u,  n)) < eps, "postcondition");
    mi_math_assert_msg( abs( dot( *u, *v)) < eps, "postcondition");
    mi_math_assert_msg( abs( dot(  n, *v)) < eps, "postcondition");
    // Sanity check: make sure u and v are unit length.
    mi_math_assert_msg( abs( length( *u) - T(1)) < eps, "postcondition");
    mi_math_assert_msg( abs( length( *v) - T(1)) < eps, "postcondition");
}
 
template <typename T>
inline void make_basis(
    const Vector<T,3>& n,     
    const Vector<T,3>& u,     
    const Vector<T,3>& v,     
    Vector<T,3>* const t,     
    Vector<T,3>* const b)     
{
#ifdef mi_base_assert_enabled
    constexpr T eps = 1e-6f;       // smallest resolvable factor
#endif
 
    mi_math_assert_msg( t != 0, "precondition");
    mi_math_assert_msg( b != 0, "precondition");
    // Sanity check: the normal vector must be unit length.
    mi_math_assert_msg( abs( length( n) - T(1)) < eps, "precondition");
    // Sanity check: the other vector lengths should be finite and non-zero
    mi_math_assert_msg( length( u) > 0, "precondition");
    mi_math_assert_msg( length( v) > 0, "precondition");
    mi_math_assert_msg( isfinite( length( u)), "precondition");
    mi_math_assert_msg( isfinite( length( v)), "precondition");
 
    // Compute b
    *b = cross(u,n);
    b->normalize();
 
    // Compute t. Since *b and n are orthogonal and unit-length,
    // there is no need to normalize *t.
    *t = cross(n,*b);
 
    // Check that b has the same orientation of v
    if( dot( *b,v) < T(0))
        *b = -*b;
 
    // Sanity check: make sure *u and t have the same orientation.
    mi_math_assert_msg( dot( u, *t) > T(0), "postcondition");
    // Sanity check: make sure (t, n, b) is an orthogonal basis.
    // We use a scaled epsilon in order to avoid false positives.
    mi_math_assert_msg( abs( dot( *t,  n)) < 20*eps, "postcondition");
    mi_math_assert_msg( abs( dot( *t, *b)) < 20*eps, "postcondition");
    mi_math_assert_msg( abs( dot(  n, *b)) < 20*eps, "postcondition");
    // Sanity check: make sure t and b are unit length.
    mi_math_assert_msg( abs( length( *t) - T(1)) < eps, "postcondition");
    mi_math_assert_msg( abs( length( *b) - T(1)) < eps, "postcondition");
}
 
template <typename T2, Size DIM2, typename T1, Size DIM1>
inline Vector<T2, DIM2> convert_vector(
    const Vector<T1, DIM1>& v,
    const T2& fill = T2(0))
{
    const Size dim_min = base::min MI_PREVENT_MACRO_EXPAND ( DIM1, DIM2 );
    Vector<T2, DIM2> result;
    for( Size i = 0; i < dim_min; ++i)
        result[i] = T2(v[i]);
    for( Size i = dim_min; i < DIM2; ++i)
        result[i] = fill;
    return result;
}
 // end group mi_math_vector
 
} // namespace math
 
} // namespace mi
 
#endif // MI_MATH_VECTOR_H