Vector.hpp

/*--------------------------------------------------------------------------------------------
Copyright (c) 2019, NDEVR LLC
tyler.parke@ndevr.org
  __    __   ____     _____ __     __  _______
 |  \  |  | |  __ \  |  ___|\ \   / / |   __  \
 |   \ |  | | |  \ \ | |___  \ \ / /  |  |__)  |
 |  . \|  | | |__/ / | |___   \ V /   |   _   /
 |  |\    |_|_____/__|_____|___\_/____|  | \  \
 |__| \__________________________________|  \__\
 
Subject to the terms of the Enterprise+ Agreement, NDEVR hereby grants 
Licensee a limited, non-exclusive, non-transferable, royalty-free license 
(without the right to sublicense) to use the API solely for the purpose of 
Licensee's internal development efforts to develop applications for which 
the API was provided.
 
The above copyright notice and this permission notice shall be included in all 
copies or substantial portions of the Software.
 
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED,
INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR
PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE
FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
DEALINGS IN THE SOFTWARE.
 
Library: Base
File: Vector
Included in API: True
Author(s): Tyler Parke
 *-----------------------------------------------------------------------------------------**/
#pragma once
#include <NDEVR/BaseValues.h>
#include <NDEVR/LibAssert.h>
#include <type_traits>
#include <cmath>
#include <type_traits>
namespace NDEVR
{
    template<uint01 t_dims, class t_type>
    class Vector
    {
    public:
        constexpr Vector() noexcept
            : m_values()
        {}

        template<class t_vec_type>
        constexpr explicit Vector(const Vector<t_dims, t_vec_type>& vector) noexcept
            : m_values()
        {
            for (uint01 dim = 0; dim < t_dims; ++dim)
                m_values[dim] = cast<t_type>(vector[dim]);
        }

 
        constexpr explicit Vector(const t_type& scaler) noexcept
            : m_values()
        {
            for(uint01 dim = 0; dim < t_dims; ++dim)
                m_values[dim] = scaler;
        }

        template<uint01 tdims = t_dims>
        constexpr Vector(const t_type& x, typename std::enable_if<tdims == 2, const t_type&>::type y)
            : m_values{x, y}
        {
            static_assert(t_dims == 2, "Unexpected Number of Dimensions. Vector Size Required: 2");
        }

        template<uint01 tdims = t_dims>
        constexpr Vector(const t_type& x, const t_type& y, const typename std::enable_if<tdims == 3, const t_type&>::type z)
            : m_values{x, y, z}
        {
            static_assert(t_dims == 3, "Unexpected Number of Dimensions. Vector Size Required: 3");
        }

        template<uint01 tdims = t_dims>
        constexpr Vector(const t_type& x, const t_type& y, const t_type& z, typename std::enable_if<tdims == 4, const t_type&>::type w)
            : m_values{ x, y, z, w }
        {
            static_assert(t_dims == 4, "Unexpected Number of Dimensions. Vector Size Required: 4");
        }
 
        template<uint01 tdims = t_dims>
        constexpr Vector(const t_type& x, const t_type& y, const t_type& z, const t_type& w, typename std::enable_if<tdims == 5, const t_type&>::type v)
            : m_values{ x, y, z, w, v }
        {
            static_assert(t_dims == 5, "Unexpected Number of Dimensions. Vector Size Required: 5");
        }
 
        template<uint01 tdims = t_dims>
        constexpr Vector(const t_type& x, const t_type& y, const t_type& z, const t_type& w, const t_type& v, typename std::enable_if<tdims == 6, const t_type&>::type u)
            : m_values{ x, y, z, w, v, u }
        {
            static_assert(t_dims == 6, "Unexpected Number of Dimensions. Vector Size Required: 6");
        }
        template<uint01 tdims = t_dims>
        constexpr Vector(const t_type& x, const t_type& y, const t_type& z, const t_type& w, const t_type& v, const t_type& u, const t_type& t, const t_type& s, typename std::enable_if<tdims == 9, const t_type&>::type r)
            : m_values{ x, y, z, w, v, u, t, s, r }
        {
            static_assert(t_dims == 9, "Unexpected Number of Dimensions. Vector Size Required: 9");
        }
        constexpr explicit Vector(const t_type(&vector)[t_dims])
            : m_values{}
        {
            for (uint01 dim = 0; dim < t_dims; dim++)
                m_values[dim] = vector[dim];
        }

