Vector4D.hpp

Go to the documentation of this file.

#pragma once
 
#include <Math/math/Functions.hpp>
#include <Math/math/Vector2D.hpp>
#include <Math/math/Vector3D.hpp>
#include <tuple>
#include <concepts>
 
namespace Math
{
 
template <class Type>
struct BasicVector4D
{
    using value_type = Type; 
 
    template <class RType>
    struct BasicRef
    {
        using value_type = RType; 
 
        constexpr BasicRef(RType &x_in, RType &y_in, RType &z_in, RType &w_in) : x{x_in}, y{y_in}, z{z_in}, w{w_in} { }
        constexpr BasicRef(const BasicRef &) = default;
        constexpr BasicRef(const BasicVector4D<RType> &other) : x{other.x}, y{other.y}, z{other.z}, w{other.w} { }
 
        constexpr BasicRef &operator =(BasicRef input)
        {
            x = input.x;
            y = input.y;
            z = input.z;
            w = input.w;
            return *this;
        }
 
        constexpr BasicRef &operator =(const BasicVector4D<RType> &input)
        {
            x = input.x;
            y = input.y;
            z = input.z;
            w = input.w;
            return *this;
        }
 
        constexpr operator BasicVector4D<RType>() const { return { x, y, z, w }; }
 
        constexpr operator std::tuple<RType, RType, RType, RType>() const { return std::make_tuple( x, y, z, w ); }
 
        RType &x;
        RType &y;
        RType &z;
        RType &w;
 
        template <class U>
            requires Concept::SameUnqualified<RType, U>
        friend constexpr bool operator ==(BasicRef left, BasicRef<U> right)
        {
            return approximately_equal_to( left, right );
        }
 
        template <class U>
            requires Concept::SameUnqualified<RType, U>
        friend constexpr bool operator ==(BasicRef left, const BasicVector4D<U> &right)
        {
            return approximately_equal_to( left, right );
        }
 
        template <class U>
            requires Concept::SameUnqualified<RType, U>
        friend constexpr BasicVector4D<RType> operator +(BasicRef left, BasicRef<U> right)
        {
            return { left.x + right.x,
                     left.y + right.y,
                     left.z + right.z,
                     left.w + right.w };
        }
 
        template <class U>
            requires Concept::SameUnqualified<RType, U>
        friend constexpr BasicVector4D<RType> operator +(BasicRef left, const BasicVector4D<U> &right)
        {
            return { left.x + right.x,
                     left.y + right.y,
                     left.z + right.z,
                     left.w + right.w };
        }
 
        template <class U>
            requires Concept::SameUnqualified<RType, U>
        friend constexpr BasicVector4D<RType> operator -(BasicRef left, BasicRef<U> right)
        {
            return { left.x - right.x,
                     left.y - right.y,
                     left.z - right.z,
                     left.w - right.w };
        }
 
        template <class U>
            requires Concept::SameUnqualified<RType, U>
        friend constexpr BasicVector4D<RType> operator -(BasicRef left, const BasicVector4D<U> &right)
        {
            return { left.x - right.x,
                     left.y - right.y,
                     left.z - right.z,
                     left.w - right.w };
        }
 
        template <class U>
            requires Concept::SameUnqualified<RType, U>
        friend constexpr BasicVector4D<RType> operator *(BasicRef left, BasicRef<U> right)
        {
            return { left.x * right.x,
                     left.y * right.y,
                     left.z * right.z,
                     left.w * right.w };
        }
 
        template <class U>
            requires Concept::SameUnqualified<RType, U>
        friend constexpr BasicVector4D<RType> operator *(BasicRef left, const BasicVector4D<U> &right)
        {
            return { left.x * right.x,
                     left.y * right.y,
                     left.z * right.z,
                     left.w * right.w };
        }
 
        template <class U>
            requires Concept::SameUnqualified<RType, U>
        friend constexpr BasicVector4D<RType> operator *(BasicRef left, const U &scalar)
        {
            return { left.x * scalar, left.y * scalar, left.z * scalar, left.w * scalar };
        }
 
        template <class U>
            requires Concept::SameUnqualified<RType, U>
        friend constexpr BasicVector4D<RType> operator *(const U &scalar, BasicRef right)
        {
            return { scalar * right.x, scalar * right.y, scalar * right.z, scalar * right.w };
        }
 
