diff --git a/src/modelchecker/region/ApproximationModel.cpp b/src/modelchecker/region/ApproximationModel.cpp
index 005a33997..82e9c8e6c 100644
--- a/src/modelchecker/region/ApproximationModel.cpp
+++ b/src/modelchecker/region/ApproximationModel.cpp
@@ -269,26 +269,42 @@ namespace storm {
template<typename ParametricSparseModelType, typename ConstantType>
ConstantType ApproximationModel<ParametricSparseModelType, ConstantType>::computeInitialStateValue(ParameterRegion<ParametricType> const& region, bool computeLowerBounds) {
instantiate(region, computeLowerBounds);
- std::vector<std::size_t> policy;
- invokeSolver(computeLowerBounds, policy);
+ std::shared_ptr<Policy> policy;
+ if(computeLowerBounds && !this->minimizingPolicies.empty()){
+ policy = std::make_shared<Policy>(**(this->minimizingPolicies.begin())); //we need a fresh policy, initialized with the values of the old one
+ } else if(!computeLowerBounds && !this->maximizingPolicies.empty()){
+ policy = std::make_shared<Policy>(**(this->maximizingPolicies.begin())); //we need a fresh policy, initialized with the values of the old one
+ } else {
+ policy = std::make_shared<Policy>(this->matrixData.matrix.getRowGroupCount());
+ }
+ invokeSolver(computeLowerBounds, *policy);
+ if(computeLowerBounds){
+ this->minimizingPolicies.insert(policy);
+ std::cout << minimizingPolicies.size() << std::endl;
+ } else {
+ this->maximizingPolicies.insert(policy);
+ std::cout << maximizingPolicies.size() << std::endl;
+ }
//TODO: policy for games.
- //TODO: do this only when necessary.
//TODO: (maybe) when a few parameters are mapped to another value, build a "nicer" scheduler and check whether it induces values that are more optimal.
- if(policy.empty()) return this->eqSysResult[this->eqSysInitIndex];
+ if(policy->empty()) return this->eqSysResult[this->eqSysInitIndex];
//Get the set of parameters which are (according to the policy) always mapped to the same region boundary.
//First, collect all (relevant) parameters, i.e., the ones that are set to the lower or upper boundary.
std::map<VariableType, RegionBoundary> fixedVariables;
+ std::map<VariableType, std::pair<std::size_t, std::size_t>> VarCount;
+ std::size_t substitutionCount =0;
for(auto const& substitution : this->funcSubData.substitutions){
for( auto const& sub : substitution){
if(sub.second!= RegionBoundary::UNSPECIFIED){
fixedVariables.insert(typename std::map<VariableType, RegionBoundary>::value_type(sub.first, RegionBoundary::UNSPECIFIED));
+ VarCount.insert(typename std::map<VariableType, std::pair<std::size_t, std::size_t>>::value_type(sub.first, std::pair<std::size_t, std::size_t>(0,0)));
}
}
}
//Now erase the parameters that are mapped to different boundaries.
for(std::size_t rowGroup=0; rowGroup<this->matrixData.matrix.getRowGroupCount(); ++rowGroup){
- std::size_t row = this->matrixData.matrix.getRowGroupIndices()[rowGroup] + policy[rowGroup];
+ std::size_t row = this->matrixData.matrix.getRowGroupIndices()[rowGroup] + (*policy)[rowGroup];
for(std::pair<VariableType, RegionBoundary> const& sub : this->funcSubData.substitutions[this->matrixData.rowSubstitutions[row]]){
auto fixedVarIt = fixedVariables.find(sub.first);
if(fixedVarIt != fixedVariables.end() && fixedVarIt->second != sub.second){
@@ -299,15 +315,29 @@ namespace storm {
fixedVariables.erase(fixedVarIt);
}
}
+ auto varcountIt = VarCount.find(sub.first);
+ if(sub.second==RegionBoundary::LOWER){
+ ++(varcountIt->second.first);
+ } else if (sub.second==RegionBoundary::UPPER){
+ ++(varcountIt->second.second);
+ }
+ ++substitutionCount;
}
if (fixedVariables.empty()){
- break;
+ // break;
+ }
+ }
+ // std::cout << "Used Approximation" << std::endl;
+ for (auto const& varcount : VarCount){
+ if(varcount.second.first > 0 && varcount.second.second > 0){
+ // std::cout << " Variable " << varcount.first << " has been set to lower " << varcount.second.first << " times and to upper " << varcount.second.second << " times. (total: " << substitutionCount << ")" << std::endl;
}
}
for (auto const& fixVar : fixedVariables){
- //std::cout << "APPROXMODEL: variable " << fixVar.first << " is always mapped to " << fixVar.second << std::endl;
+ //std::cout << " APPROXMODEL: variable " << fixVar.first << " is always mapped to " << fixVar.second << std::endl;
}
+ // std::cout << " Result is " << this->eqSysResult[this->eqSysInitIndex] << std::endl;
return this->eqSysResult[this->eqSysInitIndex];
}
@@ -342,17 +372,17 @@ namespace storm {
auto& result = functionResult.second;
result = computeLowerBounds ? storm::utility::infinity<ConstantType>() : storm::utility::zero<ConstantType>();
//Iterate over the different combinations of lower and upper bounds and update the min and max values
- auto const& vertices=region.getVerticesOfRegion(unspecifiedParameters[funcSub.getSubstitution()]);
+ auto const& vertices=region.getVerticesOfRegion(unspecifiedParameters[funcSub.second]);
for(auto const& vertex : vertices){
//extend the substitution
for(auto const& vertexSub : vertex){
- instantiatedSubs[funcSub.getSubstitution()][vertexSub.first]=vertexSub.second;
+ instantiatedSubs[funcSub.second][vertexSub.first]=vertexSub.second;
}
//evaluate the function
ConstantType currValue = storm::utility::region::convertNumber<ConstantType>(
storm::utility::region::evaluateFunction(
- funcSub.getFunction(),
- instantiatedSubs[funcSub.getSubstitution()]
+ funcSub.first,
+ instantiatedSubs[funcSub.second]
)
);
result = computeLowerBounds ? std::min(result, currValue) : std::max(result, currValue);
@@ -370,16 +400,16 @@ namespace storm {
template<>
- void ApproximationModel<storm::models::sparse::Dtmc<storm::RationalFunction>, double>::invokeSolver(bool computeLowerBounds, std::vector<std::size_t>& policy){
+ void ApproximationModel<storm::models::sparse::Dtmc<storm::RationalFunction>, double>::invokeSolver(bool computeLowerBounds, Policy& policy){
storm::solver::SolveGoal goal(computeLowerBounds);
std::unique_ptr<storm::solver::MinMaxLinearEquationSolver<double>> solver = storm::solver::configureMinMaxLinearEquationSolver(goal, storm::utility::solver::MinMaxLinearEquationSolverFactory<double>(), this->matrixData.matrix);
solver->setPolicyTracking();
- solver->solveEquationSystem(this->eqSysResult, this->vectorData.vector);
+ solver->solveEquationSystem(goal.direction(), this->eqSysResult, this->vectorData.vector, nullptr, nullptr, &policy);
policy = solver->getPolicy();
}
template<>
- void ApproximationModel<storm::models::sparse::Mdp<storm::RationalFunction>, double>::invokeSolver(bool computeLowerBounds, std::vector<std::size_t>& policy){
+ void ApproximationModel<storm::models::sparse::Mdp<storm::RationalFunction>, double>::invokeSolver(bool computeLowerBounds, Policy& policy){
storm::solver::SolveGoal player2Goal(computeLowerBounds);
std::unique_ptr<storm::solver::GameSolver<double>> solver = storm::utility::solver::GameSolverFactory<double>().create(this->player1Matrix, this->matrixData.matrix);
solver->solveGame(this->player1Goal.direction(), player2Goal.direction(), this->eqSysResult, this->vectorData.vector);
diff --git a/src/modelchecker/region/ApproximationModel.h b/src/modelchecker/region/ApproximationModel.h
index 787d1f33e..c4687d274 100644
--- a/src/modelchecker/region/ApproximationModel.h
+++ b/src/modelchecker/region/ApproximationModel.h
@@ -58,74 +58,26 @@ namespace storm {
private:
- //A class that represents a function and how it should be substituted (i.e. which variables should be replaced with lower and which with upper bounds of the region)
- //The substitution is given as an index in funcSubData.substitutions (allowing to instantiate the substitutions more easily).
- class FunctionSubstitution {
- public:
- FunctionSubstitution(ParametricType const& fun, std::size_t const& sub) : hash(computeHash(fun,sub)), function(fun), substitution(sub) {
- //intentionally left empty
- }
-
- FunctionSubstitution(ParametricType&& fun, std::size_t&& sub) : hash(computeHash(fun,sub)), function(std::move(fun)), substitution(std::move(sub)) {
- //intentionally left empty
- }
-
- FunctionSubstitution(FunctionSubstitution const& other) : hash(other.hash), function(other.function), substitution(other.substitution){
- //intentionally left empty
- }
-
- FunctionSubstitution(FunctionSubstitution&& other) : hash(std::move(other.hash)), function(std::move(other.function)), substitution(std::move(other.substitution)){
- //intentionally left empty
- }
-
- FunctionSubstitution() = default;
-
- ~FunctionSubstitution() = default;
-
- bool operator==(FunctionSubstitution const& other) const {
- return this->hash==other.hash && this->substitution==other.substitution && this->function==other.function;
- }
-
- ParametricType const& getFunction() const{
- return this->function;
- }
-
- std::size_t const& getSubstitution() const{
- return this->substitution;
- }
-
- std::size_t const& getHash() const{
- return this->hash;
- }
-
- private:
-
- static std::size_t computeHash(ParametricType const& fun, std::size_t const& sub) {
- std::size_t seed = 0;
- boost::hash_combine(seed, fun);
- boost::hash_combine(seed, sub);
- return seed;
- }
-
- std::size_t hash;
- ParametricType function;
- std::size_t substitution;
- };
-
+ typedef std::pair<ParametricType, std::size_t> FunctionSubstitution;
+ typedef std::vector<storm::storage::sparse::state_type> Policy;
class FuncSubHash{
public:
std::size_t operator()(FunctionSubstitution const& fs) const {
- return fs.getHash();
+ // return fs.getHash();
+ std::size_t seed = 0;
+ boost::hash_combine(seed, fs.first);
+ boost::hash_combine(seed, fs.second);
+ return seed;
+
}
};
-
typedef typename std::unordered_map<FunctionSubstitution, ConstantType, FuncSubHash>::value_type FunctionEntry;
void initializeProbabilities(ParametricSparseModelType const& parametricModel, std::vector<std::size_t> const& newIndices);
void initializeRewards(ParametricSparseModelType const& parametricModel, std::vector<std::size_t> const& newIndices);
void initializePlayer1Matrix(ParametricSparseModelType const& parametricModel);
void instantiate(ParameterRegion<ParametricType> const& region, bool computeLowerBounds);
- void invokeSolver(bool computeLowerBounds, std::vector<std::size_t>& policy);
+ void invokeSolver(bool computeLowerBounds, Policy& policy);
//Some designated states in the original model
storm::storage::BitVector targetStates, maybeStates;
@@ -134,6 +86,10 @@ namespace storm {
std::vector<ConstantType> eqSysResult;
//The index which represents the result for the initial state in the eqSysResult vector
std::size_t eqSysInitIndex;
+
+ std::unordered_set<std::shared_ptr<Policy>> minimizingPolicies;
+ std::unordered_set<std::shared_ptr<Policy>> maximizingPolicies;
+
//A flag that denotes whether we compute probabilities or rewards
bool computeRewards;
//Player 1 represents the nondeterminism of the given mdp (so, this is irrelevant if we approximate values of a DTMC)
diff --git a/src/solver/GmmxxMinMaxLinearEquationSolver.cpp b/src/solver/GmmxxMinMaxLinearEquationSolver.cpp
index 6c82ab1cf..e65ceed42 100644
--- a/src/solver/GmmxxMinMaxLinearEquationSolver.cpp
+++ b/src/solver/GmmxxMinMaxLinearEquationSolver.cpp
@@ -30,7 +30,7 @@ namespace storm {
template<typename ValueType>
- void GmmxxMinMaxLinearEquationSolver<ValueType>::solveEquationSystem(OptimizationDirection dir, std::vector<ValueType>& x, std::vector<ValueType> const& b, std::vector<ValueType>* multiplyResult, std::vector<ValueType>* newX) const {
+ void GmmxxMinMaxLinearEquationSolver<ValueType>::solveEquationSystem(OptimizationDirection dir, std::vector<ValueType>& x, std::vector<ValueType> const& b, std::vector<ValueType>* multiplyResult, std::vector<ValueType>* newX, std::vector<storm::storage::sparse::state_type>* initialPolicy) const {
if (this->useValueIteration) {
// Set up the environment for the power method. If scratch memory was not provided, we need to create it.
bool multiplyResultMemoryProvided = true;
@@ -45,6 +45,19 @@ namespace storm {
newX = new std::vector<ValueType>(x.size());
xMemoryProvided = false;
}
+
+ if(initialPolicy != nullptr){
+ //Get initial values for x like it is done for policy iteration.
+ storm::storage::SparseMatrix<ValueType> submatrix = this->A.selectRowsFromRowGroups(*initialPolicy, true);
+ submatrix.convertToEquationSystem();
+ GmmxxLinearEquationSolver<ValueType> gmmLinearEquationSolver(submatrix);
+ std::vector<ValueType> subB(rowGroupIndices.size() - 1);
+ storm::utility::vector::selectVectorValues<ValueType>(subB, *initialPolicy, rowGroupIndices, b);
+ // Solve the resulting linear equation system
+ std::vector<ValueType> deterministicMultiplyResult(rowGroupIndices.size() - 1);
+ gmmLinearEquationSolver.solveEquationSystem(*currentX, subB, &deterministicMultiplyResult);
+ }
+
uint_fast64_t iterations = 0;
bool converged = false;
@@ -81,6 +94,11 @@ namespace storm {
if (currentX == copyX) {
std::swap(x, *currentX);
}
+
+ if(this->trackPolicy){
+ this->policy = std::vector<storm::storage::sparse::state_type>(x.size());
+ storm::utility::vector::reduceVectorMinOrMax(dir, *multiplyResult, x, rowGroupIndices, &(this->policy));
+ }
if (!xMemoryProvided) {
delete copyX;
@@ -90,14 +108,15 @@ namespace storm {
delete multiplyResult;
}
- if(this->trackPolicy){
- this->policy = this->computePolicy(x,b);
- }
} else {
// We will use Policy Iteration to solve the given system.
// We first guess an initial choice resolution which will be refined after each iteration.
- this->policy = std::vector<storm::storage::sparse::state_type>(this->A.getRowGroupIndices().size() - 1);
+ if(initialPolicy == nullptr){
+ this->policy = std::vector<storm::storage::sparse::state_type>(this->A.getRowGroupIndices().size() - 1);
+ } else {
+ this->policy = *initialPolicy;
+ }
// Create our own multiplyResult for solving the deterministic sub-instances.
std::vector<ValueType> deterministicMultiplyResult(rowGroupIndices.size() - 1);
diff --git a/src/solver/GmmxxMinMaxLinearEquationSolver.h b/src/solver/GmmxxMinMaxLinearEquationSolver.h
index ed91278bc..8bf92086d 100644
--- a/src/solver/GmmxxMinMaxLinearEquationSolver.h
+++ b/src/solver/GmmxxMinMaxLinearEquationSolver.h
@@ -35,7 +35,7 @@ namespace storm {
virtual void performMatrixVectorMultiplication(OptimizationDirection d, std::vector<ValueType>& x, std::vector<ValueType>* b = nullptr, uint_fast64_t n = 1, std::vector<ValueType>* multiplyResult = nullptr) const override;
- virtual void solveEquationSystem(OptimizationDirection d, std::vector<ValueType>& x, std::vector<ValueType> const& b, std::vector<ValueType>* multiplyResult = nullptr, std::vector<ValueType>* newX = nullptr) const override;
+ virtual void solveEquationSystem(OptimizationDirection d, std::vector<ValueType>& x, std::vector<ValueType> const& b, std::vector<ValueType>* multiplyResult = nullptr, std::vector<ValueType>* newX = nullptr, std::vector<storm::storage::sparse::state_type>* initialPolicy = nullptr) const override;
private:
// The (gmm++) matrix associated with this equation solver.
diff --git a/src/solver/MinMaxLinearEquationSolver.h b/src/solver/MinMaxLinearEquationSolver.h
index 8514ee69a..934aae3f2 100644
--- a/src/solver/MinMaxLinearEquationSolver.h
+++ b/src/solver/MinMaxLinearEquationSolver.h
@@ -8,7 +8,6 @@
#include "src/storage/sparse/StateType.h"
#include "AllowEarlyTerminationCondition.h"
#include "OptimizationDirection.h"
-#include "src/utility/vector.h"
namespace storm {
namespace storage {
@@ -98,7 +97,7 @@ namespace storm {
* vector must be equal to the length of the vector x (and thus to the number of columns of A).
* @return The solution vector x of the system of linear equations as the content of the parameter x.
*/
- virtual void solveEquationSystem(OptimizationDirection d, std::vector<ValueType>& x, std::vector<ValueType> const& b, std::vector<ValueType>* multiplyResult = nullptr, std::vector<ValueType>* newX = nullptr) const = 0;
+ virtual void solveEquationSystem(OptimizationDirection d, std::vector<ValueType>& x, std::vector<ValueType> const& b, std::vector<ValueType>* multiplyResult = nullptr, std::vector<ValueType>* newX = nullptr, std::vector<storm::storage::sparse::state_type>* initialPolicy = nullptr) const = 0;
/*!
* As solveEquationSystem with an optimization-direction, but this uses the internally set direction.
@@ -141,17 +140,6 @@ namespace storm {
protected:
-
- std::vector<storm::storage::sparse::state_type> computePolicy(std::vector<ValueType>& x, std::vector<ValueType> const& b) const{
- std::vector<ValueType> xPrime(this->A.getRowCount());
- this->A.multiplyWithVector(x, xPrime);
- storm::utility::vector::addVectors(xPrime, b, xPrime);
- std::vector<storm::storage::sparse::state_type> policy(x.size());
- std::vector<ValueType> reduced(x.size());
- storm::utility::vector::reduceVectorMinOrMax(convert(this->direction), xPrime, reduced, this->A.getRowGroupIndices(), &(policy));
- return policy;
- }
-
storm::storage::SparseMatrix<ValueType> const& A;
std::unique_ptr<AllowEarlyTerminationCondition<ValueType>> earlyTermination;
diff --git a/src/solver/NativeMinMaxLinearEquationSolver.cpp b/src/solver/NativeMinMaxLinearEquationSolver.cpp
index 4835de497..44a8e7ba2 100644
--- a/src/solver/NativeMinMaxLinearEquationSolver.cpp
+++ b/src/solver/NativeMinMaxLinearEquationSolver.cpp
@@ -31,7 +31,7 @@ namespace storm {
}
template<typename ValueType>
- void NativeMinMaxLinearEquationSolver<ValueType>::solveEquationSystem(OptimizationDirection dir, std::vector<ValueType>& x, std::vector<ValueType> const& b, std::vector<ValueType>* multiplyResult, std::vector<ValueType>* newX) const {
+ void NativeMinMaxLinearEquationSolver<ValueType>::solveEquationSystem(OptimizationDirection dir, std::vector<ValueType>& x, std::vector<ValueType> const& b, std::vector<ValueType>* multiplyResult, std::vector<ValueType>* newX, std::vector<storm::storage::sparse::state_type>* initialPolicy) const {
if (this->useValueIteration) {
// Set up the environment for the power method. If scratch memory was not provided, we need to create it.
bool multiplyResultMemoryProvided = true;
@@ -45,6 +45,19 @@ namespace storm {
newX = new std::vector<ValueType>(x.size());
xMemoryProvided = false;
}
+
+ if(initialPolicy != nullptr){
+ //Get initial values for x like it is done for policy iteration.
+ storm::storage::SparseMatrix<ValueType> submatrix = this->A.selectRowsFromRowGroups(*initialPolicy, true);
+ submatrix.convertToEquationSystem();
+ NativeLinearEquationSolver<ValueType> nativeLinearEquationSolver(submatrix);
+ std::vector<ValueType> subB(this->A.getRowGroupIndices().size() - 1);
+ storm::utility::vector::selectVectorValues<ValueType>(subB, *initialPolicy, this->A.getRowGroupIndices(), b);
+ // Solve the resulting linear equation system
+ std::vector<ValueType> deterministicMultiplyResult(this->A.getRowGroupIndices().size() - 1);
+ nativeLinearEquationSolver.solveEquationSystem(*currentX, subB, &deterministicMultiplyResult);
+ }
+
uint_fast64_t iterations = 0;
bool converged = false;
@@ -83,6 +96,11 @@ namespace storm {
std::swap(x, *currentX);
}
+ if(this->trackPolicy){
+ this->policy = std::vector<storm::storage::sparse::state_type>(x.size());
+ storm::utility::vector::reduceVectorMinOrMax(dir, *multiplyResult, x, this->A.getRowGroupIndices(), &(this->policy));
+ }
+
if (!xMemoryProvided) {
delete copyX;
}
@@ -91,14 +109,14 @@ namespace storm {
delete multiplyResult;
}
- if(this->trackPolicy){
- this->policy = this->computePolicy(x,b);
- }
-
} else {
// We will use Policy Iteration to solve the given system.
// We first guess an initial choice resolution which will be refined after each iteration.
- this->policy = std::vector<storm::storage::sparse::state_type>(this->A.getRowGroupIndices().size() - 1);
+ if(initialPolicy == nullptr){
+ this->policy = std::vector<storm::storage::sparse::state_type>(this->A.getRowGroupIndices().size() - 1);
+ } else {
+ this->policy = *initialPolicy;
+ }
// Create our own multiplyResult for solving the deterministic sub-instances.
std::vector<ValueType> deterministicMultiplyResult(this->A.getRowGroupIndices().size() - 1);
diff --git a/src/solver/NativeMinMaxLinearEquationSolver.h b/src/solver/NativeMinMaxLinearEquationSolver.h
index 5fcd76aa9..ceaf72fcd 100644
--- a/src/solver/NativeMinMaxLinearEquationSolver.h
+++ b/src/solver/NativeMinMaxLinearEquationSolver.h
@@ -34,7 +34,7 @@ namespace storm {
virtual void performMatrixVectorMultiplication(OptimizationDirection dir, std::vector<ValueType>& x, std::vector<ValueType>* b = nullptr, uint_fast64_t n = 1, std::vector<ValueType>* newX = nullptr) const override;
- virtual void solveEquationSystem(OptimizationDirection dir, std::vector<ValueType>& x, std::vector<ValueType> const& b, std::vector<ValueType>* multiplyResult = nullptr, std::vector<ValueType>* newX = nullptr) const override;
+ virtual void solveEquationSystem(OptimizationDirection dir, std::vector<ValueType>& x, std::vector<ValueType> const& b, std::vector<ValueType>* multiplyResult = nullptr, std::vector<ValueType>* newX = nullptr, std::vector<storm::storage::sparse::state_type>* initialPolicy = nullptr) const override;
};
} // namespace solver
diff --git a/src/solver/TopologicalMinMaxLinearEquationSolver.cpp b/src/solver/TopologicalMinMaxLinearEquationSolver.cpp
index f16c92a07..9fa506bc0 100644
--- a/src/solver/TopologicalMinMaxLinearEquationSolver.cpp
+++ b/src/solver/TopologicalMinMaxLinearEquationSolver.cpp
@@ -46,7 +46,7 @@ namespace storm {
}
template<typename ValueType>
- void TopologicalMinMaxLinearEquationSolver<ValueType>::solveEquationSystem(OptimizationDirection dir, std::vector<ValueType>& x, std::vector<ValueType> const& b, std::vector<ValueType>* multiplyResult, std::vector<ValueType>* newX) const {
+ void TopologicalMinMaxLinearEquationSolver<ValueType>::solveEquationSystem(OptimizationDirection dir, std::vector<ValueType>& x, std::vector<ValueType> const& b, std::vector<ValueType>* multiplyResult, std::vector<ValueType>* newX, std::vector<storm::storage::sparse::state_type>* initialPolicy) const {
#ifdef GPU_USE_FLOAT
#define __FORCE_FLOAT_CALCULATION true
diff --git a/src/solver/TopologicalMinMaxLinearEquationSolver.h b/src/solver/TopologicalMinMaxLinearEquationSolver.h
index 25c325f75..314c8ac58 100644
--- a/src/solver/TopologicalMinMaxLinearEquationSolver.h
+++ b/src/solver/TopologicalMinMaxLinearEquationSolver.h
@@ -43,7 +43,7 @@ namespace storm {
*/
TopologicalMinMaxLinearEquationSolver(storm::storage::SparseMatrix<ValueType> const& A, double precision, uint_fast64_t maximalNumberOfIterations, bool relative = true);
- virtual void solveEquationSystem(OptimizationDirection dir, std::vector<ValueType>& x, std::vector<ValueType> const& b, std::vector<ValueType>* multiplyResult = nullptr, std::vector<ValueType>* newX = nullptr) const override;
+ virtual void solveEquationSystem(OptimizationDirection dir, std::vector<ValueType>& x, std::vector<ValueType> const& b, std::vector<ValueType>* multiplyResult = nullptr, std::vector<ValueType>* newX = nullptr, std::vector<storm::storage::sparse::state_type>* initialPolicy = nullptr) const override;
private:
bool enableCuda;