vector2.hpp

Go to the documentation of this file.

#pragma once
 
#if __cpp_constexpr >= 201304
#    define CONSTEXPR14 constexpr
#else
#    define CONSTEXPR14 inline
#endif
 
namespace ginger {
 
    template <typename T1, typename T2 = T1> class Vector2 {
      public:
        T1 _x;
        T2 _y;
 
        constexpr Vector2() : _x{0}, _y{0} {}
 
        constexpr Vector2(T1 x, T2 y) noexcept : _x{x}, _y{y} {}
 
        // constexpr Vector2(const T1 &x, const T2 &y) : _x{x}, _y{y} {}
 
        template <typename U1, typename U2> constexpr explicit Vector2(const Vector2<U1, U2>& other)
            : _x(other.x()), _y(other.y()) {}
 
        constexpr auto x() const noexcept -> const T1& { return this->_x; }
 
        constexpr auto y() const noexcept -> const T2& { return this->_y; }
 
        // /**
        //  * @brief
        //  *
        //  * @return double
        //  */
        // constexpr auto norm_inf() const -> double {
        //   return std::max(std::abs(this->_x), std::abs(this->_y));
        // }
 
        template <typename U1, typename U2>  //
        constexpr auto dot(const Vector2<U1, U2>& other) const -> double {
            return this->_x * other._x + this->_y * other._y;
        }
 
        template <typename U1, typename U2>  //
        constexpr auto cross(const Vector2<U1, U2>& other) const -> double {
            return this->_x * other._y - other._x * this->_y;
        }
 
 
        constexpr auto operator-() const -> Vector2<T1, T2> { return {-this->_x, -this->_y}; }
 
        template <typename U1, typename U2> inline auto operator+=(const Vector2<U1, U2>& other)
            -> Vector2<T1, T2>& {
            this->_x += other.x();
            this->_y += other.y();
            return *this;
        }
 
        template <typename U1, typename U2>  //
        inline auto operator-=(const Vector2<U1, U2>& other) -> Vector2<T1, T2>& {
            this->_x -= other.x();
            this->_y -= other.y();
            return *this;
        }
 
        template <typename R> inline auto operator*=(const R& alpha) -> Vector2<T1, T2>& {
            this->_x *= alpha;
            this->_y *= alpha;
            return *this;
        }
 
        template <typename R> inline auto operator/=(const R& alpha) -> Vector2<T1, T2>& {
            this->_x /= alpha;
            this->_y /= alpha;
            return *this;
        }
 
        template <typename U1, typename U2>  //
        friend constexpr auto operator+(Vector2<T1, T2> x, const Vector2<U1, U2>& y)
            -> Vector2<T1, T2> {
            return x += y;
        }
 
        template <typename U1, typename U2>  //
        friend constexpr auto operator-(Vector2<T1, T2> x, const Vector2<U1, U2>& y)
            -> Vector2<T1, T2> {
            return x -= y;
        }
 
        template <typename R> friend constexpr auto operator*(Vector2<T1, T2> x, const R& alpha)
            -> Vector2<T1, T2> {
            return x *= alpha;
        }
 
        template <typename R> friend constexpr auto operator*(const R& alpha, Vector2<T1, T2> x)
            -> Vector2<T1, T2> {
            return x *= alpha;
        }
 
        template <typename R> friend constexpr auto operator/(Vector2<T1, T2> x, const R& alpha)
            -> Vector2<T1, T2> {
            return x /= alpha;
        }
 
 
        template <class Stream> friend auto operator<<(Stream& out, const Vector2<T1, T2>& vec)
            -> Stream& {
            out << "{" << vec.x() << ", " << vec.y() << "}";
            return out;
        }
    };
}  // namespace ginger