matrix2.hpp

Go to the documentation of this file.

 
#pragma once
 
#include <utility>  // import std::move
 
#include "vector2.hpp"
 
#if __cpp_constexpr >= 201304
#    define CONSTEXPR14 constexpr
#else
#    define CONSTEXPR14 inline
#endif
 
namespace ginger {
    template <typename T1, typename T2 = T1> class Matrix2 {
      private:
        T1 _x;
        T2 _y;
 
      public:
        constexpr Matrix2(T1 x, T2 y) noexcept : _x{std::move(x)}, _y{std::move(y)} {}
 
        constexpr auto x() const -> const T1& { return this->_x; }
 
        constexpr auto y() const -> const T2& { return this->_y; }
 
        // /**
        //  * @brief Construct a new Matrix2 object
        //  *
        //  * @param[in] x
        //  * @param[in] y
        //  */
        // constexpr Matrix2(const T1& x, const T2& y) : Vector2<T1, T2>{x, y} {}
 
 
        constexpr auto operator-() const -> Matrix2<T1, T2> { return {-this->x(), -this->y()}; }
 
        template <typename U1, typename U2>
        CONSTEXPR14 auto operator+=(const Matrix2<U1, U2>& other) -> Matrix2<T1, T2>& {
            this->_x += other.x();
            this->_y += other.y();
            return *this;
        }
 
        template <typename U1, typename U2>  //
        CONSTEXPR14 auto operator-=(const Matrix2<U1, U2>& other) -> Matrix2<T1, T2>& {
            this->_x -= other.x();
            this->_y -= other.y();
            return *this;
        }
 
        template <typename R> CONSTEXPR14 auto operator*=(const R& alpha) -> Matrix2<T1, T2>& {
            this->_x *= alpha;
            this->_y *= alpha;
            return *this;
        }
 
        template <typename R> CONSTEXPR14 auto operator/=(const R& alpha) -> Matrix2<T1, T2>& {
            this->_x /= alpha;
            this->_y /= alpha;
            return *this;
        }
 
        template <typename U1, typename U2>  //
        friend constexpr auto operator+(Matrix2<T1, T2> x, const Matrix2<U1, U2>& y)
            -> Matrix2<T1, T2> {
            return std::move(x) += y;
        }
 
        template <typename U1, typename U2>  //
        friend constexpr auto operator-(Matrix2<T1, T2> x, const Matrix2<U1, U2>& y)
            -> Matrix2<T1, T2> {
            return std::move(x) -= y;
        }
 
        template <typename R> friend constexpr auto operator*(Matrix2<T1, T2> x, const R& alpha)
            -> Matrix2<T1, T2> {
            return x *= alpha;
        }
 
        template <typename R> friend constexpr auto operator*(const R& alpha, Matrix2<T1, T2> x)
            -> Matrix2<T1, T2> {
            return x *= alpha;
        }
 
        template <typename R> friend constexpr auto operator/(Matrix2<T1, T2> x, const R& alpha)
            -> Matrix2<T1, T2> {
            return x /= alpha;
        }
 
        template <typename U1, typename U2>  //
        constexpr auto mdot(const Vector2<U1, U2>& other) const -> T1 {
            return T1{this->_x.dot(other), this->_y.dot(other)};
        }
 
        constexpr auto det() const -> double {
            return this->x().x() * this->y().y() - this->x().y() * this->y().x();
        }
 
    };
}  // namespace ginger