sp
/
tempest
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity
Browse Source

added unsupported solvers of eigen 

Former-commit-id: e11b335c2d
tempestpy_adaptions
dehnert 9 years ago
parent
d24fb0cf9a
commit
07c787b49d
7 changed files with 297 additions and 24 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Unified View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 2
      resources/3rdparty/eigen-3.3-beta1/unsupported/Eigen/src/IterativeSolvers/ConstrainedConjGrad.h
  2. 21
      src/settings/modules/EigenEquationSolverSettings.cpp
  3. 17
      src/settings/modules/EigenEquationSolverSettings.h
  4. 83
      src/solver/EigenLinearEquationSolver.cpp
  5. 7
      src/solver/EigenLinearEquationSolver.h
  6. 1
      src/utility/eigen.h
  7. 190
      test/functional/solver/EigenLinearEquationSolverTest.cpp

2
resources/3rdparty/eigen-3.3-beta1/unsupported/Eigen/src/IterativeSolvers/ConstrainedConjGrad.h
View File

@ -26,6 +26,8 @@
// //
//======================================================================== //========================================================================
#include <iostream>
#include "../../../../Eigen/src/Core/util/NonMPL2.h" #include "../../../../Eigen/src/Core/util/NonMPL2.h"
#ifndef EIGEN_CONSTRAINEDCG_H #ifndef EIGEN_CONSTRAINEDCG_H

21
src/settings/modules/EigenEquationSolverSettings.cpp
View File

