UT_FixedVector.h

Go to the documentation of this file.

/*
 * PROPRIETARY INFORMATION.  This software is proprietary to
 * Side Effects Software Inc., and is not to be reproduced,
 * transmitted, or disclosed in any way without written permission.
 *
 * NAME:        UT_FixedVector.h (UT Library, C++)
 *
 * COMMENTS:
 *     A vector class templated on its scalar type and dimension.
 *
 *     All additional operations that work with UT_FixedVector should be 
 *     implemented as free-standing functions!
 *     Don't add any new members or friends.
 *
 */

#pragma once

#ifndef __UT_FixedVector__
#define __UT_FixedVector__

#include "UT_Assert.h"
#include "UT_FixedArrayMath.h"
#include "UT_FixedVectorTraits.h"

#include <SYS/SYS_Math.h>
#include <SYS/SYS_Types.h>
#include <SYS/SYS_TypeTraits.h>
#include <SYS/SYS_TypeDecorate.h>

template< typename T, exint D >
class UT_FixedVector
{
public:
    typedef T value_type;
    static constexpr int tuple_size = D;
    
    UT_FixedVector() = default;

    constexpr explicit UT_FixedVector( const T (&a)[ D ] ) noexcept :
        vec{}
    {
        UT::FA::Set< T, tuple_size >{}( vec, a );
    }

    template< typename S >
    constexpr explicit UT_FixedVector( const UT_FixedVector< S, D >& a ) noexcept :
        vec{}
    {
        UT::FA::Convert< T, tuple_size, S >{}( vec, a );
    }

    constexpr const T& operator[]( exint i ) const noexcept
    {
        UT_ASSERT_P( ( 0 <= i ) && ( i < tuple_size ) );

        return vec[ i ];
    }

    constexpr T& operator[]( exint i ) noexcept
    {
        UT_ASSERT_P( ( 0 <= i ) && ( i < tuple_size ) );

        return vec[ i ];
    }

    constexpr const T* data() const noexcept
    {
        return vec;
    }

    constexpr T* data() noexcept
    {
        return vec;
    }

    constexpr UT_FixedVector& operator+=( const UT_FixedVector& a ) noexcept
    {
        UT::FA::Add< T, tuple_size >{}( vec, a.vec );
        return *this;
    }

    constexpr UT_FixedVector& operator-=( const UT_FixedVector& a ) noexcept
    {
        UT::FA::Subtract< T, tuple_size >{}( vec, a.vec );
        return *this;
    }

    constexpr UT_FixedVector& operator*=( const T& a ) noexcept
    {
        UT::FA::Scale< T, tuple_size >{}( vec, a );
        return *this;
    }

    constexpr UT_FixedVector<T, D> operator-() const noexcept
    {
        UT_FixedVector t{ *this };
        UT::FA::Negate< T, tuple_size >{}( t.vec );
        return t;
    }

private:
    T vec[ D ];
    
    friend constexpr UT_FixedVector operator*( const T& a, const UT_FixedVector& b ) noexcept
    {
        UT_FixedVector r{ b };
        UT::FA::Scale< T, tuple_size >{}( r.vec, a );

        return r;
    }

    friend constexpr UT_FixedVector operator/( const UT_FixedVector& a, const T& b ) noexcept
    {
        UT_FixedVector r{ a };
        UT::FA::Divide< T, tuple_size >{}( r.vec, b );

        return r;
    }

    friend constexpr bool isZero( const UT_FixedVector& a ) noexcept
    {
        return UT::FA::IsUniformZero< T, tuple_size >{}( a.vec_ );
    }

    friend constexpr T dot( const UT_FixedVector& a, const UT_FixedVector& b ) noexcept
    {
        return UT::FA::Dot< T, tuple_size >{}( a.vec, b.vec );
    }

    friend constexpr T length2( const UT_FixedVector& a ) noexcept
    {
        return UT::FA::Length2< T, tuple_size >{}( a.vec );
    }

    friend constexpr T distance2( const UT_FixedVector& a, const UT_FixedVector& b ) noexcept
    {
        return UT::FA::Distance2< T, tuple_size >{}( a.vec, b.vec );
    }
    
    friend constexpr bool operator==( const UT_FixedVector& a, const UT_FixedVector& b ) noexcept
    {        
        return UT::FA::AreEqual< T, tuple_size >{}( a.vec, b.vec );
    }
    
    friend constexpr bool operator!=( const UT_FixedVector& a, const UT_FixedVector& b ) noexcept
    {
        return ! UT::FA::AreEqual< T, tuple_size >{}( a.vec, b.vec );
    }

    /// Lexicographic order comparison operators
    /// @{
    friend constexpr bool operator<( const UT_FixedVector& a, const UT_FixedVector& b ) noexcept
    {
        return UT::FA::TernaryOrder< T, tuple_size >{}( a.vec, b.vec ) < 0;
    }

    friend constexpr bool operator<=( const UT_FixedVector& a, const UT_FixedVector& b ) noexcept
    {
        return UT::FA::TernaryOrder< T, tuple_size >{}( a.vec, b.vec ) <= 0;
    }

    friend constexpr bool operator>( const UT_FixedVector& a, const UT_FixedVector& b ) noexcept
    {
        return UT::FA::TernaryOrder< T, tuple_size >{}( a.vec, b.vec ) > 0;
    }

