VectorFunctions.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: VectorFunctions
Included in API: True
Author(s): Tyler Parke
 *-----------------------------------------------------------------------------------------**/
#pragma once
#include <NDEVR/Vector.h>
#include <cmath> 
 
namespace NDEVR
{
    class VectorFunctions
    {};

    template<class t_vector_type, uint01 t_dims, class t_type>
    constexpr typename std::enable_if<std::is_base_of<Vector<t_dims, t_type>, t_vector_type>::value, t_vector_type>::type
    operator+(const t_vector_type& vec_a, const Vector<t_dims, t_type>& vec_b)
    {
        t_vector_type sum;
        for (uint01 dim = 0; dim < t_dims; ++dim)
            sum[dim] = vec_a[dim] + vec_b[dim];
        return sum;
    }

    template<uint01 t_dims, class t_type>
    constexpr Vector<t_dims, t_type> operator+(const t_type& scaler_a, const Vector<t_dims, t_type>& vec_b)
    {
        Vector<t_dims, t_type> sum;
        for (uint01 dim = 0; dim < t_dims; ++dim)
            sum[dim] = scaler_a + vec_b[dim];
        return sum;
    }

    template<class t_vector_type, class t_type>
    constexpr typename std::enable_if<IsVecType<t_vector_type, t_type>::value, t_vector_type>::type
    operator+(const t_vector_type& vec_a, const t_type& scaler_b)
    {
        t_vector_type sum;
        for (uint01 dim = 0; dim < t_vector_type::NumberOfDimensions(); ++dim)
            sum[dim] = vec_a[dim] + scaler_b;
        return sum;
    }
    template<class t_vector_type, class t_type>
    constexpr typename std::enable_if<IsVecType<t_vector_type, t_type>::value, t_vector_type>::type
    operator+(const t_type& scaler_a, const t_vector_type& vec_b)
    {
        t_vector_type sum;
        for (uint01 dim = 0; dim < t_vector_type::NumberOfDimensions(); ++dim)
            sum[dim] = scaler_a + vec_b[dim];
        return sum;
    }

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

    template<uint01 t_dims, class t_type>
    constexpr Vector<t_dims, t_type>& operator+=(Vector<t_dims, t_type>& vec_a, t_type scaler_b)
    {
        for (uint01 dim = 0; dim < t_dims; ++dim)
            vec_a[dim] += scaler_b;
        return vec_a;
    }

    template<class t_vector_type, uint01 t_dims, class t_type>
    constexpr typename std::enable_if<std::is_base_of<Vector<t_dims, t_type>, t_vector_type>::value, t_vector_type>::type
    operator-(const t_vector_type& vec_a, const Vector<t_dims, t_type>& vec_b)
    {
        t_vector_type difference;
        for (uint01 dim = 0; dim < t_dims; ++dim)
            difference[dim] = vec_a[dim] - vec_b[dim];
        return difference;
    }

    template<uint01 t_dims, class t_type>
    constexpr Vector<t_dims, t_type> operator-(const t_type& value_a, const Vector<t_dims, t_type>& vec_b)
    {
        Vector<t_dims, t_type> difference;
        for (uint01 dim = 0; dim < t_dims; ++dim)
            difference[dim] = value_a - vec_b[dim];
        return difference;
    }

    template<class t_vector_type, class t_type>
    constexpr typename std::enable_if<IsVecType<t_vector_type, t_type>::value, t_vector_type>::type
    operator-(const t_vector_type& vec_a, const t_type& value_b)
    {
        t_vector_type difference;
        for (uint01 dim = 0; dim < t_vector_type::NumberOfDimensions(); ++dim)
            difference[dim] = vec_a[dim] - value_b;
        return difference;
    }

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

    template<uint01 t_dims, class t_type>
    constexpr Vector<t_dims, t_type> operator-=(Vector<t_dims, t_type>& vec_a, t_type value_b)
    {
        for (uint01 dim = 0; dim < t_dims; ++dim)
            vec_a[dim] -= value_b;
        return vec_a;
    }

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

