MatrixMxN.h

Go to the documentation of this file.

/*************************************************************************
> File Name: MatrixMxN.h
> Project Name: CubbyFlow
> Author: Chan-Ho Chris Ohk
> Purpose: M x N matrix class.
> Created Time: 2017/09/27
> Copyright (c) 2018, Chan-Ho Chris Ohk
*************************************************************************/
#ifndef CUBBYFLOW_MATRIXMXN_H
#define CUBBYFLOW_MATRIXMXN_H

#include <Core/Array/Array2.h>
#include <Core/Matrix/MatrixExpression.h>

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

        using ContainerType = Array2<T>;
        using Iterator = typename ContainerType::Iterator;
        using ConstIterator = typename ContainerType::ConstIterator;

        // MARK: Constructors
        MatrixMxN();

        MatrixMxN(size_t m, size_t n, const T& s = T(0));

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

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

        MatrixMxN(size_t m, size_t n, const T* arr);

        MatrixMxN(const MatrixMxN& other);

        MatrixMxN(MatrixMxN&& other) noexcept;

        // 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 Set(size_t m, size_t n, const T* arr);

        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;

        bool IsSquare() const;

        Size2 size() const;

        size_t Rows() const;

        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, MatrixMxN> Add(const T& s) const;

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

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

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

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

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

        template <typename E>
        MatrixMul<T, MatrixMxN, E> Mul(const E& m) const;

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

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

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

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

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

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

        template <typename E>
        MatrixMul<T, E, MatrixMxN> RMul(const E& m) const;

        MatrixScalarRDiv<T, MatrixMxN> 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, MatrixMxN> Diagonal() const;

        MatrixDiagonal<T, MatrixMxN> OffDiagonal() const;

        MatrixTriangular<T, MatrixMxN> StrictLowerTri() const;

        MatrixTriangular<T, MatrixMxN> StrictUpperTri() const;

        MatrixTriangular<T, MatrixMxN> LowerTri() const;

        MatrixTriangular<T, MatrixMxN> UpperTri() const;

        MatrixMxN Transposed() const;

        MatrixMxN Inverse() const;

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

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

        MatrixMxN& operator=(const MatrixMxN& other);

        MatrixMxN& operator=(MatrixMxN&& other) noexcept;

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

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

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

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

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

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

        MatrixMxN& 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;

        template <typename Callback>
        void ParallelForEach(Callback func);

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

        // MARK: Builders
        static MatrixConstant<T> MakeZero(size_t m, size_t n);

        static MatrixIdentity<T> MakeIdentity(size_t m);

    private:
        ContainerType m_elements;
    };

    using MatrixMxNF = MatrixMxN<float>;

    using MatrixMxND = MatrixMxN<double>;
}

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

#endif