    friend constexpr bool operator>=( const UT_FixedVector& a, const UT_FixedVector& b ) noexcept
    {
        return UT::FA::TernaryOrder< T, tuple_size >{}( a.vec, b.vec ) >= 0;
    }
    /// @}
};

template< typename T, exint D >
constexpr T length( const UT_FixedVector< T, D >& a ) noexcept
{
    return SYSsqrt( length2( a ) );
}

template< typename T, exint D >
constexpr T distance(
    const UT_FixedVector< T, D >& a,
    const UT_FixedVector< T, D >& b
) noexcept
{
    return SYSsqrt( distance2( a, b ) );
}

template< typename T, exint D >
constexpr T normalize( UT_FixedVector< T, D >& a ) noexcept
{
    return UT::FA::Normalize< T, D >{}( a, std::numeric_limits< T >::min() );
}

template< typename T, exint D >
constexpr UT_FixedVector< T, D > productComponentwise(
    const UT_FixedVector< T, D >& a,
    const UT_FixedVector< T, D >& b
) noexcept
{
    UT_FixedVector< T, D > t{ a };
    UT::FA::ScaleComponentwise< T, D >{}( t, b );
    return t;
}

template< typename T, exint D >
constexpr UT_FixedVector< T, D > quotientComponentwise(
    const UT_FixedVector< T, D >& a,
    const UT_FixedVector< T, D >& b
) noexcept
{
    UT_FixedVector< T, D > t{ a };
    UT::FA::DivideComponentwise< T, D >{}( t, b );
    return t;
}

// Function object that creates a uniform vector
template< typename T, exint D >
struct UT_FixedVectorUniform
{
    constexpr UT_FixedVector< T, D > operator()( const T& a ) noexcept
    {
        UT_FixedVector< T, D > t{};
        UT::FA::SetUniform< T, D >{}( t, a );
        return t;
    }
};

// Function object that creates a zero vector
template< typename T, exint D >
struct UT_FixedVectorZero
{
    constexpr UT_FixedVector< T, D > operator()() noexcept
    {
        return UT_FixedVectorUniform< T, D >{}( 0 );
    }
};

template< typename T, exint D >
constexpr UT_FixedVector< T, D > operator+( const UT_FixedVector< T, D >& a, const UT_FixedVector< T, D >& b ) noexcept
{
    UT_FixedVector< T, D > r{ a };
    r += b;
    return r;
}

template< typename T, exint D >
constexpr UT_FixedVector< T, D > operator-( const UT_FixedVector< T, D >& a, const UT_FixedVector< T, D >& b ) noexcept
{
    UT_FixedVector< T, D > r{ a };
    r -= b;
    return r;
}

template<typename T, exint D>
struct UT_FixedVectorTraits<UT_FixedVector<T, D> >
{
    typedef UT_FixedVector<T, D> FixedVectorType;
    typedef T DataType;
    static const exint TupleSize = D;
    static const bool isVectorType = true;
};
// UT_FixedVectorT in the role of a fixed-size array.

template< typename T, exint D >
struct SYS_IsFixedArrayNoCVRef< UT_FixedVector< T, D > > : std::integral_constant< bool, true > {};

template< typename T, exint D >
struct SYS_FixedArrayElementNoCVRef< UT_FixedVector< T, D > > : SYS_TypeIdentity< T > {};

template< typename T, exint D >
struct SYS_FixedArraySizeNoCVRef< UT_FixedVector< T, D > > : std::integral_constant< std::size_t, D > {};

// UT_FixedVectorFixed<T, D> is a function object that
// creates a UT_FixedVector<T, D> from a fixed array-like type TS,
// examples of which include T[D], UT_FixedVector<T, D> and UT_FixedArray<T, D> (AKA std::array<T, D>)
template<typename T, exint D>
struct UT_FixedVectorFixed
{    
    template< typename TS >
    constexpr UT_FixedVector<T, D> operator()(const TS& as) const noexcept
    {        
        SYS_STATIC_ASSERT( SYS_IsFixedArrayOf_v< TS, T, D > );

        T vec[D]{};

        for ( exint i = 0; i != D; ++i )
        {
            vec[ i ] = as[ i ];
        }

        return UT_FixedVector< T, D >( vec );
    }
};

// Convert a fixed array-like type TS into a UT_FixedVector< T >.
// This allows conversion to UT_FixedVector without fixing T and D.
// Instead, the element type of TS determines the type T and D.
template< typename TS >
constexpr UT_FixedVector< SYS_FixedArrayElement_t< TS >, SYS_FixedArraySize_v< TS > > 
UTmakeFixedVector( const TS& as ) noexcept
{
    using T = SYS_FixedArrayElement_t< TS >;
    constexpr exint D = SYS_FixedArraySize_v< TS >;

    return UT_FixedVectorFixed< T, D  >{}( as );
}

// UT_FromFixed<V> creates a V from a flat, fixed array-like representation

// Primary
template <typename V >
struct UT_FromFixed;

// Partial specialization for UT_FixedVector<T, D>
template<typename T, exint D>
struct UT_FromFixed< UT_FixedVector<T, D> > : UT_FixedVectorFixed<T, D> {};

// Relocation traits

template<typename T, exint D>
struct SafeTrivialRelocationNoCV< UT_FixedVector< T, D > > : SafeTrivialRelocationNoCV< T > {};

template<typename T, exint D>
struct UnsafeTrivialRelocationNoCV< UT_FixedVector< T, D > > : UnsafeTrivialRelocationNoCV< T > {};

#endif