From 07c787b49de0dad94517af0c2a00ab448a7d182f Mon Sep 17 00:00:00 2001 From: dehnert Date: Fri, 24 Jun 2016 20:34:35 +0200 Subject: [PATCH] added unsupported solvers of eigen Former-commit-id: e11b335c2dad4822c5d4bf145bd4b39e29ca7018 --- .../IterativeSolvers/ConstrainedConjGrad.h | 2 + .../modules/EigenEquationSolverSettings.cpp | 21 +- .../modules/EigenEquationSolverSettings.h | 17 +- src/solver/EigenLinearEquationSolver.cpp | 83 ++++++-- src/solver/EigenLinearEquationSolver.h | 7 +- src/utility/eigen.h | 1 + .../solver/EigenLinearEquationSolverTest.cpp | 190 +++++++++++++++++- 7 files changed, 297 insertions(+), 24 deletions(-) diff --git a/resources/3rdparty/eigen-3.3-beta1/unsupported/Eigen/src/IterativeSolvers/ConstrainedConjGrad.h b/resources/3rdparty/eigen-3.3-beta1/unsupported/Eigen/src/IterativeSolvers/ConstrainedConjGrad.h index dc0093eb9..792a18425 100644 --- a/resources/3rdparty/eigen-3.3-beta1/unsupported/Eigen/src/IterativeSolvers/ConstrainedConjGrad.h +++ b/resources/3rdparty/eigen-3.3-beta1/unsupported/Eigen/src/IterativeSolvers/ConstrainedConjGrad.h @@ -26,6 +26,8 @@ // //======================================================================== +#include + #include "../../../../Eigen/src/Core/util/NonMPL2.h" #ifndef EIGEN_CONSTRAINEDCG_H diff --git a/src/settings/modules/EigenEquationSolverSettings.cpp b/src/settings/modules/EigenEquationSolverSettings.cpp index 568650c0a..f61b0414c 100644 --- a/src/settings/modules/EigenEquationSolverSettings.cpp +++ b/src/settings/modules/EigenEquationSolverSettings.cpp @@ -19,15 +19,18 @@ namespace storm { const std::string EigenEquationSolverSettings::maximalIterationsOptionName = "maxiter"; const std::string EigenEquationSolverSettings::maximalIterationsOptionShortName = "i"; const std::string EigenEquationSolverSettings::precisionOptionName = "precision"; + const std::string EigenEquationSolverSettings::restartOptionName = "restart"; EigenEquationSolverSettings::EigenEquationSolverSettings() : ModuleSettings(moduleName) { - std::vector 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 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. std::vector 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, 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, 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") { return EigenEquationSolverSettings::LinearEquationMethod::SparseLU; } 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."); } @@ -63,6 +70,14 @@ namespace storm { 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 { return this->getOption(maximalIterationsOptionName).getHasOptionBeenSet(); } diff --git a/src/settings/modules/EigenEquationSolverSettings.h b/src/settings/modules/EigenEquationSolverSettings.h index d415b2c31..a3a7dcf26 100644 --- a/src/settings/modules/EigenEquationSolverSettings.h +++ b/src/settings/modules/EigenEquationSolverSettings.h @@ -12,7 +12,7 @@ namespace storm { class EigenEquationSolverSettings : public ModuleSettings { public: // 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. enum class PreconditioningMethod { Ilu, Diagonal, None }; @@ -53,6 +53,20 @@ namespace storm { */ 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. * @@ -93,6 +107,7 @@ namespace storm { static const std::string maximalIterationsOptionName; static const std::string maximalIterationsOptionShortName; static const std::string precisionOptionName; + static const std::string restartOptionName; }; } // namespace modules diff --git a/src/solver/EigenLinearEquationSolver.cpp b/src/solver/EigenLinearEquationSolver.cpp index 34eda29cc..995ea2612 100644 --- a/src/solver/EigenLinearEquationSolver.cpp +++ b/src/solver/EigenLinearEquationSolver.cpp @@ -19,13 +19,18 @@ namespace storm { // Get appropriate settings. maximalNumberOfIterations = settings.getMaximalIterationCount(); precision = settings.getPrecision(); + restart = settings.getRestartIterationCount(); // Determine the method to be used. 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) { 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. @@ -59,6 +64,11 @@ namespace storm { this->maximalNumberOfIterations = maximalNumberOfIterations; } + template + void EigenLinearEquationSolverSettings::setNumberOfIterationsUntilRestart(uint64_t restart) { + this->restart = restart; + } + template typename EigenLinearEquationSolverSettings::SolutionMethod EigenLinearEquationSolverSettings::getSolutionMethod() const { return this->method; @@ -78,6 +88,11 @@ namespace storm { uint64_t EigenLinearEquationSolverSettings::getMaximalNumberOfIterations() const { return this->maximalNumberOfIterations; } + + template + uint64_t EigenLinearEquationSolverSettings::getNumberOfIterationsUntilRestart() const { + return restart; + } EigenLinearEquationSolverSettings::EigenLinearEquationSolverSettings() { // Intentionally left empty. @@ -104,23 +119,61 @@ namespace storm { auto eigenX = Eigen::Matrix::Map(x.data(), x.size()); auto eigenB = Eigen::Matrix::Map(b.data(), b.size()); - if (this->getSettings().getSolutionMethod() == EigenLinearEquationSolverSettings::SolutionMethod::SparseLU) { + typename EigenLinearEquationSolverSettings::SolutionMethod solutionMethod = this->getSettings().getSolutionMethod(); + if (solutionMethod == EigenLinearEquationSolverSettings::SolutionMethod::SparseLU) { Eigen::SparseLU, Eigen::COLAMDOrdering> solver; solver.compute(*this->eigenA); solver._solve_impl(eigenB, eigenX); } else { - if (this->getSettings().getPreconditioner() == EigenLinearEquationSolverSettings::Preconditioner::Ilu) { - Eigen::BiCGSTAB, Eigen::IncompleteLUT> solver; - solver.compute(*this->eigenA); - solver.solveWithGuess(eigenB, eigenX); - } else if (this->getSettings().getPreconditioner() == EigenLinearEquationSolverSettings::Preconditioner::Diagonal) { - Eigen::BiCGSTAB, Eigen::DiagonalPreconditioner> solver; - solver.compute(*this->eigenA); - solver.solveWithGuess(eigenB, eigenX); - } else { - Eigen::BiCGSTAB, Eigen::IdentityPreconditioner> solver; - solver.compute(*this->eigenA); - solver.solveWithGuess(eigenB, eigenX); + typename EigenLinearEquationSolverSettings::Preconditioner preconditioner = this->getSettings().getPreconditioner(); + if (solutionMethod == EigenLinearEquationSolverSettings::SolutionMethod::BiCGSTAB) { + if (preconditioner == EigenLinearEquationSolverSettings::Preconditioner::Ilu) { + Eigen::BiCGSTAB, Eigen::IncompleteLUT> solver; + solver.compute(*this->eigenA); + solver.solveWithGuess(eigenB, eigenX); + } else if (preconditioner == EigenLinearEquationSolverSettings::Preconditioner::Diagonal) { + Eigen::BiCGSTAB, Eigen::DiagonalPreconditioner> solver; + solver.compute(*this->eigenA); + solver.solveWithGuess(eigenB, eigenX); + } else { + Eigen::BiCGSTAB, Eigen::IdentityPreconditioner> solver; + solver.compute(*this->eigenA); + solver.solveWithGuess(eigenB, eigenX); + } + } else if (solutionMethod == EigenLinearEquationSolverSettings::SolutionMethod::DGMRES) { + if (preconditioner == EigenLinearEquationSolverSettings::Preconditioner::Ilu) { + Eigen::DGMRES, Eigen::IncompleteLUT> solver; + solver.set_restart(this->getSettings().getNumberOfIterationsUntilRestart()); + solver.compute(*this->eigenA); + solver.solveWithGuess(eigenB, eigenX); + } else if (preconditioner == EigenLinearEquationSolverSettings::Preconditioner::Diagonal) { + Eigen::DGMRES, Eigen::DiagonalPreconditioner> solver; + solver.set_restart(this->getSettings().getNumberOfIterationsUntilRestart()); + solver.compute(*this->eigenA); + solver.solveWithGuess(eigenB, eigenX); + } else { + Eigen::DGMRES, Eigen::IdentityPreconditioner> solver; + solver.set_restart(this->getSettings().getNumberOfIterationsUntilRestart()); + solver.compute(*this->eigenA); + solver.solveWithGuess(eigenB, eigenX); + } + } else if (solutionMethod == EigenLinearEquationSolverSettings::SolutionMethod::GMRES) { + if (preconditioner == EigenLinearEquationSolverSettings::Preconditioner::Ilu) { + Eigen::GMRES, Eigen::IncompleteLUT> solver; + solver.set_restart(this->getSettings().getNumberOfIterationsUntilRestart()); + solver.compute(*this->eigenA); + solver.solveWithGuess(eigenB, eigenX); + } else if (preconditioner == EigenLinearEquationSolverSettings::Preconditioner::Diagonal) { + Eigen::GMRES, Eigen::DiagonalPreconditioner> solver; + solver.set_restart(this->getSettings().getNumberOfIterationsUntilRestart()); + solver.compute(*this->eigenA); + solver.solveWithGuess(eigenB, eigenX); + } else { + Eigen::GMRES, Eigen::IdentityPreconditioner> solver; + solver.set_restart(this->getSettings().getNumberOfIterationsUntilRestart()); + solver.compute(*this->eigenA); + solver.solveWithGuess(eigenB, eigenX); + } } } } diff --git a/src/solver/EigenLinearEquationSolver.h b/src/solver/EigenLinearEquationSolver.h index 6aa770d7e..40768b4a7 100644 --- a/src/solver/EigenLinearEquationSolver.h +++ b/src/solver/EigenLinearEquationSolver.h @@ -11,7 +11,7 @@ namespace storm { class EigenLinearEquationSolverSettings { public: enum class SolutionMethod { - SparseLU, Bicgstab + SparseLU, BiCGSTAB, DGMRES, GMRES }; enum class Preconditioner { @@ -24,17 +24,20 @@ namespace storm { void setPreconditioner(Preconditioner const& preconditioner); void setPrecision(ValueType precision); void setMaximalNumberOfIterations(uint64_t maximalNumberOfIterations); - + void setNumberOfIterationsUntilRestart(uint64_t restart); + SolutionMethod getSolutionMethod() const; Preconditioner getPreconditioner() const; ValueType getPrecision() const; uint64_t getMaximalNumberOfIterations() const; + uint64_t getNumberOfIterationsUntilRestart() const; private: SolutionMethod method; Preconditioner preconditioner; double precision; uint64_t maximalNumberOfIterations; + uint_fast64_t restart; }; template<> diff --git a/src/utility/eigen.h b/src/utility/eigen.h index 5967852fd..9b53b7430 100644 --- a/src/utility/eigen.h +++ b/src/utility/eigen.h @@ -5,3 +5,4 @@ // Finally include the parts of Eigen we need. #include +#include \ No newline at end of file diff --git a/test/functional/solver/EigenLinearEquationSolverTest.cpp b/test/functional/solver/EigenLinearEquationSolverTest.cpp index 5bc1b4a42..126eeaf3a 100644 --- a/test/functional/solver/EigenLinearEquationSolverTest.cpp +++ b/test/functional/solver/EigenLinearEquationSolverTest.cpp @@ -116,6 +116,190 @@ TEST(EigenLinearEquationSolver, SparseLU_RationalFunction) { ASSERT_TRUE(x[2] == storm::RationalFunction(-1)); } +TEST(DISABLED_EigenLinearEquationSolver, DGMRES) { + ASSERT_NO_THROW(storm::storage::SparseMatrixBuilder builder); + storm::storage::SparseMatrixBuilder 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 A; + ASSERT_NO_THROW(A = builder.build()); + + std::vector x(3); + std::vector b = {16, -4, -7}; + + storm::solver::EigenLinearEquationSolver solver(A); + solver.getSettings().setSolutionMethod(storm::solver::EigenLinearEquationSolverSettings::SolutionMethod::DGMRES); + solver.getSettings().setPrecision(1e-6); + solver.getSettings().setMaximalNumberOfIterations(10000); + solver.getSettings().setPreconditioner(storm::solver::EigenLinearEquationSolverSettings::Preconditioner::None); + solver.getSettings().setNumberOfIterationsUntilRestart(50); + + ASSERT_NO_THROW(solver.solveEquationSystem(x, b)); + ASSERT_LT(std::abs(x[0] - 1), storm::settings::getModule().getPrecision()); + ASSERT_LT(std::abs(x[1] - 3), storm::settings::getModule().getPrecision()); + ASSERT_LT(std::abs(x[2] - (-1)), storm::settings::getModule().getPrecision()); +} + +TEST(DISABLED_EigenLinearEquationSolver, DGMRES_Ilu) { + ASSERT_NO_THROW(storm::storage::SparseMatrixBuilder builder); + storm::storage::SparseMatrixBuilder 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 A; + ASSERT_NO_THROW(A = builder.build()); + + std::vector x(3); + std::vector b = {16, -4, -7}; + + storm::solver::EigenLinearEquationSolver solver(A); + solver.getSettings().setSolutionMethod(storm::solver::EigenLinearEquationSolverSettings::SolutionMethod::DGMRES); + solver.getSettings().setPrecision(1e-6); + solver.getSettings().setMaximalNumberOfIterations(10000); + solver.getSettings().setPreconditioner(storm::solver::EigenLinearEquationSolverSettings::Preconditioner::Ilu); + ASSERT_NO_THROW(solver.solveEquationSystem(x, b)); + ASSERT_LT(std::abs(x[0] - 1), storm::settings::getModule().getPrecision()); + ASSERT_LT(std::abs(x[1] - 3), storm::settings::getModule().getPrecision()); + ASSERT_LT(std::abs(x[2] - (-1)), storm::settings::getModule().getPrecision()); +} + +TEST(DISABLED_EigenLinearEquationSolver, DGMRES_Diagonal) { + ASSERT_NO_THROW(storm::storage::SparseMatrixBuilder builder); + storm::storage::SparseMatrixBuilder 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 A; + ASSERT_NO_THROW(A = builder.build()); + + std::vector x(3); + std::vector b = {16, -4, -7}; + + storm::solver::EigenLinearEquationSolver solver(A); + solver.getSettings().setSolutionMethod(storm::solver::EigenLinearEquationSolverSettings::SolutionMethod::DGMRES); + solver.getSettings().setPrecision(1e-6); + solver.getSettings().setMaximalNumberOfIterations(10000); + solver.getSettings().setPreconditioner(storm::solver::EigenLinearEquationSolverSettings::Preconditioner::Diagonal); + ASSERT_NO_THROW(solver.solveEquationSystem(x, b)); + ASSERT_LT(std::abs(x[0] - 1), storm::settings::getModule().getPrecision()); + ASSERT_LT(std::abs(x[1] - 3), storm::settings::getModule().getPrecision()); + ASSERT_LT(std::abs(x[2] - (-1)), storm::settings::getModule().getPrecision()); +} + +TEST(DISABLED_EigenLinearEquationSolver, GMRES) { + ASSERT_NO_THROW(storm::storage::SparseMatrixBuilder builder); + storm::storage::SparseMatrixBuilder 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 A; + ASSERT_NO_THROW(A = builder.build()); + + std::vector x(3); + std::vector b = {16, -4, -7}; + + storm::solver::EigenLinearEquationSolver solver(A); + solver.getSettings().setSolutionMethod(storm::solver::EigenLinearEquationSolverSettings::SolutionMethod::GMRES); + solver.getSettings().setPrecision(1e-6); + solver.getSettings().setMaximalNumberOfIterations(10000); + solver.getSettings().setPreconditioner(storm::solver::EigenLinearEquationSolverSettings::Preconditioner::None); + solver.getSettings().setNumberOfIterationsUntilRestart(50); + + ASSERT_NO_THROW(solver.solveEquationSystem(x, b)); + ASSERT_LT(std::abs(x[0] - 1), storm::settings::getModule().getPrecision()); + ASSERT_LT(std::abs(x[1] - 3), storm::settings::getModule().getPrecision()); + ASSERT_LT(std::abs(x[2] - (-1)), storm::settings::getModule().getPrecision()); +} + +TEST(DISABLED_EigenLinearEquationSolver, GMRES_Ilu) { + ASSERT_NO_THROW(storm::storage::SparseMatrixBuilder builder); + storm::storage::SparseMatrixBuilder 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 A; + ASSERT_NO_THROW(A = builder.build()); + + std::vector x(3); + std::vector b = {16, -4, -7}; + + storm::solver::EigenLinearEquationSolver solver(A); + solver.getSettings().setSolutionMethod(storm::solver::EigenLinearEquationSolverSettings::SolutionMethod::GMRES); + solver.getSettings().setPrecision(1e-6); + solver.getSettings().setMaximalNumberOfIterations(10000); + solver.getSettings().setPreconditioner(storm::solver::EigenLinearEquationSolverSettings::Preconditioner::Ilu); + ASSERT_NO_THROW(solver.solveEquationSystem(x, b)); + ASSERT_LT(std::abs(x[0] - 1), storm::settings::getModule().getPrecision()); + ASSERT_LT(std::abs(x[1] - 3), storm::settings::getModule().getPrecision()); + ASSERT_LT(std::abs(x[2] - (-1)), storm::settings::getModule().getPrecision()); +} + +TEST(DISABLED_EigenLinearEquationSolver, GMRES_Diagonal) { + ASSERT_NO_THROW(storm::storage::SparseMatrixBuilder builder); + storm::storage::SparseMatrixBuilder 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 A; + ASSERT_NO_THROW(A = builder.build()); + + std::vector x(3); + std::vector b = {16, -4, -7}; + + storm::solver::EigenLinearEquationSolver solver(A); + solver.getSettings().setSolutionMethod(storm::solver::EigenLinearEquationSolverSettings::SolutionMethod::GMRES); + solver.getSettings().setPrecision(1e-6); + solver.getSettings().setMaximalNumberOfIterations(10000); + solver.getSettings().setPreconditioner(storm::solver::EigenLinearEquationSolverSettings::Preconditioner::Diagonal); + ASSERT_NO_THROW(solver.solveEquationSystem(x, b)); + ASSERT_LT(std::abs(x[0] - 1), storm::settings::getModule().getPrecision()); + ASSERT_LT(std::abs(x[1] - 3), storm::settings::getModule().getPrecision()); + ASSERT_LT(std::abs(x[2] - (-1)), storm::settings::getModule().getPrecision()); +} + TEST(DISABLED_EigenLinearEquationSolver, BiCGSTAB) { ASSERT_NO_THROW(storm::storage::SparseMatrixBuilder builder); storm::storage::SparseMatrixBuilder builder; @@ -136,7 +320,7 @@ TEST(DISABLED_EigenLinearEquationSolver, BiCGSTAB) { std::vector b = {16, -4, -7}; storm::solver::EigenLinearEquationSolver solver(A); - solver.getSettings().setSolutionMethod(storm::solver::EigenLinearEquationSolverSettings::SolutionMethod::Bicgstab); + solver.getSettings().setSolutionMethod(storm::solver::EigenLinearEquationSolverSettings::SolutionMethod::BiCGSTAB); solver.getSettings().setPrecision(1e-6); solver.getSettings().setMaximalNumberOfIterations(10000); solver.getSettings().setPreconditioner(storm::solver::EigenLinearEquationSolverSettings::Preconditioner::None); @@ -167,7 +351,7 @@ TEST(DISABLED_EigenLinearEquationSolver, BiCGSTAB_Ilu) { std::vector b = {16, -4, -7}; storm::solver::EigenLinearEquationSolver solver(A); - solver.getSettings().setSolutionMethod(storm::solver::EigenLinearEquationSolverSettings::SolutionMethod::Bicgstab); + solver.getSettings().setSolutionMethod(storm::solver::EigenLinearEquationSolverSettings::SolutionMethod::BiCGSTAB); solver.getSettings().setPrecision(1e-6); solver.getSettings().setMaximalNumberOfIterations(10000); solver.getSettings().setPreconditioner(storm::solver::EigenLinearEquationSolverSettings::Preconditioner::Ilu); @@ -197,7 +381,7 @@ TEST(DISABLED_EigenLinearEquationSolver, BiCGSTAB_Diagonal) { std::vector b = {16, -4, -7}; storm::solver::EigenLinearEquationSolver solver(A); - solver.getSettings().setSolutionMethod(storm::solver::EigenLinearEquationSolverSettings::SolutionMethod::Bicgstab); + solver.getSettings().setSolutionMethod(storm::solver::EigenLinearEquationSolverSettings::SolutionMethod::BiCGSTAB); solver.getSettings().setPrecision(1e-6); solver.getSettings().setMaximalNumberOfIterations(10000); solver.getSettings().setPreconditioner(storm::solver::EigenLinearEquationSolverSettings::Preconditioner::Diagonal);