@ -19,15 +19,18 @@ namespace storm {
const std::string EigenEquationSolverSettings::maximalIterationsOptionName = "maxiter"; const std::string EigenEquationSolverSettings::maximalIterationsOptionName = "maxiter";
const std::string EigenEquationSolverSettings::maximalIterationsOptionShortName = "i"; const std::string EigenEquationSolverSettings::maximalIterationsOptionShortName = "i";
const std::string EigenEquationSolverSettings::precisionOptionName = "precision"; const std::string EigenEquationSolverSettings::precisionOptionName = "precision";
const std::string EigenEquationSolverSettings::restartOptionName = "restart";
EigenEquationSolverSettings::EigenEquationSolverSettings() : ModuleSettings(moduleName) { EigenEquationSolverSettings::EigenEquationSolverSettings() : ModuleSettings(moduleName) {
std::vector<std::string> methods = {"sparselu", "bicgstab"};
this->addOption(storm::settings::OptionBuilder(moduleName, techniqueOptionName, true, "The method to be used for solving linear equation systems with the eigen solver. Available are {sparselu, bicgstab}.").addArgument(storm::settings::ArgumentBuilder::createStringArgument("name", "The name of the method to use.").addValidationFunctionString(storm::settings::ArgumentValidators::stringInListValidator(methods)).setDefaultValueString("sparselu").build()).build());
std::vector<std::string> methods = {"sparselu", "bicgstab", "dgmres", "gmres"};
this->addOption(storm::settings::OptionBuilder(moduleName, techniqueOptionName, true, "The method to be used for solving linear equation systems with the eigen solver. Available are {sparselu, bicgstab, dgmres, gmres}.").addArgument(storm::settings::ArgumentBuilder::createStringArgument("name", "The name of the method to use.").addValidationFunctionString(storm::settings::ArgumentValidators::stringInListValidator(methods)).setDefaultValueString("sparselu").build()).build());
// Register available preconditioners. // Register available preconditioners.
std::vector<std::string> preconditioner = {"ilu", "diagonal", "none"}; std::vector<std::string> preconditioner = {"ilu", "diagonal", "none"};
this->addOption(storm::settings::OptionBuilder(moduleName, preconditionOptionName, true, "The preconditioning technique used for solving linear equation systems. Available are {ilu, diagonal, none}.").addArgument(storm::settings::ArgumentBuilder::createStringArgument("name", "The name of the preconditioning method.").addValidationFunctionString(storm::settings::ArgumentValidators::stringInListValidator(preconditioner)).setDefaultValueString("ilu").build()).build()); this->addOption(storm::settings::OptionBuilder(moduleName, preconditionOptionName, true, "The preconditioning technique used for solving linear equation systems. Available are {ilu, diagonal, none}.").addArgument(storm::settings::ArgumentBuilder::createStringArgument("name", "The name of the preconditioning method.").addValidationFunctionString(storm::settings::ArgumentValidators::stringInListValidator(preconditioner)).setDefaultValueString("ilu").build()).build());
this->addOption(storm::settings::OptionBuilder(moduleName, restartOptionName, true, "The number of iteration until restarted methods are actually restarted.").addArgument(storm::settings::ArgumentBuilder::createUnsignedIntegerArgument("count", "The number of iterations.").setDefaultValueUnsignedInteger(50).build()).build());
this->addOption(storm::settings::OptionBuilder(moduleName, maximalIterationsOptionName, false, "The maximal number of iterations to perform before iterative solving is aborted.").setShortName(maximalIterationsOptionShortName).addArgument(storm::settings::ArgumentBuilder::createUnsignedIntegerArgument("count", "The maximal iteration count.").setDefaultValueUnsignedInteger(20000).build()).build()); this->addOption(storm::settings::OptionBuilder(moduleName, maximalIterationsOptionName, false, "The maximal number of iterations to perform before iterative solving is aborted.").setShortName(maximalIterationsOptionShortName).addArgument(storm::settings::ArgumentBuilder::createUnsignedIntegerArgument("count", "The maximal iteration count.").setDefaultValueUnsignedInteger(20000).build()).build());
this->addOption(storm::settings::OptionBuilder(moduleName, precisionOptionName, false, "The precision used for detecting convergence of iterative methods.").addArgument(storm::settings::ArgumentBuilder::createDoubleArgument("value", "The precision to achieve.").setDefaultValueDouble(1e-06).addValidationFunctionDouble(storm::settings::ArgumentValidators::doubleRangeValidatorExcluding(0.0, 1.0)).build()).build()); this->addOption(storm::settings::OptionBuilder(moduleName, precisionOptionName, false, "The precision used for detecting convergence of iterative methods.").addArgument(storm::settings::ArgumentBuilder::createDoubleArgument("value", "The precision to achieve.").setDefaultValueDouble(1e-06).addValidationFunctionDouble(storm::settings::ArgumentValidators::doubleRangeValidatorExcluding(0.0, 1.0)).build()).build());
@ -42,7 +45,11 @@ namespace storm {
if (linearEquationSystemTechniqueAsString == "sparselu") { if (linearEquationSystemTechniqueAsString == "sparselu") {
return EigenEquationSolverSettings::LinearEquationMethod::SparseLU; return EigenEquationSolverSettings::LinearEquationMethod::SparseLU;
} else if (linearEquationSystemTechniqueAsString == "bicgstab") { } else if (linearEquationSystemTechniqueAsString == "bicgstab") {
return EigenEquationSolverSettings::LinearEquationMethod::Bicgstab;
return EigenEquationSolverSettings::LinearEquationMethod::BiCGSTAB;
} else if (linearEquationSystemTechniqueAsString == "dgmres") {
return EigenEquationSolverSettings::LinearEquationMethod::DGMRES;
} else if (linearEquationSystemTechniqueAsString == "gmres") {
return EigenEquationSolverSettings::LinearEquationMethod::GMRES;
} }
STORM_LOG_THROW(false, storm::exceptions::IllegalArgumentValueException, "Unknown solution technique '" << linearEquationSystemTechniqueAsString << "' selected."); STORM_LOG_THROW(false, storm::exceptions::IllegalArgumentValueException, "Unknown solution technique '" << linearEquationSystemTechniqueAsString << "' selected.");
} }
@ -63,6 +70,14 @@ namespace storm {
STORM_LOG_THROW(false, storm::exceptions::IllegalArgumentValueException, "Unknown preconditioning technique '" << PreconditioningMethodAsString << "' selected."); STORM_LOG_THROW(false, storm::exceptions::IllegalArgumentValueException, "Unknown preconditioning technique '" << PreconditioningMethodAsString << "' selected.");
} }
bool EigenEquationSolverSettings::isRestartIterationCountSet() const {
return this->getOption(restartOptionName).getHasOptionBeenSet();
}
uint_fast64_t EigenEquationSolverSettings::getRestartIterationCount() const {
return this->getOption(restartOptionName).getArgumentByName("count").getValueAsUnsignedInteger();
}
bool EigenEquationSolverSettings::isMaximalIterationCountSet() const { bool EigenEquationSolverSettings::isMaximalIterationCountSet() const {
return this->getOption(maximalIterationsOptionName).getHasOptionBeenSet(); return this->getOption(maximalIterationsOptionName).getHasOptionBeenSet();
} }

17
src/settings/modules/EigenEquationSolverSettings.h
View File

@ -12,7 +12,7 @@ namespace storm {
class EigenEquationSolverSettings : public ModuleSettings { class EigenEquationSolverSettings : public ModuleSettings {
public: public:
// An enumeration of all available methods for solving linear equations. // An enumeration of all available methods for solving linear equations.
enum class LinearEquationMethod { SparseLU, Bicgstab };
enum class LinearEquationMethod { SparseLU, BiCGSTAB, DGMRES, GMRES };
// An enumeration of all available preconditioning methods. // An enumeration of all available preconditioning methods.
enum class PreconditioningMethod { Ilu, Diagonal, None }; enum class PreconditioningMethod { Ilu, Diagonal, None };
@ -53,6 +53,20 @@ namespace storm {
*/ */
PreconditioningMethod getPreconditioningMethod() const; PreconditioningMethod getPreconditioningMethod() const;
/*!
* Retrieves whether the restart iteration count has been set.
*
* @return True iff the restart iteration count has been set.
*/
bool isRestartIterationCountSet() const;
/*!
* Retrieves the number of iterations after which restarted methods are to be restarted.
*
* @return The number of iterations after which to restart.
*/
uint_fast64_t getRestartIterationCount() const;
/*! /*!
* Retrieves whether the maximal iteration count has been set. * Retrieves whether the maximal iteration count has been set.
* *
@ -93,6 +107,7 @@ namespace storm {
static const std::string maximalIterationsOptionName; static const std::string maximalIterationsOptionName;
static const std::string maximalIterationsOptionShortName; static const std::string maximalIterationsOptionShortName;
static const std::string precisionOptionName; static const std::string precisionOptionName;
static const std::string restartOptionName;
}; };
} // namespace modules } // namespace modules

83
src/solver/EigenLinearEquationSolver.cpp
View File

@ -19,13 +19,18 @@ namespace storm {
// Get appropriate settings. // Get appropriate settings.
maximalNumberOfIterations = settings.getMaximalIterationCount(); maximalNumberOfIterations = settings.getMaximalIterationCount();
precision = settings.getPrecision(); precision = settings.getPrecision();
restart = settings.getRestartIterationCount();
// Determine the method to be used. // Determine the method to be used.
storm::settings::modules::EigenEquationSolverSettings::LinearEquationMethod methodAsSetting = settings.getLinearEquationSystemMethod(); storm::settings::modules::EigenEquationSolverSettings::LinearEquationMethod methodAsSetting = settings.getLinearEquationSystemMethod();
if (methodAsSetting == storm::settings::modules::EigenEquationSolverSettings::LinearEquationMethod::Bicgstab) {
method = SolutionMethod::Bicgstab;
if (methodAsSetting == storm::settings::modules::EigenEquationSolverSettings::LinearEquationMethod::BiCGSTAB) {
method = SolutionMethod::BiCGSTAB;
} else if (methodAsSetting == storm::settings::modules::EigenEquationSolverSettings::LinearEquationMethod::SparseLU) { } else if (methodAsSetting == storm::settings::modules::EigenEquationSolverSettings::LinearEquationMethod::SparseLU) {
method = SolutionMethod::SparseLU; method = SolutionMethod::SparseLU;
} else if (methodAsSetting == storm::settings::modules::EigenEquationSolverSettings::LinearEquationMethod::DGMRES) {
method = SolutionMethod::DGMRES;
} else if (methodAsSetting == storm::settings::modules::EigenEquationSolverSettings::LinearEquationMethod::GMRES) {
method = SolutionMethod::GMRES;
} }
// Check which preconditioner to use. // Check which preconditioner to use.
@ -59,6 +64,11 @@ namespace storm {
this->maximalNumberOfIterations = maximalNumberOfIterations; this->maximalNumberOfIterations = maximalNumberOfIterations;
} }
template<typename ValueType>
void EigenLinearEquationSolverSettings<ValueType>::setNumberOfIterationsUntilRestart(uint64_t restart) {
this->restart = restart;
}
template<typename ValueType> template<typename ValueType>
typename EigenLinearEquationSolverSettings<ValueType>::SolutionMethod EigenLinearEquationSolverSettings<ValueType>::getSolutionMethod() const { typename EigenLinearEquationSolverSettings<ValueType>::SolutionMethod EigenLinearEquationSolverSettings<ValueType>::getSolutionMethod() const {
return this->method; return this->method;
@ -78,6 +88,11 @@ namespace storm {
uint64_t EigenLinearEquationSolverSettings<ValueType>::getMaximalNumberOfIterations() const { uint64_t EigenLinearEquationSolverSettings<ValueType>::getMaximalNumberOfIterations() const {
return this->maximalNumberOfIterations; return this->maximalNumberOfIterations;
} }
template<typename ValueType>
uint64_t EigenLinearEquationSolverSettings<ValueType>::getNumberOfIterationsUntilRestart() const {
return restart;
}
EigenLinearEquationSolverSettings<storm::RationalNumber>::EigenLinearEquationSolverSettings() { EigenLinearEquationSolverSettings<storm::RationalNumber>::EigenLinearEquationSolverSettings() {
// Intentionally left empty. // Intentionally left empty.
@ -104,23 +119,61 @@ namespace storm {
auto eigenX = Eigen::Matrix<ValueType, Eigen::Dynamic, 1>::Map(x.data(), x.size()); auto eigenX = Eigen::Matrix<ValueType, Eigen::Dynamic, 1>::Map(x.data(), x.size());
auto eigenB = Eigen::Matrix<ValueType, Eigen::Dynamic, 1>::Map(b.data(), b.size()); auto eigenB = Eigen::Matrix<ValueType, Eigen::Dynamic, 1>::Map(b.data(), b.size());
if (this->getSettings().getSolutionMethod() == EigenLinearEquationSolverSettings<ValueType>::SolutionMethod::SparseLU) {
typename EigenLinearEquationSolverSettings<ValueType>::SolutionMethod solutionMethod = this->getSettings().getSolutionMethod();
if (solutionMethod == EigenLinearEquationSolverSettings<ValueType>::SolutionMethod::SparseLU) {
Eigen::SparseLU<Eigen::SparseMatrix<ValueType>, Eigen::COLAMDOrdering<int>> solver; Eigen::SparseLU<Eigen::SparseMatrix<ValueType>, Eigen::COLAMDOrdering<int>> solver;
solver.compute(*this->eigenA); solver.compute(*this->eigenA);
solver._solve_impl(eigenB, eigenX); solver._solve_impl(eigenB, eigenX);
} else { } else {
if (this->getSettings().getPreconditioner() == EigenLinearEquationSolverSettings<ValueType>::Preconditioner::Ilu) {
Eigen::BiCGSTAB<Eigen::SparseMatrix<ValueType>, Eigen::IncompleteLUT<ValueType>> solver;
solver.compute(*this->eigenA);
solver.solveWithGuess(eigenB, eigenX);
} else if (this->getSettings().getPreconditioner() == EigenLinearEquationSolverSettings<ValueType>::Preconditioner::Diagonal) {
Eigen::BiCGSTAB<Eigen::SparseMatrix<ValueType>, Eigen::DiagonalPreconditioner<ValueType>> solver;
solver.compute(*this->eigenA);
solver.solveWithGuess(eigenB, eigenX);
} else {
Eigen::BiCGSTAB<Eigen::SparseMatrix<ValueType>, Eigen::IdentityPreconditioner> solver;
solver.compute(*this->eigenA);
solver.solveWithGuess(eigenB, eigenX);
typename EigenLinearEquationSolverSettings<ValueType>::Preconditioner preconditioner = this->getSettings().getPreconditioner();
if (solutionMethod == EigenLinearEquationSolverSettings<ValueType>::SolutionMethod::BiCGSTAB) {
if (preconditioner == EigenLinearEquationSolverSettings<ValueType>::Preconditioner::Ilu) {
Eigen::BiCGSTAB<Eigen::SparseMatrix<ValueType>, Eigen::IncompleteLUT<ValueType>> solver;
solver.compute(*this->eigenA);
solver.solveWithGuess(eigenB, eigenX);
} else if (preconditioner == EigenLinearEquationSolverSettings<ValueType>::Preconditioner::Diagonal) {
Eigen::BiCGSTAB<Eigen::SparseMatrix<ValueType>, Eigen::DiagonalPreconditioner<ValueType>> solver;
solver.compute(*this->eigenA);
solver.solveWithGuess(eigenB, eigenX);
} else {
Eigen::BiCGSTAB<Eigen::SparseMatrix<ValueType>, Eigen::IdentityPreconditioner> solver;
solver.compute(*this->eigenA);
solver.solveWithGuess(eigenB, eigenX);
}
} else if (solutionMethod == EigenLinearEquationSolverSettings<ValueType>::SolutionMethod::DGMRES) {
if (preconditioner == EigenLinearEquationSolverSettings<ValueType>::Preconditioner::Ilu) {
Eigen::DGMRES<Eigen::SparseMatrix<ValueType>, Eigen::IncompleteLUT<ValueType>> solver;
solver.set_restart(this->getSettings().getNumberOfIterationsUntilRestart());
solver.compute(*this->eigenA);
solver.solveWithGuess(eigenB, eigenX);
} else if (preconditioner == EigenLinearEquationSolverSettings<ValueType>::Preconditioner::Diagonal) {
Eigen::DGMRES<Eigen::SparseMatrix<ValueType>, Eigen::DiagonalPreconditioner<ValueType>> solver;
solver.set_restart(this->getSettings().getNumberOfIterationsUntilRestart());
solver.compute(*this->eigenA);
solver.solveWithGuess(eigenB, eigenX);
} else {
Eigen::DGMRES<Eigen::SparseMatrix<ValueType>, Eigen::IdentityPreconditioner> solver;
solver.set_restart(this->getSettings().getNumberOfIterationsUntilRestart());
solver.compute(*this->eigenA);
solver.solveWithGuess(eigenB, eigenX);
}
} else if (solutionMethod == EigenLinearEquationSolverSettings<ValueType>::SolutionMethod::GMRES) {
if (preconditioner == EigenLinearEquationSolverSettings<ValueType>::Preconditioner::Ilu) {
Eigen::GMRES<Eigen::SparseMatrix<ValueType>, Eigen::IncompleteLUT<ValueType>> solver;
solver.set_restart(this->getSettings().getNumberOfIterationsUntilRestart());
solver.compute(*this->eigenA);
solver.solveWithGuess(eigenB, eigenX);
} else if (preconditioner == EigenLinearEquationSolverSettings<ValueType>::Preconditioner::Diagonal) {
Eigen::GMRES<Eigen::SparseMatrix<ValueType>, Eigen::DiagonalPreconditioner<ValueType>> solver;
solver.set_restart(this->getSettings().getNumberOfIterationsUntilRestart());
solver.compute(*this->eigenA);
solver.solveWithGuess(eigenB, eigenX);
} else {
Eigen::GMRES<Eigen::SparseMatrix<ValueType>, Eigen::IdentityPreconditioner> solver;
solver.set_restart(this->getSettings().getNumberOfIterationsUntilRestart());
solver.compute(*this->eigenA);
solver.solveWithGuess(eigenB, eigenX);
}
} }
} }
} }

7
src/solver/EigenLinearEquationSolver.h
View File

@ -11,7 +11,7 @@ namespace storm {
class EigenLinearEquationSolverSettings { class EigenLinearEquationSolverSettings {
public: public:
enum class SolutionMethod { enum class SolutionMethod {
SparseLU, Bicgstab
SparseLU, BiCGSTAB, DGMRES, GMRES
}; };
enum class Preconditioner { enum class Preconditioner {
@ -24,17 +24,20 @@ namespace storm {
void setPreconditioner(Preconditioner const& preconditioner); void setPreconditioner(Preconditioner const& preconditioner);
void setPrecision(ValueType precision); void setPrecision(ValueType precision);
void setMaximalNumberOfIterations(uint64_t maximalNumberOfIterations); void setMaximalNumberOfIterations(uint64_t maximalNumberOfIterations);
void setNumberOfIterationsUntilRestart(uint64_t restart);
SolutionMethod getSolutionMethod() const; SolutionMethod getSolutionMethod() const;
Preconditioner getPreconditioner() const; Preconditioner getPreconditioner() const;
ValueType getPrecision() const; ValueType getPrecision() const;
uint64_t getMaximalNumberOfIterations() const; uint64_t getMaximalNumberOfIterations() const;
uint64_t getNumberOfIterationsUntilRestart() const;
private: private:
SolutionMethod method; SolutionMethod method;
Preconditioner preconditioner; Preconditioner preconditioner;
double precision; double precision;
uint64_t maximalNumberOfIterations; uint64_t maximalNumberOfIterations;
uint_fast64_t restart;
}; };
template<> template<>

1
src/utility/eigen.h
View File

@ -5,3 +5,4 @@
// Finally include the parts of Eigen we need. // Finally include the parts of Eigen we need.
#include <Eigen/Sparse> #include <Eigen/Sparse>
#include <unsupported/Eigen/IterativeSolvers>

190
test/functional/solver/EigenLinearEquationSolverTest.cpp
View File

@ -116,6 +116,190 @@ TEST(EigenLinearEquationSolver, SparseLU_RationalFunction) {
ASSERT_TRUE(x[2] == storm::RationalFunction(-1)); ASSERT_TRUE(x[2] == storm::RationalFunction(-1));
} }
TEST(DISABLED_EigenLinearEquationSolver, DGMRES) {
ASSERT_NO_THROW(storm::storage::SparseMatrixBuilder<double> builder);
storm::storage::SparseMatrixBuilder<double> builder;
ASSERT_NO_THROW(builder.addNextValue(0, 0, 2));
ASSERT_NO_THROW(builder.addNextValue(0, 1, 4));
ASSERT_NO_THROW(builder.addNextValue(0, 2, -2));
ASSERT_NO_THROW(builder.addNextValue(1, 0, 4));
ASSERT_NO_THROW(builder.addNextValue(1, 1, -1));
ASSERT_NO_THROW(builder.addNextValue(1, 2, 5));
ASSERT_NO_THROW(builder.addNextValue(2, 0, -1));
ASSERT_NO_THROW(builder.addNextValue(2, 1, -1));
ASSERT_NO_THROW(builder.addNextValue(2, 2, 3));
storm::storage::SparseMatrix<double> A;
ASSERT_NO_THROW(A = builder.build());
std::vector<double> x(3);
std::vector<double> b = {16, -4, -7};
storm::solver::EigenLinearEquationSolver<double> solver(A);
solver.getSettings().setSolutionMethod(storm::solver::EigenLinearEquationSolverSettings<double>::SolutionMethod::DGMRES);
solver.getSettings().setPrecision(1e-6);
solver.getSettings().setMaximalNumberOfIterations(10000);
solver.getSettings().setPreconditioner(storm::solver::EigenLinearEquationSolverSettings<double>::Preconditioner::None);
solver.getSettings().setNumberOfIterationsUntilRestart(50);
ASSERT_NO_THROW(solver.solveEquationSystem(x, b));
ASSERT_LT(std::abs(x[0] - 1), storm::settings::getModule<storm::settings::modules::EigenEquationSolverSettings>().getPrecision());
ASSERT_LT(std::abs(x[1] - 3), storm::settings::getModule<storm::settings::modules::EigenEquationSolverSettings>().getPrecision());
ASSERT_LT(std::abs(x[2] - (-1)), storm::settings::getModule<storm::settings::modules::EigenEquationSolverSettings>().getPrecision());
}
TEST(DISABLED_EigenLinearEquationSolver, DGMRES_Ilu) {
ASSERT_NO_THROW(storm::storage::SparseMatrixBuilder<double> builder);
storm::storage::SparseMatrixBuilder<double> builder;
ASSERT_NO_THROW(builder.addNextValue(0, 0, 2));
ASSERT_NO_THROW(builder.addNextValue(0, 1, 4));
ASSERT_NO_THROW(builder.addNextValue(0, 2, -2));
ASSERT_NO_THROW(builder.addNextValue(1, 0, 4));
ASSERT_NO_THROW(builder.addNextValue(1, 1, -1));
ASSERT_NO_THROW(builder.addNextValue(1, 2, 5));
ASSERT_NO_THROW(builder.addNextValue(2, 0, -1));
ASSERT_NO_THROW(builder.addNextValue(2, 1, -1));
ASSERT_NO_THROW(builder.addNextValue(2, 2, 3));
storm::storage::SparseMatrix<double> A;
ASSERT_NO_THROW(A = builder.build());
std::vector<double> x(3);
std::vector<double> b = {16, -4, -7};
storm::solver::EigenLinearEquationSolver<double> solver(A);
solver.getSettings().setSolutionMethod(storm::solver::EigenLinearEquationSolverSettings<double>::SolutionMethod::DGMRES);
solver.getSettings().setPrecision(1e-6);
solver.getSettings().setMaximalNumberOfIterations(10000);
solver.getSettings().setPreconditioner(storm::solver::EigenLinearEquationSolverSettings<double>::Preconditioner::Ilu);
ASSERT_NO_THROW(solver.solveEquationSystem(x, b));
ASSERT_LT(std::abs(x[0] - 1), storm::settings::getModule<storm::settings::modules::EigenEquationSolverSettings>().getPrecision());
ASSERT_LT(std::abs(x[1] - 3), storm::settings::getModule<storm::settings::modules::EigenEquationSolverSettings>().getPrecision());
ASSERT_LT(std::abs(x[2] - (-1)), storm::settings::getModule<storm::settings::modules::EigenEquationSolverSettings>().getPrecision());
}
TEST(DISABLED_EigenLinearEquationSolver, DGMRES_Diagonal) {
ASSERT_NO_THROW(storm::storage::SparseMatrixBuilder<double> builder);
storm::storage::SparseMatrixBuilder<double> builder;
ASSERT_NO_THROW(builder.addNextValue(0, 0, 2));
ASSERT_NO_THROW(builder.addNextValue(0, 1, 4));
ASSERT_NO_THROW(builder.addNextValue(0, 2, -2));
ASSERT_NO_THROW(builder.addNextValue(1, 0, 4));
ASSERT_NO_THROW(builder.addNextValue(1, 1, -1));
ASSERT_NO_THROW(builder.addNextValue(1, 2, 5));
ASSERT_NO_THROW(builder.addNextValue(2, 0, -1));
ASSERT_NO_THROW(builder.addNextValue(2, 1, -1));
ASSERT_NO_THROW(builder.addNextValue(2, 2, 3));
storm::storage::SparseMatrix<double> A;
ASSERT_NO_THROW(A = builder.build());
std::vector<double> x(3);
std::vector<double> b = {16, -4, -7};
storm::solver::EigenLinearEquationSolver<double> solver(A);
solver.getSettings().setSolutionMethod(storm::solver::EigenLinearEquationSolverSettings<double>::SolutionMethod::DGMRES);
solver.getSettings().setPrecision(1e-6);
solver.getSettings().setMaximalNumberOfIterations(10000);
solver.getSettings().setPreconditioner(storm::solver::EigenLinearEquationSolverSettings<double>::Preconditioner::Diagonal);
ASSERT_NO_THROW(solver.solveEquationSystem(x, b));
ASSERT_LT(std::abs(x[0] - 1), storm::settings::getModule<storm::settings::modules::EigenEquationSolverSettings>().getPrecision());
ASSERT_LT(std::abs(x[1] - 3), storm::settings::getModule<storm::settings::modules::EigenEquationSolverSettings>().getPrecision());
ASSERT_LT(std::abs(x[2] - (-1)), storm::settings::getModule<storm::settings::modules::EigenEquationSolverSettings>().getPrecision());
}
TEST(DISABLED_EigenLinearEquationSolver, GMRES) {
ASSERT_NO_THROW(storm::storage::SparseMatrixBuilder<double> builder);
storm::storage::SparseMatrixBuilder<double> builder;
ASSERT_NO_THROW(builder.addNextValue(0, 0, 2));
ASSERT_NO_THROW(builder.addNextValue(0, 1, 4));
ASSERT_NO_THROW(builder.addNextValue(0, 2, -2));
ASSERT_NO_THROW(builder.addNextValue(1, 0, 4));
ASSERT_NO_THROW(builder.addNextValue(1, 1, -1));
ASSERT_NO_THROW(builder.addNextValue(1, 2, 5));
ASSERT_NO_THROW(builder.addNextValue(2, 0, -1));
ASSERT_NO_THROW(builder.addNextValue(2, 1, -1));
ASSERT_NO_THROW(builder.addNextValue(2, 2, 3));
storm::storage::SparseMatrix<double> A;
ASSERT_NO_THROW(A = builder.build());
std::vector<double> x(3);
std::vector<double> b = {16, -4, -7};
storm::solver::EigenLinearEquationSolver<double> solver(A);
solver.getSettings().setSolutionMethod(storm::solver::EigenLinearEquationSolverSettings<double>::SolutionMethod::GMRES);
solver.getSettings().setPrecision(1e-6);
solver.getSettings().setMaximalNumberOfIterations(10000);
solver.getSettings().setPreconditioner(storm::solver::EigenLinearEquationSolverSettings<double>::Preconditioner::None);
solver.getSettings().setNumberOfIterationsUntilRestart(50);
ASSERT_NO_THROW(solver.solveEquationSystem(x, b));
ASSERT_LT(std::abs(x[0] - 1), storm::settings::getModule<storm::settings::modules::EigenEquationSolverSettings>().getPrecision());
ASSERT_LT(std::abs(x[1] - 3), storm::settings::getModule<storm::settings::modules::EigenEquationSolverSettings>().getPrecision());
ASSERT_LT(std::abs(x[2] - (-1)), storm::settings::getModule<storm::settings::modules::EigenEquationSolverSettings>().getPrecision());
}
TEST(DISABLED_EigenLinearEquationSolver, GMRES_Ilu) {
ASSERT_NO_THROW(storm::storage::SparseMatrixBuilder<double> builder);
storm::storage::SparseMatrixBuilder<double> builder;
ASSERT_NO_THROW(builder.addNextValue(0, 0, 2));
ASSERT_NO_THROW(builder.addNextValue(0, 1, 4));
ASSERT_NO_THROW(builder.addNextValue(0, 2, -2));
ASSERT_NO_THROW(builder.addNextValue(1, 0, 4));
ASSERT_NO_THROW(builder.addNextValue(1, 1, -1));
ASSERT_NO_THROW(builder.addNextValue(1, 2, 5));
ASSERT_NO_THROW(builder.addNextValue(2, 0, -1));
ASSERT_NO_THROW(builder.addNextValue(2, 1, -1));
ASSERT_NO_THROW(builder.addNextValue(2, 2, 3));
storm::storage::SparseMatrix<double> A;
ASSERT_NO_THROW(A = builder.build());
std::vector<double> x(3);
std::vector<double> b = {16, -4, -7};
storm::solver::EigenLinearEquationSolver<double> solver(A);
solver.getSettings().setSolutionMethod(storm::solver::EigenLinearEquationSolverSettings<double>::SolutionMethod::GMRES);
solver.getSettings().setPrecision(1e-6);
solver.getSettings().setMaximalNumberOfIterations(10000);
solver.getSettings().setPreconditioner(storm::solver::EigenLinearEquationSolverSettings<double>::Preconditioner::Ilu);
ASSERT_NO_THROW(solver.solveEquationSystem(x, b));
ASSERT_LT(std::abs(x[0] - 1), storm::settings::getModule<storm::settings::modules::EigenEquationSolverSettings>().getPrecision());
ASSERT_LT(std::abs(x[1] - 3), storm::settings::getModule<storm::settings::modules::EigenEquationSolverSettings>().getPrecision());
ASSERT_LT(std::abs(x[2] - (-1)), storm::settings::getModule<storm::settings::modules::EigenEquationSolverSettings>().getPrecision());
}
TEST(DISABLED_EigenLinearEquationSolver, GMRES_Diagonal) {
ASSERT_NO_THROW(storm::storage::SparseMatrixBuilder<double> builder);
storm::storage::SparseMatrixBuilder<double> builder;
ASSERT_NO_THROW(builder.addNextValue(0, 0, 2));
ASSERT_NO_THROW(builder.addNextValue(0, 1, 4));
ASSERT_NO_THROW(builder.addNextValue(0, 2, -2));
ASSERT_NO_THROW(builder.addNextValue(1, 0, 4));
ASSERT_NO_THROW(builder.addNextValue(1, 1, -1));
ASSERT_NO_THROW(builder.addNextValue(1, 2, 5));
ASSERT_NO_THROW(builder.addNextValue(2, 0, -1));
ASSERT_NO_THROW(builder.addNextValue(2, 1, -1));
ASSERT_NO_THROW(builder.addNextValue(2, 2, 3));
storm::storage::SparseMatrix<double> A;
ASSERT_NO_THROW(A = builder.build());
std::vector<double> x(3);
std::vector<double> b = {16, -4, -7};
storm::solver::EigenLinearEquationSolver<double> solver(A);
solver.getSettings().setSolutionMethod(storm::solver::EigenLinearEquationSolverSettings<double>::SolutionMethod::GMRES);
solver.getSettings().setPrecision(1e-6);
solver.getSettings().setMaximalNumberOfIterations(10000);
solver.getSettings().setPreconditioner(storm::solver::EigenLinearEquationSolverSettings<double>::Preconditioner::Diagonal);
ASSERT_NO_THROW(solver.solveEquationSystem(x, b));
ASSERT_LT(std::abs(x[0] - 1), storm::settings::getModule<storm::settings::modules::EigenEquationSolverSettings>().getPrecision());
ASSERT_LT(std::abs(x[1] - 3), storm::settings::getModule<storm::settings::modules::EigenEquationSolverSettings>().getPrecision());
ASSERT_LT(std::abs(x[2] - (-1)), storm::settings::getModule<storm::settings::modules::EigenEquationSolverSettings>().getPrecision());
}
TEST(DISABLED_EigenLinearEquationSolver, BiCGSTAB) { TEST(DISABLED_EigenLinearEquationSolver, BiCGSTAB) {
ASSERT_NO_THROW(storm::storage::SparseMatrixBuilder<double> builder); ASSERT_NO_THROW(storm::storage::SparseMatrixBuilder<double> builder);
storm::storage::SparseMatrixBuilder<double> builder; storm::storage::SparseMatrixBuilder<double> builder;
@ -136,7 +320,7 @@ TEST(DISABLED_EigenLinearEquationSolver, BiCGSTAB) {
std::vector<double> b = {16, -4, -7}; std::vector<double> b = {16, -4, -7};
storm::solver::EigenLinearEquationSolver<double> solver(A); storm::solver::EigenLinearEquationSolver<double> solver(A);
solver.getSettings().setSolutionMethod(storm::solver::EigenLinearEquationSolverSettings<double>::SolutionMethod::Bicgstab);
solver.getSettings().setSolutionMethod(storm::solver::EigenLinearEquationSolverSettings<double>::SolutionMethod::BiCGSTAB);
solver.getSettings().setPrecision(1e-6); solver.getSettings().setPrecision(1e-6);
solver.getSettings().setMaximalNumberOfIterations(10000); solver.getSettings().setMaximalNumberOfIterations(10000);
solver.getSettings().setPreconditioner(storm::solver::EigenLinearEquationSolverSettings<double>::Preconditioner::None); solver.getSettings().setPreconditioner(storm::solver::EigenLinearEquationSolverSettings<double>::Preconditioner::None);
@ -167,7 +351,7 @@ TEST(DISABLED_EigenLinearEquationSolver, BiCGSTAB_Ilu) {
std::vector<double> b = {16, -4, -7}; std::vector<double> b = {16, -4, -7};
storm::solver::EigenLinearEquationSolver<double> solver(A); storm::solver::EigenLinearEquationSolver<double> solver(A);
solver.getSettings().setSolutionMethod(storm::solver::EigenLinearEquationSolverSettings<double>::SolutionMethod::Bicgstab);
solver.getSettings().setSolutionMethod(storm::solver::EigenLinearEquationSolverSettings<double>::SolutionMethod::BiCGSTAB);
solver.getSettings().setPrecision(1e-6); solver.getSettings().setPrecision(1e-6);
solver.getSettings().setMaximalNumberOfIterations(10000); solver.getSettings().setMaximalNumberOfIterations(10000);
solver.getSettings().setPreconditioner(storm::solver::EigenLinearEquationSolverSettings<double>::Preconditioner::Ilu); solver.getSettings().setPreconditioner(storm::solver::EigenLinearEquationSolverSettings<double>::Preconditioner::Ilu);
@ -197,7 +381,7 @@ TEST(DISABLED_EigenLinearEquationSolver, BiCGSTAB_Diagonal) {
std::vector<double> b = {16, -4, -7}; std::vector<double> b = {16, -4, -7};
storm::solver::EigenLinearEquationSolver<double> solver(A); storm::solver::EigenLinearEquationSolver<double> solver(A);
solver.getSettings().setSolutionMethod(storm::solver::EigenLinearEquationSolverSettings<double>::SolutionMethod::Bicgstab);
solver.getSettings().setSolutionMethod(storm::solver::EigenLinearEquationSolverSettings<double>::SolutionMethod::BiCGSTAB);
solver.getSettings().setPrecision(1e-6); solver.getSettings().setPrecision(1e-6);
solver.getSettings().setMaximalNumberOfIterations(10000); solver.getSettings().setMaximalNumberOfIterations(10000);
solver.getSettings().setPreconditioner(storm::solver::EigenLinearEquationSolverSettings<double>::Preconditioner::Diagonal); solver.getSettings().setPreconditioner(storm::solver::EigenLinearEquationSolverSettings<double>::Preconditioner::Diagonal);

Write Preview
Loading…
Cancel
Save