Vec2.hpp

Go to the documentation of this file.

 
#pragma once
 
#include <cmath>
#include <initializer_list>
#include <iostream>
#include <sstream>
#include <string>
 
#include "NumCpp/Core/Internal/Error.hpp"
#include "NumCpp/NdArray.hpp"
#include "NumCpp/Utils/essentiallyEqual.hpp"
#include "NumCpp/Utils/interp.hpp"
 
//====================================================================================
 
namespace nc
{
    //================================================================================
    // Class Description:
    class Vec2
    {
    public:
        //====================================Attributes==============================
        double x{ 0. };
        double y{ 0. };
 
        //============================================================================
        // Method Description:
        constexpr Vec2() = default;
 
        //============================================================================
        // Method Description:
        constexpr Vec2(double inX, double inY) noexcept :
            x(inX),
            y(inY)
        {
        }
 
        //============================================================================
        // Method Description:
        Vec2(const std::initializer_list<double>& inList)
        {
            if (inList.size() != 2)
            {
                THROW_INVALID_ARGUMENT_ERROR("input initializer list must have a size = 2");
            }
 
            x = *inList.begin();
            y = *(inList.begin() + 1);
        }
 
        //============================================================================
        // Method Description:
        Vec2(const NdArray<double>& ndArray)
        {
            if (ndArray.size() != 2)
            {
                THROW_INVALID_ARGUMENT_ERROR("input NdArray must have a size = 2");
            }
 
            x = ndArray[0];
            y = ndArray[1];
        }
 
        //============================================================================
        // Method Description:
        [[nodiscard]] double angle(const Vec2& otherVec) const noexcept
        {
            double dotProduct = dot(otherVec);
            dotProduct /= norm();
            dotProduct /= otherVec.norm();
 
            // clamp the value to the acos range just to be safe
            dotProduct = std::max(std::min(dotProduct, 1.), -1.);
 
            return std::acos(dotProduct);
        }
 
        //============================================================================
        // Method Description:
        [[nodiscard]] Vec2 clampMagnitude(double maxLength) const noexcept
        {
            const double magnitude = norm();
            if (magnitude <= maxLength)
            {
                return *this;
            }
 
            Vec2 returnVec = Vec2(*this).normalize();
            returnVec *= maxLength;
            return returnVec;
        }
 
        //============================================================================
        // Method Description:
        [[nodiscard]] double distance(const Vec2& otherVec) const noexcept
        {
            return (Vec2(*this) -= otherVec).norm();
        }
 
        //============================================================================
        // Method Description:
        [[nodiscard]] double dot(const Vec2& otherVec) const noexcept
        {
            return x * otherVec.x + y * otherVec.y;
        }
 
        //============================================================================
        // Method Description:
        static constexpr Vec2 down() noexcept
        {
            return Vec2(0., -1.); // NOLINT(modernize-return-braced-init-list)
        }
 
        //============================================================================
        // Method Description:
        static constexpr Vec2 left() noexcept
        {
            return Vec2(-1., 0.); // NOLINT(modernize-return-braced-init-list)
        }
 
        //============================================================================
        // Method Description:
        [[nodiscard]] Vec2 lerp(const Vec2& otherVec, double t) const noexcept
        {
            t = std::max(std::min(t, 1.), 0.);
 
            Vec2 trajectory = otherVec;
            trajectory -= *this;
            const double xInterp = utils::interp(0., trajectory.x, t);
            const double yInterp = utils::interp(0., trajectory.y, t);
 
            return Vec2(*this) += Vec2(xInterp, yInterp);
        }
 
        //============================================================================
        // Method Description:
        [[nodiscard]] double norm() const noexcept
        {
            return std::hypot(x, y);
        }
 
        //============================================================================
        // Method Description:
        [[nodiscard]] Vec2 normalize() const noexcept
        {
            return Vec2(*this) /= norm();
        }
 
        //============================================================================
        // Method Description:
        [[nodiscard]] Vec2 project(const Vec2& otherVec) const noexcept
        {
            const double projectedMagnitude = norm() * std::cos(angle(otherVec));
            return otherVec.normalize() *= projectedMagnitude;
        }
 
        //============================================================================
        // Method Description:
        static constexpr Vec2 right() noexcept
        {
            return Vec2(1., 0.); // NOLINT(modernize-return-braced-init-list)
        }
 