    template<class t_vector_type, class t_type>
    constexpr typename std::enable_if<IsVecType<t_vector_type, t_type>::value, t_vector_type>::type
    operator*(const t_type& value_a, const t_vector_type& vec_b)
    {
        t_vector_type product;
        for (uint01 dim = 0; dim < t_vector_type::NumberOfDimensions(); ++dim)
            product[dim] = value_a * vec_b[dim];
        return product;
    }

    template<class t_vector_type, class t_type>
    constexpr typename std::enable_if<IsVecType<t_vector_type, t_type>::value, t_vector_type>::type
    operator*(const t_vector_type& vec_a, const t_type& value_b)
    {
        t_vector_type product;
        for (uint01 dim = 0; dim < t_vector_type::NumberOfDimensions(); ++dim)
            product[dim] = vec_a[dim] * value_b;
        return product;
    }

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

    template<uint01 t_dims, class t_type>
    constexpr Vector<t_dims, t_type>& operator*=(Vector<t_dims, t_type>& vec_a, t_type value_b)
    {
        for (uint01 dim = 0; dim < t_dims; ++dim)
            vec_a[dim] *= value_b;
        return vec_a;
    }

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

    template<class t_vector_type, class t_type>
    constexpr typename std::enable_if<IsVecType<t_vector_type, t_type>::value, t_vector_type>::type
    operator/(const t_type& value_a, const t_vector_type& vec_b)
    {
        t_vector_type quotient;
        for (uint01 dim = 0; dim < t_vector_type::NumberOfDimensions(); ++dim)
            quotient[dim] = value_a / vec_b[dim];
        return quotient;
    }

    template<class t_vector_type, class t_type>
    constexpr typename std::enable_if<IsVecType<t_vector_type, t_type>::value, t_vector_type>::type
    operator/(const t_vector_type& vec_a, const t_type& value_b)
    {
        t_vector_type quotient;
        for (uint01 dim = 0; dim < t_vector_type::NumberOfDimensions(); ++dim)
            quotient[dim] = vec_a[dim] / value_b;
        return quotient;
    }
 

    /*template<uint01 t_dims, class t_type>
    constexpr Vector<t_dims, t_type> operator^(const Vector<t_dims, t_type>& vec_a, const Vector<t_dims, t_type>& vec_b)
    {
        Vector<t_dims, t_type> xor;
        for (uint01 dim = 0; dim < t_dims; ++dim)
            xor[dim] = vec_a[dim] ^ vec_b[dim];
        return xor;
    }*/
 
 
    template<uint01 t_dims, class t_type>
    constexpr Vector<t_dims, t_type> operator%(const Vector<t_dims, t_type>& vec_a, const Vector<t_dims, t_type>& vec_b)
    {
        Vector<t_dims, t_type> mod;
        for (uint01 dim = 0; dim < t_dims; ++dim)
            mod [dim] = std::fmod(vec_a[dim], vec_b[dim]);
        return mod;
    }
    template<uint01 t_dims, class t_type>
    constexpr Vector<t_dims, t_type> operator%(const Vector<t_dims, t_type>& vec_a, const t_type& value_b)
    {
        Vector<t_dims, t_type> mod;
        for (uint01 dim = 0; dim < t_dims; ++dim)
            mod[dim] = cast<t_type>(::fmod(vec_a[dim], value_b));
        return mod;
    }
    

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

    template<uint01 t_dims, class t_type>
    constexpr Vector<t_dims, t_type>& operator/=(Vector<t_dims, t_type>& vec_a, t_type value_b)
    {
        for (uint01 dim = 0; dim < t_dims; ++dim)
            vec_a[dim] = vec_a[dim] / value_b;
        return vec_a;
    }
 