        template <class U>
            requires Concept::SameUnqualified<RType, U>
        friend constexpr BasicVector4D<RType> operator /(BasicRef left, BasicRef<U> right)
        {
            return { left.x / right.x,
                     left.y / right.y,
                     left.z / right.z,
                     left.w / right.w };
        }
 
        template <class U>
            requires Concept::SameUnqualified<RType, U>
        friend constexpr BasicVector4D<RType> operator /(BasicRef left, const BasicVector4D<U> &right)
        {
            return { left.x / right.x,
                     left.y / right.y,
                     left.z / right.z,
                     left.w / right.w };
        }
 
        template <class U>
            requires Concept::SameUnqualified<RType, U>
        friend constexpr BasicVector4D<RType> operator /(BasicRef left, const U &scalar)
        {
            return { left.x / scalar, left.y / scalar, left.z / scalar, left.w / scalar };
        }
 
        template <class U, std::floating_point OT = float>
            requires Concept::SameUnqualified<RType, U>
        friend constexpr bool approximately_equal_to(BasicRef    value_to_test,
                                                     BasicRef<U> value_it_should_be,
                                                     OT          tolerance = OT{0.0002})
        {
            return approximately_equal_to(value_to_test.x, value_it_should_be.x, tolerance) &&
                   approximately_equal_to(value_to_test.y, value_it_should_be.y, tolerance) &&
                   approximately_equal_to(value_to_test.z, value_it_should_be.z, tolerance) &&
                   approximately_equal_to(value_to_test.w, value_it_should_be.w, tolerance);
        }
 
        template <class U, std::floating_point OT = float>
            requires Concept::SameUnqualified<RType, U>
        friend constexpr bool approximately_equal_to(      BasicRef          value_to_test,
                                                     const BasicVector4D<U> &value_it_should_be,
                                                           OT                tolerance = OT{0.0002})
        {
            return approximately_equal_to(value_to_test.x, value_it_should_be.x, tolerance) &&
                   approximately_equal_to(value_to_test.y, value_it_should_be.y, tolerance) &&
                   approximately_equal_to(value_to_test.z, value_it_should_be.z, tolerance) &&
                   approximately_equal_to(value_to_test.w, value_it_should_be.w, tolerance);
        }
        
        friend constexpr RType accumulate(BasicRef input)
        {
            return input.x + input.y + input.z + input.w;
        }
 
        template <class U>
            requires Concept::SameUnqualified<RType, U>
        friend constexpr RType dot(BasicRef left, BasicRef<U> right)
        {
            return (left.x * right.x) + (left.y * right.y) + (left.z * right.z) + (left.w * right.w);
        }
 
        template <class U>
            requires Concept::SameUnqualified<RType, U>
        friend constexpr RType dot(BasicRef left, const BasicVector4D<U> &right)
        {
            return (left.x * right.x) + (left.y * right.y) + (left.z * right.z) + (left.w * right.w);
        }
 
        template <class U>
            requires Concept::SameUnqualified<RType, U>
        friend constexpr RType dot_normalized(BasicRef left, BasicRef<U> right)
        {
            return dot(left, right) / (left.magnitude() * right.magnitude());
        }
 
        template <class U>
            requires Concept::SameUnqualified<RType, U>
        friend constexpr RType dot_normalized(BasicRef left, const BasicVector4D<U> &right)
        {
            return dot(left, right) / (left.magnitude() * right.magnitude());
        }
 
        friend constexpr BasicVector4D<RType> normalized(BasicRef input)
        {
            return BasicVector4D<RType>( input ).normalized();
        }
 
        friend constexpr BasicVector4D<RType> abs(BasicRef input)
        {
            return { std::abs(input.x), std::abs(input.y), std::abs(input.z), std::abs(input.w) };
        }
 
        friend BasicVector4D<RType> fract(BasicRef input)
        {
            RType dummy;
 
            return { std::modf(input.x, &dummy),
                     std::modf(input.y, &dummy),
                     std::modf(input.z, &dummy),
                     std::modf(input.w, &dummy) };
        }
 
        friend constexpr BasicVector4D<RType> saturate(BasicRef input, RType lower_bound, RType upper_bound)
        {
            return { Math::saturate(input.x, lower_bound, upper_bound),
                     Math::saturate(input.y, lower_bound, upper_bound),
                     Math::saturate(input.z, lower_bound, upper_bound),
                     Math::saturate(input.w, lower_bound, upper_bound) };
        }
 
