Matrix2x2.h

Go to the documentation of this file.

/*************************************************************************
> File Name: Matrix2x2.h
> Project Name: CubbyFlow
> Author: Chan-Ho Chris Ohk
> Purpose: 2-D matrix class.
> Created Time: 2017/03/06
> Copyright (c) 2018, Chan-Ho Chris Ohk
*************************************************************************/
#ifndef CUBBYFLOW_MATRIX2X2_H
#define CUBBYFLOW_MATRIX2X2_H

#include <Core/Matrix/Matrix.h>
#include <Core/Vector/Vector2.h>

#include <array>
#include <limits>

namespace CubbyFlow
{
    template <typename T>
    class Matrix<T, 2, 2>
    {
    public:
        static_assert(std::is_floating_point<T>::value, "Matrix only can be instantiated with floating point types");

        // MARK: Constructors
        Matrix();

        explicit Matrix(T s);

        Matrix(
            T m00, T m01,
            T m10, T m11);

        template <typename U>
        Matrix(const std::initializer_list<std::initializer_list<U>>& list);

        Matrix(const Matrix& m);

        explicit Matrix(const T* arr);

        // MARK: Basic setters
        void Set(T s);

        void Set(
            T m00, T m01,
            T m10, T m11);

        template <typename U>
        void Set(const std::initializer_list<std::initializer_list<U>>& list);

        void Set(const Matrix& m);

        void Set(const T* arr);

        void SetDiagonal(T s);

        void SetOffDiagonal(T s);

        void SetRow(size_t i, const Vector2<T>& row);

        void SetColumn(size_t i, const Vector2<T>& col);

        // MARK: Basic getters
        bool IsSimilar(const Matrix& m, double tol = std::numeric_limits<double>::epsilon()) const;

        bool IsSquare() const;

        size_t Rows() const;

        size_t Cols() const;

        T* data();

        const T* data() const;

        // MARK: Binary operator methods - new instance = this instance (+) input
        Matrix Add(T s) const;

        Matrix Add(const Matrix& m) const;

        Matrix Sub(T s) const;

        Matrix Sub(const Matrix& m) const;

        Matrix Mul(T s) const;

        Vector2<T> Mul(const Vector2<T>& v) const;

        Matrix Mul(const Matrix& m) const;

        Matrix Div(T s) const;

        // MARK: Binary operator methods - new instance = input (+) this instance
        Matrix RAdd(T s) const;

        Matrix RAdd(const Matrix& m) const;

        Matrix RSub(T s) const;

        Matrix RSub(const Matrix& m) const;

        Matrix RMul(T s) const;

        Matrix RMul(const Matrix& m) const;

        Matrix RDiv(T s) const;

        // MARK: Augmented operator methods - this instance (+)= input
        void IAdd(T s);

        void IAdd(const Matrix& m);

        void ISub(T s);

        void ISub(const Matrix& m);

        void IMul(T s);

        void IMul(const Matrix& m);

        void IDiv(T s);

        // MARK: Modifiers
        void Transpose();

        void Invert();

        // MARK: Complex getters
        T Sum() const;

        T Avg() const;

        T Min() const;

        T Max() const;

        T AbsMin() const;

        T AbsMax() const;

        T Trace() const;

        T Determinant() const;

        Matrix Diagonal() const;

        Matrix OffDiagonal() const;

        Matrix StrictLowerTriangle() const;

        Matrix StrictUpperTriangle() const;

        Matrix LowerTriangle() const;

        Matrix UpperTriangle() const;

        Matrix Transposed() const;

        Matrix Inverse() const;

        template <typename U>
        Matrix<U, 2, 2> CastTo() const;

        // MARK: Setter operators
        Matrix& operator=(const Matrix& m);

        Matrix& operator+=(T s);

        Matrix& operator+=(const Matrix& m);

        Matrix& operator-=(T s);

        Matrix& operator-=(const Matrix& m);

        Matrix& operator*=(T s);

        Matrix& operator*=(const Matrix& m);

        Matrix& operator/=(T s);

        // MARK: Getter operators
        T& operator[](size_t i);

        const T& operator[](size_t i) const;

        T& operator()(size_t i, size_t j);

        const T& operator()(size_t i, size_t j) const;

        bool operator==(const Matrix& m) const;

        bool operator!=(const Matrix& m) const;

        // MARK: Helpers
        static Matrix MakeZero();

        static Matrix MakeIdentity();

        static Matrix MakeScaleMatrix(T sx, T sy);

        static Matrix MakeScaleMatrix(const Vector2<T>& s);

        static Matrix MakeRotationMatrix(const T& rad);

    private:
        std::array<T, 4> m_elements;
    };

    template <typename T> using Matrix2x2 = Matrix<T, 2, 2>;

    // MARK: Operator overloading
    template <typename T>
    Matrix<T, 2, 2> operator-(const Matrix<T, 2, 2>& a);

    template <typename T>
    Matrix<T, 2, 2> operator+(const Matrix<T, 2, 2>& a, const Matrix<T, 2, 2>& b);

    template <typename T>
    Matrix<T, 2, 2> operator+(const Matrix<T, 2, 2>& a, const T b);

    template <typename T>
    Matrix<T, 2, 2> operator+(const T a, const Matrix<T, 2, 2>& b);

    template <typename T>
    Matrix<T, 2, 2> operator-(const Matrix<T, 2, 2>& a, const Matrix<T, 2, 2>& b);

    template <typename T>
    Matrix<T, 2, 2> operator-(const Matrix<T, 2, 2>& a, T b);

    template <typename T>
    Matrix<T, 2, 2> operator-(T a, const Matrix<T, 2, 2>& b);

    template <typename T>
    Matrix<T, 2, 2> operator*(const Matrix<T, 2, 2>& a, T b);

    template <typename T>
    Matrix<T, 2, 2> operator*(T a, const Matrix<T, 2, 2>& b);

    template <typename T>
    Vector2<T> operator*(const Matrix<T, 2, 2>& a, const Vector2<T>& b);

    template <typename T>
    Matrix<T, 2, 2> operator*(const Matrix<T, 2, 2>& a, const Matrix<T, 2, 2>& b);

    template <typename T>
    Matrix2x2<T> operator/(const Matrix2x2<T>& a, T b);

    template <typename T>
    Matrix2x2<T> operator/(const T& a, const Matrix2x2<T>& b);

    using Matrix2x2F = Matrix2x2<float>;

    using Matrix2x2D = Matrix2x2<double>;
}

#include <Core/Matrix/Matrix2x2-Impl.h>

#endif