Vector3D.hpp

Go to the documentation of this file.

#pragma once
 
#include <Math/math/Functions.hpp>
#include <Math/math/Vector2D.hpp>
#include <Math/Concepts.hpp>
#include <concepts>
#include <tuple>
#include <cmath>
 
namespace Math
{
 
template <class Type>
struct BasicVector3D
{
    using value_type = Type; 
 
    template <class RType>
    struct BasicRef
    {
        using value_type = RType; 
 
        constexpr BasicRef(RType &x_in, RType &y_in, RType &z_in) : x{x_in}, y{y_in}, z{z_in} { }
        constexpr BasicRef(const BasicRef &) = default;
        constexpr BasicRef(const BasicVector3D<RType> &other) : x{other.x}, y{other.y}, z{other.z} { }
 
        constexpr BasicRef &operator =(BasicRef input)
        {
            x = input.x;
            y = input.y;
            z = input.z;
            return *this;
        }
 
        constexpr BasicRef &operator =(const BasicVector3D<RType> &input)
        {
            x = input.x;
            y = input.y;
            z = input.z;
            return *this;
        }
 
        constexpr operator BasicVector3D<RType>() const { return { x, y, z }; }
 
        constexpr operator std::tuple<RType, RType, RType>() const { return std::make_tuple( x, y, z ); }
 
        RType &x;
        RType &y;
        RType &z;
 
        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 BasicVector3D<U> &right)
        {
            return approximately_equal_to( left, right );
        }
 
        template <class U>
            requires Concept::SameUnqualified<RType, U>
        friend constexpr BasicVector3D<RType> operator +(BasicRef left, BasicRef<U> right)
        {
            return { left.x + right.x, left.y + right.y, left.z + right.z };
        }
 
        template <class U>
            requires Concept::SameUnqualified<RType, U>
        friend constexpr BasicVector3D<RType> operator +(BasicRef left, const BasicVector3D<U> &right)
        {
            return { left.x + right.x, left.y + right.y, left.z + right.z };
        }
 
        template <class U>
            requires Concept::SameUnqualified<RType, U>
        friend constexpr BasicVector3D<RType> operator -(BasicRef left, BasicRef<U> right)
        {
            return { left.x - right.x, left.y - right.y, left.z - right.z };
        }
 
        template <class U>
            requires Concept::SameUnqualified<RType, U>
        friend constexpr BasicVector3D<RType> operator -(BasicRef left, const BasicVector3D<U> &right)
        {
            return { left.x - right.x, left.y - right.y, left.z - right.z };
        }
 
        template <class U>
            requires Concept::SameUnqualified<RType, U>
        friend constexpr BasicVector3D<RType> operator *(BasicRef left, BasicRef<U> right)
        {
            return { left.x * right.x, left.y * right.y, left.z * right.z };
        }
 
        template <class U>
            requires Concept::SameUnqualified<RType, U>
        friend constexpr BasicVector3D<RType> operator *(BasicRef left, const BasicVector3D<U> &right)
        {
            return { left.x * right.x, left.y * right.y, left.z * right.z };
        }
 
        template <class U>
            requires Concept::SameUnqualified<RType, U>
        friend constexpr BasicVector3D<RType> operator *(BasicRef left, const U &scalar)
        {
            return { left.x * scalar, left.y * scalar, left.z * scalar };
        }
 
        template <class U>
            requires Concept::SameUnqualified<RType, U>
        friend constexpr BasicVector3D<RType> operator *(const U &scalar, BasicRef right)
        {
            return { scalar * right.x, scalar * right.y, scalar * right.z };
        }
 
        template <class U>
            requires Concept::SameUnqualified<RType, U>
        friend constexpr BasicVector3D<RType> operator /(BasicRef left, BasicRef<U> right)
        {
            return { left.x / right.x, left.y / right.y, left.z / right.z };
        }
 
        template <class U>
            requires Concept::SameUnqualified<RType, U>
        friend constexpr BasicVector3D<RType> operator /(BasicRef left, const BasicVector3D<U> &right)
        {
            return { left.x / right.x, left.y / right.y, left.z / right.z };
        }
 
        template <class U>
            requires Concept::SameUnqualified<RType, U>
        friend constexpr BasicVector3D<RType> operator /(BasicRef left, const U &scalar)
        {
            return { left.x / scalar, left.y / scalar, left.z / 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);
        }
 
        template <class U, std::floating_point OT = float>
            requires Concept::SameUnqualified<RType, U>
        friend constexpr bool approximately_equal_to(      BasicRef          value_to_test,
                                                     const BasicVector3D<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);
        }
 