        template <class U>
            requires Concept::SameUnqualified<RType, U>
        friend constexpr BasicVector4D<RType> lerp(BasicRef    input_lower_bound,
                                                   BasicRef<U> input_upper_bound,
                                                   float       percentage_zero_to_one)
        {
            return (input_upper_bound - input_lower_bound) * percentage_zero_to_one + input_lower_bound;
        }
 
        template <class U>
            requires Concept::SameUnqualified<RType, U>
        friend constexpr BasicVector4D<RType> lerp(BasicRef          input_lower_bound,
                                                   BasicVector4D<U> &input_upper_bound,
                                                   float             percentage_zero_to_one)
        {
            return (input_upper_bound - input_lower_bound) * percentage_zero_to_one + input_lower_bound;
        }
 
        template <class U>
            requires Concept::SameUnqualified<RType, U>
        friend constexpr BasicVector4D<RType> mix(BasicRef    input_lower_bound,
                                                  BasicRef<U> input_upper_bound,
                                                  float       percentage_zero_to_one)
        {
            return lerp( input_lower_bound, input_upper_bound, percentage_zero_to_one );
        }
 
        template <class U>
            requires Concept::SameUnqualified<RType, U>
        friend constexpr BasicVector4D<RType> mix(BasicRef          input_lower_bound,
                                                  BasicVector4D<U> &input_upper_bound,
                                                  float             percentage_zero_to_one)
        {
            return lerp( input_lower_bound, input_upper_bound, percentage_zero_to_one );
        }
 
        friend std::string format(BasicRef input)
        {
            return std::format("[x: {:.6}, y: {:.6}, z: {:.6}, w: {:.6}]", input.x, input.y, input.z, input.w);
        }
 
        template <class U, std::floating_point OT = float>
            requires Concept::SameUnqualified<RType, U>
        friend bool check_if_equal(BasicRef    input,
                                   BasicRef<U> near_to,
                                   OT          tolerance = OT{0.0002})
        {
            if (!approximately_equal_to(input, near_to, tolerance))
            {
                auto diff{ near_to - input };
 
                std::cout << std::format("input: {} is not equal to near_to: {} within tolerance: {}.  Difference is {} .",
                                        format(input),
                                        format(near_to),
                                        tolerance,
                                        format(near_to - input))
                << std::endl;
                return  false;
            }
            return true;
        }
 
        template <class U, std::floating_point OT = float>
            requires Concept::SameUnqualified<RType, U>
        friend bool check_if_equal(      BasicRef          input,
                                   const BasicVector4D<U> &near_to,
                                         OT                tolerance = OT{0.0002})
        {
            if (!approximately_equal_to(input, near_to, tolerance))
            {
                auto diff{ near_to - input };
 
                std::cout << std::format("input: {} is not equal to near_to: {} within tolerance: {}.  Difference is {} .",
                                        format(input),
                                        format(near_to),
                                        tolerance,
                                        format(near_to - input))
                << std::endl;
                return  false;
            }
            return true;
        }
 
        template <class U, std::floating_point OT = float>
            requires Concept::SameUnqualified<RType, U>
        friend bool check_if_not_equal(BasicRef input,
                                       BasicRef near_to,
                                       OT       tolerance = OT{0.0002})
        {
            if (approximately_equal_to(input, near_to, tolerance))
            {
                auto diff{ near_to - input };
 
                std::cout << std::format("input: {} is equal to near_to: {} within tolerance: {}.  Difference is {} .",
                                        format(input),
                                        format(near_to),
                                        tolerance,
                                        format(near_to - input))
                << std::endl;
                return  false;
            }
            return true;
        }
 
        template <class U, std::floating_point OT = float>
            requires Concept::SameUnqualified<RType, U>
        friend bool check_if_not_equal(      BasicRef          input,
                                       const BasicVector4D<U> &near_to,
                                             OT                tolerance = OT{0.0002})
        {
            if (approximately_equal_to(input, near_to, tolerance))
            {
                auto diff{ near_to - input };
 
                std::cout << std::format("input: {} is equal to near_to: {} within tolerance: {}.  Difference is {} .",
                                        format(input),
                                        format(near_to),
                                        tolerance,
                                        format(near_to - input))
                << std::endl;
                return  false;
            }
            return true;
        }
 
