vector2.hpp

Go to the documentation of this file.

 
#pragma once
 
#include <tuple>    // import std::tie()
#include <utility>  // import std::move
 
#if __cpp_constexpr >= 201304
#    define CONSTEXPR14 constexpr
#else
#    define CONSTEXPR14 inline
#endif
 
namespace recti {
 
    template <typename T1, typename T2 = T1> class Vector2 {
      private:
        T1 _x;
        T2 _y;
 
      public:
        constexpr Vector2(T1 vec_x, T2 vec_y) noexcept
            : _x{std::move(vec_x)}, _y{std::move(vec_y)} {}
 
        template <typename U1, typename U2>
        constexpr explicit Vector2(const Vector2<U1, U2>& other_vector)
            : _x(other_vector.x()), _y(other_vector.y()) {}
 
        constexpr auto x() const noexcept -> const T1& { return this->_x; }
 
        constexpr auto y() const noexcept -> const T2& { return this->_y; }
 
        template <typename U1, typename U2>  //
        constexpr auto cross(const Vector2<U1, U2>& other_vector) const {
            return this->_x * other_vector._y - other_vector._x * this->_y;
        }
 
 
        template <typename U1, typename U2>  //
        constexpr auto operator==(const Vector2<U1, U2>& other_vector) const -> bool {
            return std::tie(this->x(), this->y()) == std::tie(other_vector.x(), other_vector.y());
        }
 
        template <typename U1, typename U2>  //
        constexpr auto operator!=(const Vector2<U1, U2>& other_vector) const -> bool {
            return !(*this == other_vector);
        }
 
 
 
        constexpr auto operator-() const -> Vector2 { return Vector2(-this->_x, -this->_y); }
 
        template <typename U1, typename U2>
        CONSTEXPR14 auto operator+=(const Vector2<U1, U2>& other_vector) -> Vector2& {
            this->_x += other_vector.x();
            this->_y += other_vector.y();
            return *this;
        }
 
        template <typename U1, typename U2>  //
        CONSTEXPR14 auto operator-=(const Vector2<U1, U2>& other_vector) -> Vector2& {
            this->_x -= other_vector.x();
            this->_y -= other_vector.y();
            return *this;
        }
 
        template <typename R> CONSTEXPR14 auto operator*=(const R& scalar) -> Vector2& {
            this->_x *= scalar;
            this->_y *= scalar;
            return *this;
        }
 
        template <typename R> CONSTEXPR14 auto operator/=(const R& scalar) -> Vector2& {
            this->_x /= scalar;
            this->_y /= scalar;
            return *this;
        }
 
        template <typename U1, typename U2>  //
        friend constexpr auto operator+(Vector2 right_vector, const Vector2<U1, U2>& left_vector)
            -> Vector2 {
            return right_vector += left_vector;
        }
 
        template <typename U1, typename U2>  //
        friend constexpr auto operator-(Vector2 right_vector, const Vector2<U1, U2>& left_vector)
            -> Vector2 {
            return right_vector -= left_vector;
        }
 
        template <typename R> friend constexpr auto operator*(Vector2 right_vector, const R& scalar)
            -> Vector2 {
            return right_vector *= scalar;
        }
 
        template <typename R> friend constexpr auto operator*(const R& scalar, Vector2 left_vector)
            -> Vector2 {
            return left_vector *= scalar;
        }
 
        template <typename R> friend constexpr auto operator/(Vector2 right_vector, const R& scalar)
            -> Vector2 {
            return right_vector /= scalar;
        }
 
 
        template <class Stream> friend auto operator<<(Stream& output_stream, const Vector2& vector)
            -> Stream& {
            output_stream << "{" << vector.x() << ", " << vector.y() << "}";
            return output_stream;
        }
    };
}  // namespace recti