    template<class t_vector_type, class t_type>
    constexpr typename std::enable_if<IsVecType<t_vector_type, t_type>::value, bool>::type
    operator==(const t_vector_type& v, const t_type& s)
    {
        for (uint01 dim = 0; dim < t_vector_type::NumberOfDimensions(); dim++)
        {
            if (v[dim] != s)
                return false;
        }
        return true;
    }
    template<class t_vector_type, class t_type>
    constexpr typename std::enable_if<IsVecType<t_vector_type, t_type>::value, bool>::type
    operator==(const t_type& s, const t_vector_type& v)
    {
        for (uint01 dim = 0; dim < t_vector_type::NumberOfDimensions(); dim++)
        {
            if (v[dim] != s)
                return false;
        }
        return true;
    }
    template<class t_vector_type>
    constexpr typename std::enable_if<IsVec<t_vector_type>::value, bool>::type
    operator==(const t_vector_type& v_a, const t_vector_type& v_b)
    {
        for (uint01 dim = 0; dim < t_vector_type::NumberOfDimensions(); dim++)
        {
            if (v_a[dim] != v_b[dim])
                return false;
        }
        return true;
    }
    template<class t_type>
    constexpr typename std::enable_if<!IsVec<t_type>::value, bool>::type
    AreSame(const t_type& a, const t_type& b)
    {
        return (a == b) || (IsInvalid(a) && IsInvalid(b));
    }
    template<class t_type>
    constexpr typename std::enable_if<!IsVec<t_type>::value, bool>::type
    AreSame(const t_type& a, const t_type& b, const t_type& epsilon)
    {
        return (IsInvalid(a) && IsInvalid(b))
            || ::abs(a - b) < epsilon;
    }
    //Equal but with nans
    template<class t_vector_type>
    constexpr typename std::enable_if<IsVec<t_vector_type>::value, bool>::type
    AreSame(const t_vector_type& v_a, const t_vector_type& v_b)
    {
        for (uint01 dim = 0; dim < t_vector_type::NumberOfDimensions(); dim++)
        {
            if (!AreSame(v_a[dim], v_b[dim]))
                return false;
        }
        return true;
    }
    template<class t_vector_type, class t_type>
    constexpr typename std::enable_if<IsVec<t_vector_type>::value, bool>::type
    AreSame(const t_vector_type& v_a, const t_vector_type& v_b, const t_type& epsilon)
    {
        return (IsInvalid(v_a) && IsInvalid(v_b))
            || abs(v_a - v_b) < epsilon;
    }
    template<class t_vector_type>
    constexpr typename std::enable_if<IsVec<t_vector_type>::value, bool>::type
    operator!=(const t_vector_type& v_a, const t_vector_type& v_b)
    {
        for (uint01 dim = 0; dim < t_vector_type::NumberOfDimensions(); dim++)
        {
            if (v_a[dim] != v_b[dim])
                return true;
        }
        return false;
    }
    template<class t_vector_type, class t_type>
    constexpr typename std::enable_if<IsVecType<t_vector_type, t_type>::value, bool>::type
    operator!=(const t_vector_type& v, const t_type& s)
    {
        for (uint01 dim = 0; dim < t_vector_type::NumberOfDimensions(); dim++)
        {
            if (v[dim] != s)
                return true;
        }
        return false;
    }
    template<class t_vector_type, class t_type>
    constexpr typename std::enable_if<IsVecType<t_vector_type, t_type>::value, bool>::type
    operator!=(const t_type& s, const t_vector_type& v)
    {
        for (uint01 dim = 0; dim < t_vector_type::NumberOfDimensions(); dim++)
        {
            if (v[dim] != s)
                return true;
        }
        return false;
    }

    template<uint01 vec_1_size, uint01 vec_2_size, class t_type>
    constexpr bool operator>=(const Vector<vec_1_size, t_type>& v1, const Vector<vec_2_size, t_type>& v2)
    {
        const uint01 min_val = getMin(vec_1_size, vec_2_size);
        for (uint01 dim = 0; dim < min_val; ++dim)
        {
            if (!(v1[dim] >= v2[dim]))
                return false;
        }
        return true;
    }
 
    template<uint01 t_dims, class t_type>
    constexpr bool operator>=(const Vector<t_dims, t_type>& v1, const t_type& s)
    {
        for (uint01 dim = 0; dim < t_dims; ++dim)
        {
            if (!(v1[dim] >= s))
                return false;
        }
        return true;
    }
 