        friend constexpr RType accumulate(BasicRef input)
        {
            return input.x + input.y + input.z;
        }
 
        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);
        }
 
        template <class U>
            requires Concept::SameUnqualified<RType, U>
        friend constexpr RType dot(BasicRef left, const BasicVector3D<U> &right)
        {
            return (left.x * right.x) + (left.y * right.y) + (left.z * right.z);
        }
 
        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 BasicVector3D<U> &right)
        {
            return dot(left, right) / (left.magnitude() * right.magnitude());
        }
 
        template <class U>
            requires Concept::SameUnqualified<RType, U>
        friend constexpr BasicVector3D<RType> cross(BasicRef left, BasicRef<U> right)
        {
            return cross( BasicVector3D<RType>(left), BasicVector3D<RType>(right) );
        }
 
        friend constexpr BasicVector3D<RType> normalized(BasicRef input)
        {
            return BasicVector3D<RType>( input ).normalized();
        }
 
        friend constexpr BasicVector3D<RType> abs(BasicRef input)
        {
            return { std::abs(input.x), std::abs(input.y), std::abs(input.z) };
        }
 
        friend constexpr BasicVector3D<RType> fract(BasicRef input)
        {
            RType dummy;
 
            return { std::modf(input.x, &dummy),
                     std::modf(input.y, &dummy),
                     std::modf(input.z, &dummy) };
        }
 
        friend constexpr BasicVector3D<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) };
        }
 
        template <class U>
            requires Concept::SameUnqualified<RType, U>
        friend constexpr BasicVector3D<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 BasicVector3D<RType> lerp(      BasicRef          input_lower_bound,
                                                   const BasicVector3D<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 BasicVector3D<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 BasicVector3D<RType> mix(      BasicRef          input_lower_bound,
                                                  const BasicVector3D<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}]", input.x, input.y, input.z);
        }
 
        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 BasicVector3D<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 BasicVector3D<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_EQUAL(BasicRef    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<RType, U>
        friend void CHECK_IF_EQUAL(      BasicRef          input,
                                   const BasicVector3D<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<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 BasicVector3D<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, BasicVector3D<RType>::zero(), tolerance));
        }
    };
 
    using Ref      = BasicRef<Type>;
    using ConstRef = BasicRef<const Type>;
 
    constexpr BasicVector3D() = default;
    constexpr BasicVector3D(const Type &x_in, const Type &y_in = 0, const Type &z_in = 0)
        :
        x{x_in},
        y{y_in},
        z{z_in}
    {
    }
    constexpr BasicVector3D(const BasicVector2D<Type> &other, Type z_in = 0)
        :
        x{other.x},
        y{other.y},
        z{z_in}
    {
    }
    constexpr BasicVector3D(Type x_in, const BasicVector2D<Type> &other)
        :
        x{x_in},
        y{other.x},
        z{other.y}
    {
    }
    constexpr BasicVector3D(const std::tuple<Type, Type, Type> &init_value)
        :
        x{ std::get<0>(init_value) },
        y{ std::get<1>(init_value) },
        z{ std::get<2>(init_value) }
    {
    }
 
    constexpr BasicVector3D<Type> &operator =(const BasicVector3D &other) = default;
    constexpr BasicVector3D<Type> &operator =(Ref other)
    {
        x = other.x;
        y = other.y;
        return *this;
    }
 
    constexpr operator std::tuple<Type, Type, Type>() const { return std::make_tuple( x, y, z ); }
 
    constexpr static BasicVector3D<Type> unit_x() { return { Type{1}, Type{0}, Type{0} }; }
    constexpr static BasicVector3D<Type> unit_y() { return { Type{0}, Type{1}, Type{0} }; }
    constexpr static BasicVector3D<Type> unit_z() { return { Type{0}, Type{0}, Type{1} }; }
 
    constexpr static BasicVector3D<Type> zero() { return { }; }
 
    constexpr value_type normSquared() const { return (x * x) + (y * y) + (z * z); }
    constexpr value_type norm() const { return std::sqrt( normSquared() ); } 
 
    constexpr value_type magnitudeSquared() const { return normSquared(); }
    constexpr value_type magnitude() const { return norm(); }
 
    constexpr BasicVector3D<Type> normalized() const
    {
        auto n = magnitude();
 
        return { x / n, y / n, z / n };
    }
 
    bool isNaN() const { return std::isnan(x) || std::isnan(y) || std::isnan(z); }
    bool isInf() const { return std::isinf(x) || std::isinf(y) || std::isinf(z); }
 
    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 ConstRef            xyz() const &  { return { x, y, z }; }
    constexpr Ref                 xyz()       &  { return { x, y, z }; }
    constexpr BasicVector3D<Type> xyz()       && { return { x, y, z }; }
 
    constexpr ConstRef            xzy() const &  { return { x, z, y }; }
    constexpr Ref                 xzy()       &  { return { x, z, y }; }
    constexpr BasicVector3D<Type> xzy()       && { return { x, z, y }; }
 
    constexpr ConstRef            zxy() const &  { return { z, x, y }; }
    constexpr Ref                 zxy()       &  { return { z, x, y }; }
    constexpr BasicVector3D<Type> zxy()       && { return { z, x, y }; }
 
    constexpr ConstRef            zyx() const &  { return { z, y, x }; }
    constexpr Ref                 zyx()       &  { return { z, y, x }; }
    constexpr BasicVector3D<Type> zyx()       && { return { z, y, x }; }
 
    value_type x{};
    value_type y{};
    value_type z{};
 
