Vector.hpp

Go to the documentation of this file.

/*--------------------------------------------------------------------------------------------
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
{
    /**--------------------------------------------------------------------------------------------------
    Class: Vector
    \brief A fixed-size array with better performance compared to dynamic containers.
    
    An element of a vector space. An element of the real coordinate space Rn basis vector, one of a set 
    of vectors (a "basis") that, in linear combination, can represent every vector in a given vector space
    column vector or row vector, a one-dimensional matrix often representing the solution of a system of linear equations
    coordinate vector, in linear algebra, an explicit representation of an element of any abstract vector space.
    Used as the basis for Vertex class, Ray class, Point class etc. Simply stores x,y,z etc in linear memory.
    
    t_dims: The number of dimensions used in a vector.
    t_type: The numerical type used to store the value in each dimension. This may be a bool, float, integer, angle, or even another vector
    for multidimensional groupings.
 
    Author: Tyler Parke
    
    Date: 2017-09-13
    **/
    template<uint01 t_dims, class t_type>
    class Vector
    {
    public:
        constexpr Vector() noexcept
            : m_values()
        {}
 
        /**--------------------------------------------------------------------------------------------------
                Copy constructor.
 
        Author: Tyler Parke
 
        Date: 2017-11-13
 
        Parameters:
        vector -  The vector to copy to this vector.
        **/
        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]);
        }
 
        /**--------------------------------------------------------------------------------------------------
                Sets values in each dimension to the value in the passed in scaler
        
        Author: Tyler Parke
        
        Date: 2017-09-13
        
        Parameters:
        scaler -  The scaler to set all dimensions to.
        **/
 
        constexpr explicit Vector(const t_type& scaler) noexcept
            : m_values()
        {
            for(uint01 dim = 0; dim < t_dims; ++dim)
                m_values[dim] = scaler;
        }
 
        /**--------------------------------------------------------------------------------------------------
                Sets values in each dimension to the respective value in the passed in scaler. Note the Vector must
        be 2 dimensions to use this function.
 
        Author: Tyler Parke
 
        Date: 2017-09-13
 
        Parameters:
        x -  The scaler to set the 0th or X dimension to
        y -  The scaler to set the 1st or Y dimension to
        **/
        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");
        }
 
        /**--------------------------------------------------------------------------------------------------
                Sets values in each dimension to the respective value in the passed in scaler. Note the Vector must
        be 3 dimensions to use this function.
 
        Author: Tyler Parke
 
        Date: 2017-09-13
 
        Parameters:
        x -  The scaler to set the 0th or X dimension to
        y -  The scaler to set the 1st or Y dimension to
        z -  The scaler to set the 2nd or Z dimension to
        **/
        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");
        }
 
        /**--------------------------------------------------------------------------------------------------
                Sets values in each dimension to the respective value in the passed in scaler. Note the Vector must
        be 4 dimensions to use this function.
 
        Author: Tyler Parke
 
        Date: 2017-09-13
 
        Parameters:
        x -  The scaler to set the 0th or X dimension to
        y -  The scaler to set the 1st or Y dimension to
        z -  The scaler to set the 2nd or Z dimension to
        w -  The scaler to set the 3rd or W dimension to
        **/
        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");
        }
        /**--------------------------------------------------------------------------------------------------
                Given a container of statically determined array, transforms it to a vector
        
        Author: Tyler Parke
        
        Date: 2017-11-13
        
        Parameters:
        vector -  The vector container object.
        **/
        constexpr explicit Vector(const t_type(&vector)[t_dims])
            : m_values{}
        {
            for (uint01 dim = 0; dim < t_dims; dim++)
                m_values[dim] = vector[dim];
        }
 
        /**--------------------------------------------------------------------------------------------------
                Vectors.  Creates a vector where the prefix vector is combined with the suffix scalers. 
        
        Author: Tyler Parke
        
        Date: 2017-11-13
        
        Parameters:
        vector -    The vector.
        postfix -   The postfix.
        **/
        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;
        }
 
        /**--------------------------------------------------------------------------------------------------
                
        Vectors. Creates a vector where the prefix vector is combined with the suffix scalers. 
        
        Author: Tyler Parke
        
        Date: 2017-11-13
        
        Parameters:
        vector -     The vector.
        postfix_a -  The postfix a.
        postfix_b -  The postfix b.
        **/
        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;
        }
 
        /**--------------------------------------------------------------------------------------------------
                Vectors. Creates a vector where the prefix scaler is combined with the suffix vector. 
        
        Author: Tyler Parke
        
        Date: 2017-11-13
        
        Parameters:
        prefix -    The prefix.
        vector -    The vector.
        **/
        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];
        }
        /**--------------------------------------------------------------------------------------------------
                Vectors. Creates a vector where the prefix scaler values are combined with the suffix vector.
 
        Author: Tyler Parke
 
        Date: 2017-11-13
 
        Parameters:
        prefix_a -    The first prefix.
        prefix_b -    The second prefix.
        vector -    The vector.
        **/
        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];
        }
        
        /**--------------------------------------------------------------------------------------------------
                As the given extra fill value.
        
        Author: Tyler Parke
        
        Date: 2017-11-13
        
        Parameters:
        extra_fill_value -  (Optional) The extra fill value, or value to set dimensions extra that may be
        created when t_new_dim > t_dim.
        
        \returns A Vector&lt;t_new_dim,t_new_type&gt;
        **/
        template<class t_new_type>
        constexpr Vector<t_dims, t_new_type> as() const
        {
            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 Vector<t_new_dim, t_new_type> as() const
        {
            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 Vector<t_new_dim, t_new_type> as(t_new_type extra_fill_value) const
        {
            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;
        }
 
        /**--------------------------------------------------------------------------------------------------
                Used with template arguments MAX or MIN, Gets the dimensional value for the value that is either
        max or min.
        
        Author: Tyler Parke
        
        Date: 2017-11-13
        
        \returns The value of the dimension that is either max or min depending on the template t_max_min.
        **/
        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;
        }
 
        /**--------------------------------------------------------------------------------------------------
                Used with template arguments MAX or MIN, Gets the dimensional index for the value that is either
        max or min.
        
        Author: Tyler Parke
        
        Date: 2017-11-13
        
        \returns The index of the dimension that is either max or min depending on the template t_max_min.
        **/
        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;
        }
 
        /**--------------------------------------------------------------------------------------------------
                For Single dimensional objects, they may also be considered a scaler, thus allow implicit conversion
        from a vector to a scaler when the dimension of the vector is 1.
        
        Author: Tyler Parke
        
        Date: 2017-11-13
        
        \returns The result of the operation.
        **/
        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];
        }
 
        /**--------------------------------------------------------------------------------------------------
                Vectors are commonly used to model forces such as wind, sea current, gravity, and electromagnetism. 
        Calculating the magnitude of vectors is essential for all sorts of problems where forces collide.
 
        Magnitude is defined as the length of a vector. The notation for absolute value. Thus magnitude
        is the same as length of vector.
        
        Author: Tyler Parke
        
        Date: 2017-11-13
        
        \returns The magnitude, or length, of the vector squared.
        **/
        [[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;
        }
 
        /**--------------------------------------------------------------------------------------------------
                Vectors are commonly used to model forces such as wind, sea current, gravity, and electromagnetism. 
        Calculating the magnitude of vectors is essential for all sorts of problems where forces collide.
 
        Magnitude is defined as the length of a vector. The notation for absolute value. Thus magnitude
        is the same as length of vector.
        
        Author: Tyler Parke
        
        Date: 2017-11-13
        
        \returns The magnitude, or length, of the vector.
        **/
        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())));
        }
        
 
        /**--------------------------------------------------------------------------------------------------
                Gets the normalized, or unit length representation of this vector.
        
        Author: Tyler Parke
        
        Date: 2017-11-13
        
        \returns A Vector&lt;t_dims,t_norm_type&gt representing the normalized form of this vector;
        **/
        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;
        }
 
 
        /**--------------------------------------------------------------------------------------------------
                Returns the product, or value of each dimension multiplied together. 
        
        Author: Tyler Parke
        
        Date: 2017-11-13
        
        \returns The value of each dimension multiplied together.
        **/
        [[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;
        }
 
        /**--------------------------------------------------------------------------------------------------
                Returns the sum, or value of each dimension added together. 
        
        Author: Tyler Parke
        
        Date: 2017-11-13
        
        \returns The value of each dimension added together.
        **/
        [[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;
        }
 
        /**--------------------------------------------------------------------------------------------------
                Accesses the value of a certain dimension.
 
        Author: Tyler Parke
 
        Date: 2017-11-13
 
        Parameters:
        dimension_index -  The dimensional index of the the value we wish to retrieve.
 
        \returns The value at the given dimension_index.
        **/
 
        constexpr t_type& operator[](uint01 dimension_index)
        {
            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
        {
            lib_assert(dimension_index < t_dims, "Dimension requested Exceeded maximum vector dimension");
            return m_values[dimension_index];
        }
 
        /**--------------------------------------------------------------------------------------------------
                Negation operator.
        
        Author: Tyler Parke
        
        Date: 2017-11-13
        
        \returns A vector where each dimension is the opposite(-) of the original dimension 
        **/
        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;
        }
 
        /**--------------------------------------------------------------------------------------------------
                Assignment operator.
        
        Author: Tyler Parke
        
        Date: 2017-11-13
        
        Parameters:
        vector -  The vector to set this vector to.
        
        \returns A reference of this object (Useful for chaining '=' together).
        **/
 
        /*constexpr Vector<t_dims, t_type>& operator=(const Vector<t_dims, t_type>& vector)
        {
            for (uint01 dim = 0; dim < t_dims; ++dim)
                m_values[dim] = vector[dim];
            return *this;
        }*/
 
        /**--------------------------------------------------------------------------------------------------
                Assignment operator. Sets all values to the value provided in scaler argument.
        
        Author: Tyler Parke
        
        Date: 2017-11-13
        
        Parameters:
        scaler -  The scaler to set each dimension to.
        
        \returns A reference of this object (Useful for chaining '=' together).
        **/
 
        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;
        }
 
        /**--------------------------------------------------------------------------------------------------
                Number of dimensions in this vector class.
        
        Author: Tyler Parke
        
        Date: 2017-11-13
        
        \returns The total number of dimensions in this vector space.
        **/
 
        constexpr static uint01 NumberOfDimensions() { return t_dims; }
 
        /**--------------------------------------------------------------------------------------------------
                Returns the type of this class. Useful for using decltype to instantiate a member of this class in a
        static environment.
 
        Author: Tyler Parke
 
        Date: 2017-11-13
 
        \returns The type of this class. Object is inavlid outside of decl.
        **/
        constexpr static t_type Type() { return t_type(); }
 
    protected:
        /** The values[t dims]. */
        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");
    /**--------------------------------------------------------------------------------------------------
        
    Equality operator. Performs the '==' operation on the value in each dimension.
    
    Author: Tyler Parke
    
    Date: 2017-11-13
    
    Parameters:
    vec_a -     The first instance to compare.
    vec_b -     The second instance to compare.
    
    \returns True if the value in each vector dimension is considered equivalent.
    **/
    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;
    }
 
    /**--------------------------------------------------------------------------------------------------
        
    Inequality operator. Performs the '!=' operation on the value in each dimension.
    
    Author: Tyler Parke
    
    Date: 2017-11-13
    
    Parameters:
    vec_a -     The first instance to compare.
    vec_b -     The second instance to compare.
    
    \returns True  if any of the values in each vector dimension is not considered equivalent.
    **/
    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;
    }
 
 
    /**--------------------------------------------------------------------------------------------------
        
    Quantizes.
    
    Author: Tyler Parke
    
    Date: 2017-11-13
    
    Parameters:
    a -         A Vector&lt;t_dims,t_type&gt; to process.
    d -         (Optional) A t_type to process.
    
    \returns A Vector&lt;t_dims,t_type&gt;
    **/
    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>();
    }
 
    /**--------------------------------------------------------------------------------------------------
        
    Quantizes.
    
    Author: Tyler Parke
    
    Date: 2017-11-13
    
    Parameters:
    a -           A Vector&lt;t_dims,t_type&gt; to process.
    d -           (Optional) A Vector&lt;t_dims,t_type&gt; to process.
    parameter3 -  The third parameter.
    
    \returns A Vector&lt;t_dims,t_type&gt;
    **/
    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>();
    }
 
 
    /**--------------------------------------------------------------------------------------------------
    Struct: Constant<Vector<t_dims,t_type>>
 
    A constant.
 
    Author: Tyler Parke
 
    Date: 2017-11-13
    **/
    template<uint01 t_dims, class t_type>
    struct Constant<Vector<t_dims, t_type>>
    {
        /** The Invalid value. This is the value that means the vector is 'not valid' or has an unset dimension. */
        constexpr const static Vector<t_dims, t_type> Invalid{ Constant<t_type>::Invalid };
        /** The minimum. For each dimension, the value will be the minimum value*/
        constexpr const static Vector<t_dims, t_type> Min{ Constant<t_type>::Min };
        /** The maximum. For each dimension, the value will be the maximum value */
        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 < 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<NDEVR::Vector<2, NDEVR::uint04>>
    {
        std::size_t operator()(const NDEVR::Vector<2, NDEVR::uint04>& s) const noexcept
        {
            std::size_t h = 0, g = 0;
            const NDEVR::uint01* bytes = reinterpret_cast<const NDEVR::uint01*>(&s[0]);
            for (size_t i = 0; i < 2 * sizeof(NDEVR::uint04); i++)
            {
                h = (h << 4) + bytes[i];
                g = h & 0xF0000000L;
                if (g)
                    h ^= g >> 24;
                h &= ~g;
            }
            return h;
        }
    };
    template <>
    struct hash<NDEVR::Vector<3, NDEVR::uint04>>
    {
        std::size_t operator()(const NDEVR::Vector<3, NDEVR::uint04>& s) const noexcept
        {
            std::size_t h = 0, g = 0;
            const NDEVR::uint01* bytes = reinterpret_cast<const NDEVR::uint01*>(&s[0]);
            for (size_t i = 0; i < 3 * sizeof(NDEVR::uint04); i++)
            {
                h = (h << 4) + bytes[i];
                g = h & 0xF0000000L;
                if (g)
                    h ^= g >> 24;
                h &= ~g;
            }
            return h;
        }
    };
    template <>
    struct hash<NDEVR::Vector<3, NDEVR::fltp08>>
    {
        std::size_t operator()(const NDEVR::Vector<3, NDEVR::fltp08>& s) const noexcept
        {
            std::size_t h = 0, g = 0;
            const NDEVR::uint01* bytes = reinterpret_cast<const NDEVR::uint01*>(&s[0]);
            for (size_t i = 0; i < 3 * sizeof(NDEVR::fltp08); i++)
            {
                h = (h << 4) + bytes[i];
                g = h & 0xF0000000L;
                if (g)
                    h ^= g >> 24;
                h &= ~g;
            }
            return h;
        }
    };
    template <>
    struct hash<NDEVR::Vector<3, NDEVR::fltp04>>
    {
        std::size_t operator()(const NDEVR::Vector<3, NDEVR::fltp04>& s) const noexcept
        {
            std::size_t h = 0, g = 0;
            const NDEVR::uint01* bytes = reinterpret_cast<const NDEVR::uint01*>(&s[0]);
            for (NDEVR::uint04 i = 0; i < 3 * sizeof(NDEVR::fltp04); i++)
            {
                h = (h << 4) + bytes[i];
                g = h & 0xF0000000L;
                if (g)
                    h ^= g >> 24;
                h &= ~g;
            }
            return h;
        }
    };
};
#include "BoolVector.hpp"