        template <class U, std::floating_point OT = float>
            requires Concept::SameUnqualified<RType, U>
        friend void CHECK_IF_NOT_EQUAL(BasicRef    input,
                                       BasicRef<U> near_to,
                                       OT          tolerance = OT{0.0002})
        {
            assert( check_if_not_equal(input, near_to, tolerance) );
        }
 
        template <class U, std::floating_point OT = float>
            requires Concept::SameUnqualified<RType, U>
        friend void CHECK_IF_NOT_EQUAL(      BasicRef          input,
                                       const BasicVector4D<U> &near_to,
                                             OT                tolerance = OT{0.0002})
        {
            assert( check_if_not_equal(input, near_to, tolerance) );
        }
 
        template <std::floating_point OT = float>
        friend void CHECK_IF_ZERO(BasicRef input, OT tolerance = OT{0.0002})
        {
            assert( check_if_equal(input, BasicVector4D<RType>::zero(), tolerance));
        }
    };
 
    using Ref = BasicRef<Type>;
    using ConstRef = BasicRef<const Type>;
 
    constexpr BasicVector4D() = default;
    constexpr BasicVector4D(const Type &x_in, const Type &y_in = 0, const Type &z_in = 0, const Type &w_in = 0)
        :
        x{x_in},
        y{y_in},
        z{z_in},
        w{w_in}
    {
    }
    constexpr BasicVector4D(const BasicVector3D<Type> &first3, const Type &w_in = 0)
        :
        x{first3.x},
        y{first3.y},
        z{first3.z},
        w{w_in}
    {
    }
    constexpr BasicVector4D(const BasicVector2D<Type> &first2, const BasicVector2D<Type> &second2)
        :
        x{first2.x},
        y{first2.y},
        z{second2.x},
        w{second2.y}
    {
    }
    constexpr BasicVector4D(const Type &x_in, const BasicVector3D<Type> &last3)
        :
        x{x_in},
        y{last3.x},
        z{last3.y},
        w{last3.z}
    {
    }
 
    constexpr BasicVector4D<Type> &operator =(const BasicVector4D &other) = default;
    constexpr BasicVector4D<Type> &operator =(Ref other)
    {
        x = other.x;
        y = other.y;
        z = other.z;
        w = other.w;
        return *this;
    }
 
    constexpr operator std::tuple<Type, Type, Type, Type>() const { return std::make_tuple( x, y, z ); }
 
    constexpr static BasicVector4D<Type> unit_x() { return { Type{1}, Type{0}, Type{0}, Type{0} }; }
    constexpr static BasicVector4D<Type> unit_y() { return { Type{0}, Type{1}, Type{0}, Type{0} }; }
    constexpr static BasicVector4D<Type> unit_z() { return { Type{0}, Type{0}, Type{1}, Type{0} }; }
    constexpr static BasicVector4D<Type> unit_w() { return { Type{0}, Type{0}, Type{0}, Type{1} }; }
 
    constexpr static BasicVector4D<Type> zero() { return { }; }
    
    constexpr value_type normSquared() const { return (x * x) + (y * y) + (z * z) + (w * w); }
    constexpr value_type norm() const { return std::sqrt( normSquared() ); } 
 
    constexpr value_type magnitudeSquared() const { return normSquared(); }
    constexpr value_type magnitude() const { return norm(); }
 
    constexpr BasicVector4D<Type> normalized() const
    {
        auto n = magnitude();
 
        return { x / n, y / n, z / n, w / n };
    }
 
    bool isNaN() const { return std::isnan(x) || std::isnan(y) || std::isnan(z) || std::isnan(w); }
    bool isInf() const { return std::isinf(x) || std::isinf(y) || std::isinf(z) || std::isinf(w); }
 
    constexpr BasicVector2D<Type>::ConstRef xy() const &  { return { x, y }; }
    constexpr BasicVector2D<Type>::Ref      xy()       &  { return { x, y }; }
    constexpr BasicVector2D<Type>           xy()       && { return { x, y }; }
 
    constexpr BasicVector2D<Type>::ConstRef xz() const &  { return { x, z }; }
    constexpr BasicVector2D<Type>::Ref      xz()       &  { return { x, z }; }
    constexpr BasicVector2D<Type>           xz()       && { return { x, z }; }
 