    template<uint01 vec_1_size, uint01 vec_2_size, class t_type>
    constexpr bool operator>(const Vector<vec_1_size, t_type>& v1, const Vector<vec_2_size, t_type>& v2)
    {
        const uint01 min_val = getMin(vec_1_size, vec_2_size);
        for (uint01 dim = 0; dim < min_val; ++dim)
        {
            if (!(v1[dim] > v2[dim]))
                return false;
        }
        return true;
    }
 
    template<uint01 vec_1_size, uint01 vec_2_size, class t_type>
    constexpr bool operator<(const Vector<vec_1_size, t_type>& v1, const Vector<vec_2_size, t_type>& v2)
    {
        const t_type min_val = getMin(vec_1_size, vec_2_size);
        for (uint01 dim = 0; dim < min_val; ++dim)
        {
            if (!(v1[dim] < v2[dim]))
                return false;
        }
        return true;
    }
    template<uint01 vec_1_size, uint01 vec_2_size, class t_type>
    constexpr bool operator<=(const Vector<vec_1_size, t_type>& v1, const Vector<vec_2_size, t_type>& v2)
    {
        const uint01 min_val = getMin(vec_1_size, vec_2_size);
        for (uint01 dim = 0; dim < min_val; ++dim)
        {
            if (!(v1[dim] <= v2[dim]))
                return false;
        }
        return true;
    }

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

    template<uint01 t_dims, class t_type>
    constexpr bool operator>(const Vector<t_dims, t_type>& v1, const Vector<t_dims, t_type>& v2)
    {
        for (uint01 dim = 0; dim < t_dims; dim++)
        {
            if (!(v1[dim] > v2[dim]))
                return false;
        }
        return true;
    }
 
    template<uint01 t_dims, class t_type>
    constexpr bool operator<(const Vector<t_dims, t_type>& v1, const Vector<t_dims, t_type>& v2)
    {
        for (uint01 dim = 0; dim < t_dims; dim++)
        {
            if (!(v1[dim] < v2[dim]))
                return false;
        }
        return true;
    }
 
    template<class t_vector_type, class t_type>
    constexpr typename std::enable_if<IsVecType<t_vector_type, t_type>::value, bool>::type
    operator<(const t_vector_type& v, const t_type& s)
    {
        for (uint01 dim = 0; dim < t_vector_type::NumberOfDimensions(); dim++)
        {
            if (!(v[dim] < s))
                return false;
        }
        return true;
    }
    template<class t_vector_type, class t_type>
    constexpr typename std::enable_if<IsVecType<t_vector_type, t_type>::value, bool>::type
    operator<(const t_type& s, const t_vector_type& v)
    {
        for (uint01 dim = 0; dim < t_vector_type::NumberOfDimensions(); dim++)
        {
            if (!(s < v[dim]))
                return false;
        }
        return true;
    }
    template<class t_vector_type, class t_type>
    constexpr typename std::enable_if<IsVecType<t_vector_type, t_type>::value, bool>::type
    operator<=(const t_type& s, const t_vector_type& v)
    {
        for (uint01 dim = 0; dim < t_vector_type::NumberOfDimensions(); dim++)
        {
            if (!(s <= v[dim]))
                return false;
        }
        return true;
    }
 
    template<class t_vector_type, class t_type>
    constexpr typename std::enable_if<IsVecType<t_vector_type, t_type>::value, bool>::type
    operator<=(const t_vector_type& v, const t_type& s)
    {
        for (uint01 dim = 0; dim < t_vector_type::NumberOfDimensions(); dim++)
        {
            if (!(v[dim] <= s))
                return false;
        }
        return true;
    }
    template<class t_vector_type, class t_type>
    constexpr typename std::enable_if<IsVecType<t_vector_type, t_type>::value, bool>::type
    operator>(const t_vector_type& v, const t_type& s)
    {
        for (uint01 dim = 0; dim < t_vector_type::NumberOfDimensions(); dim++)
        {
            if (!(v[dim] > s))
                return false;
        }
        return true;
    }
    template<class t_vector_type, class t_type>
    constexpr typename std::enable_if<IsVecType<t_vector_type, t_type>::value, bool>::type
    operator>(const t_type& s, const t_vector_type& v)
    {
        for (uint01 dim = 0; dim < t_vector_type::NumberOfDimensions(); dim++)
        {
            if (!(s > v[dim]))
                return false;
        }
        return true;
    }
 