private:
 
    template <class U>
        requires Concept::SameUnqualified<Type, U>
    friend constexpr bool operator ==(const BasicVector3D &left, const BasicVector3D<U> &right)
    {
        return approximately_equal_to(left, right);
    }
 
    template <class U>
        requires Concept::SameUnqualified<Type, U>
    friend constexpr bool operator ==(const BasicVector3D &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 BasicVector3D    &value_to_test,
                                                 const BasicVector3D<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);
    }
 
    template <class U, std::floating_point OT = float>
        requires Concept::SameUnqualified<Type, U>
    friend constexpr bool approximately_equal_to(const BasicVector3D &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);
    }
 
    template <class U>
        requires Concept::SameUnqualified<Type, U>
    friend constexpr BasicVector3D<Type> operator +(const BasicVector3D &left, const BasicVector3D<U> &right)
    {
        return { left.x + right.x, left.y + right.y, left.z + right.z };
    }
 
    template <class U>
        requires Concept::SameUnqualified<Type, U>
    friend constexpr BasicVector3D<Type> operator +(const BasicVector3D &left, BasicRef<U> right)
    {
        return { left.x + right.x, left.y + right.y, left.z + right.z };
    }
 
    template <class U>
        requires Concept::SameUnqualified<Type, U>
    friend constexpr BasicVector3D<Type> operator -(const BasicVector3D &left, const BasicVector3D<U> &right)
    {
        return { left.x - right.x, left.y - right.y, left.z - right.z };
    }
 
    template <class U>
        requires Concept::SameUnqualified<Type, U>
    friend constexpr BasicVector3D<Type> operator -(const BasicVector3D &left, BasicRef<U> right)
    {
        return { left.x - right.x, left.y - right.y, left.z - right.z };
    }
 
    template <class U>
        requires Concept::SameUnqualified<Type, U>
    friend constexpr BasicVector3D<Type> operator *(const BasicVector3D &left, const BasicVector3D<U> &right)
    {
        return { left.x * right.x, left.y * right.y, left.z * right.z };
    }
 
    template <class U>
        requires Concept::SameUnqualified<Type, U>
    friend constexpr BasicVector3D<Type> operator *(const BasicVector3D &left, const Type &right)
    {
        return { left.x * right, left.y * right, left.z * right };
    }
 
    template <class U>
        requires Concept::SameUnqualified<Type, U>
    friend constexpr BasicVector3D<Type> operator *(const BasicVector3D &left, const U &scalar)
    {
        return { left.x * scalar, left.y * scalar, left.z * scalar };
    }
 
    template <class U>
        requires Concept::SameUnqualified<Type, U>
    friend constexpr BasicVector3D<Type> operator *(const U &scalar, const BasicVector3D &right)
    {
        return { scalar * right.x, scalar * right.y };
    }
 
    template <class U>
        requires Concept::SameUnqualified<Type, U>
    friend constexpr BasicVector3D<Type> operator /(const BasicVector3D &left, const BasicVector3D<U> &right)
    {
        return { left.x / right.x, left.y / right.y, left.z / right.z };
    }
 
    template <class U>
        requires Concept::SameUnqualified<Type, U>
    friend constexpr BasicVector3D<Type> operator /(const BasicVector3D &left, BasicRef<U> right)
    {
        return { left.x / right.x, left.y / right.y, left.z / right.z };
    }
 
    friend constexpr BasicVector3D<Type> operator /(const BasicVector3D &left, const Type &right)
    {
        return { left.x / right, left.y / right, left.z / right };
    }
 
    friend constexpr Type accumulate(const BasicVector3D<Type> &input)
    {
        return input.x + input.y + input.z;
    }
 
    template <class U>
        requires Concept::SameUnqualified<Type, U>
    friend constexpr Type dot(const BasicVector3D &left, const BasicVector3D<U> &right)
    {
        return (left.x * right.x) + (left.y * right.y) + (left.z * right.z);
    }
 
    template <class U>
        requires Concept::SameUnqualified<Type, U>
    friend constexpr Type dot(const BasicVector3D &left, BasicRef<U> right)
    {
        return (left.x * right.x) + (left.y * right.y) + (left.z * right.z);
    }
 
    template <class U>
        requires Concept::SameUnqualified<Type, U>
    friend constexpr Type dot_normalized(const BasicVector3D &left, const BasicVector3D<U> &right)
    {
        return dot(left, right) / (left.magnitude() * right.magnitude());
    }
 
    template <class U>
        requires Concept::SameUnqualified<Type, U>
    friend constexpr Type dot_normalized(const BasicVector3D &left, BasicRef<U> right)
    {
        return dot(left, right) / (left.magnitude() * right.magnitude());
    }
 
    friend constexpr BasicVector3D<Type> normalized(const BasicVector3D<Type> &input)
    {
        return input.normalized();
    }
 
    template <class U>
        requires Concept::SameUnqualified<Type, U>
    friend constexpr BasicVector3D<Type> cross(const BasicVector3D &left, const BasicVector3D<U> &right)
    {
        return { cross( left.yz(), right.yz() ),
                 cross( left.zx(), right.zx() ),
                 cross( left.xy(), right.xy() ) };
    }
 
    template <class U>
        requires Concept::SameUnqualified<Type, U>
    friend constexpr BasicVector3D<Type> cross(const BasicVector3D &left, BasicRef<U> right)
    {
        return { cross( left.yz(), right.yz() ),
                 cross( left.zx(), right.zx() ),
                 cross( left.xy(), right.xy() ) };
    }
 
    friend constexpr BasicVector3D<Type> abs(const BasicVector3D<Type> &input)
    {
        return { std::abs(input.x), std::abs(input.y), std::abs(input.z) };
    }
 
    friend constexpr BasicVector3D<Type> fract(const BasicVector3D<Type> &input)
    {
        Type dummy;
 
        return { std::modf(input.x, &dummy), std::modf(input.y, &dummy), std::modf(input.z, &dummy) };
    }
 
    friend constexpr BasicVector3D<Type> saturate(const BasicVector3D<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) };
    }
 
    template <class U>
        requires Concept::SameUnqualified<Type, U>
    friend constexpr BasicVector3D<Type> lerp(const BasicVector3D    &input_lower_bound,
                                              const BasicVector3D<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 BasicVector3D<Type> lerp(const BasicVector3D &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 BasicVector3D<Type> mix(const BasicVector3D    &input_lower_bound,
                                             const BasicVector3D<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 BasicVector3D<Type> mix(const BasicVector3D &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 BasicVector3D<Type> &input)
    {
        return std::format("[x: {:.6}, y: {:.6}, z: {:.6}]", input.x, input.y, input.z);
    }
 
    template <class U, std::floating_point OT = float>
        requires Concept::SameUnqualified<Type, U>
    friend bool check_if_equal(const BasicVector3D    &input,
                               const BasicVector3D<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 BasicVector3D &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 BasicVector3D    &input,
                                   const BasicVector3D<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 BasicVector3D &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 BasicVector3D    &input,
                               const BasicVector3D<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 BasicVector3D &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 BasicVector3D    &input,
                                   const BasicVector3D<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 BasicVector3D &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 BasicVector3D<Type> &input, OT tolerance = OT{0.0002})
    {
        assert( check_if_equal(input, BasicVector3D<Type>::zero(), tolerance));
    }
};
 
using Vector3DfRef = BasicVector3D<float>::Ref;
using Vector3DdRef = BasicVector3D<double>::Ref;
using Vector3DRef  = BasicVector3D<double>::Ref;
using Vector3DlRef = BasicVector3D<long double>::Ref;
 
using Vector3DfConstRef = BasicVector3D<float>::ConstRef;
using Vector3DdConstRef = BasicVector3D<double>::ConstRef;
using Vector3DConstRef  = BasicVector3D<double>::ConstRef;
using Vector3DlConstRef = BasicVector3D<long double>::ConstRef;
 
 
using Vector3Df = BasicVector3D<float>;
using Vector3Dd = BasicVector3D<double>;
using Vector3D  = BasicVector3D<double>;
using Vector3Dl = BasicVector3D<long double>;
 
}