    constexpr BasicVector2D<Type>::ConstRef yx() const &  { return { y, x }; }
    constexpr BasicVector2D<Type>::Ref      yx()       &  { return { y, x }; }
    constexpr BasicVector2D<Type>           yx()       && { return { y, x }; }
 
    constexpr BasicVector2D<Type>::ConstRef yz() const &  { return { y, z }; }
    constexpr BasicVector2D<Type>::Ref      yz()       &  { return { y, z }; }
    constexpr BasicVector2D<Type>           yz()       && { return { y, z }; }
 
    constexpr BasicVector2D<Type>::ConstRef zx() const &  { return { z, x }; }
    constexpr BasicVector2D<Type>::Ref      zx()       &  { return { z, x }; }
    constexpr BasicVector2D<Type>           zx()       && { return { z, x }; }
 
    constexpr BasicVector3D<Type>::ConstRef xyz() const &  { return { x, y, z }; }
    constexpr BasicVector3D<Type>::Ref      xyz()       &  { return { x, y, z }; }
    constexpr BasicVector3D<Type>           xyz()       && { return { x, y, z }; }
 
    constexpr BasicVector3D<Type>::ConstRef xzy() const &  { return { x, z, y }; }
    constexpr BasicVector3D<Type>::Ref      xzy()       &  { return { x, z, y }; }
    constexpr BasicVector3D<Type>           xzy()       && { return { x, z, y }; }
 
    constexpr BasicVector3D<Type>::ConstRef zxy() const &  { return { z, x, y }; }
    constexpr BasicVector3D<Type>::Ref      zxy()       &  { return { z, x, y }; }
    constexpr BasicVector3D<Type>           zxy()       && { return { z, x, y }; }
 
    constexpr BasicVector3D<Type>::ConstRef zyx() const &  { return { z, y, x }; }
    constexpr BasicVector3D<Type>::Ref      zyx()       &  { return { z, y, x }; }
    constexpr BasicVector3D<Type>           zyx()       && { return { z, y, x }; }
 
    constexpr BasicVector3D<Type>::ConstRef xxx() const &  { return { x, x, x }; }
    constexpr BasicVector3D<Type>::Ref      xxx()       &  { return { x, x, x }; }
    constexpr BasicVector3D<Type>           xxx()       && { return { x, x, x }; }
 
    constexpr BasicVector3D<Type>::ConstRef yyy() const &  { return { y, y, y }; }
    constexpr BasicVector3D<Type>::Ref      yyy()       &  { return { y, y, y }; }
    constexpr BasicVector3D<Type>           yyy()       && { return { y, y, y }; }
 
    constexpr BasicVector3D<Type>::ConstRef zzz() const &  { return { z, z, z }; }
    constexpr BasicVector3D<Type>::Ref      zzz()       &  { return { z, z, z }; }
    constexpr BasicVector3D<Type>           zzz()       && { return { z, z, z }; }
 
    constexpr BasicVector3D<Type>::ConstRef www() const &  { return { w, w, w }; }
    constexpr BasicVector3D<Type>::Ref      www()       &  { return { w, w, w }; }
    constexpr BasicVector3D<Type>           www()       && { return { w, w, w }; }
 
    value_type x{};
    value_type y{};
    value_type z{};
    value_type w{};
 
private:
 
    template <class U>
        requires Concept::SameUnqualified<Type, U>
    friend constexpr bool operator ==(const BasicVector4D &left, const BasicVector4D<U> &right)
    {
        return approximately_equal_to(left, right);
    }
 
    template <class U>
        requires Concept::SameUnqualified<Type, U>
    friend constexpr bool operator ==(const BasicVector4D &left, BasicRef<U> right)
    {
        return approximately_equal_to(left, right);
    }
 
    template <class U, std::floating_point OT = float>
        requires Concept::SameUnqualified<Type, U>
    friend constexpr bool approximately_equal_to(const BasicVector4D    &value_to_test,
                                                 const BasicVector4D<U> &value_it_should_be,
                                                       OT                tolerance = OT{0.0002})
    {
        return approximately_equal_to(value_to_test.x, value_it_should_be.x, tolerance) &&
               approximately_equal_to(value_to_test.y, value_it_should_be.y, tolerance) &&
               approximately_equal_to(value_to_test.z, value_it_should_be.z, tolerance) &&
               approximately_equal_to(value_to_test.w, value_it_should_be.w, tolerance);
    }
 