    template<uint01 t_dims, class t_type>
    constexpr bool operator<=(const Vector<t_dims, t_type>& v1, const Vector<t_dims, t_type>& v2)
    {
        for (uint01 dim = 0; dim < t_dims; dim++)
        {
            if (!(v1[dim] <= v2[dim]))
                return false;
        }
        return true;
    }
    

    template<class t_type>
    constexpr Vector<1, t_type> cross(const Vector<1, t_type>&, const Vector<1, t_type>&)
    {
        return Vector<1, t_type>(1);
    }
    template<class t_type>
    constexpr t_type cross(const Vector<2, t_type>& v1, const Vector<2, t_type>& v2)
    {
        return v1[X] * v2[Y] - v1[Y] * v2[X];
    }
    template<class t_type>
    constexpr Vector<2, t_type> cross(const Vector<2, t_type>& v1, const t_type& v2)
    {
        return Vector<2, t_type>(v2 * v1[Y], -v2 * v1[X]);
    }
    template<class t_type>
    constexpr Vector<3, t_type> cross(const Vector<3, t_type>& v1, const Vector<3, t_type>& v2)
    {
        Vector<3, t_type> cross;
        cross[X] = ((v1[Y] * v2[Z]) - (v1[Z] * v2[Y]));
        cross[Y] = ((v1[Z] * v2[X]) - (v1[X] * v2[Z]));
        cross[Z] = ((v1[X] * v2[Y]) - (v1[Y] * v2[X]));
        return cross;
    }

    template<uint01 t_dims, class t_type>
    constexpr Vector<t_dims, t_type> getMax(const Vector<t_dims, t_type>& v1, const Vector<t_dims, t_type>& v2)
    {
        Vector<t_dims, t_type> vec;
        for (uint01 dim = 0; dim < t_dims; dim++)
        {
            vec[dim] = getMax(v1[dim], v2[dim]);
        }
        return vec;
    }

    template<uint01 t_dims, class t_type>
    constexpr Vector<t_dims, t_type> getMin(const Vector<t_dims, t_type>& v1, const Vector<t_dims, t_type>& v2)
    {
        Vector<t_dims, t_type> vec;
        for (uint01 dim = 0; dim < t_dims; dim++)
        {
            vec[dim] = getMin(v1[dim], v2[dim]);
        }
        return vec;
    }

    template<uint01 t_dims, class t_type>
    t_type determinate(const Vector<t_dims, t_type>& v1, const Vector<t_dims, t_type>& v2)
    {
        return (v1[X] * v2[Y]) - (v1[Y] * v2[X]);
    }

    template<uint01 t_dims, class t_type>
    t_type determinate(const Vector<t_dims, t_type>& v1, const Vector<t_dims, t_type>& v2, const Vector<t_dims, t_type>& v3)
    {
        t_type x_det = v1[X] * determinate(Vector<2, t_type>(v2.dim[Y], v2.dim[Z]), Vector<2, t_type>(v3.dim[Y], v3.dim[Z]));
        t_type y_det = v1[Y] * determinate(Vector<2, t_type>(v2.dim[X], v2.dim[Z]), Vector<2, t_type>(v3.dim[X], v3.dim[Z]));
        t_type z_det = v1[Z] * determinate(Vector<2, t_type>(v2.dim[X], v2.dim[Y]), Vector<2, t_type>(v3.dim[X], v3.dim[Y]));
        return x_det - y_det + z_det;
    }

    template<uint01 t_dims, class t_type>
    t_type dot(const Vector<t_dims, t_type>& v1, const Vector<t_dims, t_type>& v2)
    {
        t_type value = 0;
        for (uint01 dim = 0; dim < t_dims; ++dim)
            value += v1[dim] * v2[dim];
        return value;
    }