        template<uint01 tdims = t_dims>
        constexpr Vector(const Vector<tdims - 1, t_type>& vector, typename std::enable_if<tdims >= 2, const t_type&>::type suffix)
            : m_values{}
        {
            static_assert(t_dims >= 2, "Unexpected Number of Dimensions. Vector Size Required: >= 2");
            for(uint01 dim = 0; dim < t_dims - 1; ++dim)
                m_values[dim] = vector[dim];
            m_values[t_dims - 1] = suffix;
        }

        template<uint01 tdims = t_dims>
        constexpr Vector(const Vector<getMax(tdims - 2, 0), t_type>& vector, const t_type& suffix_a, typename std::enable_if<tdims >= 3, const t_type&>::type suffix_b)
            : m_values{}
        {
            static_assert(t_dims >= 3, "Unexpected Number of Dimensions. Vector Size Required: >= 3");
            for(uint01 dim = 0; dim < t_dims - 2; ++dim)
                m_values[dim] = vector[dim];
            m_values[t_dims - 2] = suffix_a;
            m_values[t_dims - 1] = suffix_b;
        }

        template<uint01 tdims = t_dims>
        constexpr Vector(const t_type& prefix, typename std::enable_if<tdims >= 2, const Vector<t_dims - 1, t_type>&>::type vector)
            : m_values{}
        {
            static_assert(t_dims >= 2, "Unexpected Number of Dimensions. Vector Size Required: >= 2");
            m_values[X] = prefix;
            for(uint01 dim = Y; dim < t_dims; ++dim)
                m_values[dim] = vector[dim - 1];
        }

        template<uint01 tdims = t_dims>
        constexpr Vector(const t_type& prefix_a, const t_type& prefix_b, typename std::enable_if<tdims >= 3, const Vector<tdims - 1, t_type>&>::type vector)
            : m_values{}
        {
            static_assert(t_dims >= 3, "Unexpected Number of Dimensions. Vector Size Required: >= 3");
            m_values[X] = prefix_a;
            m_values[Y] = prefix_b;
            for (uint01 dim = Z; dim < t_dims; ++dim)
                m_values[dim] = vector[dim - 1];
        }
        
        template<class t_new_type>
        constexpr decltype(auto) as() const
        {
            if constexpr (std::is_same_v<t_new_type, t_type>)
            {
                return static_cast<const Vector<t_dims, t_type>&>(*this);
            }
            else
            {
                Vector<t_dims, t_new_type> vec;
                for (uint01 dim = 0; dim < t_dims; ++dim)
                    vec[dim] = cast<t_new_type>(m_values[dim]);
                return vec;
            }
        }
        template<uint01 t_new_dim, class t_new_type>
        constexpr decltype(auto) as() const
        {
            if constexpr (t_new_dim == t_dims && std::is_same_v<t_new_type, t_type>)
            {
                return static_cast<const Vector<t_dims, t_type>&>(*this);
            }
            else
            {
                Vector<t_new_dim, t_new_type> vec;
                constexpr uint01 min = getMin(t_new_dim, t_dims);
                for (uint01 dim = 0; dim < min; ++dim)
                    vec[dim] = cast<t_new_type>(m_values[dim]);
                return vec;
            }
        }
        template<uint01 t_new_dim, class t_new_type>
        constexpr decltype(auto) as(t_new_type extra_fill_value) const
        {
            if constexpr (t_new_dim == t_dims && std::is_same_v<t_new_type, t_type>)
            {
                return static_cast<const Vector<t_dims, t_type>&>(*this);
            }
            else
            {
                Vector<t_new_dim, t_new_type> vec;
                uint01 dim = 0;
                constexpr uint01 min = getMin(t_new_dim, t_dims);
                for (; dim < min; dim++)
                    vec[dim] = cast<t_new_type>(m_values[dim]);
                for (; dim < t_new_dim; dim++)
                    vec[dim] = extra_fill_value;
                return vec;
            }
        }

