Matrix.h

Go to the documentation of this file.

/*************************************************************************
> File Name: Matrix.h
> Project Name: CubbyFlow
> Author: Chan-Ho Chris Ohk
> Purpose: Static-sized M x N matrix class.
> Created Time: 2017/03/06
> Copyright (c) 2018, Chan-Ho Chris Ohk
*************************************************************************/
#ifndef CUBBYFLOW_MATRIX_H
#define CUBBYFLOW_MATRIX_H

#include <Core/Matrix/MatrixExpression.h>

#include <array>
#include <type_traits>

namespace CubbyFlow
{
    template <typename T, size_t M, size_t N>
    class Matrix final : public MatrixExpression<T, Matrix<T, M, N>>
    {
    public:
        static_assert(M > 0, "Number of rows for static-sized matrix should be greater than zero.");
        static_assert(N > 0, "Number of columns for static-sized matrix should be greater than zero.");
        static_assert(!(M == 2 && N == 2) && !(M == 3 && N == 3) && !(M == 4 && N == 4), "Use specialized matrix for 2z2, 3x3, and 4x4 matrices.");
        static_assert(std::is_floating_point<T>::value, "Matrix only can be instantiated with floating point types.");

        using ContainerType = std::array<T, M * N>;
        using Iterator = typename ContainerType::iterator;
        using ConstIterator = typename ContainerType::const_iterator;

        Matrix();

        template <typename... Params>
        explicit Matrix(Params... params);

        Matrix(const std::initializer_list<std::initializer_list<T>>& list);

        template <typename E>
        Matrix(const MatrixExpression<T, E>& other);

        Matrix(const Matrix& other);

        // MARK: Basic setters
        void Resize(size_t m, size_t n, const T& s = T(0));

        void Set(const T& s);

        void Set(const std::initializer_list<std::initializer_list<T>>& list);

        template <typename E>
        void Set(const MatrixExpression<T, E>& other);

        void SetDiagonal(const T& s);

        void SetOffDiagonal(const T& s);

        template <typename E>
        void SetRow(size_t i, const VectorExpression<T, E>& row);

        template <typename E>
        void SetColumn(size_t j, const VectorExpression<T, E>& col);

        // MARK: Basic getters
        template <typename E>
        bool IsEqual(const MatrixExpression<T, E>& other) const;

        template <typename E>
        bool IsSimilar(const MatrixExpression<T, E>& other, double tol = std::numeric_limits<double>::epsilon()) const;

        constexpr bool IsSquare() const;

        constexpr Size2 size() const;

        constexpr size_t Rows() const;

        constexpr size_t Cols() const;

        T* data();

        const T* data() const;

        Iterator begin();

        ConstIterator begin() const;

        Iterator end();

        ConstIterator end() const;

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

        template <typename E>
        MatrixAdd<T, Matrix, E> Add(const E& m) const;

        MatrixScalarSub<T, Matrix> Sub(const T& s) const;

        template <typename E>
        MatrixSub<T, Matrix, E> Sub(const E& m) const;

        MatrixScalarMul<T, Matrix> Mul(const T& s) const;

        template <typename VE>
        MatrixVectorMul<T, Matrix, VE> Mul(const VectorExpression<T, VE>& v) const;

        template <size_t L>
        MatrixMul<T, Matrix, Matrix<T, N, L>> Mul(const Matrix<T, N, L>& m) const;

        MatrixScalarDiv<T, Matrix> Div(const T& s) const;

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

        template <typename E>
        MatrixAdd<T, Matrix, E> RAdd(const E& m) const;

        MatrixScalarRSub<T, Matrix> RSub(const T& s) const;

        template <typename E>
        MatrixSub<T, Matrix, E> RSub(const E& m) const;

        MatrixScalarMul<T, Matrix> RMul(const T& s) const;

        template <size_t L>
        MatrixMul<T, Matrix<T, N, L>, Matrix> RMul(const Matrix<T, N, L>& m) const;

        MatrixScalarRDiv<T, Matrix> RDiv(const T& s) const;

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

        template <typename E>
        void IAdd(const E& m);

        void ISub(const T& s);

        template <typename E>
        void ISub(const E& m);

        void IMul(const T& s);

        template <typename E>
        void IMul(const E& m);

        void IDiv(const 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;

        MatrixDiagonal<T, Matrix> Diagonal() const;

        MatrixDiagonal<T, Matrix> OffDiagonal() const;

        MatrixTriangular<T, Matrix> StrictLowerTri() const;

        MatrixTriangular<T, Matrix> StrictUpperTri() const;

        MatrixTriangular<T, Matrix> LowerTri() const;

        MatrixTriangular<T, Matrix> UpperTri() const;

        Matrix<T, N, M> Transposed() const;

        Matrix Inverse() const;

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

        // MARK: Setter operators
        template <typename E>
        Matrix& operator=(const E& m);

        Matrix& operator=(const Matrix& other);

        Matrix& operator+=(const T& s);

        template <typename E>
        Matrix& operator+=(const E& m);

        Matrix& operator-=(const T& s);

        template <typename E>
        Matrix& operator-=(const E& m);

        Matrix& operator*=(const T& s);

        template <typename E>
        Matrix& operator*=(const E& m);

        Matrix& operator/=(const 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;

        template <typename E>
        bool operator==(const MatrixExpression<T, E>& m) const;

        template <typename E>
        bool operator!=(const MatrixExpression<T, E>& m) const;

        // MARK: Helpers
        template <typename Callback>
        void ForEach(Callback func) const;

        template <typename Callback>
        void ForEachIndex(Callback func) const;

        // MARK: Builders
        static MatrixConstant<T> MakeZero();

        static MatrixIdentity<T> MakeIdentity();

    private:
        ContainerType m_elements;

        template <typename... Params>
        void SetRowAt(size_t i, T v, Params... params);
        void SetRowAt(size_t i, T v);
    };
}

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

#endif