FlexibleSparseMatrix.h

Go to the documentation of this file.

#pragma once
 
#include <cstdint>
#include <vector>
 
#include "storm/storage/SparseMatrix.h"
#include "storm/storage/sparse/StateType.h"
 
namespace storm {
namespace storage {
template<typename IndexType, typename ValueType>
class MatrixEntry;
 
class BitVector;

template<typename ValueType>
class FlexibleSparseMatrix {
   public:
    // TODO: make this class a bit more consistent with the big sparse matrix and improve it:
    // * add stuff like iterator, clearRow, multiplyRowWithScalar
 
    typedef uint_fast64_t index_type;
    typedef ValueType value_type;
    typedef std::vector<storm::storage::MatrixEntry<index_type, value_type>> row_type;
    typedef typename row_type::iterator iterator;
    typedef typename row_type::const_iterator const_iterator;

    FlexibleSparseMatrix() = default;

    FlexibleSparseMatrix(index_type rows);

    FlexibleSparseMatrix(storm::storage::SparseMatrix<ValueType> const& matrix, bool setAllValuesToOne = false, bool revertEquationSystem = false);

    void reserveInRow(index_type row, index_type numberOfElements);

    row_type& getRow(index_type);

    row_type const& getRow(index_type) const;

    row_type& getRow(index_type rowGroup, index_type offset);

    row_type const& getRow(index_type rowGroup, index_type entryInGroup) const;

    std::vector<index_type> const& getRowGroupIndices() const;

    index_type getRowCount() const;

    index_type getColumnCount() const;

    index_type getNonzeroEntryCount() const;

    index_type getRowGroupCount() const;

    index_type getRowGroupSize(index_type group) const;

    value_type getRowSum(index_type row) const;

    void updateDimensions();

    bool empty() const;

    bool hasTrivialRowGrouping() const;

    void filterEntries(storm::storage::BitVector const& rowConstraint, storm::storage::BitVector const& columnConstraint);

    index_type insertNewRowsAtEnd(index_type numRows);

    storm::storage::SparseMatrix<ValueType> createSparseMatrix();

    storm::storage::SparseMatrix<ValueType> createSparseMatrix(storm::storage::BitVector const& rowConstraint,
                                                               storm::storage::BitVector const& columnConstraint);

    bool rowHasDiagonalElement(storm::storage::sparse::state_type state);

    std::ostream& printRow(std::ostream& out, index_type const& rowIndex) const;
 
    template<typename TPrime>
    friend std::ostream& operator<<(std::ostream& out, FlexibleSparseMatrix<TPrime> const& matrix);
 
   private:
    std::vector<row_type> data;
 
    // The number of columns of the matrix.
    index_type columnCount;
 
    // The number of entries in the matrix.
    index_type nonzeroEntryCount;
 
    // A flag indicating whether the matrix has a trivial row grouping. Note that this may be true and yet
    // there may be row group indices, because they were requested from the outside.
    bool trivialRowGrouping;
 
    // A vector indicating the row groups of the matrix.
    std::vector<index_type> rowGroupIndices;
};
}  // namespace storage
}  // namespace storm