        template<LocationValues t_max_min>
        [[nodiscard]] constexpr t_type dimensionalValue() const
        {
            t_type value = m_values[0];
            for(uint01 dim = 1; dim < t_dims; ++dim)
            {
                if constexpr(t_max_min == MAX)
                {
                    if(m_values[dim] > value)
                        value = m_values[dim];
                }
                else
                {
                    if(m_values[dim] < value)
                        value = m_values[dim];
                }
            }
            return value;
        }

        template<LocationValues t_max_min>
        [[nodiscard]] constexpr uint01 dimensionalIndex() const
        {
            uint01 dimension = 0;
            for(uint01 dim = 1; dim < t_dims; ++dim)
            {
                if constexpr (t_max_min == MAX)
                {
                    if (m_values[dim] > m_values[dimension])
                        dimension = dim;
                }
                else
                {
                    if(m_values[dim] < m_values[dimension])
                        dimension = dim;
                }
            }
            return dimension;
        }

        template<uint01 tdims = t_dims
            , typename = typename std::enable_if<tdims == 1>::type>
        constexpr operator t_type&()
        {
            return m_values[0];
        }
 
        template<uint01 tdims = t_dims
            , typename = typename std::enable_if<tdims == 1>::type>
        constexpr operator const t_type &() const
        {
            return m_values[0];
        }

        [[nodiscard]] constexpr t_type magnitudeSquared() const
        {
            t_type magnitude(0);
            for(uint01 dim = 0; dim < t_dims; ++dim)
                magnitude += m_values[dim] * m_values[dim];
            return magnitude;
        }

        template<class t_magnitude_type = t_type>
        constexpr t_magnitude_type magnitude() const
        {
            return cast<t_magnitude_type>(std::sqrt(cast<t_magnitude_type>(magnitudeSquared())));
        }
        

        template<class t_norm_type = t_type>
        constexpr Vector<t_dims, t_norm_type> normalized(Vector<t_dims, t_norm_type> value_if_nan = Constant<Vector<t_dims, t_norm_type>>::Invalid) const
        {
            t_norm_type magnitude = cast<t_norm_type>(magnitudeSquared());
            if(magnitude == 0)
                return value_if_nan;
            magnitude = (cast<t_norm_type>(1) / cast<t_norm_type>(sqrt(magnitude)));
            Vector<t_dims, t_norm_type> normalized;
            for (uint01 dim = 0; dim < t_dims; dim++)
            {
                normalized[dim] = cast<t_norm_type>(m_values[dim]) * magnitude;
            }
            return normalized;
        }
 

        [[nodiscard]] constexpr t_type product() const
        {
            t_type value = m_values[0];
            for(uint01 dim = 1; dim < t_dims; ++dim)
                value *= m_values[dim];
            return value;
        }

        [[nodiscard]] constexpr t_type sum() const
        {
            t_type value = m_values[0];
            for (uint01 dim = 1; dim < t_dims; ++dim)
                value += m_values[dim];
            return value;
        }

 
        constexpr t_type& operator[](uint01 dimension_index)
        {
        #if defined(__clang__) || defined(__GNUC__)
            if constexpr (__builtin_constant_p(dimension_index))
                static_assert(dimension_index < t_dims, "Dimension requested Exceeded maximum vector dimension");
        #endif
            lib_assert(dimension_index < t_dims, "Dimension requested Exceeded maximum vector dimension");
            return m_values[dimension_index];
        }
        constexpr const t_type& operator[](const uint01 dimension_index) const
        {
        #if defined(__clang__) || defined(__GNUC__)
            if constexpr (__builtin_constant_p(dimension_index))
                static_assert(dimension_index < t_dims, "Dimension requested Exceeded maximum vector dimension");
        #endif
            lib_assert(dimension_index < t_dims, "Dimension requested Exceeded maximum vector dimension");
            return m_values[dimension_index];
        }

