FlexibleSparseMatrix.h

Go to the documentation of this file.

#ifndef STORM_STORAGE_FLEXIBLESPARSEMATRIX_H_
#define STORM_STORAGE_FLEXIBLESPARSEMATRIX_H_
 
#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);
 
    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
 
#endif /* STORM_STORAGE_FLEXIBLESPARSEMATRIX_H_ */