MatrixExpression.h

Go to the documentation of this file.

/*************************************************************************
> File Name: MatrixExpression.h
> Project Name: CubbyFlow
> Author: Chan-Ho Chris Ohk
> Purpose: Base class for matrix expression.
> Created Time: 2017/09/27
> Copyright (c) 2018, Chan-Ho Chris Ohk
*************************************************************************/
#ifndef CUBBYFLOW_MATRIX_EXPRESSION_H
#define CUBBYFLOW_MATRIX_EXPRESSION_H

#include <Core/Size/Size2.h>
#include <Core/Vector/VectorExpression.h>

namespace CubbyFlow
{
    // MARK: MatrixExpression
    template <typename T, typename E>
    class MatrixExpression
    {
    public:
        Size2 size() const;

        size_t Rows() const;

        size_t Cols() const;

        const E& operator()() const;
    };

    template <typename T>
    class MatrixConstant : public MatrixExpression<T, MatrixConstant<T>>
    {
    public:
        MatrixConstant(size_t m, size_t n, const T& c);

        Size2 size() const;

        size_t Rows() const;

        size_t Cols() const;

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

    private:
        size_t m_m;
        size_t m_n;
        T m_c;
    };

    template <typename T>
    class MatrixIdentity : public MatrixExpression<T, MatrixIdentity<T>>
    {
    public:
        MatrixIdentity(size_t m);

        Size2 size() const;

        size_t Rows() const;

        size_t Cols() const;

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

    private:
        size_t m_m;
    };

    // MARK: MatrixUnaryOp
    template <typename T, typename E, typename Op>
    class MatrixUnaryOp : public MatrixExpression<T, MatrixUnaryOp<T, E, Op>>
    {
    public:
        MatrixUnaryOp(const E& u);

        Size2 size() const;

        size_t Rows() const;

        size_t Cols() const;

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

    private:
        const E& m_u;
        Op m_op;
    };

    template <typename T, typename E>
    class MatrixDiagonal : public MatrixExpression<T, MatrixDiagonal<T, E>>
    {
    public:
        MatrixDiagonal(const E& u, bool isDiag);

        Size2 size() const;

        size_t Rows() const;

        size_t Cols() const;

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

    private:
        const E& m_u;
        bool m_isDiag;
    };

    template <typename T, typename E>
    class MatrixTriangular : public MatrixExpression<T, MatrixTriangular<T, E>>
    {
    public:
        MatrixTriangular(const E& u, bool isUpper, bool isStrict);

        Size2 size() const;

        size_t Rows() const;

        size_t Cols() const;

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

    private:
        const E& m_u;
        bool m_isUpper;
        bool m_isStrict;
    };

    // MARK: MatrixUnaryOp Aliases
    template <typename T, typename E, typename U>
    using MatrixTypeCast = MatrixUnaryOp<T, E, TypeCast<U, T>>;

    // MARK: MatrixBinaryOp
    template <typename T, typename E1, typename E2, typename Op>
    class MatrixBinaryOp : public MatrixExpression<T, MatrixBinaryOp<T, E1, E2, Op>>
    {
    public:
        MatrixBinaryOp(const E1& u, const E2& v);

        Size2 size() const;

        size_t Rows() const;

        size_t Cols() const;

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

    private:
        const E1& m_u;
        const E2& m_v;
        Op m_op;
    };

    template <typename T, typename E, typename Op>
    class MatrixScalarBinaryOp : public MatrixExpression<T, MatrixScalarBinaryOp<T, E, Op>>
    {
    public:
        MatrixScalarBinaryOp(const E& u, const T& v);

        Size2 size() const;

        size_t Rows() const;

        size_t Cols() const;

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

    private:
        const E& m_u;
        T m_v;
        Op m_op;
    };

    template <typename T, typename ME, typename VE>
    class MatrixVectorMul : public VectorExpression<T, MatrixVectorMul<T, ME, VE>>
    {
    public:
        MatrixVectorMul(const ME& m, const VE& v);

        size_t size() const;

        T operator[](size_t i) const;

    private:
        const ME& m_m;
        const VE& m_v;
    };

    template <typename T, typename E1, typename E2>
    class MatrixMul : public MatrixExpression<T, MatrixMul<T, E1, E2>>
    {
    public:
        MatrixMul(const E1& u, const E2& v);

        Size2 size() const;

        size_t Rows() const;

        size_t Cols() const;

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

    private:
        const E1& m_u;
        const E2& m_v;
    };

    // MARK: MatrixBinaryOp Aliases
    template <typename T, typename E1, typename E2>
    using MatrixAdd = MatrixBinaryOp<T, E1, E2, std::plus<T>>;

    template <typename T, typename E>
    using MatrixScalarAdd = MatrixScalarBinaryOp<T, E, std::plus<T>>;

    template <typename T, typename E1, typename E2>
    using MatrixSub = MatrixBinaryOp<T, E1, E2, std::minus<T>>;

    template <typename T, typename E>
    using MatrixScalarSub = MatrixScalarBinaryOp<T, E, std::minus<T>>;

    template <typename T, typename E>
    using MatrixScalarRSub = MatrixScalarBinaryOp<T, E, RMinus<T>>;

    template <typename T, typename E>
    using MatrixScalarMul = MatrixScalarBinaryOp<T, E, std::multiplies<T>>;

    template <typename T, typename E>
    using MatrixScalarDiv = MatrixScalarBinaryOp<T, E, std::divides<T>>;

    template <typename T, typename E>
    using MatrixScalarRDiv = MatrixScalarBinaryOp<T, E, RDivides<T>>;

    // MARK: Operator overloadings
    template <typename T, typename E>
    MatrixScalarMul<T, E> operator-(const MatrixExpression<T, E>& a);

    template <typename T, typename E1, typename E2>
    MatrixAdd<T, E1, E2> operator+(const MatrixExpression<T, E1>& a, const MatrixExpression<T, E2>& b);

    template <typename T, typename E>
    MatrixScalarAdd<T, E> operator+(const MatrixExpression<T, E>& a, T b);

    template <typename T, typename E>
    MatrixScalarAdd<T, E> operator+(T a, const MatrixExpression<T, E>& b);

    template <typename T, typename E1, typename E2>
    MatrixSub<T, E1, E2> operator-(const MatrixExpression<T, E1>& a, const MatrixExpression<T, E2>& b);

    template <typename T, typename E>
    MatrixScalarSub<T, E> operator-(const MatrixExpression<T, E>& a, T b);

    template <typename T, typename E>
    MatrixScalarRSub<T, E> operator-(T a, const MatrixExpression<T, E>& b);

    template <typename T, typename E>
    MatrixScalarMul<T, E> operator*(const MatrixExpression<T, E>& a, T b);

    template <typename T, typename E>
    MatrixScalarMul<T, E> operator*(T a, const MatrixExpression<T, E>& b);

    template <typename T, typename ME, typename VE>
    MatrixVectorMul<T, ME, VE> operator*(const MatrixExpression<T, ME>& a, const VectorExpression<T, VE>& b);

    template <typename T, typename E1, typename E2>
    MatrixMul<T, E1, E2> operator*(const MatrixExpression<T, E1>& a, const MatrixExpression<T, E2>& b);

    template <typename T, typename E>
    MatrixScalarDiv<T, E> operator/(const MatrixExpression<T, E>& a, T b);

    template <typename T, typename E>
    MatrixScalarRDiv<T, E> operator/(T a, const MatrixExpression<T, E>& b);
}

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

#endif