    template <class U, std::floating_point OT = float>
        requires Concept::SameUnqualified<Type, U>
    friend constexpr bool approximately_equal_to(const BasicVector4D &value_to_test,
                                                       BasicRef<U>    value_it_should_be,
                                                       OT                   tolerance = OT{0.0002})
    {
        return approximately_equal_to(value_to_test.x, value_it_should_be.x, tolerance) &&
               approximately_equal_to(value_to_test.y, value_it_should_be.y, tolerance) &&
               approximately_equal_to(value_to_test.z, value_it_should_be.z, tolerance) &&
               approximately_equal_to(value_to_test.w, value_it_should_be.w, tolerance);
    }
 
    template <class U>
        requires Concept::SameUnqualified<Type, U>
    friend constexpr BasicVector4D<Type> operator +(const BasicVector4D &left, const BasicVector4D<U> &right)
    {
        return { left.x + right.x, left.y + right.y, left.z + right.z, left.w + right.w };
    }
 
    template <class U>
        requires Concept::SameUnqualified<Type, U>
    friend constexpr BasicVector4D<Type> operator +(const BasicVector4D &left, BasicRef<U> right)
    {
        return { left.x + right.x, left.y + right.y, left.z + right.z, left.w + right.w };
    }
 
    template <class U>
        requires Concept::SameUnqualified<Type, U>
    friend constexpr BasicVector4D<Type> operator -(const BasicVector4D &left, const BasicVector4D<U> &right)
    {
        return { left.x - right.x, left.y - right.y, left.z - right.z, left.w - right.w };
    }
 
    template <class U>
        requires Concept::SameUnqualified<Type, U>
    friend constexpr BasicVector4D<Type> operator -(const BasicVector4D &left, BasicRef<U> right)
    {
        return { left.x - right.x, left.y - right.y, left.z - right.z, left.w - right.w };
    }
 
    template <class U>
        requires Concept::SameUnqualified<Type, U>
    friend constexpr BasicVector4D<Type> operator *(const BasicVector4D &left, const BasicVector4D<U> &right)
    {
        return { left.x * right.x, left.y * right.y, left.z * right.z, left.w * right.w };
    }
 
    template <class U>
        requires Concept::SameUnqualified<Type, U>
    friend constexpr BasicVector4D<Type> operator *(const BasicVector4D &left, BasicRef<U> right)
    {
        return { left.x * right.x, left.y * right.y, left.z * right.z, left.w * right.w };
    }
 
    template <class U>
        requires Concept::SameUnqualified<Type, U>
    friend constexpr BasicVector4D<Type> operator *(const BasicVector4D &left, const U &scalar)
    {
        return { left.x * scalar, left.y * scalar, left.z * scalar, left.w * scalar };
    }
 
    template <class U>
        requires Concept::SameUnqualified<Type, U>
    friend constexpr BasicVector4D<Type> operator *(const U &scalar, const BasicVector4D<U> &right)
    {
        return { scalar * right.x, scalar * right.y, scalar * right.z, scalar * right.w };
    }
 
    template <class U>
        requires Concept::SameUnqualified<Type, U>
    friend constexpr BasicVector4D<Type> operator /(const BasicVector4D &left, const BasicVector4D<U> &right)
    {
        return { left.x / right.x, left.y / right.y, left.z / right.z, left.w / right.w };
    }
 
    template <class U>
        requires Concept::SameUnqualified<Type, U>
    friend constexpr BasicVector4D<Type> operator /(const BasicVector4D &left, BasicRef<U> right)
    {
        return { left.x / right.x, left.y / right.y, left.z / right.z, left.w / right.w };
    }
 
    template <class U>
        requires Concept::SameUnqualified<Type, U>
    friend constexpr BasicVector4D<Type> operator /(const BasicVector4D<Type> &left, const U &right)
    {
        return { left.x / right, left.y / right, left.z / right, left.w / right };
    }
 
    friend constexpr Type accumulate(const BasicVector4D<Type> &input)
    {
        return input.x + input.y + input.z + input.w;
    }
 
    template <class U>
        requires Concept::SameUnqualified<Type, U>
    friend constexpr Type dot(const BasicVector4D &left, const BasicVector4D<U> &right)
    {
        return (left.x * right.x) + (left.y * right.y) + (left.z * right.z) + (left.w * right.w);
    }
 
