matrix_csr.h

Go to the documentation of this file.

// Copyright (c) 2018 Doyub Kim
//
// I am making my contributions/submissions to this project solely in my
// personal capacity and am not conveying any rights to any intellectual
// property of any third parties.
 
#ifndef INCLUDE_JET_MATRIX_CSR_H_
#define INCLUDE_JET_MATRIX_CSR_H_
 
#include <jet/matrix_expression.h>
#include <jet/size2.h>
#include <jet/vector_n.h>
 
#include <tuple>
 
namespace jet {
 
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;
    const VE& _v;
    const VE* _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>& _m1;
    const ME& _m2;
    const T* const _nnz;
    const size_t* const _rp;
    const size_t* const _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);
    };
 
    typedef std::vector<T> NonZeroContainerType;
    typedef typename NonZeroContainerType::iterator NonZeroIterator;
    typedef typename NonZeroContainerType::const_iterator ConstNonZeroIterator;
 
    typedef std::vector<size_t> IndexContainerType;
    typedef typename IndexContainerType::iterator IndexIterator;
    typedef typename IndexContainerType::const_iterator ConstIndexIterator;
 
    // MARK: Constructors
 
    MatrixCsr();
 
    MatrixCsr(const std::initializer_list<std::initializer_list<T>>& lst,
              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);
 
    // 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>>& lst,
                  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* const nonZeroData() const;
 
    const size_t* const rowPointersData() const;
 
    const size_t* const 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);
 
    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 _size;
    NonZeroContainerType _nonZeros;
    IndexContainerType _rowPointers;
    IndexContainerType _columnIndices;
 
    size_t hasElement(size_t i, size_t j) const;
 
    template <typename Op>
    MatrixCsr binaryOp(const MatrixCsr& m, Op op) const;
};
 
typedef MatrixCsr<float> MatrixCsrF;
 
typedef MatrixCsr<double> MatrixCsrD;
 
}  // namespace jet
 
#include "detail/matrix_csr-inl.h"
 
#endif  // INCLUDE_JET_MATRIX_CSR_H_