    template<uint01 t_dims, class t_type>
    bool AreParallel(const Vector<t_dims, t_type>& v1, const Vector<t_dims, t_type>& v2)
    {
        t_type magnitude_1 = v1.getMagnitudeSquared();
        t_type magnitude_2 = v2.getMagnitudeSquared();
        return v2 * v2 * (magnitude_1) == v1 * v1 * magnitude_2;
    }

    template<uint01 t_dims, class t_type>
    constexpr bool equals(const Vector<t_dims, t_type>& left, const Vector<t_dims, t_type>& right, const t_type& epsilon = cast<t_type>(0))
    {
        return (abs(left - right) < epsilon);
    }

    template<class t_type>
    constexpr typename std::enable_if<!IsVec<t_type>::value, t_type>::type
    abs(const t_type& value)
    {
        return std::abs(value);
    }

    template<class t_type>
    constexpr typename std::enable_if<IsVec<t_type>::value, t_type>::type
    abs(const t_type& value)
    {
        t_type abs_value;
        for (uint01 dim = 0; dim < t_type::NumberOfDimensions(); ++dim)
            abs_value[dim] = abs(value[dim]);
        return abs_value;
    }
 
    template<class t_to, class t_from>
    constexpr t_to cast(Vector<1, t_from>& value)
    {
        return static_cast<t_to>(value[0]);
    }

    template<>
    constexpr uint01 abs(const uint01& value)
    {
        return value;
    }

    template<>
    constexpr uint02 abs(const uint02& value)
    {
        return value;
    }

    template<>
    constexpr uint04 abs(const uint04& value)
    {
        return value;
    }
    

    template<>
    constexpr uint08 abs(const uint08& value)
    {
        return value;
    }
    

    template<uint01 t_dims, class t_type>
    constexpr Vector<t_dims, t_type> abs(const Vector<t_dims, t_type>& vector)
    {
        Vector<t_dims, t_type> value;
        for (uint01 dim = 0; dim < t_dims; ++dim)
            value[dim] = abs(vector[dim]);
        return value;
    }

    template<class t_type>
    t_type sqrt(const t_type& value)
    {
        return ::sqrt(value);
    }

    template<uint01 t_dims, class t_type>
    Vector<t_dims, t_type> sqrt(const Vector<t_dims, t_type>& vector)
    {
        Vector<t_dims, t_type> vec;
        for (uint01 dim = 0; dim < t_dims; ++dim)
        {
            vec[dim] = std::sqrt(vector[dim]);
        }
        return vec;
    }

    template<uint01 t_dims, class t_type>
    t_type distanceSquared(const Vector<t_dims, t_type>& v1, const Vector<t_dims, t_type>& v2)
    {
        t_type value = 0;
        for (uint01 dim = 0; dim < t_dims; ++dim)
        {
            const t_type dn = (v1[dim] - v2[dim]);
            value += dn * dn;
        }
        return value;
    }

    template<uint01 t_dims, class t_type>
    t_type distance(const Vector<t_dims, t_type>& v1, const Vector<t_dims, t_type>& v2)
    {
        return sqrt(distanceSquared(v1, v2));
    }

    template<class t_distance_type, uint01 t_dims, class t_type>
    t_distance_type distance(const Vector<t_dims, t_type>& v1, const Vector<t_dims, t_type>& v2)
    {
        return sqrt(cast<t_distance_type>(distanceSquared(v1, v2)));
    }
 
    template <uint01 t_dims, typename t_type>
    constexpr Vector<t_dims, t_type> clip(const Vector<t_dims, t_type>& value, const Vector<t_dims, t_type>& lower_bound, const Vector<t_dims, t_type>& upper_bound)
    {
        Vector<t_dims, t_type> clipped;
        for (uint01 i = 0; i < t_dims; i++)
        {
            clipped[i] = clip(value[i], lower_bound[i], upper_bound[i]);
        }
        return clipped;
    }
}