    template <class U>
        requires Concept::SameUnqualified<Type, U>
    friend constexpr Type dot(const BasicVector4D &left, BasicRef<U> right)
    {
        return (left.x * right.x) + (left.y * right.y) + (left.z * right.z) + (left.w * right.w);
    }
 
    template <class U>
        requires Concept::SameUnqualified<Type, U>
    friend constexpr Type dot_normalized(const BasicVector4D &left, const BasicVector4D<U> &right)
    {
        return dot(left, right) / (left.magnitude() * right.magnitude());
    }
 
    template <class U>
        requires Concept::SameUnqualified<Type, U>
    friend constexpr Type dot_normalized(const BasicVector4D &left, BasicRef<U> right)
    {
        return dot(left, right) / (left.magnitude() * right.magnitude());
    }
 
    friend constexpr BasicVector4D<Type> normalized(const BasicVector4D<Type> &input)
    {
        return input.normalized();
    }
 
    friend constexpr BasicVector4D<Type> abs(const BasicVector4D<Type> &input)
    {
        return { std::abs(input.x),
                 std::abs(input.y),
                 std::abs(input.z),
                 std::abs(input.w) };
    }
 
    friend BasicVector4D<Type> fract(const BasicVector4D<Type> &input)
    {
        Type dummy;
 
        return { std::modf(input.x, &dummy),
                 std::modf(input.y, &dummy),
                 std::modf(input.z, &dummy),
                 std::modf(input.w, &dummy) };
    }
 
    friend constexpr BasicVector4D<Type> saturate(const BasicVector4D<Type> &input,
                                                        Type                 lower_bound,
                                                        Type                 upper_bound)
    {
        return { Math::saturate(input.x, lower_bound, upper_bound),
                 Math::saturate(input.y, lower_bound, upper_bound),
                 Math::saturate(input.z, lower_bound, upper_bound),
                 Math::saturate(input.w, lower_bound, upper_bound) };
    }
 
    template <class U>
        requires Concept::SameUnqualified<Type, U>
    friend constexpr BasicVector4D<Type> lerp(const BasicVector4D    &input_lower_bound,
                                              const BasicVector4D<U> &input_upper_bound,
                                                    float             percentage_zero_to_one)
    {
        return (input_upper_bound - input_lower_bound) * percentage_zero_to_one + input_lower_bound;
    }
 
    template <class U>
        requires Concept::SameUnqualified<Type, U>
    friend constexpr BasicVector4D<Type> lerp(const BasicVector4D &input_lower_bound,
                                                    BasicRef<U>          input_upper_bound,
                                                    float                percentage_zero_to_one)
    {
        return (input_upper_bound - input_lower_bound) * percentage_zero_to_one + input_lower_bound;
    }
 
    template <class U>
        requires Concept::SameUnqualified<Type, U>
    friend constexpr BasicVector4D<Type> mix(const BasicVector4D    &input_lower_bound,
                                             const BasicVector4D<U> &input_upper_bound,
                                                   float             percentage_zero_to_one)
    {
        return lerp( input_lower_bound, input_upper_bound, percentage_zero_to_one );
    }
 
    template <class U>
        requires Concept::SameUnqualified<Type, U>
    friend constexpr BasicVector4D<Type> mix(const BasicVector4D &input_lower_bound,
                                                   BasicRef<U>    input_upper_bound,
                                                   float          percentage_zero_to_one)
    {
        return lerp( input_lower_bound, input_upper_bound, percentage_zero_to_one );
    }
 
    friend std::string format(const BasicVector4D &input)
    {
        return std::format("[x: {:.6}, y: {:.6}, z: {:.6}, w: {:.6}]", input.x, input.y, input.z, input.w);
    }
 
    template <class U, std::floating_point OT = float>
        requires Concept::SameUnqualified<Type, U>
    friend bool check_if_equal(const BasicVector4D    &input,
                               const BasicVector4D<U> &near_to,
                                     OT                tolerance = OT{0.0002})
    {
        if (!approximately_equal_to(input, near_to, tolerance))
        {
            auto diff{ near_to - input };
 
            std::cout << std::format("input: {} is not equal to near_to: {} within tolerance: {}.  Difference is {} .",
                                     format(input),
                                     format(near_to),
                                     tolerance,
                                     format(near_to - input))
            << std::endl;
            return  false;
        }
        return true;
    }
 
