MatrixCSR.h

Go to the documentation of this file.

/*************************************************************************
> File Name: MatrixCSR.h
> Project Name: CubbyFlow
> Author: Chan-Ho Chris Ohk
> Purpose: Vector expression for CSR matrix-vector multiplication.
> Created Time: 2017/09/27
> Copyright (c) 2018, Chan-Ho Chris Ohk
*************************************************************************/
#ifndef CUBBYFLOW_MATRIX_CSR_H
#define CUBBYFLOW_MATRIX_CSR_H

#include <Core/Matrix/MatrixExpression.h>
#include <Core/Vector/VectorExpression.h>

namespace CubbyFlow
{
    // Forward declaration
    template <typename T>
    class MatrixCSR;

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

        size_t size() const;

        T operator[](size_t i) const;

    private:
        const MatrixCSR<T>& m_m;
        const VE& m_v;
        const VE* m_v2;
    };

    template <typename T, typename ME>
    class MatrixCSRMatrixMul : public MatrixExpression<T, MatrixCSRMatrixMul<T, ME>> 
    {
    public:
        MatrixCSRMatrixMul(const MatrixCSR<T>& m1, const ME& m2);

        Size2 size() const;

        size_t Rows() const;

        size_t Cols() const;

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

    private:
        const MatrixCSR<T>& m_m1;
        const ME& m_m2;
        const T* const m_nnz;
        const size_t* const m_rp;
        const size_t* const m_ci;
    };

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

        struct Element
        {
            size_t i;
            size_t j;
            T value;

            Element();

            Element(size_t i, size_t j, const T& value);
        };

        using NonZeroContainerType = std::vector<T>;
        using NonZeroIterator = typename NonZeroContainerType::iterator;
        using ConstNonZeroIterator = typename NonZeroContainerType::const_iterator;

        using IndexContainerType = std::vector<size_t>;
        using IndexIterator = IndexContainerType::iterator;
        using ConstIndexIterator = IndexContainerType::const_iterator;

        // MARK: Constructors
        MatrixCSR();

        MatrixCSR(const std::initializer_list<std::initializer_list<T>>& list, T epsilon = std::numeric_limits<T>::epsilon());

        template <typename E>
        MatrixCSR(const MatrixExpression<T, E>& other, T epsilon = std::numeric_limits<T>::epsilon());

        MatrixCSR(const MatrixCSR& other);

        MatrixCSR(MatrixCSR&& other) noexcept;

        // MARK: Basic setters
        void Clear();

        void Set(const T& s);

        void Set(const MatrixCSR& other);

        void Reserve(size_t rows, size_t cols, size_t numNonZeros);

        void Compress(const std::initializer_list<std::initializer_list<T>>& list, T epsilon = std::numeric_limits<T>::epsilon());

        template <typename E>
        void Compress(const MatrixExpression<T, E>& other, T epsilon = std::numeric_limits<T>::epsilon());

        void AddElement(size_t i, size_t j, const T& value);

        void AddElement(const Element& element);

        void AddRow(const NonZeroContainerType& nonZeros, const IndexContainerType& columnIndices);

        void SetElement(size_t i, size_t j, const T& value);

        void SetElement(const Element& element);

        // MARK: Basic getters
        bool IsEqual(const MatrixCSR& other) const;

        bool IsSimilar(const MatrixCSR& other, double tol = std::numeric_limits<double>::epsilon()) const;

        bool IsSquare() const;

        Size2 size() const;

        size_t Rows() const;

        size_t Cols() const;

        size_t NumberOfNonZeros() const;

        const T& NonZero(size_t i) const;

        T& NonZero(size_t i);

        const size_t& RowPointer(size_t i) const;

        const size_t& ColumnIndex(size_t i) const;

        T* NonZeroData();

        const T* NonZeroData() const;

        const size_t* RowPointersData() const;

        const size_t* ColumnIndicesData() const;

        NonZeroIterator NonZeroBegin();

        ConstNonZeroIterator NonZeroBegin() const;

        NonZeroIterator NonZeroEnd();

        ConstNonZeroIterator NonZeroEnd() const;

        IndexIterator RowPointersBegin();

        ConstIndexIterator RowPointersBegin() const;

        IndexIterator RowPointersEnd();

        ConstIndexIterator RowPointersEnd() const;

        IndexIterator ColumnIndicesBegin();

        ConstIndexIterator ColumnIndicesBegin() const;

        IndexIterator ColumnIndicesEnd();

        ConstIndexIterator ColumnIndicesEnd() const;

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

        MatrixCSR Add(const MatrixCSR& m) const;

        MatrixCSR Sub(const T& s) const;

        MatrixCSR Sub(const MatrixCSR& m) const;

        MatrixCSR Mul(const T& s) const;

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

        template <typename ME>
        MatrixCSRMatrixMul<T, ME> Mul(const MatrixExpression<T, ME>& m) const;

        MatrixCSR Div(const T& s) const;

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

        MatrixCSR RAdd(const MatrixCSR& m) const;

        MatrixCSR RSub(const T& s) const;

        MatrixCSR RSub(const MatrixCSR& m) const;

        MatrixCSR RMul(const T& s) const;

        MatrixCSR RDiv(const T& s) const;

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

        void IAdd(const MatrixCSR& m);

        void ISub(const T& s);

        void ISub(const MatrixCSR& m);

        void IMul(const T& s);

        template <typename ME>
        void IMul(const MatrixExpression<T, ME>& m);

        void IDiv(const T& s);

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

        T Avg() const;

        T Min() const;

        T Max() const;

        T AbsMin() const;

        T AbsMax() const;

        T Trace() const;

        template <typename U>
        MatrixCSR<U> CastTo() const;

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

        MatrixCSR& operator=(const MatrixCSR& other);

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

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

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

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

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

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

        template <typename ME>
        MatrixCSR& operator*=(const MatrixExpression<T, ME>& m);

        MatrixCSR& operator/=(const T& s);

        // MARK: Getter operators
        T operator()(size_t i, size_t j) const;

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

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

        // MARK: Builders
        static MatrixCSR<T> MakeIdentity(size_t m);

    private:
        Size2 m_size;
        NonZeroContainerType m_nonZeros;
        IndexContainerType m_rowPointers;
        IndexContainerType m_columnIndices;

        size_t HasElement(size_t i, size_t j) const;

        template <typename Op>
        MatrixCSR BinaryOp(const MatrixCSR& m, Op op) const;
    };

    using MatrixCSRF = MatrixCSR<float>;

    using MatrixCSRD = MatrixCSR<double>;
}

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

#endif