making sure that the default linear equation solver is not switched to native if we check e.g. an MDP with sound value iteration

src/storm/modelchecker/csl/helper/SparseCtmcCslHelper.cpp

@@ -664,7 +664,7 @@ namespace storm {
                     }
                 }
                 
-                std::unique_ptr<storm::solver::LinearEquationSolver<ValueType>> solver = linearEquationSolverFactory.create(env, std::move(uniformizedMatrix));
+                std::unique_ptr<storm::solver::LinearEquationSolver<ValueType>> solver = linearEquationSolverFactory.create(env, std::move(uniformizedMatrix), storm::solver::LinearEquationSolverTask::Multiply);
                 solver->setCachingEnabled(true);
                 
                 if (!useMixedPoissonProbabilities && std::get<0>(foxGlynnResult) > 1) {

src/storm/modelchecker/prctl/helper/HybridDtmcPrctlHelper.cpp

@@ -140,7 +140,7 @@ namespace storm {
                     storm::storage::SparseMatrix<ValueType> explicitSubmatrix = submatrix.toMatrix(odd, odd);
                     std::vector<ValueType> b = subvector.toVector(odd);
                     
-                    std::unique_ptr<storm::solver::LinearEquationSolver<ValueType>> solver = linearEquationSolverFactory.create(env, std::move(explicitSubmatrix));
+                    std::unique_ptr<storm::solver::LinearEquationSolver<ValueType>> solver = linearEquationSolverFactory.create(env, std::move(explicitSubmatrix), storm::solver::LinearEquationSolverTask::Multiply);
                     solver->repeatedMultiply(x, &b, stepBound);
                     
                     // Return a hybrid check result that stores the numerical values explicitly.
@@ -165,7 +165,7 @@ namespace storm {
                 storm::storage::SparseMatrix<ValueType> explicitMatrix = transitionMatrix.toMatrix(odd, odd);
                 
                 // Perform the matrix-vector multiplication.
-                std::unique_ptr<storm::solver::LinearEquationSolver<ValueType>> solver = linearEquationSolverFactory.create(env, std::move(explicitMatrix));
+                std::unique_ptr<storm::solver::LinearEquationSolver<ValueType>> solver = linearEquationSolverFactory.create(env, std::move(explicitMatrix), storm::solver::LinearEquationSolverTask::Multiply);
                 solver->repeatedMultiply(x, nullptr, stepBound);
                 
                 // Return a hybrid check result that stores the numerical values explicitly.
@@ -191,7 +191,7 @@ namespace storm {
                 std::vector<ValueType> b = totalRewardVector.toVector(odd);
                 
                 // Perform the matrix-vector multiplication.
-                std::unique_ptr<storm::solver::LinearEquationSolver<ValueType>> solver = linearEquationSolverFactory.create(env, std::move(explicitMatrix));
+                std::unique_ptr<storm::solver::LinearEquationSolver<ValueType>> solver = linearEquationSolverFactory.create(env, std::move(explicitMatrix), storm::solver::LinearEquationSolverTask::Multiply);
                 solver->repeatedMultiply(x, &b, stepBound);
                 
                 // Return a hybrid check result that stores the numerical values explicitly.

src/storm/modelchecker/prctl/helper/SparseDtmcPrctlHelper.cpp

@@ -58,7 +58,7 @@ namespace storm {
                     
                     // Perform the matrix vector multiplication as often as required by the formula bound.
                     goal.restrictRelevantValues(maybeStates);
-                    std::unique_ptr<storm::solver::LinearEquationSolver<ValueType>> solver = storm::solver::configureLinearEquationSolver(env, std::move(goal), linearEquationSolverFactory, std::move(submatrix));
+                    std::unique_ptr<storm::solver::LinearEquationSolver<ValueType>> solver = storm::solver::configureLinearEquationSolver(env, std::move(goal), linearEquationSolverFactory, std::move(submatrix), storm::solver::LinearEquationSolverTask::Multiply);
                     solver->repeatedMultiply(subresult, &b, stepBound);
                     
                     // Set the values of the resulting vector accordingly.
@@ -172,7 +172,7 @@ namespace storm {
                 storm::utility::vector::setVectorValues(result, nextStates, storm::utility::one<ValueType>());
                 
                 // Perform one single matrix-vector multiplication.
-                std::unique_ptr<storm::solver::LinearEquationSolver<ValueType>> solver = linearEquationSolverFactory.create(env, transitionMatrix);
+                std::unique_ptr<storm::solver::LinearEquationSolver<ValueType>> solver = linearEquationSolverFactory.create(env, transitionMatrix, storm::solver::LinearEquationSolverTask::Multiply);
                 solver->repeatedMultiply(result, nullptr, 1);
                 return result;
             }
@@ -186,7 +186,7 @@ namespace storm {
                 std::vector<ValueType> totalRewardVector = rewardModel.getTotalRewardVector(transitionMatrix);
                 
                 // Perform the matrix vector multiplication as often as required by the formula bound.
-                std::unique_ptr<storm::solver::LinearEquationSolver<ValueType>> solver = storm::solver::configureLinearEquationSolver(env, std::move(goal), linearEquationSolverFactory, transitionMatrix);
+                std::unique_ptr<storm::solver::LinearEquationSolver<ValueType>> solver = storm::solver::configureLinearEquationSolver(env, std::move(goal), linearEquationSolverFactory, transitionMatrix, storm::solver::LinearEquationSolverTask::Multiply);
                 solver->repeatedMultiply(result, &totalRewardVector, stepBound);
                 
                 return result;

src/storm/solver/EigenLinearEquationSolver.cpp

@@ -284,7 +284,7 @@ namespace storm {
         }
         
         template<typename ValueType>
-        std::unique_ptr<storm::solver::LinearEquationSolver<ValueType>> EigenLinearEquationSolverFactory<ValueType>::create(Environment const& env) const {
+        std::unique_ptr<storm::solver::LinearEquationSolver<ValueType>> EigenLinearEquationSolverFactory<ValueType>::create(Environment const& env, LinearEquationSolverTask const& task) const {
             return std::make_unique<storm::solver::EigenLinearEquationSolver<ValueType>>();
         }
         

src/storm/solver/EigenLinearEquationSolver.h

@@ -43,7 +43,7 @@ namespace storm {
         public:
             using LinearEquationSolverFactory<ValueType>::create;
 
-            virtual std::unique_ptr<storm::solver::LinearEquationSolver<ValueType>> create(Environment const& env) const override;
+            virtual std::unique_ptr<storm::solver::LinearEquationSolver<ValueType>> create(Environment const& env, LinearEquationSolverTask const& task = LinearEquationSolverTask::Unspecified) const override;
 
             virtual std::unique_ptr<LinearEquationSolverFactory<ValueType>> clone() const override;
         };

src/storm/solver/EliminationLinearEquationSolver.cpp

@@ -126,7 +126,7 @@ namespace storm {
         }
         
         template<typename ValueType>
-        std::unique_ptr<storm::solver::LinearEquationSolver<ValueType>> EliminationLinearEquationSolverFactory<ValueType>::create(Environment const& env) const {
+        std::unique_ptr<storm::solver::LinearEquationSolver<ValueType>> EliminationLinearEquationSolverFactory<ValueType>::create(Environment const& env, LinearEquationSolverTask const& task) const {
             return std::make_unique<storm::solver::EliminationLinearEquationSolver<ValueType>>();
         }
         

src/storm/solver/EliminationLinearEquationSolver.h

@@ -46,7 +46,7 @@ namespace storm {
         public:
             using LinearEquationSolverFactory<ValueType>::create;
             
-            virtual std::unique_ptr<storm::solver::LinearEquationSolver<ValueType>> create(Environment const& env) const override;
+            virtual std::unique_ptr<storm::solver::LinearEquationSolver<ValueType>> create(Environment const& env, LinearEquationSolverTask const& task = LinearEquationSolverTask::Unspecified) const override;
             
             virtual std::unique_ptr<LinearEquationSolverFactory<ValueType>> clone() const override;
 

src/storm/solver/EquationSystemType.h

@@ -1,13 +0,0 @@
-#pragma once
-
-namespace storm {
-    namespace solver {
-        
-        enum class EquationSystemType {
-            UntilProbabilities,
-            ReachabilityRewards,
-            StochasticShortestPath
-        };
-        
-    }
-}

src/storm/solver/GmmxxLinearEquationSolver.cpp

@@ -168,7 +168,7 @@ namespace storm {
         }
         
         template<typename ValueType>
-        std::unique_ptr<storm::solver::LinearEquationSolver<ValueType>> GmmxxLinearEquationSolverFactory<ValueType>::create(Environment const& env) const {
+        std::unique_ptr<storm::solver::LinearEquationSolver<ValueType>> GmmxxLinearEquationSolverFactory<ValueType>::create(Environment const& env, LinearEquationSolverTask const& task) const {
             return std::make_unique<storm::solver::GmmxxLinearEquationSolver<ValueType>>();
         }
         

src/storm/solver/GmmxxLinearEquationSolver.h

@@ -63,7 +63,7 @@ namespace storm {
         public:
             using LinearEquationSolverFactory<ValueType>::create;
             
-            virtual std::unique_ptr<storm::solver::LinearEquationSolver<ValueType>> create(Environment const& env) const override;
+            virtual std::unique_ptr<storm::solver::LinearEquationSolver<ValueType>> create(Environment const& env, LinearEquationSolverTask const& task = LinearEquationSolverTask::Unspecified) const override;
             
             virtual std::unique_ptr<LinearEquationSolverFactory<ValueType>> clone() const override;
 

src/storm/solver/IterativeMinMaxLinearEquationSolver.cpp

@@ -289,7 +289,7 @@ namespace storm {
         template<typename ValueType>
         bool IterativeMinMaxLinearEquationSolver<ValueType>::solveEquationsValueIteration(Environment const& env, OptimizationDirection dir, std::vector<ValueType>& x, std::vector<ValueType> const& b) const {
             if (!this->linEqSolverA) {
-                this->linEqSolverA = this->linearEquationSolverFactory->create(env, *this->A);
+                this->createLinearEquationSolver(env);
                 this->linEqSolverA->setCachingEnabled(true);
             }
             
@@ -394,7 +394,7 @@ namespace storm {
             STORM_LOG_THROW(this->hasUpperBound(), storm::exceptions::UnmetRequirementException, "Solver requires upper bound, but none was given.");
 
             if (!this->linEqSolverA) {
-                this->linEqSolverA = this->linearEquationSolverFactory->create(env, *this->A);
+                this->createLinearEquationSolver(env);
                 this->linEqSolverA->setCachingEnabled(true);
             }
             
@@ -612,7 +612,7 @@ namespace storm {
 
         template<typename ValueType>
         void IterativeMinMaxLinearEquationSolver<ValueType>::createLinearEquationSolver(Environment const& env) const {
-            this->linEqSolverA = this->linearEquationSolverFactory->create(env, *this->A);
+            this->linEqSolverA = this->linearEquationSolverFactory->create(env, *this->A, LinearEquationSolverTask::Multiply);
         }
 
         template<typename ValueType>
@@ -626,7 +626,7 @@ namespace storm {
             std::vector<storm::RationalNumber> rationalB = storm::utility::vector::convertNumericVector<storm::RationalNumber>(b);
             
             if (!this->linEqSolverA) {
-                this->linEqSolverA = this->linearEquationSolverFactory->create(env, *this->A);
+                this->createLinearEquationSolver(env);
                 this->linEqSolverA->setCachingEnabled(true);
             }
             
@@ -656,7 +656,7 @@ namespace storm {
             // Version for when the overall value type is exact and the same type is to be used for the imprecise part.
             
             if (!this->linEqSolverA) {
-                this->linEqSolverA = this->linearEquationSolverFactory->create(env, *this->A);
+                this->createLinearEquationSolver(env);
                 this->linEqSolverA->setCachingEnabled(true);
             }
             
@@ -734,7 +734,7 @@ namespace storm {
                 impreciseA = storm::storage::SparseMatrix<ImpreciseType>();
 
                 if (!this->linEqSolverA) {
-                    this->linEqSolverA = this->linearEquationSolverFactory->create(env, *this->A);
+                    createLinearEquationSolver(env);
                     this->linEqSolverA->setCachingEnabled(true);
                 }
                 

src/storm/solver/LinearEquationSolver.cpp

@@ -136,15 +136,15 @@ namespace storm {
         }
         
         template<typename ValueType>
-        std::unique_ptr<LinearEquationSolver<ValueType>> LinearEquationSolverFactory<ValueType>::create(Environment const& env, storm::storage::SparseMatrix<ValueType> const& matrix) const {
-            std::unique_ptr<LinearEquationSolver<ValueType>> solver = this->create(env);
+        std::unique_ptr<LinearEquationSolver<ValueType>> LinearEquationSolverFactory<ValueType>::create(Environment const& env, storm::storage::SparseMatrix<ValueType> const& matrix, LinearEquationSolverTask const& task) const {
+            std::unique_ptr<LinearEquationSolver<ValueType>> solver = this->create(env, task);
             solver->setMatrix(matrix);
             return solver;
         }
         
         template<typename ValueType>
-        std::unique_ptr<LinearEquationSolver<ValueType>> LinearEquationSolverFactory<ValueType>::create(Environment const& env, storm::storage::SparseMatrix<ValueType>&& matrix) const {
-            std::unique_ptr<LinearEquationSolver<ValueType>> solver = this->create(env);
+        std::unique_ptr<LinearEquationSolver<ValueType>> LinearEquationSolverFactory<ValueType>::create(Environment const& env, storm::storage::SparseMatrix<ValueType>&& matrix, LinearEquationSolverTask const& task) const {
+            std::unique_ptr<LinearEquationSolver<ValueType>> solver = this->create(env, task);
             solver->setMatrix(std::move(matrix));
             return solver;
         }
@@ -166,7 +166,7 @@ namespace storm {
         
         
         template<>
-        std::unique_ptr<LinearEquationSolver<storm::RationalNumber>> GeneralLinearEquationSolverFactory<storm::RationalNumber>::create(Environment const& env) const {
+        std::unique_ptr<LinearEquationSolver<storm::RationalNumber>> GeneralLinearEquationSolverFactory<storm::RationalNumber>::create(Environment const& env, LinearEquationSolverTask const& task) const {
             EquationSolverType type = env.solver().getLinearEquationSolverType();
             
              // Adjust the solver type if it is not supported by this value type
@@ -186,7 +186,7 @@ namespace storm {
         }
         
         template<>
-        std::unique_ptr<LinearEquationSolver<storm::RationalFunction>> GeneralLinearEquationSolverFactory<storm::RationalFunction>::create(Environment const& env) const {
+        std::unique_ptr<LinearEquationSolver<storm::RationalFunction>> GeneralLinearEquationSolverFactory<storm::RationalFunction>::create(Environment const& env, LinearEquationSolverTask const& task) const {
             EquationSolverType type = env.solver().getLinearEquationSolverType();
             
              // Adjust the solver type if it is not supported by this value type
@@ -206,11 +206,11 @@ namespace storm {
         }
         
         template<typename ValueType>
-        std::unique_ptr<LinearEquationSolver<ValueType>> GeneralLinearEquationSolverFactory<ValueType>::create(Environment const& env) const {
+        std::unique_ptr<LinearEquationSolver<ValueType>> GeneralLinearEquationSolverFactory<ValueType>::create(Environment const& env, LinearEquationSolverTask const& task) const {
             EquationSolverType type = env.solver().getLinearEquationSolverType();
             
             // Adjust the solver type if none was specified and we want sound computations
-            if (env.solver().isForceSoundness() && type != EquationSolverType::Native && type != EquationSolverType::Eigen && type != EquationSolverType::Elimination) {
+            if (env.solver().isForceSoundness() && task != LinearEquationSolverTask::Multiply, type != EquationSolverType::Native && type != EquationSolverType::Eigen && type != EquationSolverType::Elimination) {
                 if (env.solver().isLinearEquationSolverTypeSetFromDefaultValue()) {
                     type = EquationSolverType::Native;
                     STORM_LOG_INFO("Selecting '" + toString(type) + "' as the linear equation solver to guarantee sound results. If you want to override this, please explicitly specify a different solver.");

src/storm/solver/LinearEquationSolver.h

@@ -8,6 +8,7 @@
 #include "storm/solver/MultiplicationStyle.h"
 #include "storm/solver/LinearEquationSolverProblemFormat.h"
 #include "storm/solver/LinearEquationSolverRequirements.h"
+#include "storm/solver/LinearEquationSolverTask.h"
 #include "storm/solver/OptimizationDirection.h"
 
 #include "storm/utility/VectorHelper.h"
@@ -20,10 +21,6 @@ namespace storm {
     
     namespace solver {
         
-        enum class LinearEquationSolverOperation {
-            SolveEquations, MultiplyRepeatedly
-        };
-
         /*!
          * An interface that represents an abstract linear equation solver. In addition to solving a system of linear
          * equations, the functionality to repeatedly multiply a matrix with a given vector is provided.
@@ -190,7 +187,7 @@ namespace storm {
              * @param matrix The matrix that defines the equation system.
              * @return A pointer to the newly created solver.
              */
-            std::unique_ptr<LinearEquationSolver<ValueType>> create(Environment const& env, storm::storage::SparseMatrix<ValueType> const& matrix) const;
+            std::unique_ptr<LinearEquationSolver<ValueType>> create(Environment const& env, storm::storage::SparseMatrix<ValueType> const& matrix, LinearEquationSolverTask const& task = LinearEquationSolverTask::Unspecified) const;
 
             /*!
              * Creates a new linear equation solver instance with the given matrix. The caller gives up posession of the
@@ -199,12 +196,12 @@ namespace storm {
              * @param matrix The matrix that defines the equation system.
              * @return A pointer to the newly created solver.
              */
-            std::unique_ptr<LinearEquationSolver<ValueType>> create(Environment const& env, storm::storage::SparseMatrix<ValueType>&& matrix) const;
+            std::unique_ptr<LinearEquationSolver<ValueType>> create(Environment const& env, storm::storage::SparseMatrix<ValueType>&& matrix, LinearEquationSolverTask const& task = LinearEquationSolverTask::Unspecified) const;
 
             /*!
              * Creates an equation solver with the current settings, but without a matrix.
              */
-            virtual std::unique_ptr<LinearEquationSolver<ValueType>> create(Environment const& env) const = 0;
+            virtual std::unique_ptr<LinearEquationSolver<ValueType>> create(Environment const& env, LinearEquationSolverTask const& task = LinearEquationSolverTask::Unspecified) const = 0;
 
             /*!
              * Creates a copy of this factory.
@@ -230,7 +227,7 @@ namespace storm {
             
             using LinearEquationSolverFactory<ValueType>::create;
 
-            virtual std::unique_ptr<LinearEquationSolver<ValueType>> create(Environment const& env) const override;
+            virtual std::unique_ptr<LinearEquationSolver<ValueType>> create(Environment const& env, LinearEquationSolverTask const& task = LinearEquationSolverTask::Unspecified) const override;
 
             virtual std::unique_ptr<LinearEquationSolverFactory<ValueType>> clone() const override;
         };

src/storm/solver/LinearEquationSolverTask.cpp

@@ -0,0 +1,16 @@
+#include "storm/solver/LinearEquationSolverTask.h"
+
+namespace storm {
+    namespace solver {
+        
+        std::ostream& operator<<(std::ostream& out, LinearEquationSolverTask const& task) {
+            switch (task) {
+                case LinearEquationSolverTask::Unspecified: out << "unspecified"; break;
+                case LinearEquationSolverTask::SolveEquations: out << "solve equations"; break;
+                case LinearEquationSolverTask::Multiply: out << "multiply"; break;
+            }
+            return out;
+        }
+        
+    }
+}

src/storm/solver/LinearEquationSolverTask.h

@@ -0,0 +1,13 @@
+#pragma once
+
+#include <iostream>
+
+namespace storm {
+    namespace solver {
+        
+        enum class LinearEquationSolverTask { Unspecified, SolveEquations, Multiply };
+     
+        std::ostream& operator<<(std::ostream& out, LinearEquationSolverTask const& style);
+        
+    }
+}

src/storm/solver/NativeLinearEquationSolver.cpp

@@ -959,7 +959,7 @@ namespace storm {
         }
         
         template<typename ValueType>
-        std::unique_ptr<storm::solver::LinearEquationSolver<ValueType>> NativeLinearEquationSolverFactory<ValueType>::create(Environment const& env) const {
+        std::unique_ptr<storm::solver::LinearEquationSolver<ValueType>> NativeLinearEquationSolverFactory<ValueType>::create(Environment const& env, LinearEquationSolverTask const& task) const {
             return std::make_unique<storm::solver::NativeLinearEquationSolver<ValueType>>();
         }
         

src/storm/solver/NativeLinearEquationSolver.h

@@ -123,7 +123,7 @@ namespace storm {
         public:
             using LinearEquationSolverFactory<ValueType>::create;
             
-            virtual std::unique_ptr<storm::solver::LinearEquationSolver<ValueType>> create(Environment const& env) const override;
+            virtual std::unique_ptr<storm::solver::LinearEquationSolver<ValueType>> create(Environment const& env, LinearEquationSolverTask const& task = LinearEquationSolverTask::Unspecified) const override;
             
             virtual std::unique_ptr<LinearEquationSolverFactory<ValueType>> clone() const override;
 

src/storm/solver/SolveGoal.h

@@ -7,6 +7,7 @@
 #include "storm/solver/OptimizationDirection.h"
 #include "storm/logic/ComparisonType.h"
 #include "storm/storage/BitVector.h"
+#include "storm/solver/LinearEquationSolverTask.h"
 
 #include "storm/solver/LinearEquationSolver.h"
 #include "storm/solver/MinMaxLinearEquationSolver.h"
@@ -110,8 +111,8 @@ namespace storm {
         }
         
         template<typename ValueType, typename MatrixType>
-        std::unique_ptr<storm::solver::LinearEquationSolver<ValueType>> configureLinearEquationSolver(Environment const& env, SolveGoal<ValueType>&& goal, storm::solver::LinearEquationSolverFactory<ValueType> const& factory, MatrixType&& matrix) {
-            std::unique_ptr<storm::solver::LinearEquationSolver<ValueType>> solver = factory.create(env, std::forward<MatrixType>(matrix));
+        std::unique_ptr<storm::solver::LinearEquationSolver<ValueType>> configureLinearEquationSolver(Environment const& env, SolveGoal<ValueType>&& goal, storm::solver::LinearEquationSolverFactory<ValueType> const& factory, MatrixType&& matrix, storm::solver::LinearEquationSolverTask const& task = LinearEquationSolverTask::Unspecified) {
+            std::unique_ptr<storm::solver::LinearEquationSolver<ValueType>> solver = factory.create(env, std::forward<MatrixType>(matrix), task);
             if (goal.isBounded()) {
                 solver->setTerminationCondition(std::make_unique<TerminateIfFilteredExtremumExceedsThreshold<ValueType>>(goal.relevantValues(), goal.boundIsStrict(), goal.thresholdValue(), goal.minimize()));
             }
@@ -119,8 +120,8 @@ namespace storm {
         }
         
         template<typename MatrixType>
-        std::unique_ptr<storm::solver::LinearEquationSolver<storm::RationalFunction>> configureLinearEquationSolver(Environment const& env, SolveGoal<storm::RationalFunction>&& goal, storm::solver::LinearEquationSolverFactory<storm::RationalFunction> const& factory, MatrixType&& matrix) {
-            std::unique_ptr<storm::solver::LinearEquationSolver<storm::RationalFunction>> solver = factory.create(env, std::forward<MatrixType>(matrix));
+        std::unique_ptr<storm::solver::LinearEquationSolver<storm::RationalFunction>> configureLinearEquationSolver(Environment const& env, SolveGoal<storm::RationalFunction>&& goal, storm::solver::LinearEquationSolverFactory<storm::RationalFunction> const& factory, MatrixType&& matrix, storm::solver::LinearEquationSolverTask const& task = LinearEquationSolverTask::Unspecified) {
+            std::unique_ptr<storm::solver::LinearEquationSolver<storm::RationalFunction>> solver = factory.create(env, std::forward<MatrixType>(matrix), task);
             return solver;
         }
         

src/storm/solver/StandardGameSolver.cpp

@@ -139,7 +139,7 @@ namespace storm {
         bool StandardGameSolver<ValueType>::solveGameValueIteration(Environment const& env, OptimizationDirection player1Dir, OptimizationDirection player2Dir, std::vector<ValueType>& x, std::vector<ValueType> const& b) const {
                          
             if(!linEqSolverPlayer2Matrix) {
-                linEqSolverPlayer2Matrix = linearEquationSolverFactory->create(env, player2Matrix);
+                linEqSolverPlayer2Matrix = linearEquationSolverFactory->create(env, player2Matrix, storm::solver::LinearEquationSolverTask::Multiply);
                 linEqSolverPlayer2Matrix->setCachingEnabled(true);
             }
             
@@ -222,7 +222,7 @@ namespace storm {
         void StandardGameSolver<ValueType>::repeatedMultiply(Environment const& env, OptimizationDirection player1Dir, OptimizationDirection player2Dir, std::vector<ValueType>& x, std::vector<ValueType> const* b, uint_fast64_t n) const {
             
             if(!linEqSolverPlayer2Matrix) {
-                linEqSolverPlayer2Matrix = linearEquationSolverFactory->create(env, player2Matrix);
+                linEqSolverPlayer2Matrix = linearEquationSolverFactory->create(env, player2Matrix, storm::solver::LinearEquationSolverTask::Multiply);
                 linEqSolverPlayer2Matrix->setCachingEnabled(true);
             }
             

src/storm/solver/StandardMinMaxLinearEquationSolver.cpp

@@ -46,7 +46,7 @@ namespace storm {
         template<typename ValueType>
         void StandardMinMaxLinearEquationSolver<ValueType>::repeatedMultiply(Environment const& env, OptimizationDirection dir, std::vector<ValueType>& x, std::vector<ValueType> const* b, uint_fast64_t n) const {
             if (!linEqSolverA) {
-                linEqSolverA = linearEquationSolverFactory->create(env, *A);
+                linEqSolverA = linearEquationSolverFactory->create(env, *A, LinearEquationSolverTask::Multiply);
                 linEqSolverA->setCachingEnabled(true);
             }
             

src/storm/solver/SymbolicMinMaxLinearEquationSolver.h

@@ -9,7 +9,6 @@
 #include "storm/solver/SymbolicEquationSolver.h"
 #include "storm/solver/OptimizationDirection.h"
 #include "storm/solver/SymbolicLinearEquationSolver.h"
-#include "storm/solver/EquationSystemType.h"
 #include "storm/solver/MinMaxLinearEquationSolverRequirements.h"
 #include "storm/solver/SolverStatus.h"