        //============================================================================
        // Method Description:
        [[nodiscard]] std::string toString() const
        {
            std::stringstream stream;
            stream << "Vec2[" << x << ", " << y << "]";
            return stream.str();
        }
 
        //============================================================================
        // Method Description:
        [[nodiscard]] NdArray<double> toNdArray() const
        {
            NdArray<double> returnArray = { x, y };
            return returnArray.transpose();
        }
 
        //============================================================================
        // Method Description:
        static constexpr Vec2 up() noexcept
        {
            return Vec2(0., 1.); // NOLINT(modernize-return-braced-init-list)
        }
 
        //============================================================================
        // Method Description:
        bool operator==(const Vec2& rhs) const noexcept
        {
            return utils::essentiallyEqual(x, rhs.x) && utils::essentiallyEqual(y, rhs.y);
        }
 
        //============================================================================
        // Method Description:
        bool operator!=(const Vec2& rhs) const noexcept
        {
            return !(*this == rhs);
        }
 
        //============================================================================
        // Method Description:
        Vec2& operator+=(double scalar) noexcept
        {
            x += scalar;
            y += scalar;
            return *this;
        }
 
        //============================================================================
        // Method Description:
        Vec2& operator+=(const Vec2& rhs) noexcept
        {
            x += rhs.x;
            y += rhs.y;
            return *this;
        }
 
        //============================================================================
        // Method Description:
        Vec2& operator-=(double scalar) noexcept
        {
            x -= scalar;
            y -= scalar;
            return *this;
        }
 
        //============================================================================
        // Method Description:
        Vec2& operator-=(const Vec2& rhs) noexcept
        {
            x -= rhs.x;
            y -= rhs.y;
            return *this;
        }
 
        //============================================================================
        // Method Description:
        Vec2& operator*=(double scalar) noexcept
        {
            x *= scalar;
            y *= scalar;
            return *this;
        }
 
        //============================================================================
        // Method Description:
        Vec2& operator/=(double scalar) noexcept
        {
            x /= scalar;
            y /= scalar;
            return *this;
        }
    };
 
    //============================================================================
    // Method Description:
    inline Vec2 operator+(const Vec2& lhs, double rhs) noexcept
    {
        return Vec2(lhs) += rhs;
    }
 
    //============================================================================
    // Method Description:
    inline Vec2 operator+(double lhs, const Vec2& rhs) noexcept
    {
        return Vec2(rhs) += lhs;
    }
 
    //============================================================================
    // Method Description:
    inline Vec2 operator+(const Vec2& lhs, const Vec2& rhs) noexcept
    {
        return Vec2(lhs) += rhs;
    }
 
    //============================================================================
    // Method Description:
    inline Vec2 operator-(const Vec2& vec) noexcept
    {
        return Vec2(-vec.x, -vec.y); // NOLINT(modernize-return-braced-init-list)
    }
 
    //============================================================================
    // Method Description:
    inline Vec2 operator-(const Vec2& lhs, double rhs) noexcept
    {
        return Vec2(lhs) -= rhs;
    }
 
    //============================================================================
    // Method Description:
    inline Vec2 operator-(double lhs, const Vec2& rhs) noexcept
    {
        return -Vec2(rhs) += lhs;
    }
 
    //============================================================================
    // Method Description:
    inline Vec2 operator-(const Vec2& lhs, const Vec2& rhs) noexcept
    {
        return Vec2(lhs) -= rhs;
    }
 
    //============================================================================
    // Method Description:
    inline Vec2 operator*(const Vec2& lhs, double rhs) noexcept
    {
        return Vec2(lhs) *= rhs;
    }
 
    //============================================================================
    // Method Description:
    inline Vec2 operator*(double lhs, const Vec2& rhs) noexcept
    {
        return Vec2(rhs) *= lhs;
    }
 
    //============================================================================
    // Method Description:
    inline double operator*(const Vec2& lhs, const Vec2& rhs) noexcept
    {
        return lhs.dot(rhs);
    }
 
    //============================================================================
    // Method Description:
    inline Vec2 operator/(const Vec2& lhs, double rhs) noexcept
    {
        return Vec2(lhs) /= rhs;
    }
 
    //============================================================================
    // Method Description:
    inline std::ostream& operator<<(std::ostream& stream, const Vec2& vec)
    {
        stream << vec.toString() << std::endl;
        return stream;
    }
} // namespace nc