diff --git a/src/modelchecker/csl/SparseMarkovAutomatonCslModelChecker.h b/src/modelchecker/csl/SparseMarkovAutomatonCslModelChecker.h
index fc1138b21..56b36ac37 100644
--- a/src/modelchecker/csl/SparseMarkovAutomatonCslModelChecker.h
+++ b/src/modelchecker/csl/SparseMarkovAutomatonCslModelChecker.h
@@ -149,9 +149,9 @@ namespace storm {
                         for (auto& element : aMarkovian.getRow(rowIndex)) {
                             ValueType eTerm = std::exp(-exitRates[state] * delta);
                             if (element.getColumn() == rowIndex) {
-                                element.getValue() = (storm::utility::constantOne<ValueType>() - eTerm) * element.getValue() + eTerm;
+                                element.setValue((storm::utility::constantOne<ValueType>() - eTerm) * element.getValue() + eTerm);
                             } else {
-                                element.getValue() = (storm::utility::constantOne<ValueType>() - eTerm) * element.getValue();
+                                element.setValue((storm::utility::constantOne<ValueType>() - eTerm) * element.getValue());
                             }
                         }
                         ++rowIndex;
@@ -161,7 +161,7 @@ namespace storm {
                     rowIndex = 0;
                     for (auto state : markovianNonGoalStates) {
                         for (auto& element : aMarkovianToProbabilistic.getRow(rowIndex)) {
-                            element.getValue() = (1 - std::exp(-exitRates[state] * delta)) * element.getValue();
+                            element.setValue((1 - std::exp(-exitRates[state] * delta)) * element.getValue());
                         }
                         ++rowIndex;
                     }
diff --git a/src/models/MarkovAutomaton.h b/src/models/MarkovAutomaton.h
index 387590df6..8f5825d6d 100644
--- a/src/models/MarkovAutomaton.h
+++ b/src/models/MarkovAutomaton.h
@@ -259,7 +259,7 @@ namespace storm {
             void turnRatesToProbabilities() {
                 for (auto state : this->markovianStates) {
                     for (auto& transition : this->transitionMatrix.getRowGroup(state)) {
-                        transition.getValue() /= this->exitRates[state];
+                        transition.setValue(transition.getValue() / this->exitRates[state]);
                     }
                 }
             }
diff --git a/src/parser/CslParser.cpp b/src/parser/CslParser.cpp
index 1739ebecd..4aa8f7d91 100644
--- a/src/parser/CslParser.cpp
+++ b/src/parser/CslParser.cpp
@@ -98,11 +98,11 @@ struct CslParser::CslGrammar : qi::grammar<Iterator, std::shared_ptr<csl::CslFil
 		pathFormula = (timeBoundedEventually | eventually | globally | next | timeBoundedUntil | until | (qi::lit("(") >> pathFormula >> qi::lit(")")) | (qi::lit("[") >> pathFormula >> qi::lit("]")));
 		pathFormula.name("path formula");
 		timeBoundedEventually = (
-				(qi::lit("F") >> qi::lit("[") >> qi::double_ >> qi::lit(",") > qi::double_ > qi::lit("]") > stateFormula)[qi::_val =
+				((qi::lit("F") >> qi::lit("[") >> qi::double_ >> qi::lit(",")) > qi::double_ > qi::lit("]") > stateFormula)[qi::_val =
 				MAKE(csl::TimeBoundedEventually<double>, qi::_1, qi::_2, qi::_3)] |
-				(qi::lit("F") >> (qi::lit("<=") | qi::lit("<")) > qi::double_ > stateFormula)[qi::_val =
+				((qi::lit("F") >> (qi::lit("<=") | qi::lit("<"))) > qi::double_ > stateFormula)[qi::_val =
 								MAKE(csl::TimeBoundedEventually<double>, 0, qi::_1, qi::_2)] |
-				(qi::lit("F") >> (qi::lit(">=") | qi::lit(">")) > qi::double_ > stateFormula)[qi::_val =
+				((qi::lit("F") >> (qi::lit(">=") | qi::lit(">"))) > qi::double_ > stateFormula)[qi::_val =
 								MAKE(csl::TimeBoundedEventually<double>, qi::_1, std::numeric_limits<double>::infinity(), qi::_2)]
 				);
 		timeBoundedEventually.name("time bounded eventually");
@@ -135,14 +135,14 @@ struct CslParser::CslGrammar : qi::grammar<Iterator, std::shared_ptr<csl::CslFil
 		noBoundOperator = (probabilisticNoBoundOperator | steadyStateNoBoundOperator);
 		noBoundOperator.name("no bound operator");
 		probabilisticNoBoundOperator =
-				(qi::lit("P") >> qi::lit("min") >> qi::lit("=") > qi::lit("?") >> pathFormula)[qi::_val =
+				((qi::lit("P") >> qi::lit("min") >> qi::lit("=")) > qi::lit("?") >> pathFormula)[qi::_val =
 						MAKE(csl::CslFilter<double>, qi::_1, storm::properties::MINIMIZE)] |
-				(qi::lit("P") >> qi::lit("max") >> qi::lit("=") > qi::lit("?") >> pathFormula)[qi::_val =
+				((qi::lit("P") >> qi::lit("max") >> qi::lit("=")) > qi::lit("?") >> pathFormula)[qi::_val =
 						MAKE(csl::CslFilter<double>, qi::_1, storm::properties::MAXIMIZE)] |
-				(qi::lit("P") >> qi::lit("=") > qi::lit("?") >> pathFormula)[qi::_val =
+				((qi::lit("P") >> qi::lit("=")) > qi::lit("?") >> pathFormula)[qi::_val =
 						MAKE(csl::CslFilter<double>, qi::_1)];
 		probabilisticNoBoundOperator.name("probabilistic no bound operator");
-		steadyStateNoBoundOperator = (qi::lit("S") >> qi::lit("=") > qi::lit("?") >> stateFormula )[qi::_val =
+		steadyStateNoBoundOperator = ((qi::lit("S") >> qi::lit("=")) > qi::lit("?") >> stateFormula )[qi::_val =
 				MAKE(csl::CslFilter<double>, qi::_1, storm::properties::UNDEFINED, true)];
 		steadyStateNoBoundOperator.name("steady state no bound operator");
 
@@ -159,7 +159,7 @@ struct CslParser::CslGrammar : qi::grammar<Iterator, std::shared_ptr<csl::CslFil
 		formulaAction.name("formula action");
 
 		rangeAction = (
-				(qi::lit("range") >> qi::lit("(") >> qi::uint_ >> qi::lit(",") > qi::uint_ >> qi::lit(")"))[qi::_val =
+				((qi::lit("range") >> qi::lit("(") >> qi::uint_ >> qi::lit(",")) > qi::uint_ >> qi::lit(")"))[qi::_val =
 						MAKE(storm::properties::action::RangeAction<double>, qi::_1, qi::_2)] |
 				(qi::lit("range") >> qi::lit("(") >> qi::uint_ >> qi::lit(")"))[qi::_val =
 						MAKE(storm::properties::action::RangeAction<double>, qi::_1, qi::_1 + 1)]
@@ -181,9 +181,9 @@ struct CslParser::CslGrammar : qi::grammar<Iterator, std::shared_ptr<csl::CslFil
 
 		filter = (qi::lit("filter") >> qi::lit("[") >> +abstractAction >> qi::lit("]") >> qi::lit("(") >> formula >> qi::lit(")"))[qi::_val =
 					MAKE(csl::CslFilter<double>, qi::_2, qi::_1)] |
-				 (qi::lit("filter") >> qi::lit("[") >> qi::lit("max") > +abstractAction >> qi::lit("]") >> qi::lit("(") >> formula >> qi::lit(")"))[qi::_val =
+				 ((qi::lit("filter") >> qi::lit("[") >> qi::lit("max")) > +abstractAction >> qi::lit("]") >> qi::lit("(") >> formula >> qi::lit(")"))[qi::_val =
 					MAKE(csl::CslFilter<double>, qi::_2, qi::_1, storm::properties::MAXIMIZE)] |
-				 (qi::lit("filter") >> qi::lit("[") >> qi::lit("min") > +abstractAction >> qi::lit("]") >> qi::lit("(") >> formula >> qi::lit(")"))[qi::_val =
+				 ((qi::lit("filter") >> qi::lit("[") >> qi::lit("min")) > +abstractAction >> qi::lit("]") >> qi::lit("(") >> formula >> qi::lit(")"))[qi::_val =
 					MAKE(csl::CslFilter<double>, qi::_2, qi::_1, storm::properties::MINIMIZE)] |
 				 (noBoundOperator)[qi::_val =
 					qi::_1] |
diff --git a/src/parser/LtlParser.cpp b/src/parser/LtlParser.cpp
index df4d28c9e..86fff3b03 100644
--- a/src/parser/LtlParser.cpp
+++ b/src/parser/LtlParser.cpp
@@ -77,7 +77,7 @@ struct LtlParser::LtlGrammar : qi::grammar<Iterator, std::shared_ptr<storm::prop
 				MAKE(ltl::And<double>, qi::_val, qi::_1)];
 		andFormula.name("And");
 		untilFormula = notFormula[qi::_val = qi::_1] >
-				*((qi::lit("U") >> qi::lit("<=") > qi::int_ > notFormula)[qi::_val = MAKE(ltl::BoundedUntil<double>, qi::_val, qi::_2, qi::_1)] |
+				*(((qi::lit("U") >> qi::lit("<=")) > qi::int_ > notFormula)[qi::_val = MAKE(ltl::BoundedUntil<double>, qi::_val, qi::_2, qi::_1)] |
 				  (qi::lit("U") > notFormula)[qi::_val = MAKE(ltl::Until<double>, qi::_val, qi::_1)]);
 		until.name("Until");
 		notFormula = atomicLtlFormula[qi::_val = qi::_1] | (qi::lit("!") > atomicLtlFormula)[qi::_val =
@@ -95,7 +95,7 @@ struct LtlParser::LtlGrammar : qi::grammar<Iterator, std::shared_ptr<storm::prop
 		//This block defines rules for parsing probabilistic path formulas
 		pathFormula = (boundedEventually | eventually | globally | next);
 		pathFormula.name("Path Formula");
-		boundedEventually = (qi::lit("F") >> qi::lit("<=") > qi::int_ > formula)[qi::_val =
+		boundedEventually = ((qi::lit("F") >> qi::lit("<=")) > qi::int_ > formula)[qi::_val =
 				MAKE(ltl::BoundedEventually<double>, qi::_2, qi::_1)];
 		boundedEventually.name("Bounded Eventually");
 		eventually = (qi::lit("F") >> formula)[qi::_val =
@@ -117,7 +117,7 @@ struct LtlParser::LtlGrammar : qi::grammar<Iterator, std::shared_ptr<storm::prop
 		invertAction.name("invert action");
 
 		rangeAction = (
-				(qi::lit("range") >> qi::lit("(") >> qi::uint_ >> qi::lit(",") > qi::uint_ >> qi::lit(")"))[qi::_val =
+				((qi::lit("range") >> qi::lit("(") >> qi::uint_ >> qi::lit(",")) > qi::uint_ >> qi::lit(")"))[qi::_val =
 						MAKE(storm::properties::action::RangeAction<double>, qi::_1, qi::_2)] |
 				(qi::lit("range") >> qi::lit("(") >> qi::uint_ >> qi::lit(")"))[qi::_val =
 						MAKE(storm::properties::action::RangeAction<double>, qi::_1, qi::_1 + 1)]
@@ -139,9 +139,9 @@ struct LtlParser::LtlGrammar : qi::grammar<Iterator, std::shared_ptr<storm::prop
 
 		filter = (qi::lit("filter") >> qi::lit("[") >> +abstractAction >> qi::lit("]") > qi::lit("(") >> formula >> qi::lit(")"))[qi::_val =
 					MAKE(ltl::LtlFilter<double>, qi::_2, qi::_1)] |
-				 (qi::lit("filter") >> qi::lit("[") >> qi::lit("max") > +abstractAction >> qi::lit("]") >> qi::lit("(") >> formula >> qi::lit(")"))[qi::_val =
+				 ((qi::lit("filter") >> qi::lit("[") >> qi::lit("max")) > +abstractAction >> qi::lit("]") >> qi::lit("(") >> formula >> qi::lit(")"))[qi::_val =
 					MAKE(ltl::LtlFilter<double>, qi::_2, qi::_1, storm::properties::MAXIMIZE)] |
-				 (qi::lit("filter") >> qi::lit("[") >> qi::lit("min") > +abstractAction >> qi::lit("]") >> qi::lit("(") >> formula >> qi::lit(")"))[qi::_val =
+				 ((qi::lit("filter") >> qi::lit("[") >> qi::lit("min")) > +abstractAction >> qi::lit("]") >> qi::lit("(") >> formula >> qi::lit(")"))[qi::_val =
 					MAKE(ltl::LtlFilter<double>, qi::_2, qi::_1, storm::properties::MINIMIZE)] |
 				 (formula)[qi::_val =
 					MAKE(ltl::LtlFilter<double>, qi::_1)];
diff --git a/src/parser/PrctlParser.cpp b/src/parser/PrctlParser.cpp
index 899b71663..d2e6f06fa 100644
--- a/src/parser/PrctlParser.cpp
+++ b/src/parser/PrctlParser.cpp
@@ -89,7 +89,7 @@ struct PrctlParser::PrctlGrammar : qi::grammar<Iterator, std::shared_ptr<storm::
 		// This block defines rules for parsing probabilistic path formulas
 		pathFormula = (boundedEventually | eventually | next | globally | boundedUntil | until | qi::lit("(") >> pathFormula >> qi::lit(")") | qi::lit("[") >> pathFormula >> qi::lit("]"));
 		pathFormula.name("path formula");
-		boundedEventually = (qi::lit("F") >> qi::lit("<=") > qi::int_ > stateFormula)[qi::_val =
+		boundedEventually = ((qi::lit("F") >> qi::lit("<=")) > qi::int_ > stateFormula)[qi::_val =
 				MAKE(prctl::BoundedEventually<double>, qi::_2, qi::_1)];
 		boundedEventually.name("bounded eventually");
 		eventually = (qi::lit("F") > stateFormula)[qi::_val =
@@ -132,21 +132,21 @@ struct PrctlParser::PrctlGrammar : qi::grammar<Iterator, std::shared_ptr<storm::
 		noBoundOperator = (probabilisticNoBoundOperator | rewardNoBoundOperator);
 		noBoundOperator.name("no bound operator");
 		probabilisticNoBoundOperator = (
-				(qi::lit("P") >> qi::lit("min") >> qi::lit("=") > qi::lit("?") >> pathFormula )[qi::_val =
+				((qi::lit("P") >> qi::lit("min") >> qi::lit("=")) > qi::lit("?") >> pathFormula )[qi::_val =
 						MAKE(prctl::PrctlFilter<double>, qi::_1, storm::properties::MINIMIZE)] |
-				(qi::lit("P") >> qi::lit("max") >> qi::lit("=") > qi::lit("?") >> pathFormula )[qi::_val =
+				((qi::lit("P") >> qi::lit("max") >> qi::lit("=")) > qi::lit("?") >> pathFormula )[qi::_val =
 						MAKE(prctl::PrctlFilter<double>, qi::_1, storm::properties::MAXIMIZE)] |
-				(qi::lit("P") >> qi::lit("=") > qi::lit("?") >> pathFormula )[qi::_val =
+				((qi::lit("P") >> qi::lit("=")) > qi::lit("?") >> pathFormula )[qi::_val =
 						MAKE(prctl::PrctlFilter<double>, qi::_1)]
 				);
 		probabilisticNoBoundOperator.name("no bound operator");
 
 		rewardNoBoundOperator = (
-				(qi::lit("R") >> qi::lit("min") >> qi::lit("=") > qi::lit("?") >> rewardPathFormula )[qi::_val =
+				((qi::lit("R") >> qi::lit("min") >> qi::lit("=")) > qi::lit("?") >> rewardPathFormula )[qi::_val =
 						MAKE(prctl::PrctlFilter<double>, qi::_1, storm::properties::MINIMIZE)] |
-				(qi::lit("R") >> qi::lit("max") >> qi::lit("=") > qi::lit("?") >> rewardPathFormula )[qi::_val =
+				((qi::lit("R") >> qi::lit("max") >> qi::lit("=")) > qi::lit("?") >> rewardPathFormula )[qi::_val =
 						MAKE(prctl::PrctlFilter<double>, qi::_1, storm::properties::MAXIMIZE)] |
-				(qi::lit("R") >> qi::lit("=") > qi::lit("?") >> rewardPathFormula )[qi::_val =
+				((qi::lit("R") >> qi::lit("=")) > qi::lit("?") >> rewardPathFormula )[qi::_val =
 						MAKE(prctl::PrctlFilter<double>, qi::_1)]
 
 				);
@@ -166,7 +166,7 @@ struct PrctlParser::PrctlGrammar : qi::grammar<Iterator, std::shared_ptr<storm::
 		formulaAction.name("formula action");
 
 		rangeAction = (
-				(qi::lit("range") >> qi::lit("(") >> qi::uint_ >> qi::lit(",") > qi::uint_ >> qi::lit(")"))[qi::_val =
+				((qi::lit("range") >> qi::lit("(") >> qi::uint_ >> qi::lit(",")) > qi::uint_ >> qi::lit(")"))[qi::_val =
 						MAKE(storm::properties::action::RangeAction<double>, qi::_1, qi::_2)] |
 				(qi::lit("range") >> qi::lit("(") >> qi::uint_ >> qi::lit(")"))[qi::_val =
 						MAKE(storm::properties::action::RangeAction<double>, qi::_1, qi::_1 + 1)]
@@ -188,9 +188,9 @@ struct PrctlParser::PrctlGrammar : qi::grammar<Iterator, std::shared_ptr<storm::
 
 		filter = (qi::lit("filter") >> qi::lit("[") >> +abstractAction >> qi::lit("]") > qi::lit("(") >> formula >> qi::lit(")"))[qi::_val =
 					MAKE(prctl::PrctlFilter<double>, qi::_2, qi::_1)] |
-				 (qi::lit("filter") >> qi::lit("[") >> qi::lit("max") > +abstractAction >> qi::lit("]") >> qi::lit("(") >> formula >> qi::lit(")"))[qi::_val =
+				 ((qi::lit("filter") >> qi::lit("[") >> qi::lit("max")) > +abstractAction >> qi::lit("]") >> qi::lit("(") >> formula >> qi::lit(")"))[qi::_val =
 					MAKE(prctl::PrctlFilter<double>, qi::_2, qi::_1, storm::properties::MAXIMIZE)] |
-				 (qi::lit("filter") >> qi::lit("[") >> qi::lit("min") > +abstractAction >> qi::lit("]") >> qi::lit("(") >> formula >> qi::lit(")"))[qi::_val =
+				 ((qi::lit("filter") >> qi::lit("[") >> qi::lit("min")) > +abstractAction >> qi::lit("]") >> qi::lit("(") >> formula >> qi::lit(")"))[qi::_val =
 					MAKE(prctl::PrctlFilter<double>, qi::_2, qi::_1, storm::properties::MINIMIZE)] |
 				 (noBoundOperator)[qi::_val =
 					qi::_1] |
diff --git a/src/storage/SparseMatrix.cpp b/src/storage/SparseMatrix.cpp
index d88b69f53..e913fd00f 100644
--- a/src/storage/SparseMatrix.cpp
+++ b/src/storage/SparseMatrix.cpp
@@ -1,4 +1,4 @@
-#include <boost/functional/hash.hpp>
+T#include <boost/functional/hash.hpp>
 
 // To detect whether the usage of TBB is possible, this include is neccessary
 #include "storm-config.h"
@@ -19,48 +19,48 @@ extern log4cplus::Logger logger;
 namespace storm {
     namespace storage {
         
-        template<typename T>
-        MatrixEntry<T>::MatrixEntry(uint_fast64_t column, T value) : entry(column, value) {
+        template<typename IndexType, typename ValueType>
+        MatrixEntry<IndexType, ValueType>::MatrixEntry(IndexType column, ValueType value) : entry(column, value) {
             // Intentionally left empty.
         }
         
-        template<typename T>
-        MatrixEntry<T>::MatrixEntry(std::pair<uint_fast64_t, T>&& pair) : entry(std::move(pair)) {
+        template<typename IndexType, typename ValueType>
+        MatrixEntry<IndexType, ValueType>::MatrixEntry(std::pair<IndexType, ValueType>&& pair) : entry(std::move(pair)) {
             // Intentionally left empty.
         }
         
-        template<typename T>
-        uint_fast64_t const& MatrixEntry<T>::getColumn() const {
+        template<typename IndexType, typename ValueType>
+        IndexType const& MatrixEntry<IndexType, ValueType>::getColumn() const {
             return this->entry.first;
         }
         
-        template<typename T>
-        uint_fast64_t& MatrixEntry<T>::getColumn() {
-            return this->entry.first;
+        template<typename IndexType, typename ValueType>
+        void MatrixEntry<IndexType, ValueType>::setColumn(IndexType const& column) {
+            this->entry.first = column;
         }
         
-        template<typename T>
-        T const& MatrixEntry<T>::getValue() const {
+        template<typename IndexType, typename ValueType>
+        ValueType const& MatrixEntry<IndexType, ValueType>::getValue() const {
             return this->entry.second;
         }
         
-        template<typename T>
-        T& MatrixEntry<T>::getValue() {
-            return this->entry.second;
+        template<typename IndexType, typename ValueType>
+        void MatrixEntry<IndexType, ValueType>::setValue(ValueType const& value) {
+            this->entry.second = value;
         }
-        
-        template<typename T>
-        std::pair<uint_fast64_t, T> const& MatrixEntry<T>::getColumnValuePair() const {
+
+        template<typename IndexType, typename ValueType>
+        std::pair<IndexType, ValueType> const& MatrixEntry<IndexType, ValueType>::getColumnValuePair() const {
             return this->entry;
         }
         
-        template<typename T>
-        SparseMatrixBuilder<T>::SparseMatrixBuilder(uint_fast64_t rows, uint_fast64_t columns, uint_fast64_t entries, bool hasCustomRowGrouping, uint_fast64_t rowGroups) : rowCountSet(rows != 0), rowCount(rows), columnCountSet(columns != 0), columnCount(columns), entryCount(entries), hasCustomRowGrouping(hasCustomRowGrouping), rowGroupCountSet(rowGroups != 0), rowGroupCount(rowGroups), rowGroupIndices(), storagePreallocated(rows != 0 && columns != 0 && entries != 0), columnsAndValues(), rowIndications(), currentEntryCount(0), lastRow(0), lastColumn(0), currentRowGroup(0) {
+        template<typename ValueType>
+        SparseMatrixBuilder<ValueType>::SparseMatrixBuilder(index_type rows, index_type columns, index_type entries, bool hasCustomRowGrouping, index_type rowGroups) : rowCountSet(rows != 0), rowCount(rows), columnCountSet(columns != 0), columnCount(columns), entryCount(entries), hasCustomRowGrouping(hasCustomRowGrouping), rowGroupCountSet(rowGroups != 0), rowGroupCount(rowGroups), rowGroupIndices(), storagePreallocated(rows != 0 && columns != 0 && entries != 0), columnsAndValues(), rowIndications(), currentEntryCount(0), lastRow(0), lastColumn(0), currentRowGroup(0) {
             this->prepareInternalStorage();
         }
         
-        template<typename T>
-        void SparseMatrixBuilder<T>::addNextValue(uint_fast64_t row, uint_fast64_t column, T const& value) {
+        template<typename ValueType>
+        void SparseMatrixBuilder<ValueType>::addNextValue(index_type row, index_type column, ValueType const& value) {
             // Depending on whether the internal data storage was preallocated or not, adding the value is done somewhat
             // differently.
             if (storagePreallocated) {
@@ -96,18 +96,18 @@ namespace storm {
                 if (storagePreallocated) {
                     // If the storage was preallocated, we can access the elements in the vectors with the subscript
                     // operator.
-                    for (uint_fast64_t i = lastRow + 1; i <= row; ++i) {
+                    for (index_type i = lastRow + 1; i <= row; ++i) {
                         rowIndications[i] = currentEntryCount;
                     }
                 } else {
                     // Otherwise, we need to push the correct values to the vectors, which might trigger reallocations.
-                    for (uint_fast64_t i = lastRow + 1; i <= row; ++i) {
+                    for (index_type i = lastRow + 1; i <= row; ++i) {
                         rowIndications.push_back(currentEntryCount);
                     }
                 }
                 
                 if (!hasCustomRowGrouping) {
-                    for (uint_fast64_t i = lastRow + 1; i <= row; ++i) {
+                    for (index_type i = lastRow + 1; i <= row; ++i) {
                         rowGroupIndices.push_back(i);
                         ++currentRowGroup;
                     }
@@ -133,8 +133,8 @@ namespace storm {
             ++currentEntryCount;
         }
         
-        template<typename T>
-        void SparseMatrixBuilder<T>::newRowGroup(uint_fast64_t startingRow) {
+        template<typename ValueType>
+        void SparseMatrixBuilder<ValueType>::newRowGroup(index_type startingRow) {
             if (!hasCustomRowGrouping) {
                 throw storm::exceptions::InvalidStateException() << "Illegal call to SparseMatrix::newRowGroup: matrix was not created to have a custom row grouping.";
             } else if (rowGroupIndices.size() > 0 && startingRow < rowGroupIndices.back()) {
@@ -148,22 +148,22 @@ namespace storm {
             }
         }
         
-        template<typename T>
-        SparseMatrix<T> SparseMatrixBuilder<T>::build(uint_fast64_t overriddenRowCount, uint_fast64_t overriddenColumnCount, uint_fast64_t overriddenRowGroupCount) {
+        template<typename ValueType>
+        SparseMatrix<ValueType> SparseMatrixBuilder<ValueType>::build(index_type overriddenRowCount, index_type overriddenColumnCount, index_type overriddenRowGroupCount) {
             // Check whether it's safe to finalize the matrix and throw error otherwise.
             if (storagePreallocated && currentEntryCount != entryCount) {
                 throw storm::exceptions::InvalidStateException() << "Illegal call to SparseMatrix::build: expected " << entryCount << " entries, but got " << currentEntryCount << " instead.";
             } else {
                 // Fill in the missing entries in the row indices array, as there may be empty rows at the end.
                 if (storagePreallocated) {
-                    for (uint_fast64_t i = lastRow + 1; i < rowCount; ++i) {
+                    for (index_type i = lastRow + 1; i < rowCount; ++i) {
                         rowIndications[i] = currentEntryCount;
                     }
                 } else {
                     if (!rowCountSet) {
                         rowCount = std::max(overriddenRowCount, rowCount);
                     }
-                    for (uint_fast64_t i = lastRow + 1; i < rowCount; ++i) {
+                    for (index_type i = lastRow + 1; i < rowCount; ++i) {
                         rowIndications.push_back(currentEntryCount);
                     }
                 }
@@ -186,27 +186,27 @@ namespace storm {
                     rowGroupIndices[rowGroupCount] = rowCount;
                 } else {
                     if (!hasCustomRowGrouping) {
-                        for (uint_fast64_t i = currentRowGroup; i < rowCount; ++i) {
+                        for (index_type i = currentRowGroup; i < rowCount; ++i) {
                             rowGroupIndices.push_back(i + 1);
                         }
                     } else {
                         overriddenRowGroupCount = std::max(overriddenRowGroupCount, currentRowGroup + 1);
-                        for (uint_fast64_t i = currentRowGroup; i < overriddenRowGroupCount; ++i) {
+                        for (index_type i = currentRowGroup; i < overriddenRowGroupCount; ++i) {
                             rowGroupIndices.push_back(rowCount);
                         }
                     }
                 }
             }
             
-            return SparseMatrix<T>(columnCount, std::move(rowIndications), std::move(columnsAndValues), std::move(rowGroupIndices));
+            return SparseMatrix<ValueType>(columnCount, std::move(rowIndications), std::move(columnsAndValues), std::move(rowGroupIndices));
         }
         
-        template<typename T>
-        void SparseMatrixBuilder<T>::prepareInternalStorage() {
+        template<typename ValueType>
+        void SparseMatrixBuilder<ValueType>::prepareInternalStorage() {
             // Only allocate the memory for the matrix contents if the dimensions of the matrix are already known.
             if (storagePreallocated) {
-                columnsAndValues = std::vector<MatrixEntry<T>>(entryCount, MatrixEntry<T>(0, storm::utility::constantZero<T>()));
-                rowIndications = std::vector<uint_fast64_t>(rowCount + 1, 0);
+                columnsAndValues = std::vector<MatrixEntry<index_type, ValueType>>(entryCount, MatrixEntry<index_type, ValueType>(0, storm::utility::constantZero<ValueType>()));
+                rowIndications = std::vector<index_type>(rowCount + 1, 0);
             } else {
                 rowIndications.push_back(0);
             }
@@ -214,7 +214,7 @@ namespace storm {
             // Only allocate the memory for the row grouping of the matrix contents if the number of groups is already
             // known.
             if (hasCustomRowGrouping && rowGroupCountSet) {
-                rowGroupIndices = std::vector<uint_fast64_t>(rowGroupCount + 1, 0);
+                rowGroupIndices = std::vector<index_type>(rowGroupCount + 1, 0);
             } else {
                 if (hasCustomRowGrouping) {
                     // Nothing to do in this case
@@ -224,74 +224,84 @@ namespace storm {
             }
         }
         
-        template<typename T>
-        SparseMatrix<T>::rows::rows(iterator begin, uint_fast64_t entryCount) : beginIterator(begin), entryCount(entryCount) {
+        template<typename ValueType>
+        SparseMatrix<ValueType>::rows::rows(iterator begin, index_type entryCount) : beginIterator(begin), entryCount(entryCount) {
             // Intentionally left empty.
         }
         
-        template<typename T>
-        typename SparseMatrix<T>::iterator SparseMatrix<T>::rows::begin() {
+        template<typename ValueType>
+        typename SparseMatrix<ValueType>::iterator SparseMatrix<ValueType>::rows::begin() {
             return beginIterator;
         }
         
-        template<typename T>
-        typename SparseMatrix<T>::iterator SparseMatrix<T>::rows::end() {
+        template<typename ValueType>
+        typename SparseMatrix<ValueType>::iterator SparseMatrix<ValueType>::rows::end() {
             return beginIterator + entryCount;
         }
         
-        template<typename T>
-        SparseMatrix<T>::const_rows::const_rows(const_iterator begin, uint_fast64_t entryCount) : beginIterator(begin), entryCount(entryCount) {
+        template<typename ValueType>
+        typename SparseMatrix<ValueType>::index_type SparseMatrix<ValueType>::rows::getNumberOfEntries() const {
+            return this->entryCount;
+        }
+        
+        template<typename ValueType>
+        SparseMatrix<ValueType>::const_rows::const_rows(const_iterator begin, index_type entryCount) : beginIterator(begin), entryCount(entryCount) {
             // Intentionally left empty.
         }
         
-        template<typename T>
-        typename SparseMatrix<T>::const_iterator SparseMatrix<T>::const_rows::begin() const {
+        template<typename ValueType>
+        typename SparseMatrix<ValueType>::const_iterator SparseMatrix<ValueType>::const_rows::begin() const {
             return beginIterator;
         }
         
-        template<typename T>
-        typename SparseMatrix<T>::const_iterator SparseMatrix<T>::const_rows::end() const {
+        template<typename ValueType>
+        typename SparseMatrix<ValueType>::const_iterator SparseMatrix<ValueType>::const_rows::end() const {
             return beginIterator + entryCount;
         }
         
-        template<typename T>
-        SparseMatrix<T>::SparseMatrix() : rowCount(0), columnCount(0), entryCount(0), nonzeroEntryCount(0), columnsAndValues(), rowIndications(), rowGroupIndices() {
+        template<typename ValueType>
+        typename SparseMatrix<ValueType>::index_type SparseMatrix<ValueType>::const_rows::getNumberOfEntries() const {
+            return this->entryCount;
+        }
+        
+        template<typename ValueType>
+        SparseMatrix<ValueType>::SparseMatrix() : rowCount(0), columnCount(0), entryCount(0), nonzeroEntryCount(0), columnsAndValues(), rowIndications(), rowGroupIndices() {
             // Intentionally left empty.
         }
         
-        template<typename T>
-        SparseMatrix<T>::SparseMatrix(SparseMatrix<T> const& other) : rowCount(other.rowCount), columnCount(other.columnCount), entryCount(other.entryCount), nonzeroEntryCount(other.nonzeroEntryCount), columnsAndValues(other.columnsAndValues), rowIndications(other.rowIndications), rowGroupIndices(other.rowGroupIndices) {
+        template<typename ValueType>
+        SparseMatrix<ValueType>::SparseMatrix(SparseMatrix<ValueType> const& other) : rowCount(other.rowCount), columnCount(other.columnCount), entryCount(other.entryCount), nonzeroEntryCount(other.nonzeroEntryCount), columnsAndValues(other.columnsAndValues), rowIndications(other.rowIndications), rowGroupIndices(other.rowGroupIndices) {
             // Intentionally left empty.
         }
         
-        template<typename T>
-        SparseMatrix<T>::SparseMatrix(SparseMatrix<T>&& other) : rowCount(other.rowCount), columnCount(other.columnCount), entryCount(other.entryCount), nonzeroEntryCount(other.nonzeroEntryCount), columnsAndValues(std::move(other.columnsAndValues)), rowIndications(std::move(other.rowIndications)), rowGroupIndices(std::move(other.rowGroupIndices)) {
+        template<typename ValueType>
+        SparseMatrix<ValueType>::SparseMatrix(SparseMatrix<ValueType>&& other) : rowCount(other.rowCount), columnCount(other.columnCount), entryCount(other.entryCount), nonzeroEntryCount(other.nonzeroEntryCount), columnsAndValues(std::move(other.columnsAndValues)), rowIndications(std::move(other.rowIndications)), rowGroupIndices(std::move(other.rowGroupIndices)) {
             // Now update the source matrix
             other.rowCount = 0;
             other.columnCount = 0;
             other.entryCount = 0;
         }
         
-        template<typename T>
-        SparseMatrix<T>::SparseMatrix(uint_fast64_t columnCount, std::vector<uint_fast64_t> const& rowIndications, std::vector<MatrixEntry<T>> const& columnsAndValues, std::vector<uint_fast64_t> const& rowGroupIndices) : rowCount(rowIndications.size() - 1), columnCount(columnCount), entryCount(columnsAndValues.size()), nonzeroEntryCount(0), columnsAndValues(columnsAndValues), rowIndications(rowIndications), rowGroupIndices(rowGroupIndices) {
+        template<typename ValueType>
+        SparseMatrix<ValueType>::SparseMatrix(index_type columnCount, std::vector<index_type> const& rowIndications, std::vector<MatrixEntry<index_type, ValueType>> const& columnsAndValues, std::vector<index_type> const& rowGroupIndices) : rowCount(rowIndications.size() - 1), columnCount(columnCount), entryCount(columnsAndValues.size()), nonzeroEntryCount(0), columnsAndValues(columnsAndValues), rowIndications(rowIndications), rowGroupIndices(rowGroupIndices) {
             for (auto const& element : *this) {
-                if (element.getValue() != storm::utility::constantZero<T>()) {
+                if (element.getValue() != storm::utility::constantZero<ValueType>()) {
                     ++this->nonzeroEntryCount;
                 }
             }
         }
         
-        template<typename T>
-        SparseMatrix<T>::SparseMatrix(uint_fast64_t columnCount, std::vector<uint_fast64_t>&& rowIndications, std::vector<MatrixEntry<T>>&& columnsAndValues, std::vector<uint_fast64_t>&& rowGroupIndices) : rowCount(rowIndications.size() - 1), columnCount(columnCount), entryCount(columnsAndValues.size()), nonzeroEntryCount(0), columnsAndValues(std::move(columnsAndValues)), rowIndications(std::move(rowIndications)), rowGroupIndices(std::move(rowGroupIndices)) {
+        template<typename ValueType>
+        SparseMatrix<ValueType>::SparseMatrix(index_type columnCount, std::vector<index_type>&& rowIndications, std::vector<MatrixEntry<index_type, ValueType>>&& columnsAndValues, std::vector<index_type>&& rowGroupIndices) : rowCount(rowIndications.size() - 1), columnCount(columnCount), entryCount(columnsAndValues.size()), nonzeroEntryCount(0), columnsAndValues(std::move(columnsAndValues)), rowIndications(std::move(rowIndications)), rowGroupIndices(std::move(rowGroupIndices)) {
             for (auto const& element : *this) {
-                if (element.getValue() != storm::utility::constantZero<T>()) {
+                if (element.getValue() != storm::utility::constantZero<ValueType>()) {
                     ++this->nonzeroEntryCount;
                 }
             }
         }
                 
-        template<typename T>
-        SparseMatrix<T>& SparseMatrix<T>::operator=(SparseMatrix<T> const& other) {
+        template<typename ValueType>
+        SparseMatrix<ValueType>& SparseMatrix<ValueType>::operator=(SparseMatrix<ValueType> const& other) {
             // Only perform assignment if source and target are not the same.
             if (this != &other) {
                 rowCount = other.rowCount;
@@ -307,8 +317,8 @@ namespace storm {
             return *this;
         }
         
-        template<typename T>
-        SparseMatrix<T>& SparseMatrix<T>::operator=(SparseMatrix<T>&& other) {
+        template<typename ValueType>
+        SparseMatrix<ValueType>& SparseMatrix<ValueType>::operator=(SparseMatrix<ValueType>&& other) {
             // Only perform assignment if source and target are not the same.
             if (this != &other) {
                 rowCount = other.rowCount;
@@ -324,8 +334,8 @@ namespace storm {
             return *this;
         }
         
-        template<typename T>
-        bool SparseMatrix<T>::operator==(SparseMatrix<T> const& other) const {
+        template<typename ValueType>
+        bool SparseMatrix<ValueType>::operator==(SparseMatrix<ValueType> const& other) const {
             if (this == &other) {
                 return true;
             }
@@ -333,18 +343,27 @@ namespace storm {
             bool equalityResult = true;
 
             equalityResult &= this->getRowCount() == other.getRowCount();
+            if (!equalityResult) {
+                return false;
+            }
             equalityResult &= this->getColumnCount() == other.getColumnCount();
+            if (!equalityResult) {
+                return false;
+            }
             equalityResult &= this->getRowGroupIndices() == other.getRowGroupIndices();
+            if (!equalityResult) {
+                return false;
+            }
             
             // For the actual contents, we need to do a little bit more work, because we want to ignore elements that
             // are set to zero, please they may be represented implicitly in the other matrix.
-            for (uint_fast64_t row = 0; row < this->getRowCount(); ++row) {
+            for (index_type row = 0; row < this->getRowCount(); ++row) {
                 for (const_iterator it1 = this->begin(row), ite1 = this->end(row), it2 = other.begin(row), ite2 = other.end(row); it1 != ite1 && it2 != ite2; ++it1, ++it2) {
                     // Skip over all zero entries in both matrices.
-                    while (it1 != ite1 && it1->getValue() == storm::utility::constantZero<T>()) {
+                    while (it1 != ite1 && it1->getValue() == storm::utility::constantZero<ValueType>()) {
                         ++it1;
                     }
-                    while (it2 != ite2 && it2->getValue() == storm::utility::constantZero<T>()) {
+                    while (it2 != ite2 && it2->getValue() == storm::utility::constantZero<ValueType>()) {
                         ++it2;
                     }
                     if ((it1 == ite1) || (it2 == ite2)) {
@@ -357,64 +376,67 @@ namespace storm {
                         }
                     }
                 }
+                if (!equalityResult) {
+                    return false;
+                }
             }
             
             return equalityResult;
         }
         
-        template<typename T>
-        uint_fast64_t SparseMatrix<T>::getRowCount() const {
+        template<typename ValueType>
+        typename SparseMatrix<ValueType>::index_type SparseMatrix<ValueType>::getRowCount() const {
             return rowCount;
         }
         
-        template<typename T>
-        uint_fast64_t SparseMatrix<T>::getColumnCount() const {
+        template<typename ValueType>
+        typename SparseMatrix<ValueType>::index_type SparseMatrix<ValueType>::getColumnCount() const {
             return columnCount;
         }
         
-        template<typename T>
-        uint_fast64_t SparseMatrix<T>::getEntryCount() const {
+        template<typename ValueType>
+        typename SparseMatrix<ValueType>::index_type SparseMatrix<ValueType>::getEntryCount() const {
             return entryCount;
         }
         
-        template<typename T>
-        uint_fast64_t SparseMatrix<T>::getNonzeroEntryCount() const {
+        template<typename ValueType>
+        typename SparseMatrix<ValueType>::index_type SparseMatrix<ValueType>::getNonzeroEntryCount() const {
             return nonzeroEntryCount;
         }
         
-        template<typename T>
-        uint_fast64_t SparseMatrix<T>::getRowGroupCount() const {
+        template<typename ValueType>
+        typename SparseMatrix<ValueType>::index_type SparseMatrix<ValueType>::getRowGroupCount() const {
             return rowGroupIndices.size() - 1;
         }
         
-        template<typename T>
-        uint_fast64_t SparseMatrix<T>::getRowGroupSize(uint_fast64_t group) const {
+        template<typename ValueType>
+        typename SparseMatrix<ValueType>::index_type SparseMatrix<ValueType>::getRowGroupSize(index_type group) const {
             return this->getRowGroupIndices()[group + 1] - this->getRowGroupIndices()[group];
         }
         
-        template<typename T>
-        std::vector<uint_fast64_t> const& SparseMatrix<T>::getRowGroupIndices() const {
+        template<typename ValueType>
+        std::vector<typename SparseMatrix<ValueType>::index_type> const& SparseMatrix<ValueType>::getRowGroupIndices() const {
             return rowGroupIndices;
         }
 
-        template<typename T>
-        void SparseMatrix<T>::makeRowsAbsorbing(storm::storage::BitVector const& rows) {
+        template<typename ValueType>
+        void SparseMatrix<ValueType>::makeRowsAbsorbing(storm::storage::BitVector const& rows) {
             for (auto row : rows) {
                 makeRowDirac(row, row);
             }
         }
         
-        template<typename T>
-        void SparseMatrix<T>::makeRowGroupsAbsorbing(storm::storage::BitVector const& rowGroupConstraint) {
+        template<typename ValueType>
+        void SparseMatrix<ValueType>::makeRowGroupsAbsorbing(storm::storage::BitVector const& rowGroupConstraint) {
             for (auto rowGroup : rowGroupConstraint) {
-                for (uint_fast64_t row = this->getRowGroupIndices()[rowGroup]; row < this->getRowGroupIndices()[rowGroup + 1]; ++row) {
+                for (index_type row = this->getRowGroupIndices()[rowGroup]; row < this->getRowGroupIndices()[rowGroup + 1]; ++row) {
                     makeRowDirac(row, rowGroup);
                 }
             }
         }
         
-        template<typename T>
-        void SparseMatrix<T>::makeRowDirac(uint_fast64_t row, uint_fast64_t column) {
+        template<typename ValueType>
+        void SparseMatrix<ValueType>::makeRowDirac(index_type row, index_type column) {
             iterator columnValuePtr = this->begin(row);
             iterator columnValuePtrEnd = this->end(row);
             
@@ -426,18 +448,18 @@ namespace storm {
             
             // If there is at least one entry in this row, we can just set it to one, modify its column value to the
             // one given by the parameter and set all subsequent elements of this row to zero.
-            columnValuePtr->getColumn() = column;
-            columnValuePtr->getValue() = storm::utility::constantOne<T>();
+            columnValuePtr->setColumn(column);
+            columnValuePtr->setValue(storm::utility::constantOne<ValueType>());
             ++columnValuePtr;
             for (; columnValuePtr != columnValuePtrEnd; ++columnValuePtr) {
-                columnValuePtr->getColumn() = 0;
-                columnValuePtr->getValue() = storm::utility::constantZero<T>();
+                columnValuePtr->setColumn(0);
+                columnValuePtr->setValue(storm::utility::constantZero<ValueType>());
             }
         }
         
-        template<typename T>
-        T SparseMatrix<T>::getConstrainedRowSum(uint_fast64_t row, storm::storage::BitVector const& constraint) const {
-            T result(0);
+        template<typename ValueType>
+        ValueType SparseMatrix<ValueType>::getConstrainedRowSum(index_type row, storm::storage::BitVector const& constraint) const {
+            ValueType result = storm::utility::constantZero<ValueType>();
             for (const_iterator it = this->begin(row), ite = this->end(row); it != ite; ++it) {
                 if (constraint.get(it->getColumn())) {
                     result += it->getValue();
@@ -446,51 +468,51 @@ namespace storm {
             return result;
         }
         
-        template<typename T>
-        std::vector<T> SparseMatrix<T>::getConstrainedRowSumVector(storm::storage::BitVector const& rowConstraint, storm::storage::BitVector const& columnConstraint) const {
-            std::vector<T> result(rowConstraint.getNumberOfSetBits());
-            uint_fast64_t currentRowCount = 0;
+        template<typename ValueType>
+        std::vector<ValueType> SparseMatrix<ValueType>::getConstrainedRowSumVector(storm::storage::BitVector const& rowConstraint, storm::storage::BitVector const& columnConstraint) const {
+            std::vector<ValueType> result(rowConstraint.getNumberOfSetBits());
+            index_type currentRowCount = 0;
             for (auto row : rowConstraint) {
                 result[currentRowCount++] = getConstrainedRowSum(row, columnConstraint);
             }
             return result;
         }
         
-        template<typename T>
-        std::vector<T> SparseMatrix<T>::getConstrainedRowGroupSumVector(storm::storage::BitVector const& rowGroupConstraint, storm::storage::BitVector const& columnConstraint) const {
-            std::vector<T> result;
+        template<typename ValueType>
+        std::vector<ValueType> SparseMatrix<ValueType>::getConstrainedRowGroupSumVector(storm::storage::BitVector const& rowGroupConstraint, storm::storage::BitVector const& columnConstraint) const {
+            std::vector<ValueType> result;
             result.reserve(rowGroupConstraint.getNumberOfSetBits());
             for (auto rowGroup : rowGroupConstraint) {
-                for (uint_fast64_t row = this->getRowGroupIndices()[rowGroup]; row < this->getRowGroupIndices()[rowGroup + 1]; ++row) {
+                for (index_type row = this->getRowGroupIndices()[rowGroup]; row < this->getRowGroupIndices()[rowGroup + 1]; ++row) {
                     result.push_back(getConstrainedRowSum(row, columnConstraint));
                 }
             }
             return result;
         }
         
-        template<typename T>
-        SparseMatrix<T> SparseMatrix<T>::getSubmatrix(bool useGroups, storm::storage::BitVector const& rowConstraint, storm::storage::BitVector const& columnConstraint, bool insertDiagonalElements) const {
+        template<typename ValueType>
+        SparseMatrix<ValueType> SparseMatrix<ValueType>::getSubmatrix(bool useGroups, storm::storage::BitVector const& rowConstraint, storm::storage::BitVector const& columnConstraint, bool insertDiagonalElements) const {
             if (useGroups) {
                 return getSubmatrix(rowConstraint, columnConstraint, this->getRowGroupIndices(), insertDiagonalElements);
             } else {
                 // Create a fake row grouping to reduce this to a call to a more general method.
-                std::vector<uint_fast64_t> fakeRowGroupIndices(rowCount + 1);
-                uint_fast64_t i = 0;
-                for (std::vector<uint_fast64_t>::iterator it = fakeRowGroupIndices.begin(); it != fakeRowGroupIndices.end(); ++it, ++i) {
+                std::vector<index_type> fakeRowGroupIndices(rowCount + 1);
+                index_type i = 0;
+                for (std::vector<index_type>::iterator it = fakeRowGroupIndices.begin(); it != fakeRowGroupIndices.end(); ++it, ++i) {
                     *it = i;
                 }
                 return getSubmatrix(rowConstraint, columnConstraint, fakeRowGroupIndices, insertDiagonalElements);
             }
         }
                 
-        template<typename T>
-        SparseMatrix<T> SparseMatrix<T>::getSubmatrix(storm::storage::BitVector const& rowGroupConstraint, storm::storage::BitVector const& columnConstraint, std::vector<uint_fast64_t> const& rowGroupIndices, bool insertDiagonalEntries) const {
+        template<typename ValueType>
+        SparseMatrix<ValueType> SparseMatrix<ValueType>::getSubmatrix(storm::storage::BitVector const& rowGroupConstraint, storm::storage::BitVector const& columnConstraint, std::vector<index_type> const& rowGroupIndices, bool insertDiagonalEntries) const {
             // First, we need to determine the number of entries and the number of rows of the submatrix.
-            uint_fast64_t subEntries = 0;
-            uint_fast64_t subRows = 0;
+            index_type subEntries = 0;
+            index_type subRows = 0;
             for (auto index : rowGroupConstraint) {
                 subRows += rowGroupIndices[index + 1] - rowGroupIndices[index];
-                for (uint_fast64_t i = rowGroupIndices[index]; i < rowGroupIndices[index + 1]; ++i) {
+                for (index_type i = rowGroupIndices[index]; i < rowGroupIndices[index + 1]; ++i) {
                     bool foundDiagonalElement = false;
                     
                     for (const_iterator it = this->begin(i), ite = this->end(i); it != ite; ++it) {
@@ -511,16 +533,16 @@ namespace storm {
             }
             
             // Create and initialize resulting matrix.
-            SparseMatrixBuilder<T> matrixBuilder(subRows, columnConstraint.getNumberOfSetBits(), subEntries, true);
+            SparseMatrixBuilder<ValueType> matrixBuilder(subRows, columnConstraint.getNumberOfSetBits(), subEntries, true);
             
             // Create a temporary vector that stores for each index whose bit is set to true the number of bits that
             // were set before that particular index.
-            std::vector<uint_fast64_t> bitsSetBeforeIndex;
+            std::vector<index_type> bitsSetBeforeIndex;
             bitsSetBeforeIndex.reserve(columnCount);
             
             // Compute the information to fill this vector.
-            uint_fast64_t lastIndex = 0;
-            uint_fast64_t currentNumberOfSetBits = 0;
+            index_type lastIndex = 0;
+            index_type currentNumberOfSetBits = 0;
             
             // If we are requested to add missing diagonal entries, we need to make sure the corresponding rows are also
             // taken.
@@ -537,10 +559,10 @@ namespace storm {
             }
             
             // Copy over selected entries.
-            uint_fast64_t rowCount = 0;
+            index_type rowCount = 0;
             for (auto index : rowGroupConstraint) {
                 matrixBuilder.newRowGroup(rowCount);
-                for (uint_fast64_t i = rowGroupIndices[index]; i < rowGroupIndices[index + 1]; ++i) {
+                for (index_type i = rowGroupIndices[index]; i < rowGroupIndices[index + 1]; ++i) {
                     bool insertedDiagonalElement = false;
                     
                     for (const_iterator it = this->begin(i), ite = this->end(i); it != ite; ++it) {
@@ -548,14 +570,14 @@ namespace storm {
                             if (index == it->getColumn()) {
                                 insertedDiagonalElement = true;
                             } else if (insertDiagonalEntries && !insertedDiagonalElement && it->getColumn() > index) {
-                                matrixBuilder.addNextValue(rowCount, bitsSetBeforeIndex[index], storm::utility::constantZero<T>());
+                                matrixBuilder.addNextValue(rowCount, bitsSetBeforeIndex[index], storm::utility::constantZero<ValueType>());
                                 insertedDiagonalElement = true;
                             }
                             matrixBuilder.addNextValue(rowCount, bitsSetBeforeIndex[it->getColumn()], it->getValue());
                         }
                     }
                     if (insertDiagonalEntries && !insertedDiagonalElement) {
-                        matrixBuilder.addNextValue(rowCount, bitsSetBeforeIndex[index], storm::utility::constantZero<T>());
+                        matrixBuilder.addNextValue(rowCount, bitsSetBeforeIndex[index], storm::utility::constantZero<ValueType>());
                     }
                     
                     ++rowCount;
@@ -565,14 +587,14 @@ namespace storm {
             return matrixBuilder.build();
         }
         
-        template<typename T>
-        SparseMatrix<T> SparseMatrix<T>::selectRowsFromRowGroups(std::vector<uint_fast64_t> const& rowGroupToRowIndexMapping, bool insertDiagonalEntries) const {
+        template<typename ValueType>
+        SparseMatrix<ValueType> SparseMatrix<ValueType>::selectRowsFromRowGroups(std::vector<index_type> const& rowGroupToRowIndexMapping, bool insertDiagonalEntries) const {
             // First, we need to count how many non-zero entries the resulting matrix will have and reserve space for
             // diagonal entries if requested.
-            uint_fast64_t subEntries = 0;
-            for (uint_fast64_t rowGroupIndex = 0, rowGroupIndexEnd = rowGroupToRowIndexMapping.size(); rowGroupIndex < rowGroupIndexEnd; ++rowGroupIndex) {
+            index_type subEntries = 0;
+            for (index_type rowGroupIndex = 0, rowGroupIndexEnd = rowGroupToRowIndexMapping.size(); rowGroupIndex < rowGroupIndexEnd; ++rowGroupIndex) {
                 // Determine which row we need to select from the current row group.
-                uint_fast64_t rowToCopy = rowGroupIndices[rowGroupIndex] + rowGroupToRowIndexMapping[rowGroupIndex];
+                index_type rowToCopy = rowGroupIndices[rowGroupIndex] + rowGroupToRowIndexMapping[rowGroupIndex];
                 
                 // Iterate through that row and count the number of slots we have to reserve for copying.
                 bool foundDiagonalElement = false;
@@ -588,12 +610,12 @@ namespace storm {
             }
             
             // Now create the matrix to be returned with the appropriate size.
-            SparseMatrixBuilder<T> matrixBuilder(rowGroupIndices.size() - 1, columnCount, subEntries);
+            SparseMatrixBuilder<ValueType> matrixBuilder(rowGroupIndices.size() - 1, columnCount, subEntries);
             
             // Copy over the selected lines from the source matrix.
-            for (uint_fast64_t rowGroupIndex = 0, rowGroupIndexEnd = rowGroupToRowIndexMapping.size(); rowGroupIndex < rowGroupIndexEnd; ++rowGroupIndex) {
+            for (index_type rowGroupIndex = 0, rowGroupIndexEnd = rowGroupToRowIndexMapping.size(); rowGroupIndex < rowGroupIndexEnd; ++rowGroupIndex) {
                 // Determine which row we need to select from the current row group.
-                uint_fast64_t rowToCopy = rowGroupIndices[rowGroupIndex] + rowGroupToRowIndexMapping[rowGroupIndex];
+                index_type rowToCopy = rowGroupIndices[rowGroupIndex] + rowGroupToRowIndexMapping[rowGroupIndex];
                 
                 // Iterate through that row and copy the entries. This also inserts a zero element on the diagonal if
                 // there is no entry yet.
@@ -602,13 +624,13 @@ namespace storm {
                     if (it->getColumn() == rowGroupIndex) {
                         insertedDiagonalElement = true;
                     } else if (insertDiagonalEntries && !insertedDiagonalElement && it->getColumn() > rowGroupIndex) {
-                        matrixBuilder.addNextValue(rowGroupIndex, rowGroupIndex, storm::utility::constantZero<T>());
+                        matrixBuilder.addNextValue(rowGroupIndex, rowGroupIndex, storm::utility::constantZero<ValueType>());
                         insertedDiagonalElement = true;
                     }
                     matrixBuilder.addNextValue(rowGroupIndex, it->getColumn(), it->getValue());
                 }
                 if (insertDiagonalEntries && !insertedDiagonalElement) {
-                    matrixBuilder.addNextValue(rowGroupIndex, rowGroupIndex, storm::utility::constantZero<T>());
+                    matrixBuilder.addNextValue(rowGroupIndex, rowGroupIndex, storm::utility::constantZero<ValueType>());
                 }
             }
             
@@ -616,70 +638,70 @@ namespace storm {
             return matrixBuilder.build();
         }
         
-        template <typename T>
-        SparseMatrix<T> SparseMatrix<T>::transpose(bool joinGroups) const {
-            uint_fast64_t rowCount = this->getColumnCount();
-            uint_fast64_t columnCount = joinGroups ? this->getRowGroupCount() : this->getRowCount();
-            uint_fast64_t entryCount = this->getEntryCount();
+        template <typename ValueType>
+        SparseMatrix<ValueType> SparseMatrix<ValueType>::transpose(bool joinGroups) const {
+            index_type rowCount = this->getColumnCount();
+            index_type columnCount = joinGroups ? this->getRowGroupCount() : this->getRowCount();
+            index_type entryCount = this->getEntryCount();
             
-            std::vector<uint_fast64_t> rowIndications(rowCount + 1);
-            std::vector<MatrixEntry<T>> columnsAndValues(entryCount);
+            std::vector<index_type> rowIndications(rowCount + 1);
+            std::vector<MatrixEntry<index_type, ValueType>> columnsAndValues(entryCount);
             
             // First, we need to count how many entries each column has.
-            for (uint_fast64_t group = 0; group < columnCount; ++group) {
+            for (index_type group = 0; group < columnCount; ++group) {
                 for (auto const& transition : joinGroups ? this->getRowGroup(group) : this->getRow(group)) {
-                    if (transition.getValue() != storm::utility::constantZero<T>()) {
+                    if (transition.getValue() != storm::utility::constantZero<ValueType>()) {
                         ++rowIndications[transition.getColumn() + 1];
                     }
                 }
             }
             
             // Now compute the accumulated offsets.
-            for (uint_fast64_t i = 1; i < rowCount + 1; ++i) {
+            for (index_type i = 1; i < rowCount + 1; ++i) {
                 rowIndications[i] = rowIndications[i - 1] + rowIndications[i];
             }
             
             // Create an array that stores the index for the next value to be added for
             // each row in the transposed matrix. Initially this corresponds to the previously
             // computed accumulated offsets.
-            std::vector<uint_fast64_t> nextIndices = rowIndications;
+            std::vector<index_type> nextIndices = rowIndications;
             
             // Now we are ready to actually fill in the values of the transposed matrix.
-            for (uint_fast64_t group = 0; group < columnCount; ++group) {
+            for (index_type group = 0; group < columnCount; ++group) {
                 for (auto const& transition : joinGroups ? this->getRowGroup(group) : this->getRow(group)) {
-                    if (transition.getValue() != storm::utility::constantZero<T>()) {
+                    if (transition.getValue() != storm::utility::constantZero<ValueType>()) {
                         columnsAndValues[nextIndices[transition.getColumn()]] = std::make_pair(group, transition.getValue());
                         nextIndices[transition.getColumn()]++;
                     }
                 }
             }
             
-            std::vector<uint_fast64_t> rowGroupIndices(rowCount + 1);
-            for (uint_fast64_t i = 0; i <= rowCount; ++i) {
+            std::vector<index_type> rowGroupIndices(rowCount + 1);
+            for (index_type i = 0; i <= rowCount; ++i) {
                 rowGroupIndices[i] = i;
             }
             
-            storm::storage::SparseMatrix<T> transposedMatrix(columnCount, std::move(rowIndications), std::move(columnsAndValues), std::move(rowGroupIndices));
+            storm::storage::SparseMatrix<ValueType> transposedMatrix(columnCount, std::move(rowIndications), std::move(columnsAndValues), std::move(rowGroupIndices));
                         
             return transposedMatrix;
         }
                 
-        template<typename T>
-        void SparseMatrix<T>::convertToEquationSystem() {
+        template<typename ValueType>
+        void SparseMatrix<ValueType>::convertToEquationSystem() {
             invertDiagonal();
             negateAllNonDiagonalEntries();
         }
         
-        template<typename T>
-        void SparseMatrix<T>::invertDiagonal() {
+        template<typename ValueType>
+        void SparseMatrix<ValueType>::invertDiagonal() {
             // Now iterate over all row groups and set the diagonal elements to the inverted value.
             // If there is a row without the diagonal element, an exception is thrown.
-            T one = storm::utility::constantOne<T>();
+            ValueType one = storm::utility::constantOne<ValueType>();
             bool foundDiagonalElement = false;
-            for (uint_fast64_t group = 0; group < this->getRowGroupCount(); ++group) {
+            for (index_type group = 0; group < this->getRowGroupCount(); ++group) {
                 for (auto& entry : this->getRowGroup(group)) {
                     if (entry.getColumn() == group) {
-                        entry.getValue() = one - entry.getValue();
+                        entry.setValue(one - entry.getValue());
                         foundDiagonalElement = true;
                     }
                 }
@@ -691,46 +713,46 @@ namespace storm {
             }
         }
         
-        template<typename T>
-        void SparseMatrix<T>::negateAllNonDiagonalEntries() {
+        template<typename ValueType>
+        void SparseMatrix<ValueType>::negateAllNonDiagonalEntries() {
             // Iterate over all row groups and negate all the elements that are not on the diagonal.
-            for (uint_fast64_t group = 0; group < this->getRowGroupCount(); ++group) {
+            for (index_type group = 0; group < this->getRowGroupCount(); ++group) {
                 for (auto& entry : this->getRowGroup(group)) {
                     if (entry.getColumn() != group) {
-                        entry.getValue() = -entry.getValue();
+                        entry.setValue(-entry.getValue());
                     }
                 }
             }
         }
         
-        template<typename T>
-        void SparseMatrix<T>::deleteDiagonalEntries() {
+        template<typename ValueType>
+        void SparseMatrix<ValueType>::deleteDiagonalEntries() {
             // Iterate over all rows and negate all the elements that are not on the diagonal.
-            for (uint_fast64_t group = 0; group < this->getRowGroupCount(); ++group) {
+            for (index_type group = 0; group < this->getRowGroupCount(); ++group) {
                 for (auto& entry : this->getRowGroup(group)) {
                     if (entry.getColumn() == group) {
-                        entry.getValue() = storm::utility::constantZero<T>();
+                        entry.setValue(storm::utility::constantZero<ValueType>());
                     }
                 }
             }
         }
         
-        template<typename T>
-        typename std::pair<storm::storage::SparseMatrix<T>, storm::storage::SparseMatrix<T>> SparseMatrix<T>::getJacobiDecomposition() const {
+        template<typename ValueType>
+        typename std::pair<storm::storage::SparseMatrix<ValueType>, storm::storage::SparseMatrix<ValueType>> SparseMatrix<ValueType>::getJacobiDecomposition() const {
             if (rowCount != columnCount) {
                 throw storm::exceptions::InvalidArgumentException() << "Illegal call to SparseMatrix::invertDiagonal: matrix is non-square.";
             }
-            storm::storage::SparseMatrix<T> resultLU(*this);
+            storm::storage::SparseMatrix<ValueType> resultLU(*this);
             resultLU.deleteDiagonalEntries();
             
-            SparseMatrixBuilder<T> dInvBuilder(rowCount, columnCount, rowCount);
+            SparseMatrixBuilder<ValueType> dInvBuilder(rowCount, columnCount, rowCount);
             
             // Copy entries to the appropriate matrices.
-            for (uint_fast64_t rowNumber = 0; rowNumber < rowCount; ++rowNumber) {
+            for (index_type rowNumber = 0; rowNumber < rowCount; ++rowNumber) {
                 
                 // Because the matrix may have several entries on the diagonal, we need to sum them before we are able
                 // to invert the entry.
-                T diagonalValue = storm::utility::constantZero<T>();
+                ValueType diagonalValue = storm::utility::constantZero<ValueType>();
                 for (const_iterator it = this->begin(rowNumber), ite = this->end(rowNumber); it != ite; ++it) {
                     if (it->getColumn() == rowNumber) {
                         diagonalValue += it->getValue();
@@ -738,7 +760,7 @@ namespace storm {
                         break;
                     }
                 }
-                dInvBuilder.addNextValue(rowNumber, rowNumber, storm::utility::constantOne<T>() / diagonalValue);
+                dInvBuilder.addNextValue(rowNumber, rowNumber, storm::utility::constantOne<ValueType>() / diagonalValue);
             }
             
             return std::make_pair(std::move(resultLU), dInvBuilder.build());
@@ -752,14 +774,14 @@ namespace storm {
         }
         
         
-        template<typename T>
-        std::vector<T> SparseMatrix<T>::getPointwiseProductRowSumVector(storm::storage::SparseMatrix<T> const& otherMatrix) const {
-            std::vector<T> result(rowCount, storm::utility::constantZero<T>());
+        template<typename ValueType>
+        std::vector<ValueType> SparseMatrix<ValueType>::getPointwiseProductRowSumVector(storm::storage::SparseMatrix<ValueType> const& otherMatrix) const {
+            std::vector<ValueType> result(rowCount, storm::utility::constantZero<ValueType>());
             
             // Iterate over all elements of the current matrix and either continue with the next element in case the
             // given matrix does not have a non-zero element at this column position, or multiply the two entries and
             // add the result to the corresponding position in the vector.
-            for (uint_fast64_t row = 0; row < rowCount && row < otherMatrix.rowCount; ++row) {
+            for (index_type row = 0; row < rowCount && row < otherMatrix.rowCount; ++row) {
                 for (const_iterator it1 = this->begin(row), ite1 = this->end(row), it2 = otherMatrix.begin(row), ite2 = otherMatrix.end(row); it1 != ite1 && it2 != ite2; ++it1) {
                     if (it1->getColumn() < it2->getColumn()) {
                         continue;
@@ -777,8 +799,8 @@ namespace storm {
         }
         
         
-        template<typename T>
-        void SparseMatrix<T>::multiplyWithVector(std::vector<T> const& vector, std::vector<T>& result) const {
+        template<typename ValueType>
+        void SparseMatrix<ValueType>::multiplyWithVector(std::vector<ValueType> const& vector, std::vector<ValueType>& result) const {
 #ifdef STORM_HAVE_INTELTBB
             if (this->getNonzeroEntryCount() > 10000) {
                 return this->multiplyWithVectorParallel(vector, result);
@@ -790,16 +812,16 @@ namespace storm {
 #endif
         }
         
-        template<typename T>
-        void SparseMatrix<T>::multiplyWithVectorSequential(std::vector<T> const& vector, std::vector<T>& result) const {
+        template<typename ValueType>
+        void SparseMatrix<ValueType>::multiplyWithVectorSequential(std::vector<ValueType> const& vector, std::vector<ValueType>& result) const {
             const_iterator it = this->begin();
             const_iterator ite;
-            typename std::vector<uint_fast64_t>::const_iterator rowIterator = rowIndications.begin();
-            typename std::vector<T>::iterator resultIterator = result.begin();
-            typename std::vector<T>::iterator resultIteratorEnd = result.end();
+            typename std::vector<index_type>::const_iterator rowIterator = rowIndications.begin();
+            typename std::vector<ValueType>::iterator resultIterator = result.begin();
+            typename std::vector<ValueType>::iterator resultIteratorEnd = result.end();
             
             for (; resultIterator != resultIteratorEnd; ++rowIterator, ++resultIterator) {
-                *resultIterator = storm::utility::constantZero<T>();
+                *resultIterator = storm::utility::constantZero<ValueType>();
                 
                 for (ite = this->begin() + *(rowIterator + 1); it != ite; ++it) {
                     *resultIterator += it->getValue() * vector[it->getColumn()];
@@ -808,21 +830,21 @@ namespace storm {
         }
 
 #ifdef STORM_HAVE_INTELTBB
-        template<typename T>
-        void SparseMatrix<T>::multiplyWithVectorParallel(std::vector<T> const& vector, std::vector<T>& result) const {
-            tbb::parallel_for(tbb::blocked_range<uint_fast64_t>(0, result.size(), 10),
-                              [&] (tbb::blocked_range<uint_fast64_t> const& range) {
-                                  uint_fast64_t startRow = range.begin();
-                                  uint_fast64_t endRow = range.end();
+        template<typename ValueType>
+        void SparseMatrix<ValueType>::multiplyWithVectorParallel(std::vector<ValueType> const& vector, std::vector<ValueType>& result) const {
+            tbb::parallel_for(tbb::blocked_range<index_type>(0, result.size(), 10),
+                              [&] (tbb::blocked_range<index_type> const& range) {
+                                  index_type startRow = range.begin();
+                                  index_type endRow = range.end();
                                   const_iterator it = this->begin(startRow);
                                   const_iterator ite;
-                                  std::vector<uint_fast64_t>::const_iterator rowIterator = this->rowIndications.begin() + startRow;
-                                  std::vector<uint_fast64_t>::const_iterator rowIteratorEnd = this->rowIndications.begin() + endRow;
-                                  typename std::vector<T>::iterator resultIterator = result.begin() + startRow;
-                                  typename std::vector<T>::iterator resultIteratorEnd = result.begin() + endRow;
+                                  std::vector<index_type>::const_iterator rowIterator = this->rowIndications.begin() + startRow;
+                                  std::vector<index_type>::const_iterator rowIteratorEnd = this->rowIndications.begin() + endRow;
+                                  typename std::vector<ValueType>::iterator resultIterator = result.begin() + startRow;
+                                  typename std::vector<ValueType>::iterator resultIteratorEnd = result.begin() + endRow;
                                   
                                   for (; resultIterator != resultIteratorEnd; ++rowIterator, ++resultIterator) {
-                                      *resultIterator = storm::utility::constantZero<T>();
+                                      *resultIterator = storm::utility::constantZero<ValueType>();
                                       
                                       for (ite = this->begin() + *(rowIterator + 1); it != ite; ++it) {
                                           *resultIterator += it->getValue() * vector[it->getColumn()];
@@ -832,12 +854,12 @@ namespace storm {
         }
 #endif
 
-        template<typename T>
-        uint_fast64_t SparseMatrix<T>::getSizeInMemory() const {
+        template<typename ValueType>
+        uint_fast64_t SparseMatrix<ValueType>::getSizeInMemory() const {
             uint_fast64_t size = sizeof(*this);
             
             // Add size of columns and values.
-            size += sizeof(MatrixEntry<T>) * columnsAndValues.capacity();
+            size += sizeof(MatrixEntry<index_type, ValueType>) * columnsAndValues.capacity();
             
             // Add row_indications size.
             size += sizeof(uint_fast64_t) * rowIndications.capacity();
@@ -845,84 +867,84 @@ namespace storm {
             return size;
         }
         
-        template<typename T>
-        typename SparseMatrix<T>::const_rows SparseMatrix<T>::getRows(uint_fast64_t startRow, uint_fast64_t endRow) const {
+        template<typename ValueType>
+        typename SparseMatrix<ValueType>::const_rows SparseMatrix<ValueType>::getRows(index_type startRow, index_type endRow) const {
             return const_rows(this->columnsAndValues.begin() + this->rowIndications[startRow], this->rowIndications[endRow + 1] - this->rowIndications[startRow]);
         }
         
-        template<typename T>
-        typename SparseMatrix<T>::rows SparseMatrix<T>::getRows(uint_fast64_t startRow, uint_fast64_t endRow) {
+        template<typename ValueType>
+        typename SparseMatrix<ValueType>::rows SparseMatrix<ValueType>::getRows(index_type startRow, index_type endRow) {
             return rows(this->columnsAndValues.begin() + this->rowIndications[startRow], this->rowIndications[endRow + 1] - this->rowIndications[startRow]);
         }
         
-        template<typename T>
-        typename SparseMatrix<T>::const_rows SparseMatrix<T>::getRow(uint_fast64_t row) const {
+        template<typename ValueType>
+        typename SparseMatrix<ValueType>::const_rows SparseMatrix<ValueType>::getRow(index_type row) const {
             return getRows(row, row);
         }
         
-        template<typename T>
-        typename SparseMatrix<T>::rows SparseMatrix<T>::getRow(uint_fast64_t row) {
+        template<typename ValueType>
+        typename SparseMatrix<ValueType>::rows SparseMatrix<ValueType>::getRow(index_type row) {
             return getRows(row, row);
         }
         
-        template<typename T>
-        typename SparseMatrix<T>::const_rows SparseMatrix<T>::getRowGroup(uint_fast64_t rowGroup) const {
+        template<typename ValueType>
+        typename SparseMatrix<ValueType>::const_rows SparseMatrix<ValueType>::getRowGroup(index_type rowGroup) const {
             return getRows(rowGroupIndices[rowGroup], rowGroupIndices[rowGroup + 1] - 1);
         }
         
-        template<typename T>
-        typename SparseMatrix<T>::rows SparseMatrix<T>::getRowGroup(uint_fast64_t rowGroup) {
+        template<typename ValueType>
+        typename SparseMatrix<ValueType>::rows SparseMatrix<ValueType>::getRowGroup(index_type rowGroup) {
             return getRows(rowGroupIndices[rowGroup], rowGroupIndices[rowGroup + 1] - 1);
         }
         
-        template<typename T>
-        typename SparseMatrix<T>::const_iterator SparseMatrix<T>::begin(uint_fast64_t row) const {
+        template<typename ValueType>
+        typename SparseMatrix<ValueType>::const_iterator SparseMatrix<ValueType>::begin(index_type row) const {
             return this->columnsAndValues.begin() + this->rowIndications[row];
         }
         
-        template<typename T>
-        typename SparseMatrix<T>::iterator SparseMatrix<T>::begin(uint_fast64_t row)  {
+        template<typename ValueType>
+        typename SparseMatrix<ValueType>::iterator SparseMatrix<ValueType>::begin(index_type row)  {
             return this->columnsAndValues.begin() + this->rowIndications[row];
         }
         
-        template<typename T>
-        typename SparseMatrix<T>::const_iterator SparseMatrix<T>::end(uint_fast64_t row) const {
+        template<typename ValueType>
+        typename SparseMatrix<ValueType>::const_iterator SparseMatrix<ValueType>::end(index_type row) const {
             return this->columnsAndValues.begin() + this->rowIndications[row + 1];
         }
         
-        template<typename T>
-        typename SparseMatrix<T>::iterator SparseMatrix<T>::end(uint_fast64_t row)  {
+        template<typename ValueType>
+        typename SparseMatrix<ValueType>::iterator SparseMatrix<ValueType>::end(index_type row)  {
             return this->columnsAndValues.begin() + this->rowIndications[row + 1];
         }
         
-        template<typename T>
-        typename SparseMatrix<T>::const_iterator SparseMatrix<T>::end() const {
+        template<typename ValueType>
+        typename SparseMatrix<ValueType>::const_iterator SparseMatrix<ValueType>::end() const {
             return this->columnsAndValues.begin() + this->rowIndications[rowCount];
         }
         
-        template<typename T>
-        typename SparseMatrix<T>::iterator SparseMatrix<T>::end()  {
+        template<typename ValueType>
+        typename SparseMatrix<ValueType>::iterator SparseMatrix<ValueType>::end()  {
             return this->columnsAndValues.begin() + this->rowIndications[rowCount];
         }
         
-        template<typename T>
-        T SparseMatrix<T>::getRowSum(uint_fast64_t row) const {
-            T sum = storm::utility::constantZero<T>();
+        template<typename ValueType>
+        ValueType SparseMatrix<ValueType>::getRowSum(index_type row) const {
+            ValueType sum = storm::utility::constantZero<ValueType>();
             for (const_iterator it = this->begin(row), ite = this->end(row); it != ite; ++it) {
                 sum += it->getValue();
             }
             return sum;
         }
         
-        template<typename T>
-        bool SparseMatrix<T>::isSubmatrixOf(SparseMatrix<T> const& matrix) const {
+        template<typename ValueType>
+        bool SparseMatrix<ValueType>::isSubmatrixOf(SparseMatrix<ValueType> const& matrix) const {
             // Check for matching sizes.
             if (this->getRowCount() != matrix.getRowCount()) return false;
             if (this->getColumnCount() != matrix.getColumnCount()) return false;
             if (this->getRowGroupIndices() != matrix.getRowGroupIndices()) return false;
 
             // Check the subset property for all rows individually.
-            for (uint_fast64_t row = 0; row < this->getRowCount(); ++row) {
+            for (index_type row = 0; row < this->getRowCount(); ++row) {
                 for (const_iterator it1 = this->begin(row), ite1 = this->end(row), it2 = matrix.begin(row), ite2 = matrix.end(row); it1 != ite1; ++it1) {
                     // Skip over all entries of the other matrix that are before the current entry in the current matrix.
                     while (it2 != ite2 && it2->getColumn() < it1->getColumn()) {
@@ -936,24 +958,24 @@ namespace storm {
             return true;
         }
         
-        template<typename T>
-        std::ostream& operator<<(std::ostream& out, SparseMatrix<T> const& matrix) {
+        template<typename ValueType>
+        std::ostream& operator<<(std::ostream& out, SparseMatrix<ValueType> const& matrix) {
             // Print column numbers in header.
             out << "\t\t";
-            for (uint_fast64_t i = 0; i < matrix.getColumnCount(); ++i) {
+            for (typename SparseMatrix<ValueType>::index_type i = 0; i < matrix.getColumnCount(); ++i) {
                 out << i << "\t";
             }
             out << std::endl;
             
             // Iterate over all row groups.
-            for (uint_fast64_t group = 0; group < matrix.getRowGroupCount(); ++group) {
+            for (typename SparseMatrix<ValueType>::index_type group = 0; group < matrix.getRowGroupCount(); ++group) {
                 out << "\t---- group " << group << "/" << (matrix.getRowGroupCount() - 1) << " ---- " << std::endl;
-                for (uint_fast64_t i = matrix.getRowGroupIndices()[group]; i < matrix.getRowGroupIndices()[group + 1]; ++i) {
-                    uint_fast64_t nextIndex = matrix.rowIndications[i];
+                for (typename SparseMatrix<ValueType>::index_type i = matrix.getRowGroupIndices()[group]; i < matrix.getRowGroupIndices()[group + 1]; ++i) {
+                    typename SparseMatrix<ValueType>::index_type nextIndex = matrix.rowIndications[i];
                     
                     // Print the actual row.
                     out << i << "\t(\t";
-                    uint_fast64_t currentRealIndex = 0;
+                    typename SparseMatrix<ValueType>::index_type currentRealIndex = 0;
                     while (currentRealIndex < matrix.columnCount) {
                         if (nextIndex < matrix.rowIndications[i + 1] && currentRealIndex == matrix.columnsAndValues[nextIndex].getColumn()) {
                             out << matrix.columnsAndValues[nextIndex].getValue() << "\t";
@@ -969,7 +991,7 @@ namespace storm {
             
             // Print column numbers in footer.
             out << "\t\t";
-            for (uint_fast64_t i = 0; i < matrix.getColumnCount(); ++i) {
+            for (typename SparseMatrix<ValueType>::index_type i = 0; i < matrix.getColumnCount(); ++i) {
                 out << i << "\t";
             }
             out << std::endl;
@@ -977,8 +999,8 @@ namespace storm {
             return out;
         }
         
-        template<typename T>
-        std::size_t SparseMatrix<T>::hash() const {
+        template<typename ValueType>
+        std::size_t SparseMatrix<ValueType>::hash() const {
             std::size_t result = 0;
             
             boost::hash_combine(result, this->getRowCount());
@@ -992,11 +1014,11 @@ namespace storm {
         }
         
         // Explicitly instantiate the entry, builder and the matrix.
-        template class MatrixEntry<double>;
+        template class MatrixEntry<typename SparseMatrix<double>::index_type, double>;
         template class SparseMatrixBuilder<double>;
         template class SparseMatrix<double>;
         template std::ostream& operator<<(std::ostream& out, SparseMatrix<double> const& matrix);
-        template class MatrixEntry<int>;
+        template class MatrixEntry<typename SparseMatrix<int>::index_type, int>;
         template class SparseMatrixBuilder<int>;
         template class SparseMatrix<int>;
         template std::ostream& operator<<(std::ostream& out, SparseMatrix<int> const& matrix);
diff --git a/src/storage/SparseMatrix.h b/src/storage/SparseMatrix.h
index 38b1cec9e..e87f215af 100644
--- a/src/storage/SparseMatrix.h
+++ b/src/storage/SparseMatrix.h
@@ -14,6 +14,7 @@
 #include "src/exceptions/OutOfRangeException.h"
 
 #include <boost/functional/hash.hpp>
+#include <boost/container/flat_map.hpp>
 
 // Forward declaration for adapter classes.
 namespace storm {
@@ -30,23 +31,26 @@ namespace storm {
         // Forward declare matrix class.
         template<typename T> class SparseMatrix;
         
-        template<typename T>
+        template<typename IndexType, typename ValueType>
         class MatrixEntry {
         public:
+            typedef IndexType index_type;
+            typedef ValueType value_type;
+            
             /*!
              * Constructs a matrix entry with the given column and value.
              *
              * @param column The column of the matrix entry.
              * @param value The value of the matrix entry.
              */
-            MatrixEntry(uint_fast64_t column, T value);
+            MatrixEntry(index_type column, value_type value);
             
             /*!
              * Move-constructs the matrix entry fro the given column-value pair.
              *
              * @param pair The column-value pair from which to move-construct the matrix entry.
              */
-            MatrixEntry(std::pair<uint_fast64_t, T>&& pair);
+            MatrixEntry(std::pair<index_type, value_type>&& pair);
             
             MatrixEntry() = default;
             MatrixEntry(MatrixEntry const& other) = default;
@@ -61,46 +65,46 @@ namespace storm {
              *
              * @return The column of the matrix entry.
              */
-            uint_fast64_t const& getColumn() const;
+            index_type const& getColumn() const;
             
             /*!
-             * Retrieves the column of the matrix entry.
+             * Sets the column of the current entry.
              *
-             * @return The column of the matrix entry.
+             * @param column The column to set for this entry.
              */
-            uint_fast64_t& getColumn();
+            void setColumn(index_type const& column);
             
             /*!
              * Retrieves the value of the matrix entry.
              *
              * @return The value of the matrix entry.
              */
-            T const& getValue() const;
-
+            value_type const& getValue() const;
+            
             /*!
-             * Retrieves the value of the matrix entry.
+             * Sets the value of the entry in the matrix.
              *
-             * @return The value of the matrix entry.
+             * @param value The value that is to be set for this entry.
              */
-            T& getValue();
+            void setValue(value_type const& value);
             
             /*!
              * Retrieves a pair of column and value that characterizes this entry.
              *
              * @return A column-value pair that characterizes this entry.
              */
-            std::pair<uint_fast64_t, T> const& getColumnValuePair() const;
+            std::pair<index_type, value_type> const& getColumnValuePair() const;
             
         private:
             // The actual matrix entry.
-            std::pair<uint_fast64_t, T> entry;
+            std::pair<index_type, value_type> entry;
         };
         
         /*!
          * Computes the hash value of a matrix entry.
          */
-        template<typename T>
-        std::size_t hash_value(MatrixEntry<T> const& matrixEntry) {
+        template<typename IndexType, typename ValueType>
+        std::size_t hash_value(MatrixEntry<IndexType, ValueType> const& matrixEntry) {
             std::size_t seed = 0;
             boost::hash_combine(seed, matrixEntry.getColumn());
             boost::hash_combine(seed, matrixEntry.getValue());
@@ -110,9 +114,12 @@ namespace storm {
         /*!
          * A class that can be used to build a sparse matrix by adding value by value.
          */
-        template<typename T>
+        template<typename ValueType>
         class SparseMatrixBuilder {
         public:
+            typedef uint_fast64_t index_type;
+            typedef ValueType value_type;
+            
             /*!
              * Constructs a sparse matrix builder producing a matrix with the given number of rows, columns and entries.
              *
@@ -124,7 +131,7 @@ namespace storm {
              * @param rowGroups The number of row groups of the resulting matrix. This is only relevant if the matrix
              * has a custom row grouping.
              */
-            SparseMatrixBuilder(uint_fast64_t rows = 0, uint_fast64_t columns = 0, uint_fast64_t entries = 0, bool hasCustomRowGrouping = false, uint_fast64_t rowGroups = 0);
+            SparseMatrixBuilder(index_type rows = 0, index_type columns = 0, index_type entries = 0, bool hasCustomRowGrouping = false, index_type rowGroups = 0);
             
             /*!
              * Sets the matrix entry at the given row and column to the given value. After all entries have been added,
@@ -139,7 +146,7 @@ namespace storm {
              * @param column The column in which the matrix entry is to be set.
              * @param value The value that is to be set at the specified row and column.
              */
-            void addNextValue(uint_fast64_t row, uint_fast64_t column, T const& value);
+            void addNextValue(index_type row, index_type column, value_type const& value);
             
             /*!
              * Starts a new row group in the matrix. Note that this needs to be called before any entries in the new row
@@ -147,7 +154,7 @@ namespace storm {
              *
              * @param startingRow The starting row of the new row group.
              */
-            void newRowGroup(uint_fast64_t startingRow);
+            void newRowGroup(index_type startingRow);
             
             /*
              * Finalizes the sparse matrix to indicate that initialization process has been completed and the matrix
@@ -168,7 +175,7 @@ namespace storm {
              * effect if the matrix has been created without the number of row groups given. By construction, the row
              * groups added this way will be empty.
              */
-            SparseMatrix<T> build(uint_fast64_t overriddenRowCount = 0, uint_fast64_t overriddenColumnCount = 0, uint_fast64_t overriddenRowGroupCount = 0);
+            SparseMatrix<value_type> build(index_type overriddenRowCount = 0, index_type overriddenColumnCount = 0, index_type overriddenRowGroupCount = 0);
             
         private:
             /*!
@@ -182,16 +189,16 @@ namespace storm {
             bool rowCountSet;
             
             // The number of rows of the matrix.
-            uint_fast64_t rowCount;
+            index_type rowCount;
             
             // A flag indicating whether the number of columns was set upon construction.
             bool columnCountSet;
             
             // The number of columns of the matrix.
-            uint_fast64_t columnCount;
+            index_type columnCount;
             
             // The number of entries in the matrix.
-            uint_fast64_t entryCount;
+            index_type entryCount;
             
             // A flag indicating whether the builder is to construct a custom row grouping for the matrix.
             bool hasCustomRowGrouping;
@@ -200,37 +207,37 @@ namespace storm {
             bool rowGroupCountSet;
             
             // The number of row groups in the matrix.
-            uint_fast64_t rowGroupCount;
+            index_type rowGroupCount;
             
-            std::vector<uint_fast64_t> rowGroupIndices;
+            std::vector<index_type> rowGroupIndices;
             
             // Stores whether the storage of the matrix was preallocated or not.
             bool storagePreallocated;
             
             // The storage for the columns and values of all entries in the matrix.
-            std::vector<MatrixEntry<T>> columnsAndValues;
+            std::vector<MatrixEntry<index_type, value_type>> columnsAndValues;
             
             // A vector containing the indices at which each given row begins. This index is to be interpreted as an
             // index in the valueStorage and the columnIndications vectors. Put differently, the values of the entries
             // in row i are valueStorage[rowIndications[i]] to valueStorage[rowIndications[i + 1]] where the last
             // entry is not included anymore.
-            std::vector<uint_fast64_t> rowIndications;
+            std::vector<index_type> rowIndications;
             
             // Stores the current number of entries in the matrix. This is used for inserting an entry into a matrix
             // with preallocated storage.
-            uint_fast64_t currentEntryCount;
+            index_type currentEntryCount;
             
             // Stores the row of the last entry in the matrix. This is used for correctly inserting an entry into a
             // matrix.
-            uint_fast64_t lastRow;
+            index_type lastRow;
             
             // Stores the column of the currently last entry in the matrix. This is used for correctly inserting an
             // entry into a matrix.
-            uint_fast64_t lastColumn;
+            index_type lastColumn;
             
             // Stores the currently active row group. This is used for correctly constructing the row grouping of the
             // matrix.
-            uint_fast64_t currentRowGroup;
+            index_type currentRowGroup;
         };
         
         /*!
@@ -247,7 +254,7 @@ namespace storm {
          * It should be observed that due to the nature of the sparse matrix format, entries can only be inserted in
          * order, i.e. row by row and column by column.
          */
-        template<typename T>
+        template<typename ValueType>
         class SparseMatrix {
         public:
             // Declare adapter classes as friends to use internal data.
@@ -255,8 +262,10 @@ namespace storm {
             friend class storm::adapters::EigenAdapter;
             friend class storm::adapters::StormAdapter;
             
-            typedef typename std::vector<MatrixEntry<T>>::iterator iterator;
-            typedef typename std::vector<MatrixEntry<T>>::const_iterator const_iterator;
+            typedef uint_fast64_t index_type;
+            typedef ValueType value_type;
+            typedef typename std::vector<MatrixEntry<index_type, value_type>>::iterator iterator;
+            typedef typename std::vector<MatrixEntry<index_type, value_type>>::const_iterator const_iterator;
             
             /*!
              * This class represents a number of consecutive rows of the matrix.
@@ -270,7 +279,7 @@ namespace storm {
                  * @param begin An iterator that points to the beginning of the row.
                  * @param entryCount The number of entrys in the rows.
                  */
-                rows(iterator begin, uint_fast64_t entryCount);
+                rows(iterator begin, index_type entryCount);
                 
                 /*!
                  * Retrieves an iterator that points to the beginning of the rows.
@@ -286,12 +295,19 @@ namespace storm {
                  */
                 iterator end();
                 
+                /*!
+                 * Retrieves the number of entries in the rows.
+                 *
+                 * @return The number of entries in the rows.
+                 */
+                index_type getNumberOfEntries() const;
+                
             private:
                 // The pointer to the columnd and value of the first entry.
                 iterator beginIterator;
                 
                 // The number of non-zero entries in the rows.
-                uint_fast64_t entryCount;
+                index_type entryCount;
             };
 
             /*!
@@ -306,7 +322,7 @@ namespace storm {
                  * @param begin An iterator that points to the beginning of the row.
                  * @param entryCount The number of entrys in the rows.
                  */
-                const_rows(const_iterator begin, uint_fast64_t entryCount);
+                const_rows(const_iterator begin, index_type entryCount);
                 
                 /*!
                  * Retrieves an iterator that points to the beginning of the rows.
@@ -322,12 +338,19 @@ namespace storm {
                  */
                 const_iterator end() const;
                 
+                /*!
+                 * Retrieves the number of entries in the rows.
+                 *
+                 * @return The number of entries in the rows.
+                 */
+                index_type getNumberOfEntries() const;
+                
             private:
                 // The pointer to the columnd and value of the first entry.
                 const_iterator beginIterator;
                 
                 // The number of non-zero entries in the rows.
-                uint_fast64_t entryCount;
+                index_type entryCount;
             };
             
             /*!
@@ -347,14 +370,14 @@ namespace storm {
              *
              * @param other The matrix from which to copy the content.
              */
-            SparseMatrix(SparseMatrix<T> const& other);
+            SparseMatrix(SparseMatrix<value_type> const& other);
             
             /*!
              * Constructs a sparse matrix by moving the contents of the given matrix to the newly created one.
              *
              * @param other The matrix from which to move the content.
              */
-            SparseMatrix(SparseMatrix<T>&& other);
+            SparseMatrix(SparseMatrix<value_type>&& other);
             
             /*!
              * Constructs a sparse matrix by copying the given contents.
@@ -364,7 +387,7 @@ namespace storm {
              * @param columnsAndValues The vector containing the columns and values of the entries in the matrix.
              * @param rowGroupIndices The vector representing the row groups in the matrix.
              */
-            SparseMatrix(uint_fast64_t columnCount, std::vector<uint_fast64_t> const& rowIndications, std::vector<MatrixEntry<T>> const& columnsAndValues, std::vector<uint_fast64_t> const& rowGroupIndices);
+            SparseMatrix(index_type columnCount, std::vector<index_type> const& rowIndications, std::vector<MatrixEntry<index_type, value_type>> const& columnsAndValues, std::vector<index_type> const& rowGroupIndices);
             
             /*!
              * Constructs a sparse matrix by moving the given contents.
@@ -374,21 +397,21 @@ namespace storm {
              * @param columnsAndValues The vector containing the columns and values of the entries in the matrix.
              * @param rowGroupIndices The vector representing the row groups in the matrix.
              */
-            SparseMatrix(uint_fast64_t columnCount, std::vector<uint_fast64_t>&& rowIndications, std::vector<MatrixEntry<T>>&& columnsAndValues, std::vector<uint_fast64_t>&& rowGroupIndices);
+            SparseMatrix(index_type columnCount, std::vector<index_type>&& rowIndications, std::vector<MatrixEntry<index_type, value_type>>&& columnsAndValues, std::vector<index_type>&& rowGroupIndices);
 
             /*!
              * Assigns the contents of the given matrix to the current one by deep-copying its contents.
              *
              * @param other The matrix from which to copy-assign.
              */
-            SparseMatrix<T>& operator=(SparseMatrix<T> const& other);
+            SparseMatrix<value_type>& operator=(SparseMatrix<value_type> const& other);
             
             /*!
              * Assigns the contents of the given matrix to the current one by moving its contents.
              *
              * @param other The matrix from which to move to contents.
              */
-            SparseMatrix<T>& operator=(SparseMatrix<T>&& other);
+            SparseMatrix<value_type>& operator=(SparseMatrix<value_type>&& other);
             
             /*!
              * Determines whether the current and the given matrix are semantically equal.
@@ -396,42 +419,42 @@ namespace storm {
              * @param other The matrix with which to compare the current matrix.
              * @return True iff the given matrix is semantically equal to the current one.
              */
-            bool operator==(SparseMatrix<T> const& other) const;
+            bool operator==(SparseMatrix<value_type> const& other) const;
             
             /*!
              * Returns the number of rows of the matrix.
              *
              * @return The number of rows of the matrix.
              */
-            uint_fast64_t getRowCount() const;
+            index_type getRowCount() const;
             
             /*!
              * Returns the number of columns of the matrix.
              *
              * @return The number of columns of the matrix.
              */
-            uint_fast64_t getColumnCount() const;
+            index_type getColumnCount() const;
             
             /*!
              * Returns the number of entries in the matrix.
              *
              * @return The number of entries in the matrix.
              */
-            uint_fast64_t getEntryCount() const;
+            index_type getEntryCount() const;
             
             /*!
              * Returns the number of nonzero entries in the matrix.
              *
              * @return The number of nonzero entries in the matrix.
              */
-            uint_fast64_t getNonzeroEntryCount() const;
+            index_type getNonzeroEntryCount() const;
             
             /*!
              * Returns the number of row groups in the matrix.
              *
              * @return The number of row groups in the matrix.
              */
-            uint_fast64_t getRowGroupCount() const;
+            index_type getRowGroupCount() const;
             
             /*!
              * Returns the size of the given row group.
@@ -439,14 +462,14 @@ namespace storm {
              * @param group The group whose size to retrieve.
              * @return The number of rows that belong to the given row group.
              */
-            uint_fast64_t getRowGroupSize(uint_fast64_t group) const;
+            index_type getRowGroupSize(index_type group) const;
             
             /*!
              * Returns the grouping of rows of this matrix.
              *
              * @return The grouping of rows of this matrix.
              */
-            std::vector<uint_fast64_t> const& getRowGroupIndices() const;
+            std::vector<index_type> const& getRowGroupIndices() const;
             
             /*!
              * This function makes the given rows absorbing.
@@ -469,7 +492,7 @@ namespace storm {
              * @param row The row to be made Dirac.
              * @param column The index of the column whose value is to be set to 1.
              */
-            void makeRowDirac(const uint_fast64_t row, const uint_fast64_t column);
+            void makeRowDirac(index_type row, index_type column);
             
             /*
              * Sums the entries in the given row and columns.
@@ -478,7 +501,7 @@ namespace storm {
              * @param columns A bit vector that indicates which columns to add.
              * @return The sum of the entries in the given row and columns.
              */
-            T getConstrainedRowSum(uint_fast64_t row, storm::storage::BitVector const& columns) const;
+            value_type getConstrainedRowSum(index_type row, storm::storage::BitVector const& columns) const;
             
             /*!
              * Computes a vector whose i-th entry is the sum of the entries in the i-th selected row where only those
@@ -489,7 +512,7 @@ namespace storm {
              *
              * @return A vector whose elements are the sums of the selected columns in each row.
              */
-            std::vector<T> getConstrainedRowSumVector(storm::storage::BitVector const& rowConstraint, storm::storage::BitVector const& columnConstraint) const;
+            std::vector<value_type> getConstrainedRowSumVector(storm::storage::BitVector const& rowConstraint, storm::storage::BitVector const& columnConstraint) const;
             
             /*!
              * Computes a vector whose entries represent the sums of selected columns for all rows in selected row
@@ -500,7 +523,7 @@ namespace storm {
              * @return A vector whose entries represent the sums of selected columns for all rows in selected row
              * groups.
              */
-            std::vector<T> getConstrainedRowGroupSumVector(storm::storage::BitVector const& rowGroupConstraint, storm::storage::BitVector const& columnConstraint) const;
+            std::vector<value_type> getConstrainedRowGroupSumVector(storm::storage::BitVector const& rowGroupConstraint, storm::storage::BitVector const& columnConstraint) const;
             
             /*!
              * Creates a submatrix of the current matrix by dropping all rows and columns whose bits are not
@@ -524,7 +547,7 @@ namespace storm {
              * each row in row group i. This can then be used for inserting other values later.
              * @return A submatrix of the current matrix by selecting one row out of each row group.
              */
-            SparseMatrix selectRowsFromRowGroups(std::vector<uint_fast64_t> const& rowGroupToRowIndexMapping, bool insertDiagonalEntries = true) const;
+            SparseMatrix selectRowsFromRowGroups(std::vector<index_type> const& rowGroupToRowIndexMapping, bool insertDiagonalEntries = true) const;
             
             /*!
              * Transposes the matrix.
@@ -533,7 +556,7 @@ namespace storm {
              *
              * @return A sparse matrix that represents the transpose of this matrix.
              */
-            storm::storage::SparseMatrix<T> transpose(bool joinGroups = false) const;
+            storm::storage::SparseMatrix<value_type> transpose(bool joinGroups = false) const;
             
             /*!
              * Transforms the matrix into an equation system. That is, it transforms the matrix A into a matrix (1-A).
@@ -561,7 +584,7 @@ namespace storm {
              *
              * @return A pair (L+U, D^-1) containing the matrix L+U and the inverted diagonal matrix D^-1.
              */
-            std::pair<storm::storage::SparseMatrix<T>, storm::storage::SparseMatrix<T>> getJacobiDecomposition() const;
+            std::pair<storm::storage::SparseMatrix<value_type>, storm::storage::SparseMatrix<value_type>> getJacobiDecomposition() const;
             
             /*!
              * Performs a pointwise matrix multiplication of the matrix with the given matrix and returns a vector
@@ -573,7 +596,7 @@ namespace storm {
              * @return A vector containing the sum of the entries in each row of the matrix resulting from pointwise
              * multiplication of the current matrix with the given matrix.
              */
-            std::vector<T> getPointwiseProductRowSumVector(storm::storage::SparseMatrix<T> const& otherMatrix) const;
+            std::vector<value_type> getPointwiseProductRowSumVector(storm::storage::SparseMatrix<value_type> const& otherMatrix) const;
             
             /*!
              * Multiplies the matrix with the given vector and writes the result to the given result vector. If a
@@ -584,7 +607,7 @@ namespace storm {
              * @param result The vector that is supposed to hold the result of the multiplication after the operation.
              * @return The product of the matrix and the given vector as the content of the given result vector.
              */
-            void multiplyWithVector(std::vector<T> const& vector, std::vector<T>& result) const;
+            void multiplyWithVector(std::vector<value_type> const& vector, std::vector<value_type>& result) const;
             
             /*!
              * Multiplies the matrix with the given vector in a sequential way and writes the result to the given result
@@ -594,7 +617,7 @@ namespace storm {
              * @param result The vector that is supposed to hold the result of the multiplication after the operation.
              * @return The product of the matrix and the given vector as the content of the given result vector.
              */
-            void multiplyWithVectorSequential(std::vector<T> const& vector, std::vector<T>& result) const;
+            void multiplyWithVectorSequential(std::vector<value_type> const& vector, std::vector<value_type>& result) const;
 
 #ifdef STORM_HAVE_INTELTBB
             /*!
@@ -605,7 +628,7 @@ namespace storm {
              * @param result The vector that is supposed to hold the result of the multiplication after the operation.
              * @return The product of the matrix and the given vector as the content of the given result vector.
              */
-            void multiplyWithVectorParallel(std::vector<T> const& vector, std::vector<T>& result) const;
+            void multiplyWithVectorParallel(std::vector<value_type> const& vector, std::vector<value_type>& result) const;
 #endif
             
             /*!
@@ -614,7 +637,7 @@ namespace storm {
              * @param row The row that is to be summed.
              * @return The sum of the selected row.
              */
-            T getRowSum(uint_fast64_t row) const;
+            value_type getRowSum(index_type row) const;
             
             /*!
              * Checks if the current matrix is a submatrix of the given matrix, where a matrix A is called a submatrix
@@ -623,7 +646,7 @@ namespace storm {
              * @param matrix The matrix that possibly is a supermatrix of the current matrix.
              * @return True iff the current matrix is a submatrix of the given matrix.
              */
-            bool isSubmatrixOf(SparseMatrix<T> const& matrix) const;
+            bool isSubmatrixOf(SparseMatrix<value_type> const& matrix) const;
             
             template<typename TPrime>
             friend std::ostream& operator<<(std::ostream& out, SparseMatrix<TPrime> const& matrix);
@@ -649,7 +672,7 @@ namespace storm {
              * @param endRow The ending row (which is included in the result).
              * @return An object representing the consecutive rows given by the parameters.
              */
-            const_rows getRows(uint_fast64_t startRow, uint_fast64_t endRow) const;
+            const_rows getRows(index_type startRow, index_type endRow) const;
 
             /*!
              * Returns an object representing the consecutive rows given by the parameters.
@@ -658,7 +681,7 @@ namespace storm {
              * @param endRow The ending row (which is included in the result).
              * @return An object representing the consecutive rows given by the parameters.
              */
-            rows getRows(uint_fast64_t startRow, uint_fast64_t endRow);
+            rows getRows(index_type startRow, index_type endRow);
 
             /*!
              * Returns an object representing the given row.
@@ -666,7 +689,7 @@ namespace storm {
              * @param row The row to get.
              * @return An object representing the given row.
              */
-            const_rows getRow(uint_fast64_t row) const;
+            const_rows getRow(index_type row) const;
 
             /*!
              * Returns an object representing the given row.
@@ -674,7 +697,7 @@ namespace storm {
              * @param row The row to get.
              * @return An object representing the given row.
              */
-            rows getRow(uint_fast64_t row);
+            rows getRow(index_type row);
             
             /*!
              * Returns an object representing the given row group.
@@ -682,7 +705,7 @@ namespace storm {
              * @param rowGroup The row group to get.
              * @return An object representing the given row group.
              */
-            const_rows getRowGroup(uint_fast64_t rowGroup) const;
+            const_rows getRowGroup(index_type rowGroup) const;
             
             /*!
              * Returns an object representing the given row group.
@@ -690,7 +713,7 @@ namespace storm {
              * @param rowGroup The row group to get.
              * @return An object representing the given row group.
              */
-            rows getRowGroup(uint_fast64_t rowGroup);
+            rows getRowGroup(index_type rowGroup);
             
             /*!
              * Retrieves an iterator that points to the beginning of the given row.
@@ -698,7 +721,7 @@ namespace storm {
              * @param row The row to the beginning of which the iterator has to point.
              * @return An iterator that points to the beginning of the given row.
              */
-            const_iterator begin(uint_fast64_t row = 0) const;
+            const_iterator begin(index_type row = 0) const;
             
             /*!
              * Retrieves an iterator that points to the beginning of the given row.
@@ -706,7 +729,7 @@ namespace storm {
              * @param row The row to the beginning of which the iterator has to point.
              * @return An iterator that points to the beginning of the given row.
              */
-            iterator begin(uint_fast64_t row = 0);
+            iterator begin(index_type row = 0);
             
             /*!
              * Retrieves an iterator that points past the end of the given row.
@@ -714,7 +737,7 @@ namespace storm {
              * @param row The row past the end of which the iterator has to point.
              * @return An iterator that points past the end of the given row.
              */
-            const_iterator end(uint_fast64_t row) const;
+            const_iterator end(index_type row) const;
 
             /*!
              * Retrieves an iterator that points past the end of the given row.
@@ -722,7 +745,7 @@ namespace storm {
              * @param row The row past the end of which the iterator has to point.
              * @return An iterator that points past the end of the given row.
              */
-            iterator end(uint_fast64_t row);
+            iterator end(index_type row);
 
             /*!
              * Retrieves an iterator that points past the end of the last row of the matrix.
@@ -751,31 +774,31 @@ namespace storm {
              * @return A matrix corresponding to a submatrix of the current matrix in which only row groups and columns
              * given by the row group constraint are kept and all others are dropped.
              */
-            SparseMatrix getSubmatrix(storm::storage::BitVector const& rowGroupConstraint, storm::storage::BitVector const& columnConstraint, std::vector<uint_fast64_t> const& rowGroupIndices, bool insertDiagonalEntries = false) const;
+            SparseMatrix getSubmatrix(storm::storage::BitVector const& rowGroupConstraint, storm::storage::BitVector const& columnConstraint, std::vector<index_type> const& rowGroupIndices, bool insertDiagonalEntries = false) const;
             
             // The number of rows of the matrix.
-            uint_fast64_t rowCount;
+            index_type rowCount;
             
             // The number of columns of the matrix.
-            uint_fast64_t columnCount;
+            index_type columnCount;
             
             // The number of entries in the matrix.
-            uint_fast64_t entryCount;
+            index_type entryCount;
             
             // The number of nonzero entries in the matrix.
-            uint_fast64_t nonzeroEntryCount;
+            index_type nonzeroEntryCount;
             
             // The storage for the columns and values of all entries in the matrix.
-            std::vector<MatrixEntry<T>> columnsAndValues;
+            std::vector<MatrixEntry<index_type, value_type>> columnsAndValues;
             
             // A vector containing the indices at which each given row begins. This index is to be interpreted as an
             // index in the valueStorage and the columnIndications vectors. Put differently, the values of the entries
             // in row i are valueStorage[rowIndications[i]] to valueStorage[rowIndications[i + 1]] where the last
             // entry is not included anymore.
-            std::vector<uint_fast64_t> rowIndications;
+            std::vector<index_type> rowIndications;
             
             // A vector indicating the row groups of the matrix.
-            std::vector<uint_fast64_t> rowGroupIndices;
+            std::vector<index_type> rowGroupIndices;
         };
 
     } // namespace storage
diff --git a/src/storage/dd/CuddDd.cpp b/src/storage/dd/CuddDd.cpp
index 57cda7018..724b20018 100644
--- a/src/storage/dd/CuddDd.cpp
+++ b/src/storage/dd/CuddDd.cpp
@@ -496,7 +496,7 @@ namespace storm {
             
             // Prepare the vectors that represent the matrix.
             std::vector<uint_fast64_t> rowIndications(rowOdd.getTotalOffset() + 1);
-            std::vector<storm::storage::MatrixEntry<double>> columnsAndValues(this->getNonZeroCount());
+            std::vector<storm::storage::MatrixEntry<uint_fast64_t, double>> columnsAndValues(this->getNonZeroCount());
             
             // Create a trivial row grouping.
             std::vector<uint_fast64_t> trivialRowGroupIndices(rowIndications.size());
@@ -584,7 +584,7 @@ namespace storm {
             splitGroupsRec(this->getCuddAdd().getNode(), groups, ddGroupVariableIndices, 0, ddGroupVariableIndices.size(), rowAndColumnMetaVariables);
             
             // Create the actual storage for the non-zero entries.
-            std::vector<storm::storage::MatrixEntry<double>> columnsAndValues(this->getNonZeroCount());
+            std::vector<storm::storage::MatrixEntry<uint_fast64_t, double>> columnsAndValues(this->getNonZeroCount());
             
             // Now compute the indices at which the individual rows start.
             std::vector<uint_fast64_t> rowIndications(rowGroupIndices.back() + 1);
@@ -638,7 +638,7 @@ namespace storm {
             return storm::storage::SparseMatrix<double>(columnOdd.getTotalOffset(), std::move(rowIndications), std::move(columnsAndValues), std::move(rowGroupIndices));
         }
         
-        void Dd<DdType::CUDD>::toMatrixRec(DdNode const* dd, std::vector<uint_fast64_t>& rowIndications, std::vector<storm::storage::MatrixEntry<double>>& columnsAndValues, std::vector<uint_fast64_t> const& rowGroupOffsets, Odd<DdType::CUDD> const& rowOdd, Odd<DdType::CUDD> const& columnOdd, uint_fast64_t currentRowLevel, uint_fast64_t currentColumnLevel, uint_fast64_t maxLevel, uint_fast64_t currentRowOffset, uint_fast64_t currentColumnOffset, std::vector<uint_fast64_t> const& ddRowVariableIndices, std::vector<uint_fast64_t> const& ddColumnVariableIndices, bool generateValues) const {
+        void Dd<DdType::CUDD>::toMatrixRec(DdNode const* dd, std::vector<uint_fast64_t>& rowIndications, std::vector<storm::storage::MatrixEntry<uint_fast64_t, double>>& columnsAndValues, std::vector<uint_fast64_t> const& rowGroupOffsets, Odd<DdType::CUDD> const& rowOdd, Odd<DdType::CUDD> const& columnOdd, uint_fast64_t currentRowLevel, uint_fast64_t currentColumnLevel, uint_fast64_t maxLevel, uint_fast64_t currentRowOffset, uint_fast64_t currentColumnOffset, std::vector<uint_fast64_t> const& ddRowVariableIndices, std::vector<uint_fast64_t> const& ddColumnVariableIndices, bool generateValues) const {
             // For the empty DD, we do not need to add any entries.
             if (dd == this->getDdManager()->getZero().getCuddAdd().getNode()) {
                 return;
@@ -647,7 +647,7 @@ namespace storm {
             // If we are at the maximal level, the value to be set is stored as a constant in the DD.
             if (currentRowLevel + currentColumnLevel == maxLevel) {
                 if (generateValues) {
-                    columnsAndValues[rowIndications[rowGroupOffsets[currentRowOffset]]] = storm::storage::MatrixEntry<double>(currentColumnOffset, Cudd_V(dd));
+                    columnsAndValues[rowIndications[rowGroupOffsets[currentRowOffset]]] = storm::storage::MatrixEntry<uint_fast64_t, double>(currentColumnOffset, Cudd_V(dd));
                 }
                 ++rowIndications[rowGroupOffsets[currentRowOffset]];
             } else {
diff --git a/src/storage/dd/CuddDd.h b/src/storage/dd/CuddDd.h
index 316e30c89..adcb2e490 100644
--- a/src/storage/dd/CuddDd.h
+++ b/src/storage/dd/CuddDd.h
@@ -685,7 +685,7 @@ namespace storm {
              * only works if the offsets given in rowIndications are already correct. If they need to be computed first,
              * this flag needs to be false.
              */
-            void toMatrixRec(DdNode const* dd, std::vector<uint_fast64_t>& rowIndications, std::vector<storm::storage::MatrixEntry<double>>& columnsAndValues, std::vector<uint_fast64_t> const& rowGroupOffsets, Odd<DdType::CUDD> const& rowOdd, Odd<DdType::CUDD> const& columnOdd, uint_fast64_t currentRowLevel, uint_fast64_t currentColumnLevel, uint_fast64_t maxLevel, uint_fast64_t currentRowOffset, uint_fast64_t currentColumnOffset, std::vector<uint_fast64_t> const& ddRowVariableIndices, std::vector<uint_fast64_t> const& ddColumnVariableIndices, bool generateValues = true) const;
+            void toMatrixRec(DdNode const* dd, std::vector<uint_fast64_t>& rowIndications, std::vector<storm::storage::MatrixEntry<uint_fast64_t, double>>& columnsAndValues, std::vector<uint_fast64_t> const& rowGroupOffsets, Odd<DdType::CUDD> const& rowOdd, Odd<DdType::CUDD> const& columnOdd, uint_fast64_t currentRowLevel, uint_fast64_t currentColumnLevel, uint_fast64_t maxLevel, uint_fast64_t currentRowOffset, uint_fast64_t currentColumnOffset, std::vector<uint_fast64_t> const& ddRowVariableIndices, std::vector<uint_fast64_t> const& ddColumnVariableIndices, bool generateValues = true) const;
             
             /*!
              * Splits the given matrix DD into the groups using the given group variables.
diff --git a/test/functional/solver/Z3SmtSolverTest.cpp b/test/functional/solver/Z3SmtSolverTest.cpp
index c3222404c..4f10871f0 100644
--- a/test/functional/solver/Z3SmtSolverTest.cpp
+++ b/test/functional/solver/Z3SmtSolverTest.cpp
@@ -7,7 +7,7 @@
 
 TEST(Z3SmtSolver, CheckSat) {
 	storm::solver::Z3SmtSolver s;
-	storm::solver::Z3SmtSolver::CheckResult result;
+	storm::solver::Z3SmtSolver::CheckResult result = storm::solver::Z3SmtSolver::CheckResult::UNKNOWN;
 
 	storm::expressions::Expression exprDeMorgan = !(storm::expressions::Expression::createBooleanVariable("x") && storm::expressions::Expression::createBooleanVariable("y")).iff((!storm::expressions::Expression::createBooleanVariable("x") || !storm::expressions::Expression::createBooleanVariable("y")));
 
@@ -33,7 +33,7 @@ TEST(Z3SmtSolver, CheckSat) {
 
 TEST(Z3SmtSolver, CheckUnsat) {
 	storm::solver::Z3SmtSolver s;
-	storm::solver::Z3SmtSolver::CheckResult result;
+	storm::solver::Z3SmtSolver::CheckResult result = storm::solver::Z3SmtSolver::CheckResult::UNKNOWN;
 
 	storm::expressions::Expression exprDeMorgan = !(storm::expressions::Expression::createBooleanVariable("x") && storm::expressions::Expression::createBooleanVariable("y")).iff( (!storm::expressions::Expression::createBooleanVariable("x") || !storm::expressions::Expression::createBooleanVariable("y")));
 
@@ -60,7 +60,7 @@ TEST(Z3SmtSolver, CheckUnsat) {
 
 TEST(Z3SmtSolver, Backtracking) {
 	storm::solver::Z3SmtSolver s;
-	storm::solver::Z3SmtSolver::CheckResult result;
+	storm::solver::Z3SmtSolver::CheckResult result = storm::solver::Z3SmtSolver::CheckResult::UNKNOWN;
 
 	storm::expressions::Expression expr1 = storm::expressions::Expression::createTrue();
 	storm::expressions::Expression expr2 = storm::expressions::Expression::createFalse();
@@ -114,7 +114,7 @@ TEST(Z3SmtSolver, Backtracking) {
 
 TEST(Z3SmtSolver, Assumptions) {
 	storm::solver::Z3SmtSolver s;
-	storm::solver::Z3SmtSolver::CheckResult result;
+	storm::solver::Z3SmtSolver::CheckResult result = storm::solver::Z3SmtSolver::CheckResult::UNKNOWN;
 
 	storm::expressions::Expression a = storm::expressions::Expression::createIntegerVariable("a");
 	storm::expressions::Expression b = storm::expressions::Expression::createIntegerVariable("b");
diff --git a/test/functional/storage/SparseMatrixTest.cpp b/test/functional/storage/SparseMatrixTest.cpp
index de89f4950..52746ef97 100644
--- a/test/functional/storage/SparseMatrixTest.cpp
+++ b/test/functional/storage/SparseMatrixTest.cpp
@@ -147,7 +147,7 @@ TEST(SparseMatrix, Build) {
 }
 
 TEST(SparseMatrix, CreationWithMovingContents) {
-    std::vector<storm::storage::MatrixEntry<double>> columnsAndValues;
+    std::vector<storm::storage::MatrixEntry<uint_fast64_t, double>> columnsAndValues;
     columnsAndValues.emplace_back(1, 1.0);
     columnsAndValues.emplace_back(2, 1.2);
     columnsAndValues.emplace_back(0, 0.5);