        constexpr Vector<t_dims, t_type> operator-() const
        {
            Vector<t_dims, t_type> value;
            for(uint01 dim = 0; dim < t_dims; ++dim)
                value[dim] = -m_values[dim];
            return value;
        }

 
        constexpr Vector<t_dims, t_type>& operator=(const t_type& scaler)
        {
            for (uint01 dim = 0; dim < t_dims; ++dim)
                m_values[dim] = scaler;
            return *this;
        }

 
        constexpr static uint01 NumberOfDimensions() { return t_dims; }

        constexpr static t_type Type() { return t_type(); }
 
    protected:
        t_type m_values[t_dims];
    };
    
    static_assert(sizeof(Vector<3, fltp08>) == 24, "Bad Vector<3, fltp08> size");
    static_assert(sizeof(Vector<4, Vector<4, fltp08>>) == 128, "Bad Vector<4, Vector<4, fltp08>> size");
    template<uint01 t_dims, class t_type>
    constexpr bool operator==(const Vector<t_dims, t_type>& vec_a, const Vector<t_dims, t_type>& vec_b)
    {
        for (uint01 dim = 0; dim < t_dims; ++dim)
        {
            if (vec_a[dim] != vec_b[dim])
                return false;
        }
        return true;
    }

    template<uint01 t_dims, class t_type>
    constexpr bool operator!=(const Vector<t_dims, t_type>& vec_a, const Vector<t_dims, t_type>& vec_b)
    {
        for (uint01 dim = 0; dim < t_dims; ++dim)
        {
            if (vec_a[dim] != vec_b[dim])
                return true;
        }
        return false;
    }
 

    template<uint01 t_dims, class t_type>
    constexpr Vector<t_dims, t_type> quantize(const Vector<t_dims, t_type>& value, t_type d = cast<t_type>(1))
    {
        return (((value.template as<t_dims, fltp08>() / cast<fltp08>(d) + 0.5).template as<t_dims, sint08>()).template as<t_dims, fltp08>() * cast<fltp08>(d)).template as<t_dims, t_type>();
    }

    template<uint01 t_dims, class t_type>
    constexpr Vector<t_dims, t_type> quantize(const Vector<t_dims, t_type>& value, Vector<t_dims, t_type> d = Vector<t_dims, t_type>(1))
    {
        return (((value.template as<t_dims, fltp08>() 
            / d.template as<t_dims, fltp08>() + 0.5).template as<t_dims, uint08>()).template as<t_dims, fltp08>() 
            * d.template as<t_dims, fltp08>()).template as<t_dims, t_type>();
    }
    template<uint01 t_dims, class t_type>
    struct Constant<Vector<t_dims, t_type>>
    {
        constexpr const static Vector<t_dims, t_type> Invalid{ Constant<t_type>::Invalid };
        constexpr const static Vector<t_dims, t_type> Min{ Constant<t_type>::Min };
        constexpr const static Vector<t_dims, t_type> Max{ Constant<t_type>::Max };
    };
 