    template <class U, std::floating_point OT = float>
        requires Concept::SameUnqualified<Type, U>
    friend bool check_if_equal(const BasicVector4D &input,
                                     BasicRef<U>    near_to,
                                     OT             tolerance = OT{0.0002})
    {
        if (!approximately_equal_to(input, near_to, tolerance))
        {
            auto diff{ near_to - input };
 
            std::cout << std::format("input: {} is not equal to near_to: {} within tolerance: {}.  Difference is {} .",
                                     format(input),
                                     format(near_to),
                                     tolerance,
                                     format(near_to - input))
            << std::endl;
            return  false;
        }
        return true;
    }
 
    template <class U, std::floating_point OT = float>
        requires Concept::SameUnqualified<Type, U>
    friend bool check_if_not_equal(const BasicVector4D    &input,
                                   const BasicVector4D<U> &near_to,
                                         OT                tolerance = OT{0.0002})
    {
        if (approximately_equal_to(input, near_to, tolerance))
        {
            auto diff{ near_to - input };
 
            std::cout << std::format("input: {} is equal to near_to: {} within tolerance: {}.  Difference is {} .",
                                     format(input),
                                     format(near_to),
                                     tolerance,
                                     format(near_to - input))
            << std::endl;
            return  false;
        }
        return true;
    }
 
    template <class U, std::floating_point OT = float>
        requires Concept::SameUnqualified<Type, U>
    friend bool check_if_not_equal(const BasicVector4D &input,
                                         BasicRef<U>    near_to,
                                         OT             tolerance = OT{0.0002})
    {
        if (approximately_equal_to(input, near_to, tolerance))
        {
            auto diff{ near_to - input };
 
            std::cout << std::format("input: {} is equal to near_to: {} within tolerance: {}.  Difference is {} .",
                                     format(input),
                                     format(near_to),
                                     tolerance,
                                     format(near_to - input))
            << std::endl;
            return  false;
        }
        return true;
    }
 
    template <class U, std::floating_point OT = float>
        requires Concept::SameUnqualified<Type, U>
    friend void CHECK_IF_EQUAL(const BasicVector4D    &input,
                               const BasicVector4D<U> &near_to,
                                     OT                tolerance = OT{0.0002})
    {
        assert( check_if_equal(input, near_to, tolerance) );
    }
 
    template <class U, std::floating_point OT = float>
        requires Concept::SameUnqualified<Type, U>
    friend void CHECK_IF_EQUAL(const BasicVector4D &input,
                                     BasicRef<U>    near_to,
                                     OT             tolerance = OT{0.0002})
    {
        assert( check_if_equal(input, near_to, tolerance) );
    }
    
    template <class U, std::floating_point OT = float>
        requires Concept::SameUnqualified<Type, U>
    friend void CHECK_IF_NOT_EQUAL(const BasicVector4D    &input,
                                   const BasicVector4D<U> &near_to,
                                         OT                tolerance = OT{0.0002})
    {
        assert( check_if_not_equal(input, near_to, tolerance) );
    }
 
    template <class U, std::floating_point OT = float>
        requires Concept::SameUnqualified<Type, U>
    friend void CHECK_IF_NOT_EQUAL(const BasicVector4D &input,
                                         BasicRef<U>    near_to,
                                         OT             tolerance = OT{0.0002})
    {
        assert( check_if_not_equal(input, near_to, tolerance) );
    }
 
    template <std::floating_point OT = float>
    friend void CHECK_IF_ZERO(const BasicVector4D<Type> &input, OT tolerance = OT{0.0002})
    {
        assert( check_if_equal(input, BasicVector4D<Type>::zero(), tolerance));
    }
};
 
 
using Vector4DfRef = BasicVector4D<float>::Ref;
using Vector4DdRef = BasicVector4D<double>::Ref;
using Vector4DRef  = BasicVector4D<double>::Ref;
using Vector4DlRef = BasicVector4D<long double>::Ref;
 
using Vector4DfConstRef = BasicVector4D<float>::ConstRef;
using Vector4DdConstRef = BasicVector4D<double>::ConstRef;
using Vector4DConstRef  = BasicVector4D<double>::ConstRef;
using Vector4DlConstRef = BasicVector4D<long double>::ConstRef;
 
 
using Vector4Df = BasicVector4D<float>;
using Vector4Dd = BasicVector4D<double>;
using Vector4D  = BasicVector4D<double>;
using Vector4Dl = BasicVector4D<long double>;
 
}