Browse Source
started working on general min-max solver that uses an underlying linear equation solver. provided necessary factories. adapted code and removed old min-max solvers
started working on general min-max solver that uses an underlying linear equation solver. provided necessary factories. adapted code and removed old min-max solvers
Former-commit-id: c1895472c7
main
dehnert
9 years ago
54 changed files with 817 additions and 1003 deletions
-
2src/counterexamples/MILPMinimalLabelSetGenerator.h
-
5src/counterexamples/SMTMinimalCommandSetGenerator.h
-
4src/modelchecker/csl/SparseMarkovAutomatonCslModelChecker.cpp
-
6src/modelchecker/csl/SparseMarkovAutomatonCslModelChecker.h
-
16src/modelchecker/csl/helper/SparseMarkovAutomatonCslHelper.cpp
-
16src/modelchecker/csl/helper/SparseMarkovAutomatonCslHelper.h
-
4src/modelchecker/prctl/HybridMdpPrctlModelChecker.cpp
-
6src/modelchecker/prctl/HybridMdpPrctlModelChecker.h
-
4src/modelchecker/prctl/SparseMdpPrctlModelChecker.cpp
-
6src/modelchecker/prctl/SparseMdpPrctlModelChecker.h
-
12src/modelchecker/prctl/helper/HybridMdpPrctlHelper.cpp
-
14src/modelchecker/prctl/helper/HybridMdpPrctlHelper.h
-
35src/modelchecker/prctl/helper/SparseMdpPrctlHelper.cpp
-
26src/modelchecker/prctl/helper/SparseMdpPrctlHelper.h
-
10src/settings/modules/CoreSettings.cpp
-
5src/solver/EigenLinearEquationSolver.cpp
-
2src/solver/EigenLinearEquationSolver.h
-
5src/solver/EliminationLinearEquationSolver.cpp
-
2src/solver/EliminationLinearEquationSolver.h
-
5src/solver/GmmxxLinearEquationSolver.cpp
-
2src/solver/GmmxxLinearEquationSolver.h
-
207src/solver/GmmxxMinMaxLinearEquationSolver.cpp
-
53src/solver/GmmxxMinMaxLinearEquationSolver.h
-
57src/solver/LinearEquationSolver.cpp
-
34src/solver/LinearEquationSolver.h
-
131src/solver/MinMaxLinearEquationSolver.cpp
-
153src/solver/MinMaxLinearEquationSolver.h
-
5src/solver/NativeLinearEquationSolver.cpp
-
2src/solver/NativeLinearEquationSolver.h
-
209src/solver/NativeMinMaxLinearEquationSolver.cpp
-
43src/solver/NativeMinMaxLinearEquationSolver.h
-
8src/solver/SolveGoal.cpp
-
5src/solver/SolveGoal.h
-
8src/solver/SolverSelectionOptions.cpp
-
4src/solver/SolverSelectionOptions.h
-
147src/solver/StandardMinMaxLinearEquationSolver.cpp
-
97src/solver/StandardMinMaxLinearEquationSolver.h
-
57src/solver/TopologicalMinMaxLinearEquationSolver.cpp
-
112src/solver/TopologicalMinMaxLinearEquationSolver.h
-
57src/utility/solver.cpp
-
19src/utility/solver.h
-
51src/utility/storm.h
-
10test/functional/modelchecker/GmmxxHybridMdpPrctlModelCheckerTest.cpp
-
18test/functional/modelchecker/GmmxxMdpPrctlModelCheckerTest.cpp
-
10test/functional/modelchecker/NativeHybridMdpPrctlModelCheckerTest.cpp
-
20test/functional/modelchecker/NativeMdpPrctlModelCheckerTest.cpp
-
10test/functional/modelchecker/TopologicalValueIterationMdpPrctlModelCheckerTest.cpp
-
4test/functional/permissiveschedulers/MilpPermissiveSchedulerTest.cpp
-
4test/functional/permissiveschedulers/SmtPermissiveSchedulerTest.cpp
-
49test/functional/solver/GmmxxMinMaxLinearEquationSolverTest.cpp
-
37test/functional/solver/NativeMinMaxLinearEquationSolverTest.cpp
-
4test/performance/modelchecker/GmmxxMdpPrctlModelCheckerTest.cpp
-
4test/performance/modelchecker/NativeMdpPrctlModelCheckerTest.cpp
-
4test/performance/modelchecker/TopologicalValueIterationMdpPrctlModelCheckerTest.cpp
@ -1,207 +0,0 @@ |
|||
#include "src/solver/GmmxxMinMaxLinearEquationSolver.h"
|
|||
|
|||
#include <utility>
|
|||
|
|||
#include "src/settings/SettingsManager.h"
|
|||
#include "src/adapters/GmmxxAdapter.h"
|
|||
#include "src/solver/GmmxxLinearEquationSolver.h"
|
|||
#include "src/storage/TotalScheduler.h"
|
|||
#include "src/utility/vector.h"
|
|||
|
|||
#include "src/settings/modules/GeneralSettings.h"
|
|||
#include "src/settings/modules/GmmxxEquationSolverSettings.h"
|
|||
|
|||
namespace storm { |
|||
namespace solver { |
|||
|
|||
template<typename ValueType> |
|||
GmmxxMinMaxLinearEquationSolver<ValueType>::GmmxxMinMaxLinearEquationSolver(storm::storage::SparseMatrix<ValueType> const& A, MinMaxTechniqueSelection preferredTechnique, bool trackScheduler) : |
|||
MinMaxLinearEquationSolver<ValueType>(A, storm::settings::getModule<storm::settings::modules::GmmxxEquationSolverSettings>().getPrecision(), storm::settings::getModule<storm::settings::modules::GmmxxEquationSolverSettings>().getConvergenceCriterion() == storm::settings::modules::GmmxxEquationSolverSettings::ConvergenceCriterion::Relative, storm::settings::getModule<storm::settings::modules::GmmxxEquationSolverSettings>().getMaximalIterationCount(), trackScheduler, preferredTechnique), gmmxxMatrix(storm::adapters::GmmxxAdapter::toGmmxxSparseMatrix<ValueType>(A)), rowGroupIndices(A.getRowGroupIndices()) { |
|||
// Intentionally left empty.
|
|||
} |
|||
|
|||
template<typename ValueType> |
|||
GmmxxMinMaxLinearEquationSolver<ValueType>::GmmxxMinMaxLinearEquationSolver(storm::storage::SparseMatrix<ValueType> const& A, double precision, uint_fast64_t maximalNumberOfIterations, MinMaxTechniqueSelection tech, bool relative, bool trackScheduler) : MinMaxLinearEquationSolver<ValueType>(A, precision, relative, maximalNumberOfIterations, trackScheduler, tech), gmmxxMatrix(storm::adapters::GmmxxAdapter::toGmmxxSparseMatrix<ValueType>(A)), rowGroupIndices(A.getRowGroupIndices()) { |
|||
// Intentionally left empty.
|
|||
} |
|||
|
|||
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 { |
|||
if (this->useValueIteration) { |
|||
STORM_LOG_THROW(!this->isTrackSchedulerSet(), storm::exceptions::InvalidSettingsException, "Unable to produce a scheduler when using value iteration. Use policy iteration instead."); |
|||
|
|||
// Set up the environment for the power method. If scratch memory was not provided, we need to create it.
|
|||
bool multiplyResultMemoryProvided = true; |
|||
if (multiplyResult == nullptr) { |
|||
multiplyResult = new std::vector<ValueType>(b.size()); |
|||
multiplyResultMemoryProvided = false; |
|||
} |
|||
|
|||
std::vector<ValueType>* currentX = &x; |
|||
bool xMemoryProvided = true; |
|||
if (newX == nullptr) { |
|||
newX = new std::vector<ValueType>(x.size()); |
|||
xMemoryProvided = false; |
|||
} |
|||
uint_fast64_t iterations = 0; |
|||
bool converged = false; |
|||
|
|||
// Keep track of which of the vectors for x is the auxiliary copy.
|
|||
std::vector<ValueType>* copyX = newX; |
|||
|
|||
// Proceed with the iterations as long as the method did not converge or reach the user-specified maximum number
|
|||
// of iterations.
|
|||
while (!converged && iterations < this->maximalNumberOfIterations) { |
|||
// Compute x' = A*x + b.
|
|||
gmm::mult(*gmmxxMatrix, *currentX, *multiplyResult); |
|||
gmm::add(b, *multiplyResult); |
|||
|
|||
// Reduce the vector x by applying min/max over all nondeterministic choices.
|
|||
storm::utility::vector::reduceVectorMinOrMax(dir, *multiplyResult, *newX, rowGroupIndices); |
|||
|
|||
// Determine whether the method converged.
|
|||
converged = storm::utility::vector::equalModuloPrecision(*currentX, *newX, this->precision, this->relative) || (this->hasCustomTerminationCondition() && this->getTerminationCondition().terminateNow(*newX)); |
|||
|
|||
// Update environment variables.
|
|||
std::swap(currentX, newX); |
|||
++iterations; |
|||
} |
|||
|
|||
// Check if the solver converged and issue a warning otherwise.
|
|||
if (converged) { |
|||
STORM_LOG_INFO("Iterative solver converged after " << iterations << " iterations."); |
|||
} else { |
|||
STORM_LOG_WARN("Iterative solver did not converge after " << iterations << " iterations."); |
|||
} |
|||
|
|||
// If we performed an odd number of iterations, we need to swap the x and currentX, because the newest result
|
|||
// is currently stored in currentX, but x is the output vector.
|
|||
if (currentX == copyX) { |
|||
std::swap(x, *currentX); |
|||
} |
|||
|
|||
if (!xMemoryProvided) { |
|||
delete copyX; |
|||
} |
|||
|
|||
if (!multiplyResultMemoryProvided) { |
|||
delete multiplyResult; |
|||
} |
|||
} 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.
|
|||
std::vector<storm::storage::sparse::state_type> scheduler(this->A.getRowGroupIndices().size() - 1); |
|||
|
|||
// Create our own multiplyResult for solving the deterministic sub-instances.
|
|||
std::vector<ValueType> deterministicMultiplyResult(rowGroupIndices.size() - 1); |
|||
std::vector<ValueType> subB(rowGroupIndices.size() - 1); |
|||
|
|||
bool multiplyResultMemoryProvided = true; |
|||
if (multiplyResult == nullptr) { |
|||
multiplyResult = new std::vector<ValueType>(b.size()); |
|||
multiplyResultMemoryProvided = false; |
|||
} |
|||
|
|||
std::vector<ValueType>* currentX = &x; |
|||
bool xMemoryProvided = true; |
|||
if (newX == nullptr) { |
|||
newX = new std::vector<ValueType>(x.size()); |
|||
xMemoryProvided = false; |
|||
} |
|||
|
|||
uint_fast64_t iterations = 0; |
|||
bool converged = false; |
|||
|
|||
// Keep track of which of the vectors for x is the auxiliary copy.
|
|||
std::vector<ValueType>* copyX = newX; |
|||
|
|||
// Proceed with the iterations as long as the method did not converge or reach the user-specified maximum number
|
|||
// of iterations.
|
|||
while (!converged && iterations < this->maximalNumberOfIterations && !(this->hasCustomTerminationCondition() && this->getTerminationCondition().terminateNow(*currentX))) { |
|||
// Take the sub-matrix according to the current choices
|
|||
storm::storage::SparseMatrix<ValueType> submatrix = this->A.selectRowsFromRowGroups(scheduler, true); |
|||
submatrix.convertToEquationSystem(); |
|||
|
|||
GmmxxLinearEquationSolver<ValueType> gmmxxLinearEquationSolver(submatrix); |
|||
|
|||
storm::utility::vector::selectVectorValues<ValueType>(subB, scheduler, rowGroupIndices, b); |
|||
|
|||
// Copy X since we will overwrite it
|
|||
std::copy(currentX->begin(), currentX->end(), newX->begin()); |
|||
|
|||
// Solve the resulting linear equation system
|
|||
gmmxxLinearEquationSolver.solveEquationSystem(*newX, subB, &deterministicMultiplyResult); |
|||
|
|||
// Compute x' = A*x + b. This step is necessary to allow the choosing of the optimal policy for the next iteration.
|
|||
gmm::mult(*gmmxxMatrix, *newX, *multiplyResult); |
|||
gmm::add(b, *multiplyResult); |
|||
|
|||
// Reduce the vector x by applying min/max over all nondeterministic choices.
|
|||
// Here, we capture which choice was taken in each state, thereby refining our initial guess.
|
|||
storm::utility::vector::reduceVectorMinOrMax(dir, *multiplyResult, *newX, rowGroupIndices, &(scheduler)); |
|||
|
|||
// Determine whether the method converged.
|
|||
converged = storm::utility::vector::equalModuloPrecision<ValueType>(*currentX, *newX, static_cast<ValueType>(this->precision), this->relative); |
|||
|
|||
// Update environment variables.
|
|||
std::swap(currentX, newX); |
|||
++iterations; |
|||
} |
|||
|
|||
// Check if the solver converged and issue a warning otherwise.
|
|||
if (converged) { |
|||
STORM_LOG_INFO("Iterative solver converged after " << iterations << " iterations."); |
|||
} else { |
|||
STORM_LOG_WARN("Iterative solver did not converge after " << iterations << " iterations."); |
|||
} |
|||
|
|||
// If requested, we store the scheduler for retrieval.
|
|||
if (this->isTrackSchedulerSet()) { |
|||
this->scheduler = std::make_unique<storm::storage::TotalScheduler>(std::move(scheduler)); |
|||
} |
|||
|
|||
// If we performed an odd number of iterations, we need to swap the x and currentX, because the newest result
|
|||
// is currently stored in currentX, but x is the output vector.
|
|||
if (currentX == copyX) { |
|||
std::swap(x, *currentX); |
|||
} |
|||
|
|||
if (!xMemoryProvided) { |
|||
delete copyX; |
|||
} |
|||
|
|||
if (!multiplyResultMemoryProvided) { |
|||
delete multiplyResult; |
|||
} |
|||
} |
|||
} |
|||
|
|||
template<typename ValueType> |
|||
void GmmxxMinMaxLinearEquationSolver<ValueType>::performMatrixVectorMultiplication(OptimizationDirection dir, std::vector<ValueType>& x, std::vector<ValueType>* b, uint_fast64_t n, std::vector<ValueType>* multiplyResult) const { |
|||
bool multiplyResultMemoryProvided = true; |
|||
if (multiplyResult == nullptr) { |
|||
multiplyResult = new std::vector<ValueType>(gmmxxMatrix->nr); |
|||
multiplyResultMemoryProvided = false; |
|||
} |
|||
|
|||
// Now perform matrix-vector multiplication as long as we meet the bound of the formula.
|
|||
for (uint_fast64_t i = 0; i < n; ++i) { |
|||
gmm::mult(*gmmxxMatrix, x, *multiplyResult); |
|||
|
|||
if (b != nullptr) { |
|||
gmm::add(*b, *multiplyResult); |
|||
} |
|||
|
|||
storm::utility::vector::reduceVectorMinOrMax(dir, *multiplyResult, x, rowGroupIndices); |
|||
|
|||
} |
|||
|
|||
if (!multiplyResultMemoryProvided) { |
|||
delete multiplyResult; |
|||
} |
|||
} |
|||
|
|||
// Explicitly instantiate the solver.
|
|||
template class GmmxxMinMaxLinearEquationSolver<double>; |
|||
} // namespace solver
|
|||
} // namespace storm
|
|||
@ -1,53 +0,0 @@ |
|||
#ifndef STORM_SOLVER_GMMXXMINMAXLINEAREQUATIONSOLVER_H_ |
|||
#define STORM_SOLVER_GMMXXMINMAXLINEAREQUATIONSOLVER_H_ |
|||
|
|||
#include <memory> |
|||
|
|||
#include "src/utility/gmm.h" |
|||
|
|||
#include "src/solver/MinMaxLinearEquationSolver.h" |
|||
|
|||
namespace storm { |
|||
namespace solver { |
|||
|
|||
/*! |
|||
* A class that uses the gmm++ library to implement the MinMaxLinearEquationSolver interface. |
|||
*/ |
|||
template<class ValueType> |
|||
class GmmxxMinMaxLinearEquationSolver : public MinMaxLinearEquationSolver<ValueType> { |
|||
public: |
|||
/*! |
|||
* Constructs a min/max linear equation solver with parameters being set according to the settings |
|||
* object. |
|||
* |
|||
* @param A The matrix defining the coefficients of the linear equation system. |
|||
*/ |
|||
GmmxxMinMaxLinearEquationSolver(storm::storage::SparseMatrix<ValueType> const& A, MinMaxTechniqueSelection preferredTechnique = MinMaxTechniqueSelection::FROMSETTINGS, bool trackScheduler = false); |
|||
|
|||
/*! |
|||
* Constructs a min/max linear equation solver with the given parameters. |
|||
* |
|||
* @param A The matrix defining the coefficients of the linear equation system. |
|||
* @param precision The precision to use for convergence detection. |
|||
* @param maximalNumberOfIterations The maximal number of iterations do perform before iteration is aborted. |
|||
* @param relative If set, the relative error rather than the absolute error is considered for convergence |
|||
* detection. |
|||
*/ |
|||
GmmxxMinMaxLinearEquationSolver(storm::storage::SparseMatrix<ValueType> const& A, double precision, uint_fast64_t maximalNumberOfIterations, MinMaxTechniqueSelection tech, bool relative, bool trackScheduler = false); |
|||
|
|||
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; |
|||
|
|||
private: |
|||
// The (gmm++) matrix associated with this equation solver. |
|||
std::unique_ptr<gmm::csr_matrix<ValueType>> gmmxxMatrix; |
|||
|
|||
// A reference to the row group indices of the original matrix. |
|||
std::vector<uint_fast64_t> const& rowGroupIndices; |
|||
|
|||
}; |
|||
} // namespace solver |
|||
} // namespace storm |
|||
|
|||
#endif /* STORM_SOLVER_GMMXXMINMAXLINEAREQUATIONSOLVER_H_ */ |
|||
@ -1,62 +1,139 @@ |
|||
#include "MinMaxLinearEquationSolver.h"
|
|||
#include "src/solver/MinMaxLinearEquationSolver.h"
|
|||
|
|||
#include <cstdint>
|
|||
|
|||
#include "src/solver/LinearEquationSolver.h"
|
|||
#include "src/solver/StandardMinMaxLinearEquationSolver.h"
|
|||
#include "src/solver/TopologicalMinMaxLinearEquationSolver.h"
|
|||
|
|||
#include "src/settings/SettingsManager.h"
|
|||
#include "src/settings/modules/CoreSettings.h"
|
|||
|
|||
#include "src/utility/macros.h"
|
|||
#include "src/exceptions/NotImplementedException.h"
|
|||
#include <cstdint>
|
|||
#include "src/exceptions/InvalidSettingsException.h"
|
|||
#include "src/exceptions/IllegalFunctionCallException.h"
|
|||
|
|||
namespace storm { |
|||
namespace solver { |
|||
|
|||
template<typename ValueType> |
|||
AbstractMinMaxLinearEquationSolver<ValueType>::AbstractMinMaxLinearEquationSolver(double precision, bool relativeError, uint_fast64_t maximalIterations, bool trackScheduler, MinMaxTechniqueSelection prefTech) : precision(precision), relative(relativeError), maximalNumberOfIterations(maximalIterations), trackScheduler(trackScheduler) { |
|||
|
|||
if(prefTech == MinMaxTechniqueSelection::FROMSETTINGS) { |
|||
useValueIteration = (storm::settings::getModule<storm::settings::modules::CoreSettings>().getMinMaxEquationSolvingTechnique() == storm::solver::MinMaxTechnique::ValueIteration); |
|||
} else { |
|||
useValueIteration = (prefTech == MinMaxTechniqueSelection::ValueIteration); |
|||
} |
|||
MinMaxLinearEquationSolver<ValueType>::MinMaxLinearEquationSolver(OptimizationDirectionSetting direction) : direction(direction), trackScheduler(false) { |
|||
// Intentionally left empty.
|
|||
} |
|||
|
|||
template<typename ValueType> |
|||
void AbstractMinMaxLinearEquationSolver<ValueType>::setTrackScheduler(bool trackScheduler) { |
|||
this->trackScheduler = trackScheduler; |
|||
MinMaxLinearEquationSolver<ValueType>::~MinMaxLinearEquationSolver() { |
|||
// Intentionally left empty.
|
|||
} |
|||
|
|||
template<typename ValueType> |
|||
void MinMaxLinearEquationSolver<ValueType>::solveEquationSystem(std::vector<ValueType>& x, std::vector<ValueType> const& b, std::vector<ValueType>* multiplyResult, std::vector<ValueType>* newX) const { |
|||
STORM_LOG_THROW(isSet(this->direction), storm::exceptions::IllegalFunctionCallException, "Optimization direction not set."); |
|||
solveEquationSystem(convert(this->direction), x, b, multiplyResult, newX); |
|||
} |
|||
|
|||
template<typename ValueType> |
|||
void MinMaxLinearEquationSolver<ValueType>::performMatrixVectorMultiplication( std::vector<ValueType>& x, std::vector<ValueType>* b, uint_fast64_t n, std::vector<ValueType>* multiplyResult) const { |
|||
STORM_LOG_THROW(isSet(this->direction), storm::exceptions::IllegalFunctionCallException, "Optimization direction not set."); |
|||
return performMatrixVectorMultiplication(convert(this->direction), x, b, n, multiplyResult); |
|||
} |
|||
|
|||
template<typename ValueType> |
|||
void MinMaxLinearEquationSolver<ValueType>::setOptimizationDirection(OptimizationDirection d) { |
|||
direction = convert(d); |
|||
} |
|||
|
|||
template<typename ValueType> |
|||
bool AbstractMinMaxLinearEquationSolver<ValueType>::hasScheduler() const { |
|||
return static_cast<bool>(scheduler); |
|||
void MinMaxLinearEquationSolver<ValueType>::unsetOptimizationDirection() { |
|||
direction = OptimizationDirectionSetting::Unset; |
|||
} |
|||
|
|||
template<typename ValueType> |
|||
void MinMaxLinearEquationSolver<ValueType>::setTrackScheduler(bool trackScheduler) { |
|||
this->trackScheduler = trackScheduler; |
|||
if (!this->trackScheduler) { |
|||
scheduler = boost::none; |
|||
} |
|||
} |
|||
|
|||
template<typename ValueType> |
|||
bool AbstractMinMaxLinearEquationSolver<ValueType>::isTrackSchedulerSet() const { |
|||
bool MinMaxLinearEquationSolver<ValueType>::isTrackSchedulerSet() const { |
|||
return this->trackScheduler; |
|||
} |
|||
|
|||
template<typename ValueType> |
|||
storm::storage::TotalScheduler const& AbstractMinMaxLinearEquationSolver<ValueType>::getScheduler() const { |
|||
STORM_LOG_THROW(scheduler, storm::exceptions::InvalidSettingsException, "Cannot retrieve scheduler, because none was generated."); |
|||
return *scheduler.get(); |
|||
bool MinMaxLinearEquationSolver<ValueType>::hasScheduler() const { |
|||
return static_cast<bool>(scheduler); |
|||
} |
|||
|
|||
|
|||
template<typename ValueType> |
|||
storm::storage::TotalScheduler& AbstractMinMaxLinearEquationSolver<ValueType>::getScheduler() { |
|||
STORM_LOG_THROW(scheduler, storm::exceptions::InvalidSettingsException, "Cannot retrieve scheduler, because none was generated."); |
|||
storm::storage::TotalScheduler const& MinMaxLinearEquationSolver<ValueType>::getScheduler() const { |
|||
STORM_LOG_THROW(scheduler, storm::exceptions::IllegalFunctionCallException, "Cannot retrieve scheduler, because none was generated."); |
|||
return *scheduler.get(); |
|||
} |
|||
|
|||
template<typename ValueType> |
|||
void AbstractMinMaxLinearEquationSolver<ValueType>::setOptimizationDirection(OptimizationDirection d) { |
|||
direction = convert(d); |
|||
std::unique_ptr<storm::storage::TotalScheduler> MinMaxLinearEquationSolver<ValueType>::getScheduler() { |
|||
STORM_LOG_THROW(scheduler, storm::exceptions::IllegalFunctionCallException, "Cannot retrieve scheduler, because none was generated."); |
|||
return std::move(scheduler.get()); |
|||
} |
|||
|
|||
template<typename ValueType> |
|||
void AbstractMinMaxLinearEquationSolver<ValueType>::resetOptimizationDirection() { |
|||
direction = OptimizationDirectionSetting::Unset; |
|||
MinMaxLinearEquationSolverFactory<ValueType>::MinMaxLinearEquationSolverFactory(bool trackScheduler) : trackScheduler(trackScheduler) { |
|||
// Intentionally left empty.
|
|||
} |
|||
|
|||
template class AbstractMinMaxLinearEquationSolver<float>; |
|||
template class AbstractMinMaxLinearEquationSolver<double>; |
|||
|
|||
template<typename ValueType> |
|||
std::unique_ptr<MinMaxLinearEquationSolver<ValueType>> MinMaxLinearEquationSolverFactory<ValueType>::create(storm::storage::SparseMatrix<ValueType>&& matrix) const { |
|||
return this->create(matrix); |
|||
} |
|||
|
|||
template<typename ValueType> |
|||
void MinMaxLinearEquationSolverFactory<ValueType>::setTrackScheduler(bool value) { |
|||
this->trackScheduler = value; |
|||
} |
|||
|
|||
template<typename ValueType> |
|||
bool MinMaxLinearEquationSolverFactory<ValueType>::isTrackSchedulerSet() const { |
|||
return trackScheduler; |
|||
} |
|||
|
|||
template<typename ValueType> |
|||
GeneralMinMaxLinearEquationSolverFactory<ValueType>::GeneralMinMaxLinearEquationSolverFactory(bool trackScheduler) : MinMaxLinearEquationSolverFactory<ValueType>(trackScheduler) { |
|||
// Intentionally left empty.
|
|||
} |
|||
|
|||
template<typename ValueType> |
|||
std::unique_ptr<MinMaxLinearEquationSolver<ValueType>> GeneralMinMaxLinearEquationSolverFactory<ValueType>::create(storm::storage::SparseMatrix<ValueType> const& matrix) const { |
|||
return selectSolver(matrix); |
|||
} |
|||
|
|||
template<typename ValueType> |
|||
std::unique_ptr<MinMaxLinearEquationSolver<ValueType>> GeneralMinMaxLinearEquationSolverFactory<ValueType>::create(storm::storage::SparseMatrix<ValueType>&& matrix) const { |
|||
return selectSolver(std::move(matrix)); |
|||
} |
|||
|
|||
template<typename ValueType> |
|||
template<typename MatrixType> |
|||
std::unique_ptr<MinMaxLinearEquationSolver<ValueType>> GeneralMinMaxLinearEquationSolverFactory<ValueType>::selectSolver(MatrixType&& matrix) const { |
|||
std::unique_ptr<MinMaxLinearEquationSolver<ValueType>> result; |
|||
auto technique = storm::settings::getModule<storm::settings::modules::CoreSettings>().getMinMaxEquationSolvingTechnique(); |
|||
if (technique == MinMaxTechnique::ValueIteration || technique == MinMaxTechnique::PolicyIteration) { |
|||
result = std::make_unique<StandardMinMaxLinearEquationSolver<ValueType>>(std::forward<MatrixType>(matrix), std::make_unique<GeneralLinearEquationSolverFactory<ValueType>>()); |
|||
} else if (technique == MinMaxTechnique::Topological) { |
|||
result = std::make_unique<TopologicalMinMaxLinearEquationSolver<ValueType>>(std::forward<MatrixType>(matrix)); |
|||
} else { |
|||
STORM_LOG_THROW(false, storm::exceptions::InvalidSettingsException, "Unsupported technique."); |
|||
} |
|||
return result; |
|||
} |
|||
|
|||
template class MinMaxLinearEquationSolver<float>; |
|||
template class MinMaxLinearEquationSolver<double>; |
|||
|
|||
template class MinMaxLinearEquationSolverFactory<double>; |
|||
template class GeneralMinMaxLinearEquationSolverFactory<double>; |
|||
|
|||
} |
|||
} |
|||
@ -1,209 +0,0 @@ |
|||
#include "src/solver/NativeMinMaxLinearEquationSolver.h"
|
|||
|
|||
#include <utility>
|
|||
|
|||
#include "src/storage/TotalScheduler.h"
|
|||
|
|||
#include "src/settings/SettingsManager.h"
|
|||
#include "src/settings/modules/NativeEquationSolverSettings.h"
|
|||
#include "src/settings/modules/GeneralSettings.h"
|
|||
#include "src/utility/vector.h"
|
|||
#include "src/solver/NativeLinearEquationSolver.h"
|
|||
|
|||
namespace storm { |
|||
namespace solver { |
|||
|
|||
template<typename ValueType> |
|||
NativeMinMaxLinearEquationSolver<ValueType>::NativeMinMaxLinearEquationSolver(storm::storage::SparseMatrix<ValueType> const& A, MinMaxTechniqueSelection preferredTechnique, bool trackScheduler) : MinMaxLinearEquationSolver<ValueType>(A, storm::settings::getModule<storm::settings::modules::NativeEquationSolverSettings>().getPrecision(), storm::settings::getModule<storm::settings::modules::NativeEquationSolverSettings>().getConvergenceCriterion() == storm::settings::modules::NativeEquationSolverSettings::ConvergenceCriterion::Relative, storm::settings::getModule<storm::settings::modules::NativeEquationSolverSettings>().getMaximalIterationCount(), trackScheduler, preferredTechnique) { |
|||
// Intentionally left empty.
|
|||
} |
|||
|
|||
template<typename ValueType> |
|||
NativeMinMaxLinearEquationSolver<ValueType>::NativeMinMaxLinearEquationSolver(storm::storage::SparseMatrix<ValueType> const& A, double precision, uint_fast64_t maximalNumberOfIterations, MinMaxTechniqueSelection tech, bool relative, bool trackScheduler) : MinMaxLinearEquationSolver<ValueType>(A, precision, relative, maximalNumberOfIterations, trackScheduler, tech) { |
|||
// Intentionally left empty.
|
|||
} |
|||
|
|||
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 { |
|||
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; |
|||
if (multiplyResult == nullptr) { |
|||
multiplyResult = new std::vector<ValueType>(this->A.getRowCount()); |
|||
multiplyResultMemoryProvided = false; |
|||
} |
|||
std::vector<ValueType>* currentX = &x; |
|||
bool xMemoryProvided = true; |
|||
if (newX == nullptr) { |
|||
newX = new std::vector<ValueType>(x.size()); |
|||
xMemoryProvided = false; |
|||
} |
|||
uint_fast64_t iterations = 0; |
|||
bool converged = false; |
|||
|
|||
// Keep track of which of the vectors for x is the auxiliary copy.
|
|||
std::vector<ValueType>* copyX = newX; |
|||
|
|||
// Proceed with the iterations as long as the method did not converge or reach the
|
|||
// user-specified maximum number of iterations.
|
|||
while (!converged && iterations < this->maximalNumberOfIterations && (!this->hasCustomTerminationCondition() || this->getTerminationCondition().terminateNow(*currentX))) { |
|||
// Compute x' = A*x + b.
|
|||
this->A.multiplyWithVector(*currentX, *multiplyResult); |
|||
storm::utility::vector::addVectors(*multiplyResult, b, *multiplyResult); |
|||
|
|||
// Reduce the vector x' by applying min/max for all non-deterministic choices as given by the topmost
|
|||
// element of the min/max operator stack.
|
|||
storm::utility::vector::reduceVectorMinOrMax(dir, *multiplyResult, *newX, this->A.getRowGroupIndices()); |
|||
|
|||
// Determine whether the method converged.
|
|||
converged = storm::utility::vector::equalModuloPrecision<ValueType>(*currentX, *newX, static_cast<ValueType>(this->precision), this->relative); |
|||
|
|||
// Update environment variables.
|
|||
std::swap(currentX, newX); |
|||
++iterations; |
|||
} |
|||
|
|||
// Check if the solver converged and issue a warning otherwise.
|
|||
if (converged) { |
|||
STORM_LOG_INFO("Iterative solver converged after " << iterations << " iterations."); |
|||
} else { |
|||
STORM_LOG_WARN("Iterative solver did not converge after " << iterations << " iterations."); |
|||
} |
|||
|
|||
// If we performed an odd number of iterations, we need to swap the x and currentX, because the newest result
|
|||
// is currently stored in currentX, but x is the output vector.
|
|||
if (currentX == copyX) { |
|||
std::swap(x, *currentX); |
|||
} |
|||
|
|||
if (!xMemoryProvided) { |
|||
delete copyX; |
|||
} |
|||
|
|||
if (!multiplyResultMemoryProvided) { |
|||
delete multiplyResult; |
|||
} |
|||
} 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.
|
|||
std::vector<storm::storage::sparse::state_type> scheduler(this->A.getRowGroupIndices().size() - 1); |
|||
|
|||
// Create our own multiplyResult for solving the deterministic sub-instances.
|
|||
std::vector<ValueType> deterministicMultiplyResult(this->A.getRowGroupIndices().size() - 1); |
|||
std::vector<ValueType> subB(this->A.getRowGroupIndices().size() - 1); |
|||
|
|||
// Check whether intermediate storage was provided and create it otherwise.
|
|||
bool multiplyResultMemoryProvided = true; |
|||
if (multiplyResult == nullptr) { |
|||
multiplyResult = new std::vector<ValueType>(b.size()); |
|||
multiplyResultMemoryProvided = false; |
|||
} |
|||
|
|||
std::vector<ValueType>* currentX = &x; |
|||
bool xMemoryProvided = true; |
|||
if (newX == nullptr) { |
|||
newX = new std::vector<ValueType>(x.size()); |
|||
xMemoryProvided = false; |
|||
} |
|||
|
|||
uint_fast64_t iterations = 0; |
|||
bool converged = false; |
|||
|
|||
// Keep track of which of the vectors for x is the auxiliary copy.
|
|||
std::vector<ValueType>* copyX = newX; |
|||
|
|||
// Proceed with the iterations as long as the method did not converge or reach the user-specified maximum number
|
|||
// of iterations.
|
|||
while (!converged && iterations < this->maximalNumberOfIterations && !(this->hasCustomTerminationCondition() && this->getTerminationCondition().terminateNow(*currentX))) { |
|||
// Take the sub-matrix according to the current choices
|
|||
storm::storage::SparseMatrix<ValueType> submatrix = this->A.selectRowsFromRowGroups(scheduler, true); |
|||
submatrix.convertToEquationSystem(); |
|||
|
|||
NativeLinearEquationSolver<ValueType> nativeLinearEquationSolver(submatrix); |
|||
storm::utility::vector::selectVectorValues<ValueType>(subB, scheduler, this->A.getRowGroupIndices(), b); |
|||
|
|||
// Copy X since we will overwrite it
|
|||
std::copy(currentX->begin(), currentX->end(), newX->begin()); |
|||
|
|||
// Solve the resulting linear equation system of the sub-instance for x under the current choices
|
|||
nativeLinearEquationSolver.solveEquationSystem(*newX, subB, &deterministicMultiplyResult); |
|||
|
|||
// Compute x' = A*x + b. This step is necessary to allow the choosing of the optimal policy for the next iteration.
|
|||
this->A.multiplyWithVector(*newX, *multiplyResult); |
|||
storm::utility::vector::addVectors(*multiplyResult, b, *multiplyResult); |
|||
|
|||
// Reduce the vector x by applying min/max over all nondeterministic choices.
|
|||
// Here, we capture which choice was taken in each state, thereby refining our initial guess.
|
|||
storm::utility::vector::reduceVectorMinOrMax(dir, *multiplyResult, *newX, this->A.getRowGroupIndices(), &(scheduler)); |
|||
|
|||
|
|||
// Determine whether the method converged.
|
|||
converged = storm::utility::vector::equalModuloPrecision<ValueType>(*currentX, *newX, static_cast<ValueType>(this->precision), this->relative); |
|||
|
|||
// Update environment variables.
|
|||
std::swap(currentX, newX); |
|||
++iterations; |
|||
} |
|||
|
|||
// Check if the solver converged and issue a warning otherwise.
|
|||
if (converged) { |
|||
STORM_LOG_INFO("Iterative solver converged after " << iterations << " iterations."); |
|||
} else { |
|||
STORM_LOG_WARN("Iterative solver did not converge after " << iterations << " iterations."); |
|||
} |
|||
|
|||
// If requested, we store the scheduler for retrieval.
|
|||
if (this->isTrackSchedulerSet()) { |
|||
this->scheduler = std::make_unique<storm::storage::TotalScheduler>(std::move(scheduler)); |
|||
} |
|||
|
|||
// If we performed an odd number of iterations, we need to swap the x and currentX, because the newest result
|
|||
// is currently stored in currentX, but x is the output vector.
|
|||
if (currentX == copyX) { |
|||
std::swap(x, *currentX); |
|||
} |
|||
|
|||
if (!xMemoryProvided) { |
|||
delete copyX; |
|||
} |
|||
|
|||
if (!multiplyResultMemoryProvided) { |
|||
delete multiplyResult; |
|||
} |
|||
} |
|||
} |
|||
|
|||
template<typename ValueType> |
|||
void NativeMinMaxLinearEquationSolver<ValueType>::performMatrixVectorMultiplication(OptimizationDirection dir, std::vector<ValueType>& x, std::vector<ValueType>* b, uint_fast64_t n, std::vector<ValueType>* multiplyResult) const { |
|||
|
|||
// If scratch memory was not provided, we need to create it.
|
|||
bool multiplyResultMemoryProvided = true; |
|||
if (multiplyResult == nullptr) { |
|||
multiplyResult = new std::vector<ValueType>(this->A.getRowCount()); |
|||
multiplyResultMemoryProvided = false; |
|||
} |
|||
|
|||
// Now perform matrix-vector multiplication as long as we meet the bound of the formula.
|
|||
for (uint_fast64_t i = 0; i < n; ++i) { |
|||
this->A.multiplyWithVector(x, *multiplyResult); |
|||
|
|||
// Add b if it is non-null.
|
|||
if (b != nullptr) { |
|||
storm::utility::vector::addVectors(*multiplyResult, *b, *multiplyResult); |
|||
} |
|||
|
|||
// Reduce the vector x' by applying min/max for all non-deterministic choices as given by the topmost
|
|||
// element of the min/max operator stack.
|
|||
storm::utility::vector::reduceVectorMinOrMax(dir, *multiplyResult, x, this->A.getRowGroupIndices()); |
|||
|
|||
} |
|||
|
|||
if (!multiplyResultMemoryProvided) { |
|||
delete multiplyResult; |
|||
} |
|||
} |
|||
|
|||
// Explicitly instantiate the solver.
|
|||
template class NativeMinMaxLinearEquationSolver<double>; |
|||
} // namespace solver
|
|||
} // namespace storm
|
|||
@ -1,43 +0,0 @@ |
|||
#ifndef STORM_SOLVER_NATIVEMINMAXLINEAREQUATIONSOLVER_H_ |
|||
#define STORM_SOLVER_NATIVEMINMAXLINEAREQUATIONSOLVER_H_ |
|||
|
|||
#include <cstdint> |
|||
#include "src/solver/MinMaxLinearEquationSolver.h" |
|||
|
|||
namespace storm { |
|||
namespace solver { |
|||
|
|||
/*! |
|||
* A class that uses the gmm++ library to implement the MinMaxLinearEquationSolver interface. |
|||
*/ |
|||
template<class ValueType> |
|||
class NativeMinMaxLinearEquationSolver : public MinMaxLinearEquationSolver<ValueType> { |
|||
public: |
|||
/*! |
|||
* Constructs a min/max linear equation solver with parameters being set according to the settings |
|||
* object. |
|||
* |
|||
* @param A The matrix defining the coefficients of the linear equation system. |
|||
*/ |
|||
NativeMinMaxLinearEquationSolver(storm::storage::SparseMatrix<ValueType> const& A, MinMaxTechniqueSelection preferredTechnique = MinMaxTechniqueSelection::FROMSETTINGS, bool trackScheduler = false); |
|||
|
|||
/*! |
|||
* Constructs a min/max linear equation solver with the given parameters. |
|||
* |
|||
* @param A The matrix defining the coefficients of the linear equation system. |
|||
* @param precision The precision to use for convergence detection. |
|||
* @param maximalNumberOfIterations The maximal number of iterations do perform before iteration is aborted. |
|||
* @param relative If set, the relative error rather than the absolute error is considered for convergence |
|||
* detection. |
|||
*/ |
|||
NativeMinMaxLinearEquationSolver(storm::storage::SparseMatrix<ValueType> const& A, double precision, uint_fast64_t maximalNumberOfIterations, MinMaxTechniqueSelection tech, bool relative = true, bool trackScheduler = false); |
|||
|
|||
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; |
|||
|
|||
}; |
|||
} // namespace solver |
|||
} // namespace storm |
|||
|
|||
#endif /* STORM_SOLVER_NATIVEMINMAXLINEAREQUATIONSOLVER_H_ */ |
|||
@ -0,0 +1,147 @@ |
|||
#include "src/solver/StandardMinMaxLinearEquationSolver.h"
|
|||
|
|||
#include "src/settings/SettingsManager.h"
|
|||
#include "src/settings/modules/CoreSettings.h"
|
|||
|
|||
#include "src/solver/GmmxxLinearEquationSolver.h"
|
|||
#include "src/solver/EigenLinearEquationSolver.h"
|
|||
#include "src/solver/NativeLinearEquationSolver.h"
|
|||
#include "src/solver/EliminationLinearEquationSolver.h"
|
|||
|
|||
#include "src/utility/macros.h"
|
|||
#include "src/exceptions/InvalidSettingsException.h"
|
|||
|
|||
namespace storm { |
|||
namespace solver { |
|||
|
|||
StandardMinMaxLinearEquationSolverSettings::StandardMinMaxLinearEquationSolverSettings() { |
|||
auto technique = storm::settings::getModule<storm::settings::modules::CoreSettings>().getMinMaxEquationSolvingTechnique(); |
|||
switch (technique) { |
|||
case MinMaxTechnique::ValueIteration: this->solutionMethod = SolutionMethod::ValueIteration; break; |
|||
case MinMaxTechnique::PolicyIteration: this->solutionMethod = SolutionMethod::PolicyIteration; break; |
|||
default: |
|||
STORM_LOG_THROW(false, storm::exceptions::InvalidSettingsException, "Unsupported technique."); |
|||
} |
|||
} |
|||
|
|||
void StandardMinMaxLinearEquationSolverSettings::setSolutionMethod(SolutionMethod const& solutionMethod) { |
|||
this->solutionMethod = solutionMethod; |
|||
} |
|||
|
|||
StandardMinMaxLinearEquationSolverSettings::SolutionMethod const& StandardMinMaxLinearEquationSolverSettings::getSolutionMethod() const { |
|||
return solutionMethod; |
|||
} |
|||
|
|||
template<typename ValueType> |
|||
StandardMinMaxLinearEquationSolver<ValueType>::StandardMinMaxLinearEquationSolver(storm::storage::SparseMatrix<ValueType> const& A, std::unique_ptr<LinearEquationSolverFactory<ValueType>>&& linearEquationSolverFactory, StandardMinMaxLinearEquationSolverSettings const& settings) : settings(settings), linearEquationSolverFactory(std::move(linearEquationSolverFactory)), localA(nullptr), A(A) { |
|||
// Intentionally left empty.
|
|||
} |
|||
|
|||
template<typename ValueType> |
|||
StandardMinMaxLinearEquationSolver<ValueType>::StandardMinMaxLinearEquationSolver(storm::storage::SparseMatrix<ValueType>&& A, std::unique_ptr<LinearEquationSolverFactory<ValueType>>&& linearEquationSolverFactory, StandardMinMaxLinearEquationSolverSettings const& settings) : settings(settings), linearEquationSolverFactory(std::move(linearEquationSolverFactory)), localA(std::make_unique<storm::storage::SparseMatrix<ValueType>>(std::move(A))), A(*localA) { |
|||
// Intentionally left empty.
|
|||
} |
|||
|
|||
template<typename ValueType> |
|||
void StandardMinMaxLinearEquationSolver<ValueType>::solveEquationSystem(OptimizationDirection d, std::vector<ValueType>& x, std::vector<ValueType> const& b, std::vector<ValueType>* multiplyResult, std::vector<ValueType>* newX) const { |
|||
//FIXME: implement
|
|||
} |
|||
|
|||
template<typename ValueType> |
|||
void StandardMinMaxLinearEquationSolver<ValueType>::performMatrixVectorMultiplication(OptimizationDirection d, std::vector<ValueType>& x, std::vector<ValueType>* b, uint_fast64_t n, std::vector<ValueType>* multiplyResult) const { |
|||
//FIXME: implement
|
|||
} |
|||
|
|||
template<typename ValueType> |
|||
StandardMinMaxLinearEquationSolverSettings const& StandardMinMaxLinearEquationSolver<ValueType>::getSettings() const { |
|||
return settings; |
|||
} |
|||
|
|||
template<typename ValueType> |
|||
StandardMinMaxLinearEquationSolverSettings& StandardMinMaxLinearEquationSolver<ValueType>::getSettings() { |
|||
return settings; |
|||
} |
|||
|
|||
template<typename ValueType> |
|||
StandardMinMaxLinearEquationSolverFactory<ValueType>::StandardMinMaxLinearEquationSolverFactory(bool trackScheduler) : MinMaxLinearEquationSolverFactory<ValueType>(trackScheduler), linearEquationSolverFactory(nullptr) { |
|||
// Intentionally left empty.
|
|||
} |
|||
|
|||
template<typename ValueType> |
|||
StandardMinMaxLinearEquationSolverFactory<ValueType>::StandardMinMaxLinearEquationSolverFactory(std::unique_ptr<LinearEquationSolverFactory<ValueType>>&& linearEquationSolverFactory, bool trackScheduler) : MinMaxLinearEquationSolverFactory<ValueType>(trackScheduler), linearEquationSolverFactory(std::move(linearEquationSolverFactory)) { |
|||
// Intentionally left empty.
|
|||
} |
|||
|
|||
template<typename ValueType> |
|||
StandardMinMaxLinearEquationSolverFactory<ValueType>::StandardMinMaxLinearEquationSolverFactory(EquationSolverType const& solverType, bool trackScheduler) : MinMaxLinearEquationSolverFactory<ValueType>(trackScheduler) { |
|||
switch (solverType) { |
|||
case EquationSolverType::Gmmxx: linearEquationSolverFactory = std::make_unique<GmmxxLinearEquationSolverFactory<ValueType>>(); break; |
|||
case EquationSolverType::Eigen: linearEquationSolverFactory = std::make_unique<EigenLinearEquationSolverFactory<ValueType>>(); break; |
|||
case EquationSolverType::Native: linearEquationSolverFactory = std::make_unique<NativeLinearEquationSolverFactory<ValueType>>(); break; |
|||
case EquationSolverType::Elimination: linearEquationSolverFactory = std::make_unique<EliminationLinearEquationSolverFactory<ValueType>>(); break; |
|||
} |
|||
} |
|||
|
|||
template<typename ValueType> |
|||
std::unique_ptr<MinMaxLinearEquationSolver<ValueType>> StandardMinMaxLinearEquationSolverFactory<ValueType>::create(storm::storage::SparseMatrix<ValueType> const& matrix) const { |
|||
if (linearEquationSolverFactory) { |
|||
return std::make_unique<StandardMinMaxLinearEquationSolver<ValueType>>(matrix, linearEquationSolverFactory->clone(), settings); |
|||
} else { |
|||
return std::make_unique<StandardMinMaxLinearEquationSolver<ValueType>>(matrix, std::make_unique<GeneralLinearEquationSolverFactory<ValueType>>(), settings); |
|||
} |
|||
} |
|||
|
|||
template<typename ValueType> |
|||
std::unique_ptr<MinMaxLinearEquationSolver<ValueType>> StandardMinMaxLinearEquationSolverFactory<ValueType>::create(storm::storage::SparseMatrix<ValueType>&& matrix) const { |
|||
std::unique_ptr<MinMaxLinearEquationSolver<ValueType>> result; |
|||
if (linearEquationSolverFactory) { |
|||
result = std::make_unique<StandardMinMaxLinearEquationSolver<ValueType>>(std::move(matrix), linearEquationSolverFactory->clone(), settings); |
|||
} else { |
|||
result = std::make_unique<StandardMinMaxLinearEquationSolver<ValueType>>(std::move(matrix), std::make_unique<GeneralLinearEquationSolverFactory<ValueType>>(), settings); |
|||
} |
|||
if (this->isTrackSchedulerSet()) { |
|||
result->setTrackScheduler(true); |
|||
} |
|||
return result; |
|||
} |
|||
|
|||
template<typename ValueType> |
|||
StandardMinMaxLinearEquationSolverSettings& StandardMinMaxLinearEquationSolverFactory<ValueType>::getSettings() { |
|||
return settings; |
|||
} |
|||
|
|||
template<typename ValueType> |
|||
StandardMinMaxLinearEquationSolverSettings const& StandardMinMaxLinearEquationSolverFactory<ValueType>::getSettings() const { |
|||
return settings; |
|||
} |
|||
|
|||
template<typename ValueType> |
|||
GmmxxMinMaxLinearEquationSolverFactory<ValueType>::GmmxxMinMaxLinearEquationSolverFactory(bool trackScheduler) : StandardMinMaxLinearEquationSolverFactory<ValueType>(EquationSolverType::Gmmxx, trackScheduler) { |
|||
// Intentionally left empty.
|
|||
} |
|||
|
|||
template<typename ValueType> |
|||
EigenMinMaxLinearEquationSolverFactory<ValueType>::EigenMinMaxLinearEquationSolverFactory(bool trackScheduler) : StandardMinMaxLinearEquationSolverFactory<ValueType>(EquationSolverType::Eigen, trackScheduler) { |
|||
// Intentionally left empty.
|
|||
} |
|||
|
|||
template<typename ValueType> |
|||
NativeMinMaxLinearEquationSolverFactory<ValueType>::NativeMinMaxLinearEquationSolverFactory(bool trackScheduler) : StandardMinMaxLinearEquationSolverFactory<ValueType>(EquationSolverType::Native, trackScheduler) { |
|||
// Intentionally left empty.
|
|||
} |
|||
|
|||
template<typename ValueType> |
|||
EliminationMinMaxLinearEquationSolverFactory<ValueType>::EliminationMinMaxLinearEquationSolverFactory(bool trackScheduler) : StandardMinMaxLinearEquationSolverFactory<ValueType>(EquationSolverType::Elimination, trackScheduler) { |
|||
// Intentionally left empty.
|
|||
} |
|||
|
|||
template class StandardMinMaxLinearEquationSolver<double>; |
|||
|
|||
template class StandardMinMaxLinearEquationSolverFactory<double>; |
|||
template class GmmxxMinMaxLinearEquationSolverFactory<double>; |
|||
template class EigenMinMaxLinearEquationSolverFactory<double>; |
|||
template class NativeMinMaxLinearEquationSolverFactory<double>; |
|||
template class EliminationMinMaxLinearEquationSolverFactory<double>; |
|||
|
|||
} |
|||
} |
|||
@ -0,0 +1,97 @@ |
|||
#pragma once |
|||
|
|||
#include "src/solver/LinearEquationSolver.h" |
|||
#include "src/solver/MinMaxLinearEquationSolver.h" |
|||
|
|||
namespace storm { |
|||
namespace solver { |
|||
|
|||
class StandardMinMaxLinearEquationSolverSettings { |
|||
public: |
|||
StandardMinMaxLinearEquationSolverSettings(); |
|||
|
|||
enum class SolutionMethod { |
|||
ValueIteration, PolicyIteration |
|||
}; |
|||
|
|||
void setSolutionMethod(SolutionMethod const& solutionMethod); |
|||
|
|||
SolutionMethod const& getSolutionMethod() const; |
|||
|
|||
private: |
|||
SolutionMethod solutionMethod; |
|||
}; |
|||
|
|||
template<typename ValueType> |
|||
class StandardMinMaxLinearEquationSolver : public MinMaxLinearEquationSolver<ValueType> { |
|||
public: |
|||
StandardMinMaxLinearEquationSolver(storm::storage::SparseMatrix<ValueType> const& A, std::unique_ptr<LinearEquationSolverFactory<ValueType>>&& linearEquationSolverFactory, StandardMinMaxLinearEquationSolverSettings const& settings = StandardMinMaxLinearEquationSolverSettings()); |
|||
StandardMinMaxLinearEquationSolver(storm::storage::SparseMatrix<ValueType>&& A, std::unique_ptr<LinearEquationSolverFactory<ValueType>>&& linearEquationSolverFactory, StandardMinMaxLinearEquationSolverSettings const& settings = StandardMinMaxLinearEquationSolverSettings()); |
|||
|
|||
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 performMatrixVectorMultiplication(OptimizationDirection d, std::vector<ValueType>& x, std::vector<ValueType>* b = nullptr, uint_fast64_t n = 1, std::vector<ValueType>* multiplyResult = nullptr) const override; |
|||
|
|||
StandardMinMaxLinearEquationSolverSettings const& getSettings() const; |
|||
StandardMinMaxLinearEquationSolverSettings& getSettings(); |
|||
|
|||
private: |
|||
/// The settings of this solver. |
|||
StandardMinMaxLinearEquationSolverSettings settings; |
|||
|
|||
/// The factory used to obtain linear equation solvers. |
|||
std::unique_ptr<LinearEquationSolverFactory<ValueType>> linearEquationSolverFactory; |
|||
|
|||
// If the solver takes posession of the matrix, we store the moved matrix in this member, so it gets deleted |
|||
// when the solver is destructed. |
|||
std::unique_ptr<storm::storage::SparseMatrix<ValueType>> localA; |
|||
|
|||
// A reference to the original sparse matrix given to this solver. If the solver takes posession of the matrix |
|||
// the reference refers to localA. |
|||
storm::storage::SparseMatrix<ValueType> const& A; |
|||
}; |
|||
|
|||
template<typename ValueType> |
|||
class StandardMinMaxLinearEquationSolverFactory : public MinMaxLinearEquationSolverFactory<ValueType> { |
|||
public: |
|||
StandardMinMaxLinearEquationSolverFactory(bool trackScheduler = false); |
|||
StandardMinMaxLinearEquationSolverFactory(std::unique_ptr<LinearEquationSolverFactory<ValueType>>&& linearEquationSolverFactory, bool trackScheduler = false); |
|||
StandardMinMaxLinearEquationSolverFactory(EquationSolverType const& solverType, bool trackScheduler = false); |
|||
|
|||
virtual std::unique_ptr<MinMaxLinearEquationSolver<ValueType>> create(storm::storage::SparseMatrix<ValueType> const& matrix) const override; |
|||
virtual std::unique_ptr<MinMaxLinearEquationSolver<ValueType>> create(storm::storage::SparseMatrix<ValueType>&& matrix) const override; |
|||
|
|||
StandardMinMaxLinearEquationSolverSettings& getSettings(); |
|||
StandardMinMaxLinearEquationSolverSettings const& getSettings() const; |
|||
|
|||
private: |
|||
StandardMinMaxLinearEquationSolverSettings settings; |
|||
|
|||
std::unique_ptr<LinearEquationSolverFactory<ValueType>> linearEquationSolverFactory; |
|||
}; |
|||
|
|||
template<typename ValueType> |
|||
class GmmxxMinMaxLinearEquationSolverFactory : public StandardMinMaxLinearEquationSolverFactory<ValueType> { |
|||
public: |
|||
GmmxxMinMaxLinearEquationSolverFactory(bool trackScheduler = false); |
|||
}; |
|||
|
|||
template<typename ValueType> |
|||
class EigenMinMaxLinearEquationSolverFactory : public StandardMinMaxLinearEquationSolverFactory<ValueType> { |
|||
public: |
|||
EigenMinMaxLinearEquationSolverFactory(bool trackScheduler = false); |
|||
}; |
|||
|
|||
template<typename ValueType> |
|||
class NativeMinMaxLinearEquationSolverFactory : public StandardMinMaxLinearEquationSolverFactory<ValueType> { |
|||
public: |
|||
NativeMinMaxLinearEquationSolverFactory(bool trackScheduler = false); |
|||
}; |
|||
|
|||
template<typename ValueType> |
|||
class EliminationMinMaxLinearEquationSolverFactory : public StandardMinMaxLinearEquationSolverFactory<ValueType> { |
|||
public: |
|||
EliminationMinMaxLinearEquationSolverFactory(bool trackScheduler = false); |
|||
}; |
|||
|
|||
} |
|||
} |
|||
Write
Preview
Loading…
Cancel
Save
Reference in new issue