    template<uint01 t_dims, class t_type>
    static constexpr bool IsInvalid(const Vector<t_dims, t_type>& value)
    {
        for (uint01 dim = 0; dim < t_dims; ++dim)
        {
            if (IsInvalid(value[dim]))
                return true;
        }
        return false;
    }
    template<uint01 t_dims, class t_type>
    static constexpr bool IsValid(const Vector<t_dims, t_type>& value)
    {
        for (uint01 dim = 0; dim < t_dims; ++dim)
        {
            if (IsInvalid(value[dim]))
                return false;
        }
        return true;
    }
    template < template <uint01 t_dims, class t_type> class base, typename derived>
    struct is_base_of_template_impl
    {
        template<uint01 t_dims, class t_type>
        static constexpr std::true_type  test(const base<t_dims, t_type>*);
        static constexpr std::false_type test(...);
        using type = decltype(test(std::declval<derived*>()));
    };
 
    template < template <uint01 t_dims, class t_type> class base, typename derived>
    using is_base_of_template = typename is_base_of_template_impl<base, derived>::type;
 
    template<class t_type>
    struct IsVec
    {
        static constexpr bool value = is_base_of_template<Vector, t_type>::value;
    };
    template<class t_type_a, class t_type_b>
    struct IsSameType
    {
        static constexpr bool value = false;
    };
    template<class t_type_a>
    struct IsSameType<t_type_a, t_type_a>
    {
        static constexpr bool value = true;
    };
    template<class t_type_a, class t_type_b>
    struct IsVecType
    {
    private:
        template<class t = t_type_a, std::enable_if_t<!IsVec<t>::value, int> = 0>
        static constexpr bool internalValue()
        {
            return false;
        }
        template<class t = t_type_a, std::enable_if_t<IsVec<t>::value, int> = 0>
        static constexpr bool internalValue()
        {
            return IsSameType<decltype(t::Type()), t_type_b>::value;
        }
    public:
        static constexpr bool value = internalValue();
    };
};
namespace std//Define things to allow use within std libs
{
    template <>
    struct hash<Vector<2, uint04>>
    {
        std::size_t operator()(const Vector<2, uint04>& s) const noexcept
        {
            std::size_t h = 0, g = 0;
            const uint01* bytes = reinterpret_cast<const uint01*>(&s[0]);
            for (size_t i = 0; i < 2 * sizeof(uint04); i++)
            {
                h = (h << 4) + bytes[i];
                g = h & 0xF0000000L;
                if (g)
                    h ^= g >> 24;
                h &= ~g;
            }
            return h;
        }
    };
    template <>
    struct hash<Vector<3, uint04>>
    {
        std::size_t operator()(const Vector<3, uint04>& s) const noexcept
        {
            std::size_t h = 0, g = 0;
            const uint01* bytes = reinterpret_cast<const uint01*>(&s[0]);
            for (size_t i = 0; i < 3 * sizeof(uint04); i++)
            {
                h = (h << 4) + bytes[i];
                g = h & 0xF0000000L;
                if (g)
                    h ^= g >> 24;
                h &= ~g;
            }
            return h;
        }
    };
    template <>
    struct hash<Vector<3, fltp08>>
    {
        std::size_t operator()(const Vector<3, fltp08>& s) const noexcept
        {
            std::size_t h = 0, g = 0;
            const uint01* bytes = reinterpret_cast<const uint01*>(&s[0]);
            for (size_t i = 0; i < 3 * sizeof(fltp08); i++)
            {
                h = (h << 4) + bytes[i];
                g = h & 0xF0000000L;
                if (g)
                    h ^= g >> 24;
                h &= ~g;
            }
            return h;
        }
    };
    template <>
    struct hash<Vector<3, fltp04>>
    {
        std::size_t operator()(const Vector<3, fltp04>& s) const noexcept
        {
            std::size_t h = 0, g = 0;
            const uint01* bytes = reinterpret_cast<const uint01*>(&s[0]);
            for (uint04 i = 0; i < 3 * sizeof(fltp04); i++)
            {
                h = (h << 4) + bytes[i];
                g = h & 0xF0000000L;
                if (g)
                    h ^= g >> 24;
                h &= ~g;
            }
            return h;
        }
    };
};
#include "BoolVector.hpp"