diff --git a/src/test/storm/modelchecker/ConditionalDtmcPrctlModelCheckerTest.cpp b/src/test/storm/modelchecker/ConditionalDtmcPrctlModelCheckerTest.cpp new file mode 100644 index 000000000..a0377209c --- /dev/null +++ b/src/test/storm/modelchecker/ConditionalDtmcPrctlModelCheckerTest.cpp @@ -0,0 +1,170 @@ +#include "gtest/gtest.h" +#include "test/storm_gtest.h" +#include "storm-config.h" + +#include "storm/parser/FormulaParser.h" +#include "storm/logic/Formulas.h" +#include "storm/models/sparse/StandardRewardModel.h" +#include "storm/modelchecker/prctl/SparseDtmcPrctlModelChecker.h" +#include "storm/modelchecker/results/ExplicitQuantitativeCheckResult.h" +#include "storm/parser/PrismParser.h" +#include "storm/api/builder.h" +#include "storm/storage/expressions/ExpressionManager.h" + +#include "storm/environment/solver/GmmxxSolverEnvironment.h" +#include "storm/environment/solver/EigenSolverEnvironment.h" +#include "storm/environment/solver/NativeSolverEnvironment.h" + +namespace { + + class GmmxxDoubleGmresEnvironment { + public: + typedef storm::RationalNumber ValueType; + static const bool isExact = false; + static storm::Environment createEnvironment() { + storm::Environment env; + env.solver().setLinearEquationSolverType(storm::solver::EquationSolverType::Gmmxx); + env.solver().gmmxx().setMethod(storm::solver::GmmxxLinearEquationSolverMethod::Gmres); + env.solver().gmmxx().setPreconditioner(storm::solver::GmmxxLinearEquationSolverPreconditioner::Ilu); + env.solver().gmmxx().setPrecision(storm::utility::convertNumber<ValueType>(1e-8)); + return env; + } + }; + + class EigenDoubleDGmresEnvironment { + public: + typedef storm::RationalNumber ValueType; + static const bool isExact = false; + static storm::Environment createEnvironment() { + storm::Environment env; + env.solver().setLinearEquationSolverType(storm::solver::EquationSolverType::Eigen); + env.solver().eigen().setMethod(storm::solver::EigenLinearEquationSolverMethod::DGmres); + env.solver().eigen().setPreconditioner(storm::solver::EigenLinearEquationSolverPreconditioner::Ilu); + env.solver().eigen().setPrecision(storm::utility::convertNumber<ValueType>(1e-8)); + return env; + } + }; + + class EigenRationalLUEnvironment { + public: + typedef storm::RationalNumber ValueType; + static const bool isExact = true; + static storm::Environment createEnvironment() { + storm::Environment env; + env.solver().setLinearEquationSolverType(storm::solver::EquationSolverType::Eigen); + env.solver().eigen().setMethod(storm::solver::EigenLinearEquationSolverMethod::SparseLU); + return env; + } + }; + + class NativeSorEnvironment { + public: + typedef double ValueType; + static const bool isExact = false; + static storm::Environment createEnvironment() { + storm::Environment env; + env.solver().setLinearEquationSolverType(storm::solver::EquationSolverType::Native); + env.solver().native().setMethod(storm::solver::NativeLinearEquationSolverMethod::SOR); + env.solver().native().setSorOmega(storm::utility::convertNumber<ValueType>(0.9)); + env.solver().native().setPrecision(storm::utility::convertNumber<storm::RationalNumber>(1e-8)); + return env; + } + }; + + class NativePowerEnvironment { + public: + typedef double ValueType; + static const bool isExact = false; + static storm::Environment createEnvironment() { + storm::Environment env; + env.solver().setLinearEquationSolverType(storm::solver::EquationSolverType::Native); + env.solver().native().setMethod(storm::solver::NativeLinearEquationSolverMethod::Power); + env.solver().native().setPrecision(storm::utility::convertNumber<storm::RationalNumber>(1e-8)); + return env; + } + }; + + class NativeWalkerChaeEnvironment { + public: + typedef double ValueType; + static const bool isExact = false; + static storm::Environment createEnvironment() { + storm::Environment env; + env.solver().setLinearEquationSolverType(storm::solver::EquationSolverType::Native); + env.solver().native().setMethod(storm::solver::NativeLinearEquationSolverMethod::WalkerChae); + env.solver().native().setPrecision(storm::utility::convertNumber<storm::RationalNumber>(1e-8)); + env.solver().native().setMaximalNumberOfIterations(50000); + return env; + } + }; + + template<typename TestType> + class ConditionalDtmcPrctlModelCheckerTest : public ::testing::Test { + public: + typedef typename TestType::ValueType ValueType; + ConditionalDtmcPrctlModelCheckerTest() : _environment(TestType::createEnvironment()) {} + storm::Environment const& env() const { return _environment; } + ValueType parseNumber(std::string const& input) const { return storm::utility::convertNumber<ValueType>(input);} + ValueType precision() const { return TestType::isExact ? parseNumber("0") : parseNumber("1e-6");} + + private: + storm::Environment _environment; + }; + + typedef ::testing::Types< + GmmxxDoubleGmresEnvironment, + EigenDoubleDGmresEnvironment, + EigenRationalLUEnvironment, + NativeSorEnvironment, + NativePowerEnvironment, + NativeWalkerChaeEnvironment + > TestingTypes; + + TYPED_TEST_CASE(ConditionalDtmcPrctlModelCheckerTest, TestingTypes); + + + TYPED_TEST(ConditionalDtmcPrctlModelCheckerTest, Conditional) { + typedef typename TestFixture::ValueType ValueType; + + storm::prism::Program program = storm::parser::PrismParser::parse(STORM_TEST_RESOURCES_DIR "/dtmc/test_conditional.pm"); + + storm::generator::NextStateGeneratorOptions options; + options.setBuildAllLabels().setBuildAllRewardModels(); + std::shared_ptr<storm::models::sparse::Model<ValueType>> model = storm::builder::ExplicitModelBuilder<ValueType>(program, options).build(); + ASSERT_TRUE(model->getType() == storm::models::ModelType::Dtmc); + ASSERT_EQ(4ul, model->getNumberOfStates()); + ASSERT_EQ(5ul, model->getNumberOfTransitions()); + + std::shared_ptr<storm::models::sparse::Dtmc<ValueType>> dtmc = model->template as<storm::models::sparse::Dtmc<ValueType>>(); + + storm::modelchecker::SparseDtmcPrctlModelChecker<storm::models::sparse::Dtmc<ValueType>> checker(*dtmc); + + // A parser that we use for conveniently constructing the formulas. + + auto expManager = std::make_shared<storm::expressions::ExpressionManager>(); + storm::parser::FormulaParser formulaParser(expManager); + std::shared_ptr<storm::logic::Formula const> formula = formulaParser.parseSingleFormulaFromString("P=? [F \"target\"]"); + + std::unique_ptr<storm::modelchecker::CheckResult> result = checker.check(this->env(), *formula); + storm::modelchecker::ExplicitQuantitativeCheckResult<ValueType>& quantitativeResult1 = result->asExplicitQuantitativeCheckResult<ValueType>(); + EXPECT_NEAR(this->parseNumber("0.5"), quantitativeResult1[0], this->precision()); + + formula = formulaParser.parseSingleFormulaFromString("P=? [F \"target\" || F \"condition\"]"); + + result = checker.check(this->env(), *formula); + storm::modelchecker::ExplicitQuantitativeCheckResult<ValueType>& quantitativeResult2 = result->asExplicitQuantitativeCheckResult<ValueType>(); + EXPECT_NEAR(storm::utility::one<ValueType>(), quantitativeResult2[0], this->precision()); + + formula = formulaParser.parseSingleFormulaFromString("R=? [F \"target\"]"); + + result = checker.check(this->env(), *formula); + storm::modelchecker::ExplicitQuantitativeCheckResult<ValueType>& quantitativeResult3 = result->asExplicitQuantitativeCheckResult<ValueType>(); + EXPECT_EQ(storm::utility::infinity<ValueType>(), quantitativeResult3[0]); + + formula = formulaParser.parseSingleFormulaFromString("R=? [F \"target\" || F \"condition\"]"); + + result = checker.check(this->env(), *formula); + storm::modelchecker::ExplicitQuantitativeCheckResult<ValueType>& quantitativeResult4 = result->asExplicitQuantitativeCheckResult<ValueType>(); + EXPECT_NEAR(storm::utility::one<ValueType>(), quantitativeResult4[0], this->precision()); + } +} diff --git a/src/test/storm/modelchecker/CtmcCslModelCheckerTest.cpp b/src/test/storm/modelchecker/CtmcCslModelCheckerTest.cpp new file mode 100644 index 000000000..47a3f5e5b --- /dev/null +++ b/src/test/storm/modelchecker/CtmcCslModelCheckerTest.cpp @@ -0,0 +1,366 @@ +#include "gtest/gtest.h" +#include "test/storm_gtest.h" +#include "storm-config.h" + +#include "storm/api/builder.h" +#include "storm/api/model_descriptions.h" +#include "storm/api/properties.h" +#include "storm/parser/FormulaParser.h" +#include "storm/logic/Formulas.h" +#include "storm/solver/EigenLinearEquationSolver.h" +#include "storm/models/sparse/StandardRewardModel.h" +#include "storm/models/sparse/Ctmc.h" +#include "storm/models/symbolic/Ctmc.h" +#include "storm/modelchecker/csl/SparseCtmcCslModelChecker.h" +#include "storm/modelchecker/csl/HybridCtmcCslModelChecker.h" +#include "storm/modelchecker/results/QuantitativeCheckResult.h" +#include "storm/modelchecker/results/ExplicitQualitativeCheckResult.h" +#include "storm/modelchecker/results/SymbolicQualitativeCheckResult.h" +#include "storm/modelchecker/results/QualitativeCheckResult.h" +#include "storm/parser/PrismParser.h" +#include "storm/storage/expressions/ExpressionManager.h" +#include "storm/settings/modules/CoreSettings.h" +#include "storm/environment/solver/NativeSolverEnvironment.h" +#include "storm/environment/solver/GmmxxSolverEnvironment.h" +#include "storm/environment/solver/EigenSolverEnvironment.h" + +namespace { + + class SparseGmmxxGmresIluEnvironment { + public: + static const storm::dd::DdType ddType = storm::dd::DdType::Sylvan; // unused for sparse models + static const storm::settings::modules::CoreSettings::Engine engine = storm::settings::modules::CoreSettings::Engine::Sparse; + static const bool isExact = false; + typedef double ValueType; + typedef storm::models::sparse::Ctmc<ValueType> ModelType; + static storm::Environment createEnvironment() { + storm::Environment env; + env.solver().setLinearEquationSolverType(storm::solver::EquationSolverType::Gmmxx); + env.solver().gmmxx().setMethod(storm::solver::GmmxxLinearEquationSolverMethod::Gmres); + env.solver().gmmxx().setPreconditioner(storm::solver::GmmxxLinearEquationSolverPreconditioner::Ilu); + env.solver().gmmxx().setPrecision(storm::utility::convertNumber<storm::RationalNumber>(1e-8)); + return env; + } + }; + + class SparseEigenDGmresEnvironment { + public: + static const storm::dd::DdType ddType = storm::dd::DdType::Sylvan; // unused for sparse models + static const storm::settings::modules::CoreSettings::Engine engine = storm::settings::modules::CoreSettings::Engine::Sparse; + static const bool isExact = false; + typedef double ValueType; + typedef storm::models::sparse::Ctmc<ValueType> ModelType; + static storm::Environment createEnvironment() { + storm::Environment env; + env.solver().setLinearEquationSolverType(storm::solver::EquationSolverType::Eigen); + env.solver().eigen().setMethod(storm::solver::EigenLinearEquationSolverMethod::DGmres); + env.solver().eigen().setPreconditioner(storm::solver::EigenLinearEquationSolverPreconditioner::Ilu); + env.solver().eigen().setPrecision(storm::utility::convertNumber<storm::RationalNumber>(1e-8)); + return env; + } + }; + + class SparseEigenDoubleLUEnvironment { + public: + static const storm::dd::DdType ddType = storm::dd::DdType::Sylvan; // unused for sparse models + static const storm::settings::modules::CoreSettings::Engine engine = storm::settings::modules::CoreSettings::Engine::Sparse; + static const bool isExact = false; + typedef double ValueType; + typedef storm::models::sparse::Ctmc<ValueType> ModelType; + static storm::Environment createEnvironment() { + storm::Environment env; + env.solver().setLinearEquationSolverType(storm::solver::EquationSolverType::Eigen); + env.solver().eigen().setMethod(storm::solver::EigenLinearEquationSolverMethod::SparseLU); + return env; + } + }; + + class SparseNativeSorEnvironment { + public: + static const storm::dd::DdType ddType = storm::dd::DdType::Sylvan; // unused for sparse models + static const storm::settings::modules::CoreSettings::Engine engine = storm::settings::modules::CoreSettings::Engine::Sparse; + static const bool isExact = false; + typedef double ValueType; + typedef storm::models::sparse::Ctmc<ValueType> ModelType; + static storm::Environment createEnvironment() { + storm::Environment env; + env.solver().setLinearEquationSolverType(storm::solver::EquationSolverType::Native); + env.solver().native().setMethod(storm::solver::NativeLinearEquationSolverMethod::SOR); + env.solver().native().setPrecision(storm::utility::convertNumber<storm::RationalNumber>(1e-8)); + env.solver().native().setRelativeTerminationCriterion(false); + env.solver().native().setMaximalNumberOfIterations(5000000); + return env; + } + }; + + class HybridCuddGmmxxGmresEnvironment { + public: + static const storm::dd::DdType ddType = storm::dd::DdType::CUDD; + static const storm::settings::modules::CoreSettings::Engine engine = storm::settings::modules::CoreSettings::Engine::Hybrid; + static const bool isExact = false; + typedef double ValueType; + typedef storm::models::symbolic::Ctmc<ddType, ValueType> ModelType; + static storm::Environment createEnvironment() { + storm::Environment env; + env.solver().setLinearEquationSolverType(storm::solver::EquationSolverType::Gmmxx); + env.solver().gmmxx().setMethod(storm::solver::GmmxxLinearEquationSolverMethod::Gmres); + env.solver().gmmxx().setPrecision(storm::utility::convertNumber<storm::RationalNumber>(1e-8)); + return env; + } + }; + + class HybridSylvanGmmxxGmresEnvironment { + public: + static const storm::dd::DdType ddType = storm::dd::DdType::Sylvan; + static const storm::settings::modules::CoreSettings::Engine engine = storm::settings::modules::CoreSettings::Engine::Hybrid; + static const bool isExact = false; + typedef double ValueType; + typedef storm::models::symbolic::Ctmc<ddType, ValueType> ModelType; + static storm::Environment createEnvironment() { + storm::Environment env; + env.solver().setLinearEquationSolverType(storm::solver::EquationSolverType::Gmmxx); + env.solver().gmmxx().setMethod(storm::solver::GmmxxLinearEquationSolverMethod::Gmres); + env.solver().gmmxx().setPrecision(storm::utility::convertNumber<storm::RationalNumber>(1e-8)); + return env; + } + }; + + template<typename TestType> + class CtmcCslModelCheckerTest : public ::testing::Test { + public: + typedef typename TestType::ValueType ValueType; + typedef typename storm::models::sparse::Ctmc<ValueType> SparseModelType; + typedef typename storm::models::symbolic::Ctmc<TestType::ddType, ValueType> SymbolicModelType; + + CtmcCslModelCheckerTest() : _environment(TestType::createEnvironment()) {} + storm::Environment const& env() const { return _environment; } + ValueType parseNumber(std::string const& input) const { return storm::utility::convertNumber<ValueType>(input);} + ValueType precision() const { return TestType::isExact ? parseNumber("0") : parseNumber("1e-6");} + bool isSparseModel() const { return std::is_same<typename TestType::ModelType, SparseModelType>::value; } + bool isSymbolicModel() const { return std::is_same<typename TestType::ModelType, SymbolicModelType>::value; } + + template <typename MT = typename TestType::ModelType> + typename std::enable_if<std::is_same<MT, SparseModelType>::value, std::pair<std::shared_ptr<MT>, std::vector<std::shared_ptr<storm::logic::Formula const>>>>::type + buildModelFormulas(std::string const& pathToPrismFile, std::string const& formulasAsString, std::string const& constantDefinitionString = "") const { + std::pair<std::shared_ptr<MT>, std::vector<std::shared_ptr<storm::logic::Formula const>>> result; + storm::prism::Program program = storm::api::parseProgram(pathToPrismFile, true); + program = storm::utility::prism::preprocess(program, constantDefinitionString); + result.second = storm::api::extractFormulasFromProperties(storm::api::parsePropertiesForPrismProgram(formulasAsString, program)); + result.first = storm::api::buildSparseModel<ValueType>(program, result.second)->template as<MT>(); + return result; + } + + template <typename MT = typename TestType::ModelType> + typename std::enable_if<std::is_same<MT, SymbolicModelType>::value, std::pair<std::shared_ptr<MT>, std::vector<std::shared_ptr<storm::logic::Formula const>>>>::type + buildModelFormulas(std::string const& pathToPrismFile, std::string const& formulasAsString, std::string const& constantDefinitionString = "") const { + std::pair<std::shared_ptr<MT>, std::vector<std::shared_ptr<storm::logic::Formula const>>> result; + storm::prism::Program program = storm::api::parseProgram(pathToPrismFile, true); + program = storm::utility::prism::preprocess(program, constantDefinitionString); + result.second = storm::api::extractFormulasFromProperties(storm::api::parsePropertiesForPrismProgram(formulasAsString, program)); + result.first = storm::api::buildSymbolicModel<TestType::ddType, ValueType>(program, result.second)->template as<MT>(); + return result; + } + + std::vector<storm::modelchecker::CheckTask<storm::logic::Formula, ValueType>> getTasks(std::vector<std::shared_ptr<storm::logic::Formula const>> const& formulas) const { + std::vector<storm::modelchecker::CheckTask<storm::logic::Formula, ValueType>> result; + for (auto const& f : formulas) { + result.emplace_back(*f); + } + return result; + } + + template <typename MT = typename TestType::ModelType> + typename std::enable_if<std::is_same<MT, SparseModelType>::value, std::shared_ptr<storm::modelchecker::AbstractModelChecker<MT>>>::type + createModelChecker(std::shared_ptr<MT> const& model) const { + if (TestType::engine == storm::settings::modules::CoreSettings::Engine::Sparse) { + return std::make_shared<storm::modelchecker::SparseCtmcCslModelChecker<SparseModelType>>(*model); + } + } + + template <typename MT = typename TestType::ModelType> + typename std::enable_if<std::is_same<MT, SymbolicModelType>::value, std::shared_ptr<storm::modelchecker::AbstractModelChecker<MT>>>::type + createModelChecker(std::shared_ptr<MT> const& model) const { + if (TestType::engine == storm::settings::modules::CoreSettings::Engine::Hybrid) { + return std::make_shared<storm::modelchecker::HybridCtmcCslModelChecker<SymbolicModelType>>(*model); + } + } + + bool getQualitativeResultAtInitialState(std::shared_ptr<storm::models::Model<ValueType>> const& model, std::unique_ptr<storm::modelchecker::CheckResult>& result) { + auto filter = getInitialStateFilter(model); + result->filter(*filter); + return result->asQualitativeCheckResult().forallTrue(); + } + + ValueType getQuantitativeResultAtInitialState(std::shared_ptr<storm::models::Model<ValueType>> const& model, std::unique_ptr<storm::modelchecker::CheckResult>& result) { + auto filter = getInitialStateFilter(model); + result->filter(*filter); + return result->asQuantitativeCheckResult<ValueType>().getMin(); + } + + private: + storm::Environment _environment; + + std::unique_ptr<storm::modelchecker::QualitativeCheckResult> getInitialStateFilter(std::shared_ptr<storm::models::Model<ValueType>> const& model) const { + if (isSparseModel()) { + return std::make_unique<storm::modelchecker::ExplicitQualitativeCheckResult>(model->template as<SparseModelType>()->getInitialStates()); + } else { + return std::make_unique<storm::modelchecker::SymbolicQualitativeCheckResult<TestType::ddType>>(model->template as<SymbolicModelType>()->getReachableStates(), model->template as<SymbolicModelType>()->getInitialStates()); + } + } + }; + + typedef ::testing::Types< + SparseGmmxxGmresIluEnvironment, + SparseEigenDGmresEnvironment, + SparseEigenDoubleLUEnvironment, + SparseNativeSorEnvironment, + HybridCuddGmmxxGmresEnvironment, + HybridSylvanGmmxxGmresEnvironment + > TestingTypes; + + TYPED_TEST_CASE(CtmcCslModelCheckerTest, TestingTypes); + + TYPED_TEST(CtmcCslModelCheckerTest, Cluster) { + std::string formulasString = "P=? [ F<=100 !\"minimum\"]"; + formulasString += "; P=? [ F[100,100] !\"minimum\"]"; + formulasString += "; P=? [ F[100,2000] !\"minimum\"]"; + formulasString += "; P=? [ \"minimum\" U<=10 \"premium\"]"; + formulasString += "; P=? [ !\"minimum\" U>=1 \"minimum\"]"; + formulasString += "; P=? [ \"minimum\" U>=1 !\"minimum\"]"; + formulasString += "; R=? [C<=100]"; + formulasString += "; LRA=? [\"minimum\"]"; + + auto modelFormulas = this->buildModelFormulas(STORM_TEST_RESOURCES_DIR "/ctmc/cluster2.sm", formulasString); + auto model = std::move(modelFormulas.first); + auto tasks = this->getTasks(modelFormulas.second); + EXPECT_EQ(276ul, model->getNumberOfStates()); + EXPECT_EQ(1120ul, model->getNumberOfTransitions()); + ASSERT_EQ(model->getType(), storm::models::ModelType::Ctmc); + auto checker = this->createModelChecker(model); + std::unique_ptr<storm::modelchecker::CheckResult> result; + + result = checker->check(this->env(), tasks[0]); + EXPECT_NEAR(this->parseNumber("5.5461254704419085E-5"), this->getQuantitativeResultAtInitialState(model, result), this->precision()); + + result = checker->check(this->env(), tasks[1]); + EXPECT_NEAR(this->parseNumber("2.3397873548343415E-6"), this->getQuantitativeResultAtInitialState(model, result), this->precision()); + + result = checker->check(this->env(), tasks[2]); + EXPECT_NEAR(this->parseNumber("0.001105335651670241"), this->getQuantitativeResultAtInitialState(model, result), this->precision()); + + result = checker->check(this->env(), tasks[3]); + EXPECT_NEAR(this->parseNumber("1"), this->getQuantitativeResultAtInitialState(model, result), this->precision()); + + result = checker->check(this->env(), tasks[4]); + EXPECT_NEAR(this->parseNumber("0"), this->getQuantitativeResultAtInitialState(model, result), this->precision()); + + result = checker->check(this->env(), tasks[5]); + EXPECT_NEAR(this->parseNumber("0.9999999033633374"), this->getQuantitativeResultAtInitialState(model, result), this->precision()); + + result = checker->check(this->env(), tasks[6]); + EXPECT_NEAR(this->parseNumber("0.8602815057967503"), this->getQuantitativeResultAtInitialState(model, result), this->precision()); + + result = checker->check(this->env(), tasks[7]); + EXPECT_NEAR(this->parseNumber("0.99999766034263426"), this->getQuantitativeResultAtInitialState(model, result), this->precision()); + + } + + TYPED_TEST(CtmcCslModelCheckerTest, Embedded) { + std::string formulasString = "P=? [ F<=10000 \"down\"]"; + formulasString += "; P=? [ !\"down\" U<=10000 \"fail_actuators\"]"; + formulasString += "; P=? [ !\"down\" U<=10000 \"fail_io\"]"; + formulasString += "; P=? [ !\"down\" U<=10000 \"fail_sensors\"]"; + formulasString += "; R{\"up\"}=? [C<=10000]"; + formulasString += "; LRA=? [\"fail_sensors\"]"; + + auto modelFormulas = this->buildModelFormulas(STORM_TEST_RESOURCES_DIR "/ctmc/embedded2.sm", formulasString); + auto model = std::move(modelFormulas.first); + auto tasks = this->getTasks(modelFormulas.second); + EXPECT_EQ(3478ul, model->getNumberOfStates()); + EXPECT_EQ(14639ul, model->getNumberOfTransitions()); + ASSERT_EQ(model->getType(), storm::models::ModelType::Ctmc); + auto checker = this->createModelChecker(model); + std::unique_ptr<storm::modelchecker::CheckResult> result; + + result = checker->check(this->env(), tasks[0]); + EXPECT_NEAR(this->parseNumber("0.0019216435246119591"), this->getQuantitativeResultAtInitialState(model, result), this->precision()); + + result = checker->check(this->env(), tasks[1]); + EXPECT_NEAR(this->parseNumber("3.7079151806696567E-6"), this->getQuantitativeResultAtInitialState(model, result), this->precision()); + + result = checker->check(this->env(), tasks[2]); + EXPECT_NEAR(this->parseNumber("0.001556839327673734"), this->getQuantitativeResultAtInitialState(model, result), this->precision()); + + result = checker->check(this->env(), tasks[3]); + EXPECT_NEAR(this->parseNumber("4.429620626755424E-5"), this->getQuantitativeResultAtInitialState(model, result), this->precision()); + + result = checker->check(this->env(), tasks[4]); + EXPECT_NEAR(this->parseNumber("2.7745274082080154"), this->getQuantitativeResultAtInitialState(model, result), this->precision()); + + result = checker->check(this->env(), tasks[5]); + EXPECT_NEAR(this->parseNumber("0.93458866427696596"), this->getQuantitativeResultAtInitialState(model, result), this->precision()); + } + + TYPED_TEST(CtmcCslModelCheckerTest, Polling) { + std::string formulasString = "P=?[ F<=10 \"target\"]"; + formulasString += "; LRA=?[\"target\"]"; + + auto modelFormulas = this->buildModelFormulas(STORM_TEST_RESOURCES_DIR "/ctmc/polling2.sm", formulasString); + auto model = std::move(modelFormulas.first); + auto tasks = this->getTasks(modelFormulas.second); + EXPECT_EQ(12ul, model->getNumberOfStates()); + EXPECT_EQ(22ul, model->getNumberOfTransitions()); + ASSERT_EQ(model->getType(), storm::models::ModelType::Ctmc); + auto checker = this->createModelChecker(model); + std::unique_ptr<storm::modelchecker::CheckResult> result; + + result = checker->check(this->env(), tasks[0]); + EXPECT_NEAR(this->parseNumber("1"), this->getQuantitativeResultAtInitialState(model, result), this->precision()); + + result = checker->check(this->env(), tasks[1]); + EXPECT_NEAR(this->parseNumber("0.20079750055570736"), this->getQuantitativeResultAtInitialState(model, result), this->precision()); + + } + + TYPED_TEST(CtmcCslModelCheckerTest, Tandem) { + std::string formulasString = "P=? [ F<=10 \"network_full\" ]"; + formulasString += "; P=? [ F<=10 \"first_queue_full\" ]"; + formulasString += "; P=? [\"second_queue_full\" U<=1 !\"second_queue_full\"]"; + formulasString += "; R=? [I=10]"; + formulasString += "; R=? [C<=10]"; + formulasString += "; R=? [F \"first_queue_full\"&\"second_queue_full\"]"; + formulasString += "; LRA=? [\"first_queue_full\"]"; + + auto modelFormulas = this->buildModelFormulas(STORM_TEST_RESOURCES_DIR "/ctmc/tandem5.sm", formulasString); + auto model = std::move(modelFormulas.first); + auto tasks = this->getTasks(modelFormulas.second); + EXPECT_EQ(66ul, model->getNumberOfStates()); + EXPECT_EQ(189ul, model->getNumberOfTransitions()); + ASSERT_EQ(model->getType(), storm::models::ModelType::Ctmc); + auto checker = this->createModelChecker(model); + std::unique_ptr<storm::modelchecker::CheckResult> result; + + result = checker->check(this->env(), tasks[0]); + EXPECT_NEAR(this->parseNumber("0.015446370562428037"), this->getQuantitativeResultAtInitialState(model, result), this->precision()); + + result = checker->check(this->env(), tasks[1]); + EXPECT_NEAR(this->parseNumber("0.999999837225515"), this->getQuantitativeResultAtInitialState(model, result), this->precision()); + + result = checker->check(this->env(), tasks[2]); + EXPECT_NEAR(this->parseNumber("1"), this->getQuantitativeResultAtInitialState(model, result), this->precision()); + + result = checker->check(this->env(), tasks[3]); + EXPECT_NEAR(this->parseNumber("5.679243850315877"), this->getQuantitativeResultAtInitialState(model, result), this->precision()); + + result = checker->check(this->env(), tasks[4]); + EXPECT_NEAR(this->parseNumber("55.44792186036232"), this->getQuantitativeResultAtInitialState(model, result), this->precision()); + + result = checker->check(this->env(), tasks[5]); + EXPECT_NEAR(this->parseNumber("262.85103824276308"), this->getQuantitativeResultAtInitialState(model, result), this->precision()); + + result = checker->check(this->env(), tasks[6]); + EXPECT_NEAR(this->parseNumber("0.9100373532"), this->getQuantitativeResultAtInitialState(model, result), this->precision()); + + + } +} \ No newline at end of file diff --git a/src/test/storm/modelchecker/DtmcPrctlModelCheckerTest.cpp b/src/test/storm/modelchecker/DtmcPrctlModelCheckerTest.cpp new file mode 100644 index 000000000..e72c5b334 --- /dev/null +++ b/src/test/storm/modelchecker/DtmcPrctlModelCheckerTest.cpp @@ -0,0 +1,539 @@ +#include "gtest/gtest.h" +#include "test/storm_gtest.h" +#include "storm-config.h" + +#include "storm/api/builder.h" +#include "storm/api/model_descriptions.h" +#include "storm/api/properties.h" +#include "storm/parser/FormulaParser.h" +#include "storm/logic/Formulas.h" +#include "storm/solver/EigenLinearEquationSolver.h" +#include "storm/models/sparse/StandardRewardModel.h" +#include "storm/models/sparse/Dtmc.h" +#include "storm/models/symbolic/Dtmc.h" +#include "storm/modelchecker/prctl/SparseDtmcPrctlModelChecker.h" +#include "storm/modelchecker/prctl/HybridDtmcPrctlModelChecker.h" +#include "storm/modelchecker/prctl/SymbolicDtmcPrctlModelChecker.h" +#include "storm/modelchecker/results/QuantitativeCheckResult.h" +#include "storm/modelchecker/results/ExplicitQualitativeCheckResult.h" +#include "storm/modelchecker/results/SymbolicQualitativeCheckResult.h" +#include "storm/modelchecker/results/QualitativeCheckResult.h" +#include "storm/parser/PrismParser.h" +#include "storm/storage/expressions/ExpressionManager.h" +#include "storm/settings/modules/CoreSettings.h" +#include "storm/environment/solver/NativeSolverEnvironment.h" +#include "storm/environment/solver/GmmxxSolverEnvironment.h" +#include "storm/environment/solver/EigenSolverEnvironment.h" + +namespace { + + class SparseGmmxxGmresIluEnvironment { + public: + static const storm::dd::DdType ddType = storm::dd::DdType::Sylvan; // unused for sparse models + static const storm::settings::modules::CoreSettings::Engine engine = storm::settings::modules::CoreSettings::Engine::Sparse; + static const bool isExact = false; + typedef double ValueType; + typedef storm::models::sparse::Dtmc<ValueType> ModelType; + static storm::Environment createEnvironment() { + storm::Environment env; + env.solver().setLinearEquationSolverType(storm::solver::EquationSolverType::Gmmxx); + env.solver().gmmxx().setMethod(storm::solver::GmmxxLinearEquationSolverMethod::Gmres); + env.solver().gmmxx().setPreconditioner(storm::solver::GmmxxLinearEquationSolverPreconditioner::Ilu); + env.solver().gmmxx().setPrecision(storm::utility::convertNumber<storm::RationalNumber>(1e-8)); + return env; + } + }; + + class SparseGmmxxGmresDiagEnvironment { + public: + static const storm::dd::DdType ddType = storm::dd::DdType::Sylvan; // unused for sparse models + static const storm::settings::modules::CoreSettings::Engine engine = storm::settings::modules::CoreSettings::Engine::Sparse; + static const bool isExact = false; + typedef double ValueType; + typedef storm::models::sparse::Dtmc<ValueType> ModelType; + static storm::Environment createEnvironment() { + storm::Environment env; + env.solver().setLinearEquationSolverType(storm::solver::EquationSolverType::Gmmxx); + env.solver().gmmxx().setMethod(storm::solver::GmmxxLinearEquationSolverMethod::Gmres); + env.solver().gmmxx().setPreconditioner(storm::solver::GmmxxLinearEquationSolverPreconditioner::Diagonal); + env.solver().gmmxx().setPrecision(storm::utility::convertNumber<storm::RationalNumber>(1e-8)); + return env; + } + }; + + class SparseGmmxxBicgstabIluEnvironment { + public: + static const storm::dd::DdType ddType = storm::dd::DdType::Sylvan; // unused for sparse models + static const storm::settings::modules::CoreSettings::Engine engine = storm::settings::modules::CoreSettings::Engine::Sparse; + static const bool isExact = false; + typedef double ValueType; + typedef storm::models::sparse::Dtmc<ValueType> ModelType; + static storm::Environment createEnvironment() { + storm::Environment env; + env.solver().setLinearEquationSolverType(storm::solver::EquationSolverType::Gmmxx); + env.solver().gmmxx().setMethod(storm::solver::GmmxxLinearEquationSolverMethod::Bicgstab); + env.solver().gmmxx().setPreconditioner(storm::solver::GmmxxLinearEquationSolverPreconditioner::Ilu); + env.solver().gmmxx().setPrecision(storm::utility::convertNumber<storm::RationalNumber>(1e-8)); + return env; + } + }; + + class SparseEigenDGmresEnvironment { + public: + static const storm::dd::DdType ddType = storm::dd::DdType::Sylvan; // unused for sparse models + static const storm::settings::modules::CoreSettings::Engine engine = storm::settings::modules::CoreSettings::Engine::Sparse; + static const bool isExact = false; + typedef double ValueType; + typedef storm::models::sparse::Dtmc<ValueType> ModelType; + static storm::Environment createEnvironment() { + storm::Environment env; + env.solver().setLinearEquationSolverType(storm::solver::EquationSolverType::Eigen); + env.solver().eigen().setMethod(storm::solver::EigenLinearEquationSolverMethod::DGmres); + env.solver().eigen().setPreconditioner(storm::solver::EigenLinearEquationSolverPreconditioner::Ilu); + env.solver().eigen().setPrecision(storm::utility::convertNumber<storm::RationalNumber>(1e-8)); + return env; + } + }; + + class SparseEigenDoubleLUEnvironment { + public: + static const storm::dd::DdType ddType = storm::dd::DdType::Sylvan; // unused for sparse models + static const storm::settings::modules::CoreSettings::Engine engine = storm::settings::modules::CoreSettings::Engine::Sparse; + static const bool isExact = false; + typedef double ValueType; + typedef storm::models::sparse::Dtmc<ValueType> ModelType; + static storm::Environment createEnvironment() { + storm::Environment env; + env.solver().setLinearEquationSolverType(storm::solver::EquationSolverType::Eigen); + env.solver().eigen().setMethod(storm::solver::EigenLinearEquationSolverMethod::SparseLU); + return env; + } + }; + + class SparseEigenRationalLUEnvironment { + public: + static const storm::dd::DdType ddType = storm::dd::DdType::Sylvan; // unused for sparse models + static const storm::settings::modules::CoreSettings::Engine engine = storm::settings::modules::CoreSettings::Engine::Sparse; + static const bool isExact = true; + typedef storm::RationalNumber ValueType; + typedef storm::models::sparse::Dtmc<ValueType> ModelType; + static storm::Environment createEnvironment() { + storm::Environment env; + env.solver().setLinearEquationSolverType(storm::solver::EquationSolverType::Eigen); + env.solver().eigen().setMethod(storm::solver::EigenLinearEquationSolverMethod::SparseLU); + return env; + } + }; + + class SparseRationalEliminationEnvironment { + public: + static const storm::dd::DdType ddType = storm::dd::DdType::Sylvan; // unused for sparse models + static const storm::settings::modules::CoreSettings::Engine engine = storm::settings::modules::CoreSettings::Engine::Sparse; + static const bool isExact = true; + typedef storm::RationalNumber ValueType; + typedef storm::models::sparse::Dtmc<ValueType> ModelType; + static storm::Environment createEnvironment() { + storm::Environment env; + env.solver().setLinearEquationSolverType(storm::solver::EquationSolverType::Elimination); + return env; + } + }; + + class SparseNativeJacobiEnvironment { + public: + static const storm::dd::DdType ddType = storm::dd::DdType::Sylvan; // unused for sparse models + static const storm::settings::modules::CoreSettings::Engine engine = storm::settings::modules::CoreSettings::Engine::Sparse; + static const bool isExact = false; + typedef double ValueType; + typedef storm::models::sparse::Dtmc<ValueType> ModelType; + static storm::Environment createEnvironment() { + storm::Environment env; + env.solver().setLinearEquationSolverType(storm::solver::EquationSolverType::Native); + env.solver().native().setMethod(storm::solver::NativeLinearEquationSolverMethod::Jacobi); + env.solver().native().setPrecision(storm::utility::convertNumber<storm::RationalNumber>(1e-8)); + return env; + } + }; + + class SparseNativeWalkerChaeEnvironment { + public: + static const storm::dd::DdType ddType = storm::dd::DdType::Sylvan; // unused for sparse models + static const storm::settings::modules::CoreSettings::Engine engine = storm::settings::modules::CoreSettings::Engine::Sparse; + static const bool isExact = false; + typedef double ValueType; + typedef storm::models::sparse::Dtmc<ValueType> ModelType; + static storm::Environment createEnvironment() { + storm::Environment env; + env.solver().setLinearEquationSolverType(storm::solver::EquationSolverType::Native); + env.solver().native().setMethod(storm::solver::NativeLinearEquationSolverMethod::WalkerChae); + env.solver().native().setMaximalNumberOfIterations(1000000); + env.solver().native().setPrecision(storm::utility::convertNumber<storm::RationalNumber>(1e-7)); + return env; + } + }; + + class SparseNativeSorEnvironment { + public: + static const storm::dd::DdType ddType = storm::dd::DdType::Sylvan; // unused for sparse models + static const storm::settings::modules::CoreSettings::Engine engine = storm::settings::modules::CoreSettings::Engine::Sparse; + static const bool isExact = false; + typedef double ValueType; + typedef storm::models::sparse::Dtmc<ValueType> ModelType; + static storm::Environment createEnvironment() { + storm::Environment env; + env.solver().setLinearEquationSolverType(storm::solver::EquationSolverType::Native); + env.solver().native().setMethod(storm::solver::NativeLinearEquationSolverMethod::SOR); + env.solver().native().setPrecision(storm::utility::convertNumber<storm::RationalNumber>(1e-8)); + return env; + } + }; + + class SparseNativePowerEnvironment { + public: + static const storm::dd::DdType ddType = storm::dd::DdType::Sylvan; // unused for sparse models + static const storm::settings::modules::CoreSettings::Engine engine = storm::settings::modules::CoreSettings::Engine::Sparse; + static const bool isExact = false; + typedef double ValueType; + typedef storm::models::sparse::Dtmc<ValueType> ModelType; + static storm::Environment createEnvironment() { + storm::Environment env; + env.solver().setLinearEquationSolverType(storm::solver::EquationSolverType::Native); + env.solver().native().setMethod(storm::solver::NativeLinearEquationSolverMethod::Power); + env.solver().native().setPrecision(storm::utility::convertNumber<storm::RationalNumber>(1e-8)); + return env; + } + }; + + class SparseNativeSoundPowerEnvironment { + public: + static const storm::dd::DdType ddType = storm::dd::DdType::Sylvan; // unused for sparse models + static const storm::settings::modules::CoreSettings::Engine engine = storm::settings::modules::CoreSettings::Engine::Sparse; + static const bool isExact = false; + typedef double ValueType; + typedef storm::models::sparse::Dtmc<ValueType> ModelType; + static storm::Environment createEnvironment() { + storm::Environment env; + env.solver().setForceSoundness(true); + env.solver().setLinearEquationSolverType(storm::solver::EquationSolverType::Native); + env.solver().native().setMethod(storm::solver::NativeLinearEquationSolverMethod::Power); + env.solver().native().setPrecision(storm::utility::convertNumber<storm::RationalNumber>(1e-6)); + return env; + } + }; + + class SparseNativeRationalSearchEnvironment { + public: + static const storm::dd::DdType ddType = storm::dd::DdType::Sylvan; // unused for sparse models + static const storm::settings::modules::CoreSettings::Engine engine = storm::settings::modules::CoreSettings::Engine::Sparse; + static const bool isExact = true; + typedef storm::RationalNumber ValueType; + typedef storm::models::sparse::Dtmc<ValueType> ModelType; + static storm::Environment createEnvironment() { + storm::Environment env; + env.solver().setLinearEquationSolverType(storm::solver::EquationSolverType::Native); + env.solver().native().setMethod(storm::solver::NativeLinearEquationSolverMethod::RationalSearch); + return env; + } + }; + + class HybridSylvanGmmxxGmresEnvironment { + public: + static const storm::dd::DdType ddType = storm::dd::DdType::Sylvan; + static const storm::settings::modules::CoreSettings::Engine engine = storm::settings::modules::CoreSettings::Engine::Hybrid; + static const bool isExact = false; + typedef double ValueType; + typedef storm::models::symbolic::Dtmc<ddType, ValueType> ModelType; + static storm::Environment createEnvironment() { + storm::Environment env; + env.solver().setLinearEquationSolverType(storm::solver::EquationSolverType::Gmmxx); + env.solver().gmmxx().setMethod(storm::solver::GmmxxLinearEquationSolverMethod::Gmres); + env.solver().gmmxx().setPrecision(storm::utility::convertNumber<storm::RationalNumber>(1e-8)); + return env; + } + }; + + class HybridCuddNativeJacobiEnvironment { + public: + static const storm::dd::DdType ddType = storm::dd::DdType::CUDD; + static const storm::settings::modules::CoreSettings::Engine engine = storm::settings::modules::CoreSettings::Engine::Hybrid; + static const bool isExact = false; + typedef double ValueType; + typedef storm::models::symbolic::Dtmc<ddType, ValueType> ModelType; + static storm::Environment createEnvironment() { + storm::Environment env; + env.solver().setLinearEquationSolverType(storm::solver::EquationSolverType::Native); + env.solver().native().setMethod(storm::solver::NativeLinearEquationSolverMethod::Jacobi); + env.solver().native().setPrecision(storm::utility::convertNumber<storm::RationalNumber>(1e-8)); + return env; + } + }; + + class HybridCuddNativeSoundPowerEnvironment { + public: + static const storm::dd::DdType ddType = storm::dd::DdType::CUDD; + static const storm::settings::modules::CoreSettings::Engine engine = storm::settings::modules::CoreSettings::Engine::Hybrid; + static const bool isExact = false; + typedef double ValueType; + typedef storm::models::symbolic::Dtmc<ddType, ValueType> ModelType; + static storm::Environment createEnvironment() { + storm::Environment env; + env.solver().setForceSoundness(true); + env.solver().setLinearEquationSolverType(storm::solver::EquationSolverType::Native); + env.solver().native().setMethod(storm::solver::NativeLinearEquationSolverMethod::Power); + env.solver().native().setPrecision(storm::utility::convertNumber<storm::RationalNumber>(1e-6)); + return env; + } + }; + + class HybridSylvanNativeRationalSearchEnvironment { + public: + static const storm::dd::DdType ddType = storm::dd::DdType::Sylvan; + static const storm::settings::modules::CoreSettings::Engine engine = storm::settings::modules::CoreSettings::Engine::Hybrid; + static const bool isExact = true; + typedef storm::RationalNumber ValueType; + typedef storm::models::symbolic::Dtmc<ddType, ValueType> ModelType; + static storm::Environment createEnvironment() { + storm::Environment env; + env.solver().setLinearEquationSolverType(storm::solver::EquationSolverType::Native); + env.solver().native().setMethod(storm::solver::NativeLinearEquationSolverMethod::RationalSearch); + return env; + } + }; + + class DdSylvanNativePowerEnvironment { + public: + static const storm::dd::DdType ddType = storm::dd::DdType::Sylvan; + static const storm::settings::modules::CoreSettings::Engine engine = storm::settings::modules::CoreSettings::Engine::Dd; + static const bool isExact = false; + typedef double ValueType; + typedef storm::models::symbolic::Dtmc<ddType, ValueType> ModelType; + static storm::Environment createEnvironment() { + storm::Environment env; + env.solver().setLinearEquationSolverType(storm::solver::EquationSolverType::Native); + env.solver().native().setMethod(storm::solver::NativeLinearEquationSolverMethod::Power); + env.solver().native().setPrecision(storm::utility::convertNumber<storm::RationalNumber>(1e-8)); + return env; + } + }; + + class DdCuddNativeJacobiEnvironment { + public: + static const storm::dd::DdType ddType = storm::dd::DdType::CUDD; + static const storm::settings::modules::CoreSettings::Engine engine = storm::settings::modules::CoreSettings::Engine::Dd; + static const bool isExact = false; + typedef double ValueType; + typedef storm::models::symbolic::Dtmc<ddType, ValueType> ModelType; + static storm::Environment createEnvironment() { + storm::Environment env; + env.solver().setLinearEquationSolverType(storm::solver::EquationSolverType::Native); + env.solver().native().setMethod(storm::solver::NativeLinearEquationSolverMethod::Power); + env.solver().native().setPrecision(storm::utility::convertNumber<storm::RationalNumber>(1e-8)); + return env; + } + }; + + class DdSylvanRationalSearchEnvironment { + public: + static const storm::dd::DdType ddType = storm::dd::DdType::Sylvan; + static const storm::settings::modules::CoreSettings::Engine engine = storm::settings::modules::CoreSettings::Engine::Dd; + static const bool isExact = true; + typedef storm::RationalNumber ValueType; + typedef storm::models::symbolic::Dtmc<ddType, ValueType> ModelType; + static storm::Environment createEnvironment() { + storm::Environment env; + env.solver().setLinearEquationSolverType(storm::solver::EquationSolverType::Native); + env.solver().native().setMethod(storm::solver::NativeLinearEquationSolverMethod::RationalSearch); + return env; + } + }; + + template<typename TestType> + class DtmcPrctlModelCheckerTest : public ::testing::Test { + public: + typedef typename TestType::ValueType ValueType; + typedef typename storm::models::sparse::Dtmc<ValueType> SparseModelType; + typedef typename storm::models::symbolic::Dtmc<TestType::ddType, ValueType> SymbolicModelType; + + DtmcPrctlModelCheckerTest() : _environment(TestType::createEnvironment()) {} + storm::Environment const& env() const { return _environment; } + ValueType parseNumber(std::string const& input) const { return storm::utility::convertNumber<ValueType>(input);} + ValueType precision() const { return TestType::isExact ? parseNumber("0") : parseNumber("1e-6");} + bool isSparseModel() const { return std::is_same<typename TestType::ModelType, SparseModelType>::value; } + bool isSymbolicModel() const { return std::is_same<typename TestType::ModelType, SymbolicModelType>::value; } + + template <typename MT = typename TestType::ModelType> + typename std::enable_if<std::is_same<MT, SparseModelType>::value, std::pair<std::shared_ptr<MT>, std::vector<std::shared_ptr<storm::logic::Formula const>>>>::type + buildModelFormulas(std::string const& pathToPrismFile, std::string const& formulasAsString, std::string const& constantDefinitionString = "") const { + std::pair<std::shared_ptr<MT>, std::vector<std::shared_ptr<storm::logic::Formula const>>> result; + storm::prism::Program program = storm::api::parseProgram(pathToPrismFile); + program = storm::utility::prism::preprocess(program, constantDefinitionString); + result.second = storm::api::extractFormulasFromProperties(storm::api::parsePropertiesForPrismProgram(formulasAsString, program)); + result.first = storm::api::buildSparseModel<ValueType>(program, result.second)->template as<MT>(); + return result; + } + + template <typename MT = typename TestType::ModelType> + typename std::enable_if<std::is_same<MT, SymbolicModelType>::value, std::pair<std::shared_ptr<MT>, std::vector<std::shared_ptr<storm::logic::Formula const>>>>::type + buildModelFormulas(std::string const& pathToPrismFile, std::string const& formulasAsString, std::string const& constantDefinitionString = "") const { + std::pair<std::shared_ptr<MT>, std::vector<std::shared_ptr<storm::logic::Formula const>>> result; + storm::prism::Program program = storm::api::parseProgram(pathToPrismFile); + program = storm::utility::prism::preprocess(program, constantDefinitionString); + result.second = storm::api::extractFormulasFromProperties(storm::api::parsePropertiesForPrismProgram(formulasAsString, program)); + result.first = storm::api::buildSymbolicModel<TestType::ddType, ValueType>(program, result.second)->template as<MT>(); + return result; + } + + std::vector<storm::modelchecker::CheckTask<storm::logic::Formula, ValueType>> getTasks(std::vector<std::shared_ptr<storm::logic::Formula const>> const& formulas) const { + std::vector<storm::modelchecker::CheckTask<storm::logic::Formula, ValueType>> result; + for (auto const& f : formulas) { + result.emplace_back(*f); + } + return result; + } + + template <typename MT = typename TestType::ModelType> + typename std::enable_if<std::is_same<MT, SparseModelType>::value, std::shared_ptr<storm::modelchecker::AbstractModelChecker<MT>>>::type + createModelChecker(std::shared_ptr<MT> const& model) const { + if (TestType::engine == storm::settings::modules::CoreSettings::Engine::Sparse) { + return std::make_shared<storm::modelchecker::SparseDtmcPrctlModelChecker<SparseModelType>>(*model); + } + } + + template <typename MT = typename TestType::ModelType> + typename std::enable_if<std::is_same<MT, SymbolicModelType>::value, std::shared_ptr<storm::modelchecker::AbstractModelChecker<MT>>>::type + createModelChecker(std::shared_ptr<MT> const& model) const { + if (TestType::engine == storm::settings::modules::CoreSettings::Engine::Hybrid) { + return std::make_shared<storm::modelchecker::HybridDtmcPrctlModelChecker<SymbolicModelType>>(*model); + } else if (TestType::engine == storm::settings::modules::CoreSettings::Engine::Dd) { + return std::make_shared<storm::modelchecker::SymbolicDtmcPrctlModelChecker<SymbolicModelType>>(*model); + } + } + + bool getQualitativeResultAtInitialState(std::shared_ptr<storm::models::Model<ValueType>> const& model, std::unique_ptr<storm::modelchecker::CheckResult>& result) { + auto filter = getInitialStateFilter(model); + result->filter(*filter); + return result->asQualitativeCheckResult().forallTrue(); + } + + ValueType getQuantitativeResultAtInitialState(std::shared_ptr<storm::models::Model<ValueType>> const& model, std::unique_ptr<storm::modelchecker::CheckResult>& result) { + auto filter = getInitialStateFilter(model); + result->filter(*filter); + return result->asQuantitativeCheckResult<ValueType>().getMin(); + } + + private: + storm::Environment _environment; + + std::unique_ptr<storm::modelchecker::QualitativeCheckResult> getInitialStateFilter(std::shared_ptr<storm::models::Model<ValueType>> const& model) const { + if (isSparseModel()) { + return std::make_unique<storm::modelchecker::ExplicitQualitativeCheckResult>(model->template as<SparseModelType>()->getInitialStates()); + } else { + return std::make_unique<storm::modelchecker::SymbolicQualitativeCheckResult<TestType::ddType>>(model->template as<SymbolicModelType>()->getReachableStates(), model->template as<SymbolicModelType>()->getInitialStates()); + } + } + }; + + typedef ::testing::Types< + SparseGmmxxGmresIluEnvironment, + SparseGmmxxGmresDiagEnvironment, + SparseGmmxxBicgstabIluEnvironment, + SparseEigenDGmresEnvironment, + SparseEigenDoubleLUEnvironment, + SparseEigenRationalLUEnvironment, + SparseRationalEliminationEnvironment, + SparseNativeJacobiEnvironment, + SparseNativeWalkerChaeEnvironment, + SparseNativeSorEnvironment, + SparseNativePowerEnvironment, + SparseNativeSoundPowerEnvironment, + SparseNativeRationalSearchEnvironment, + HybridSylvanGmmxxGmresEnvironment, + HybridCuddNativeJacobiEnvironment, + HybridCuddNativeSoundPowerEnvironment, + HybridSylvanNativeRationalSearchEnvironment, + DdSylvanNativePowerEnvironment, + DdCuddNativeJacobiEnvironment //, + // DdSylvanRationalSearchEnvironment + > TestingTypes; + + TYPED_TEST_CASE(DtmcPrctlModelCheckerTest, TestingTypes); + + TYPED_TEST(DtmcPrctlModelCheckerTest, Die) { + std::string formulasString = "P=? [F \"one\"]"; + formulasString += "; P=? [F \"two\"]"; + formulasString += "; P=? [F \"three\"]"; + formulasString += "; R=? [F \"done\"]"; + + auto modelFormulas = this->buildModelFormulas(STORM_TEST_RESOURCES_DIR "/dtmc/die.pm", formulasString); + auto model = std::move(modelFormulas.first); + auto tasks = this->getTasks(modelFormulas.second); + EXPECT_EQ(13ul, model->getNumberOfStates()); + EXPECT_EQ(20ul, model->getNumberOfTransitions()); + ASSERT_EQ(model->getType(), storm::models::ModelType::Dtmc); + auto checker = this->createModelChecker(model); + std::unique_ptr<storm::modelchecker::CheckResult> result; + + result = checker->check(this->env(), tasks[0]); + EXPECT_NEAR(this->parseNumber("1/6"), this->getQuantitativeResultAtInitialState(model, result), this->precision()); + + result = checker->check(this->env(), tasks[1]); + EXPECT_NEAR(this->parseNumber("1/6"), this->getQuantitativeResultAtInitialState(model, result), this->precision()); + + result = checker->check(this->env(), tasks[2]); + EXPECT_NEAR(this->parseNumber("1/6"), this->getQuantitativeResultAtInitialState(model, result), this->precision()); + + result = checker->check(this->env(), tasks[3]); + EXPECT_NEAR(this->parseNumber("11/3"), this->getQuantitativeResultAtInitialState(model, result), this->precision()); + } + + TYPED_TEST(DtmcPrctlModelCheckerTest, Crowds) { + std::string formulasString = "P=? [F observe0>1]"; + formulasString += "; P=? [F \"observeIGreater1\"]"; + formulasString += "; P=? [F observe1>1]"; + + auto modelFormulas = this->buildModelFormulas(STORM_TEST_RESOURCES_DIR "/dtmc/crowds-4-3.pm", formulasString); + auto model = std::move(modelFormulas.first); + auto tasks = this->getTasks(modelFormulas.second); + EXPECT_EQ(726ul, model->getNumberOfStates()); + EXPECT_EQ(1146ul, model->getNumberOfTransitions()); + ASSERT_EQ(model->getType(), storm::models::ModelType::Dtmc); + auto checker = this->createModelChecker(model); + std::unique_ptr<storm::modelchecker::CheckResult> result; + + result = checker->check(this->env(), tasks[0]); + EXPECT_NEAR(this->parseNumber("78686542099694893/1268858272000000000"), this->getQuantitativeResultAtInitialState(model, result), this->precision()); + + result = checker->check(this->env(), tasks[1]); + EXPECT_NEAR(this->parseNumber("40300855878315123/1268858272000000000"), this->getQuantitativeResultAtInitialState(model, result), this->precision()); + + result = checker->check(this->env(), tasks[2]); + EXPECT_NEAR(this->parseNumber("13433618626105041/1268858272000000000"), this->getQuantitativeResultAtInitialState(model, result), this->precision()); + + } + + TYPED_TEST(DtmcPrctlModelCheckerTest, SynchronousLeader) { + std::string formulasString = "P=? [F \"elected\"]"; + formulasString += "; P=? [F<=5 \"elected\"]"; + formulasString += "; R=? [F \"elected\"]"; + + auto modelFormulas = this->buildModelFormulas(STORM_TEST_RESOURCES_DIR "/dtmc/leader-3-5.pm", formulasString); + auto model = std::move(modelFormulas.first); + auto tasks = this->getTasks(modelFormulas.second); + EXPECT_EQ(273ul, model->getNumberOfStates()); + EXPECT_EQ(397ul, model->getNumberOfTransitions()); + ASSERT_EQ(model->getType(), storm::models::ModelType::Dtmc); + auto checker = this->createModelChecker(model); + std::unique_ptr<storm::modelchecker::CheckResult> result; + + result = checker->check(this->env(), tasks[0]); + EXPECT_NEAR(this->parseNumber("1"), this->getQuantitativeResultAtInitialState(model, result), this->precision()); + + result = checker->check(this->env(), tasks[1]); + EXPECT_NEAR(this->parseNumber("24/25"), this->getQuantitativeResultAtInitialState(model, result), this->precision()); + + result = checker->check(this->env(), tasks[2]); + EXPECT_NEAR(this->parseNumber("25/24"), this->getQuantitativeResultAtInitialState(model, result), this->precision()); + } + + +} diff --git a/src/test/storm/modelchecker/EigenDtmcPrctlModelCheckerTest.cpp b/src/test/storm/modelchecker/EigenDtmcPrctlModelCheckerTest.cpp deleted file mode 100644 index 8ec80c0b7..000000000 --- a/src/test/storm/modelchecker/EigenDtmcPrctlModelCheckerTest.cpp +++ /dev/null @@ -1,442 +0,0 @@ -#include "gtest/gtest.h" -#include "storm-config.h" - -#include "storm/parser/FormulaParser.h" -#include "storm/logic/Formulas.h" -#include "storm/solver/EigenLinearEquationSolver.h" -#include "storm/models/sparse/StandardRewardModel.h" -#include "storm/modelchecker/prctl/SparseDtmcPrctlModelChecker.h" -#include "storm/modelchecker/results/ExplicitQuantitativeCheckResult.h" -#include "storm/settings/SettingsManager.h" -#include "storm/settings/modules/GeneralSettings.h" -#include "storm/settings/modules/EigenEquationSolverSettings.h" -#include "storm/settings/modules/NativeEquationSolverSettings.h" -#include "storm/settings/SettingMemento.h" -#include "storm/parser/AutoParser.h" -#include "storm/parser/PrismParser.h" -#include "storm/builder/ExplicitModelBuilder.h" -#include "storm/storage/expressions/ExpressionManager.h" - -TEST(EigenDtmcPrctlModelCheckerTest, Die) { - std::shared_ptr<storm::models::sparse::Model<double>> abstractModel = storm::parser::AutoParser<>::parseModel(STORM_TEST_RESOURCES_DIR "/tra/die.tra", STORM_TEST_RESOURCES_DIR "/lab/die.lab", "", STORM_TEST_RESOURCES_DIR "/rew/die.coin_flips.trans.rew"); - - // A parser that we use for conveniently constructing the formulas. - - auto expManager = std::make_shared<storm::expressions::ExpressionManager>(); - storm::parser::FormulaParser formulaParser(expManager); - - ASSERT_EQ(abstractModel->getType(), storm::models::ModelType::Dtmc); - - std::shared_ptr<storm::models::sparse::Dtmc<double>> dtmc = abstractModel->as<storm::models::sparse::Dtmc<double>>(); - - ASSERT_EQ(dtmc->getNumberOfStates(), 13ull); - ASSERT_EQ(dtmc->getNumberOfTransitions(), 20ull); - - storm::modelchecker::SparseDtmcPrctlModelChecker<storm::models::sparse::Dtmc<double>> checker(*dtmc, std::make_unique<storm::solver::EigenLinearEquationSolverFactory<double>>()); - - std::shared_ptr<storm::logic::Formula const> formula = formulaParser.parseSingleFormulaFromString("P=? [F \"one\"]"); - - std::unique_ptr<storm::modelchecker::CheckResult> result = checker.check(*formula); - storm::modelchecker::ExplicitQuantitativeCheckResult<double>& quantitativeResult1 = result->asExplicitQuantitativeCheckResult<double>(); - - EXPECT_NEAR(1.0 / 6.0, quantitativeResult1[0], storm::settings::getModule<storm::settings::modules::EigenEquationSolverSettings>().getPrecision()); - - formula = formulaParser.parseSingleFormulaFromString("P=? [F \"two\"]"); - - result = checker.check(*formula); - storm::modelchecker::ExplicitQuantitativeCheckResult<double>& quantitativeResult2 = result->asExplicitQuantitativeCheckResult<double>(); - - EXPECT_NEAR(1.0 / 6.0, quantitativeResult2[0], storm::settings::getModule<storm::settings::modules::EigenEquationSolverSettings>().getPrecision()); - - formula = formulaParser.parseSingleFormulaFromString("P=? [F \"three\"]"); - - result = checker.check(*formula); - storm::modelchecker::ExplicitQuantitativeCheckResult<double>& quantitativeResult3 = result->asExplicitQuantitativeCheckResult<double>(); - - EXPECT_NEAR(1.0 / 6.0, quantitativeResult3[0], storm::settings::getModule<storm::settings::modules::EigenEquationSolverSettings>().getPrecision()); - - formula = formulaParser.parseSingleFormulaFromString("R=? [F \"done\"]"); - - result = checker.check(*formula); - storm::modelchecker::ExplicitQuantitativeCheckResult<double>& quantitativeResult4 = result->asExplicitQuantitativeCheckResult<double>(); - - EXPECT_NEAR(11.0 / 3.0, quantitativeResult4[0], storm::settings::getModule<storm::settings::modules::EigenEquationSolverSettings>().getPrecision()); -} - -#ifdef STORM_HAVE_CARL -TEST(EigenDtmcPrctlModelCheckerTest, Die_RationalNumber) { - storm::prism::Program program = storm::parser::PrismParser::parse(STORM_TEST_RESOURCES_DIR "/dtmc/die.pm"); - - storm::generator::NextStateGeneratorOptions options; - options.setBuildAllLabels().setBuildAllRewardModels(); - std::shared_ptr<storm::models::sparse::Model<storm::RationalNumber>> model = storm::builder::ExplicitModelBuilder<storm::RationalNumber>(program, options).build(); - - // A parser that we use for conveniently constructing the formulas. - - auto expManager = std::make_shared<storm::expressions::ExpressionManager>(); - storm::parser::FormulaParser formulaParser(expManager); - - ASSERT_EQ(model->getType(), storm::models::ModelType::Dtmc); - - std::shared_ptr<storm::models::sparse::Dtmc<storm::RationalNumber>> dtmc = model->as<storm::models::sparse::Dtmc<storm::RationalNumber>>(); - - ASSERT_EQ(dtmc->getNumberOfStates(), 13ull); - ASSERT_EQ(dtmc->getNumberOfTransitions(), 20ull); - - storm::modelchecker::SparseDtmcPrctlModelChecker<storm::models::sparse::Dtmc<storm::RationalNumber>> checker(*dtmc, std::make_unique<storm::solver::EigenLinearEquationSolverFactory<storm::RationalNumber>>()); - - std::shared_ptr<storm::logic::Formula const> formula = formulaParser.parseSingleFormulaFromString("P=? [F \"one\"]"); - - std::unique_ptr<storm::modelchecker::CheckResult> result = checker.check(*formula); - storm::modelchecker::ExplicitQuantitativeCheckResult<storm::RationalNumber>& quantitativeResult1 = result->asExplicitQuantitativeCheckResult<storm::RationalNumber>(); - - EXPECT_EQ(storm::RationalNumber(1) / storm::RationalNumber(6), quantitativeResult1[0]); - - formula = formulaParser.parseSingleFormulaFromString("P=? [F \"two\"]"); - - result = checker.check(*formula); - storm::modelchecker::ExplicitQuantitativeCheckResult<storm::RationalNumber>& quantitativeResult2 = result->asExplicitQuantitativeCheckResult<storm::RationalNumber>(); - - EXPECT_EQ(storm::RationalNumber(1) / storm::RationalNumber(6), quantitativeResult2[0]); - - formula = formulaParser.parseSingleFormulaFromString("P=? [F \"three\"]"); - - result = checker.check(*formula); - storm::modelchecker::ExplicitQuantitativeCheckResult<storm::RationalNumber>& quantitativeResult3 = result->asExplicitQuantitativeCheckResult<storm::RationalNumber>(); - - EXPECT_EQ(storm::RationalNumber(1) / storm::RationalNumber(6), quantitativeResult3[0]); - - formula = formulaParser.parseSingleFormulaFromString("R=? [F \"done\"]"); - - result = checker.check(*formula); - storm::modelchecker::ExplicitQuantitativeCheckResult<storm::RationalNumber>& quantitativeResult4 = result->asExplicitQuantitativeCheckResult<storm::RationalNumber>(); - - EXPECT_EQ(storm::RationalNumber(11) / storm::RationalNumber(3), quantitativeResult4[0]); -} - -TEST(EigenDtmcPrctlModelCheckerTest, Die_RationalFunction) { - storm::prism::Program program = storm::parser::PrismParser::parse(STORM_TEST_RESOURCES_DIR "/pdtmc/parametric_die.pm"); - storm::generator::NextStateGeneratorOptions options; - options.setBuildAllLabels().setBuildAllRewardModels(); - std::shared_ptr<storm::models::sparse::Model<storm::RationalFunction>> model = storm::builder::ExplicitModelBuilder<storm::RationalFunction>(program, options).build(); - - // A parser that we use for conveniently constructing the formulas. - - auto expManager = std::make_shared<storm::expressions::ExpressionManager>(); - storm::parser::FormulaParser formulaParser(expManager); - - ASSERT_EQ(model->getType(), storm::models::ModelType::Dtmc); - - std::shared_ptr<storm::models::sparse::Dtmc<storm::RationalFunction>> dtmc = model->as<storm::models::sparse::Dtmc<storm::RationalFunction>>(); - - ASSERT_EQ(dtmc->getNumberOfStates(), 13ull); - ASSERT_EQ(dtmc->getNumberOfTransitions(), 20ull); - - std::map<storm::RationalFunctionVariable, storm::RationalFunctionCoefficient> instantiation; - std::set<storm::RationalFunctionVariable> variables = storm::models::sparse::getProbabilityParameters(*dtmc); - ASSERT_EQ(variables.size(), 1ull); - instantiation.emplace(*variables.begin(), storm::utility::one<storm::RationalFunctionCoefficient>() / storm::utility::convertNumber<storm::RationalFunctionCoefficient>(2)); - - storm::modelchecker::SparseDtmcPrctlModelChecker<storm::models::sparse::Dtmc<storm::RationalFunction>> checker(*dtmc, std::make_unique<storm::solver::EigenLinearEquationSolverFactory<storm::RationalFunction>>()); - - std::shared_ptr<storm::logic::Formula const> formula = formulaParser.parseSingleFormulaFromString("P=? [F \"one\"]"); - - std::unique_ptr<storm::modelchecker::CheckResult> result = checker.check(*formula); - storm::modelchecker::ExplicitQuantitativeCheckResult<storm::RationalFunction>& quantitativeResult1 = result->asExplicitQuantitativeCheckResult<storm::RationalFunction>(); - - EXPECT_EQ(storm::utility::one<storm::RationalFunctionCoefficient>() / storm::utility::convertNumber<storm::RationalFunctionCoefficient>(6), quantitativeResult1[0].evaluate(instantiation)); - - formula = formulaParser.parseSingleFormulaFromString("P=? [F \"two\"]"); - - result = checker.check(*formula); - storm::modelchecker::ExplicitQuantitativeCheckResult<storm::RationalFunction>& quantitativeResult2 = result->asExplicitQuantitativeCheckResult<storm::RationalFunction>(); - - EXPECT_EQ(storm::utility::one<storm::RationalFunctionCoefficient>() / storm::utility::convertNumber<storm::RationalFunctionCoefficient>(6), quantitativeResult2[0].evaluate(instantiation)); - - formula = formulaParser.parseSingleFormulaFromString("P=? [F \"three\"]"); - - result = checker.check(*formula); - storm::modelchecker::ExplicitQuantitativeCheckResult<storm::RationalFunction>& quantitativeResult3 = result->asExplicitQuantitativeCheckResult<storm::RationalFunction>(); - - EXPECT_EQ(storm::utility::one<storm::RationalFunctionCoefficient>() / storm::utility::convertNumber<storm::RationalFunctionCoefficient>(6), quantitativeResult3[0].evaluate(instantiation)); - - formula = formulaParser.parseSingleFormulaFromString("R=? [F \"done\"]"); - - result = checker.check(*formula); - storm::modelchecker::ExplicitQuantitativeCheckResult<storm::RationalFunction>& quantitativeResult4 = result->asExplicitQuantitativeCheckResult<storm::RationalFunction>(); - - EXPECT_EQ(storm::utility::convertNumber<storm::RationalFunctionCoefficient>(11) / storm::utility::convertNumber<storm::RationalFunctionCoefficient>(3), quantitativeResult4[0].evaluate(instantiation)); -} -#endif - -TEST(EigenDtmcPrctlModelCheckerTest, Crowds) { - std::shared_ptr<storm::models::sparse::Model<double>> abstractModel = storm::parser::AutoParser<>::parseModel(STORM_TEST_RESOURCES_DIR "/tra/crowds5_5.tra", STORM_TEST_RESOURCES_DIR "/lab/crowds5_5.lab", "", ""); - - ASSERT_EQ(abstractModel->getType(), storm::models::ModelType::Dtmc); - - // A parser that we use for conveniently constructing the formulas. - - auto expManager = std::make_shared<storm::expressions::ExpressionManager>(); - storm::parser::FormulaParser formulaParser(expManager); - - std::shared_ptr<storm::models::sparse::Dtmc<double>> dtmc = abstractModel->as<storm::models::sparse::Dtmc<double>>(); - - ASSERT_EQ(8607ull, dtmc->getNumberOfStates()); - ASSERT_EQ(15113ull, dtmc->getNumberOfTransitions()); - - storm::modelchecker::SparseDtmcPrctlModelChecker<storm::models::sparse::Dtmc<double>> checker(*dtmc, std::unique_ptr<storm::solver::LinearEquationSolverFactory<double>>(new storm::solver::EigenLinearEquationSolverFactory<double>())); - - std::shared_ptr<storm::logic::Formula const> formula = formulaParser.parseSingleFormulaFromString("P=? [F \"observe0Greater1\"]"); - - std::unique_ptr<storm::modelchecker::CheckResult> result = checker.check(*formula); - storm::modelchecker::ExplicitQuantitativeCheckResult<double>& quantitativeResult1 = result->asExplicitQuantitativeCheckResult<double>(); - - EXPECT_NEAR(0.3328800375801578281, quantitativeResult1[0], storm::settings::getModule<storm::settings::modules::EigenEquationSolverSettings>().getPrecision()); - - formula = formulaParser.parseSingleFormulaFromString("P=? [F \"observeIGreater1\"]"); - - result = checker.check(*formula); - storm::modelchecker::ExplicitQuantitativeCheckResult<double>& quantitativeResult2 = result->asExplicitQuantitativeCheckResult<double>(); - - EXPECT_NEAR(0.1522194965, quantitativeResult2[0], storm::settings::getModule<storm::settings::modules::EigenEquationSolverSettings>().getPrecision()); - - formula = formulaParser.parseSingleFormulaFromString("P=? [F \"observeOnlyTrueSender\"]"); - - result = checker.check(*formula); - storm::modelchecker::ExplicitQuantitativeCheckResult<double>& quantitativeResult3 = result->asExplicitQuantitativeCheckResult<double>(); - - EXPECT_NEAR(0.32153724292835045, quantitativeResult3[0], storm::settings::getModule<storm::settings::modules::EigenEquationSolverSettings>().getPrecision()); -} - -TEST(EigenDtmcPrctlModelCheckerTest, SynchronousLeader) { - std::shared_ptr<storm::models::sparse::Model<double>> abstractModel = storm::parser::AutoParser<>::parseModel(STORM_TEST_RESOURCES_DIR "/tra/leader4_8.tra", STORM_TEST_RESOURCES_DIR "/lab/leader4_8.lab", "", STORM_TEST_RESOURCES_DIR "/rew/leader4_8.pick.trans.rew"); - - ASSERT_EQ(abstractModel->getType(), storm::models::ModelType::Dtmc); - - // A parser that we use for conveniently constructing the formulas. - - auto expManager = std::make_shared<storm::expressions::ExpressionManager>(); - storm::parser::FormulaParser formulaParser(expManager); - - std::shared_ptr<storm::models::sparse::Dtmc<double>> dtmc = abstractModel->as<storm::models::sparse::Dtmc<double>>(); - - ASSERT_EQ(12400ull, dtmc->getNumberOfStates()); - ASSERT_EQ(16495ull, dtmc->getNumberOfTransitions()); - - storm::modelchecker::SparseDtmcPrctlModelChecker<storm::models::sparse::Dtmc<double>> checker(*dtmc, std::make_unique<storm::solver::EigenLinearEquationSolverFactory<double>>()); - - std::shared_ptr<storm::logic::Formula const> formula = formulaParser.parseSingleFormulaFromString("P=? [F \"elected\"]"); - - std::unique_ptr<storm::modelchecker::CheckResult> result = checker.check(*formula); - storm::modelchecker::ExplicitQuantitativeCheckResult<double>& quantitativeResult1 = result->asExplicitQuantitativeCheckResult<double>(); - - EXPECT_NEAR(1.0, quantitativeResult1[0], storm::settings::getModule<storm::settings::modules::EigenEquationSolverSettings>().getPrecision()); - - formula = formulaParser.parseSingleFormulaFromString("P=? [F<=20 \"elected\"]"); - - result = checker.check(*formula); - storm::modelchecker::ExplicitQuantitativeCheckResult<double>& quantitativeResult2 = result->asExplicitQuantitativeCheckResult<double>(); - - EXPECT_NEAR(0.9999965911265462636, quantitativeResult2[0], storm::settings::getModule<storm::settings::modules::EigenEquationSolverSettings>().getPrecision()); - - formula = formulaParser.parseSingleFormulaFromString("R=? [F \"elected\"]"); - - result = checker.check(*formula); - storm::modelchecker::ExplicitQuantitativeCheckResult<double>& quantitativeResult3 = result->asExplicitQuantitativeCheckResult<double>(); - - EXPECT_NEAR(1.0448979591836789, quantitativeResult3[0], storm::settings::getModule<storm::settings::modules::EigenEquationSolverSettings>().getPrecision()); -} - -TEST(EigenDtmcPrctlModelCheckerTest, LRASingleBscc) { - storm::storage::SparseMatrixBuilder<double> matrixBuilder; - std::shared_ptr<storm::models::sparse::Dtmc<double>> dtmc; - - // A parser that we use for conveniently constructing the formulas. - - auto expManager = std::make_shared<storm::expressions::ExpressionManager>(); - storm::parser::FormulaParser formulaParser(expManager); - - { - matrixBuilder = storm::storage::SparseMatrixBuilder<double>(2, 2, 2); - matrixBuilder.addNextValue(0, 1, 1.); - matrixBuilder.addNextValue(1, 0, 1.); - storm::storage::SparseMatrix<double> transitionMatrix = matrixBuilder.build(); - - storm::models::sparse::StateLabeling ap(2); - ap.addLabel("a"); - ap.addLabelToState("a", 1); - - dtmc.reset(new storm::models::sparse::Dtmc<double>(transitionMatrix, ap)); - - storm::modelchecker::SparseDtmcPrctlModelChecker<storm::models::sparse::Dtmc<double>> checker(*dtmc, std::make_unique<storm::solver::EigenLinearEquationSolverFactory<double>>()); - - std::shared_ptr<storm::logic::Formula const> formula = formulaParser.parseSingleFormulaFromString("LRA=? [\"a\"]"); - - std::unique_ptr<storm::modelchecker::CheckResult> result = checker.check(*formula); - storm::modelchecker::ExplicitQuantitativeCheckResult<double>& quantitativeResult1 = result->asExplicitQuantitativeCheckResult<double>(); - - EXPECT_NEAR(.5, quantitativeResult1[0], storm::settings::getModule<storm::settings::modules::NativeEquationSolverSettings>().getPrecision()); - EXPECT_NEAR(.5, quantitativeResult1[1], storm::settings::getModule<storm::settings::modules::NativeEquationSolverSettings>().getPrecision()); - } - { - matrixBuilder = storm::storage::SparseMatrixBuilder<double>(2, 2, 4); - matrixBuilder.addNextValue(0, 0, .5); - matrixBuilder.addNextValue(0, 1, .5); - matrixBuilder.addNextValue(1, 0, .5); - matrixBuilder.addNextValue(1, 1, .5); - storm::storage::SparseMatrix<double> transitionMatrix = matrixBuilder.build(); - - storm::models::sparse::StateLabeling ap(2); - ap.addLabel("a"); - ap.addLabelToState("a", 1); - - dtmc.reset(new storm::models::sparse::Dtmc<double>(transitionMatrix, ap)); - - storm::modelchecker::SparseDtmcPrctlModelChecker<storm::models::sparse::Dtmc<double>> checker(*dtmc, std::make_unique<storm::solver::EigenLinearEquationSolverFactory<double>>()); - - std::shared_ptr<storm::logic::Formula const> formula = formulaParser.parseSingleFormulaFromString("LRA=? [\"a\"]"); - - std::unique_ptr<storm::modelchecker::CheckResult> result = checker.check(*formula); - storm::modelchecker::ExplicitQuantitativeCheckResult<double>& quantitativeResult1 = result->asExplicitQuantitativeCheckResult<double>(); - - EXPECT_NEAR(.5, quantitativeResult1[0], storm::settings::getModule<storm::settings::modules::NativeEquationSolverSettings>().getPrecision()); - EXPECT_NEAR(.5, quantitativeResult1[1], storm::settings::getModule<storm::settings::modules::NativeEquationSolverSettings>().getPrecision()); - } - - { - matrixBuilder = storm::storage::SparseMatrixBuilder<double>(3, 3, 3); - matrixBuilder.addNextValue(0, 1, 1); - matrixBuilder.addNextValue(1, 2, 1); - matrixBuilder.addNextValue(2, 0, 1); - storm::storage::SparseMatrix<double> transitionMatrix = matrixBuilder.build(); - - storm::models::sparse::StateLabeling ap(3); - ap.addLabel("a"); - ap.addLabelToState("a", 2); - - dtmc.reset(new storm::models::sparse::Dtmc<double>(transitionMatrix, ap)); - - storm::modelchecker::SparseDtmcPrctlModelChecker<storm::models::sparse::Dtmc<double>> checker(*dtmc, std::make_unique<storm::solver::EigenLinearEquationSolverFactory<double>>()); - - std::shared_ptr<storm::logic::Formula const> formula = formulaParser.parseSingleFormulaFromString("LRA=? [\"a\"]"); - - std::unique_ptr<storm::modelchecker::CheckResult> result = checker.check(*formula); - storm::modelchecker::ExplicitQuantitativeCheckResult<double>& quantitativeResult1 = result->asExplicitQuantitativeCheckResult<double>(); - - EXPECT_NEAR(1. / 3., quantitativeResult1[0], storm::settings::getModule<storm::settings::modules::NativeEquationSolverSettings>().getPrecision()); - EXPECT_NEAR(1. / 3., quantitativeResult1[1], storm::settings::getModule<storm::settings::modules::NativeEquationSolverSettings>().getPrecision()); - EXPECT_NEAR(1. / 3., quantitativeResult1[2], storm::settings::getModule<storm::settings::modules::NativeEquationSolverSettings>().getPrecision()); - } -} - -TEST(EigenDtmcPrctlModelCheckerTest, LRA) { - storm::storage::SparseMatrixBuilder<double> matrixBuilder; - std::shared_ptr<storm::models::sparse::Dtmc<double>> dtmc; - - // A parser that we use for conveniently constructing the formulas. - - auto expManager = std::make_shared<storm::expressions::ExpressionManager>(); - storm::parser::FormulaParser formulaParser(expManager); - - { - matrixBuilder = storm::storage::SparseMatrixBuilder<double>(15, 15, 20, true); - matrixBuilder.addNextValue(0, 1, 1); - matrixBuilder.addNextValue(1, 4, 0.7); - matrixBuilder.addNextValue(1, 6, 0.3); - matrixBuilder.addNextValue(2, 0, 1); - - matrixBuilder.addNextValue(3, 5, 0.8); - matrixBuilder.addNextValue(3, 9, 0.2); - matrixBuilder.addNextValue(4, 3, 1); - matrixBuilder.addNextValue(5, 3, 1); - - matrixBuilder.addNextValue(6, 7, 1); - matrixBuilder.addNextValue(7, 8, 1); - matrixBuilder.addNextValue(8, 6, 1); - - matrixBuilder.addNextValue(9, 10, 1); - matrixBuilder.addNextValue(10, 9, 1); - matrixBuilder.addNextValue(11, 9, 1); - - matrixBuilder.addNextValue(12, 5, 0.4); - matrixBuilder.addNextValue(12, 8, 0.3); - matrixBuilder.addNextValue(12, 11, 0.3); - - matrixBuilder.addNextValue(13, 7, 0.7); - matrixBuilder.addNextValue(13, 12, 0.3); - - matrixBuilder.addNextValue(14, 12, 1); - - storm::storage::SparseMatrix<double> transitionMatrix = matrixBuilder.build(); - - storm::models::sparse::StateLabeling ap(15); - ap.addLabel("a"); - ap.addLabelToState("a", 1); - ap.addLabelToState("a", 4); - ap.addLabelToState("a", 5); - ap.addLabelToState("a", 7); - ap.addLabelToState("a", 11); - ap.addLabelToState("a", 13); - ap.addLabelToState("a", 14); - - dtmc.reset(new storm::models::sparse::Dtmc<double>(transitionMatrix, ap)); - - storm::modelchecker::SparseDtmcPrctlModelChecker<storm::models::sparse::Dtmc<double>> checker(*dtmc, std::make_unique<storm::solver::EigenLinearEquationSolverFactory<double>>()); - - std::shared_ptr<storm::logic::Formula const> formula = formulaParser.parseSingleFormulaFromString("LRA=? [\"a\"]"); - - std::unique_ptr<storm::modelchecker::CheckResult> result = checker.check(*formula); - storm::modelchecker::ExplicitQuantitativeCheckResult<double>& quantitativeResult1 = result->asExplicitQuantitativeCheckResult<double>(); - - EXPECT_NEAR(0.3 / 3., quantitativeResult1[0], storm::settings::getModule<storm::settings::modules::NativeEquationSolverSettings>().getPrecision()); - EXPECT_NEAR(0.0, quantitativeResult1[3], storm::settings::getModule<storm::settings::modules::NativeEquationSolverSettings>().getPrecision()); - EXPECT_NEAR(1. / 3., quantitativeResult1[6], storm::settings::getModule<storm::settings::modules::NativeEquationSolverSettings>().getPrecision()); - EXPECT_NEAR(0.0, quantitativeResult1[9], storm::settings::getModule<storm::settings::modules::NativeEquationSolverSettings>().getPrecision()); - EXPECT_NEAR(0.3 / 3., quantitativeResult1[12], storm::settings::getModule<storm::settings::modules::NativeEquationSolverSettings>().getPrecision()); - EXPECT_NEAR(.79 / 3., quantitativeResult1[13], storm::settings::getModule<storm::settings::modules::NativeEquationSolverSettings>().getPrecision()); - EXPECT_NEAR(0.3 / 3., quantitativeResult1[14], storm::settings::getModule<storm::settings::modules::NativeEquationSolverSettings>().getPrecision()); - } -} - -TEST(EigenDtmcPrctlModelCheckerTest, Conditional) { - storm::prism::Program program = storm::parser::PrismParser::parse(STORM_TEST_RESOURCES_DIR "/dtmc/test_conditional.pm"); - - storm::generator::NextStateGeneratorOptions options; - options.setBuildAllLabels().setBuildAllRewardModels(); - std::shared_ptr<storm::models::sparse::Model<double>> model = storm::builder::ExplicitModelBuilder<double>(program, options).build(); - ASSERT_TRUE(model->getType() == storm::models::ModelType::Dtmc); - ASSERT_EQ(4ul, model->getNumberOfStates()); - ASSERT_EQ(5ul, model->getNumberOfTransitions()); - - std::shared_ptr<storm::models::sparse::Dtmc<double>> dtmc = model->as<storm::models::sparse::Dtmc<double>>(); - - storm::modelchecker::SparseDtmcPrctlModelChecker<storm::models::sparse::Dtmc<double>> checker(*dtmc, std::make_unique<storm::solver::EigenLinearEquationSolverFactory<double>>()); - - // A parser that we use for conveniently constructing the formulas. - - auto expManager = std::make_shared<storm::expressions::ExpressionManager>(); - storm::parser::FormulaParser formulaParser(expManager); - std::shared_ptr<storm::logic::Formula const> formula = formulaParser.parseSingleFormulaFromString("P=? [F \"target\"]"); - - std::unique_ptr<storm::modelchecker::CheckResult> result = checker.check(*formula); - storm::modelchecker::ExplicitQuantitativeCheckResult<double>& quantitativeResult1 = result->asExplicitQuantitativeCheckResult<double>(); - EXPECT_NEAR(0.5, quantitativeResult1[0], storm::settings::getModule<storm::settings::modules::NativeEquationSolverSettings>().getPrecision()); - - formula = formulaParser.parseSingleFormulaFromString("P=? [F \"target\" || F \"condition\"]"); - - result = checker.check(*formula); - storm::modelchecker::ExplicitQuantitativeCheckResult<double>& quantitativeResult2 = result->asExplicitQuantitativeCheckResult<double>(); - EXPECT_NEAR(storm::utility::one<double>(), quantitativeResult2[0], storm::settings::getModule<storm::settings::modules::NativeEquationSolverSettings>().getPrecision()); - - formula = formulaParser.parseSingleFormulaFromString("R=? [F \"target\"]"); - - result = checker.check(*formula); - storm::modelchecker::ExplicitQuantitativeCheckResult<double>& quantitativeResult3 = result->asExplicitQuantitativeCheckResult<double>(); - EXPECT_EQ(storm::utility::infinity<double>(), quantitativeResult3[0]); - - formula = formulaParser.parseSingleFormulaFromString("R=? [F \"target\" || F \"condition\"]"); - - result = checker.check(*formula); - storm::modelchecker::ExplicitQuantitativeCheckResult<double>& quantitativeResult4 = result->asExplicitQuantitativeCheckResult<double>(); - EXPECT_NEAR(storm::utility::one<double>(), quantitativeResult4[0], storm::settings::getModule<storm::settings::modules::NativeEquationSolverSettings>().getPrecision()); -} diff --git a/src/test/storm/modelchecker/ExplicitDtmcPrctlModelCheckerTest.cpp b/src/test/storm/modelchecker/ExplicitDtmcPrctlModelCheckerTest.cpp new file mode 100644 index 000000000..06b90270b --- /dev/null +++ b/src/test/storm/modelchecker/ExplicitDtmcPrctlModelCheckerTest.cpp @@ -0,0 +1,158 @@ +#include "gtest/gtest.h" +#include "storm-config.h" + +#include "storm/parser/FormulaParser.h" +#include "storm/logic/Formulas.h" +#include "storm/models/sparse/StandardRewardModel.h" +#include "storm/modelchecker/prctl/SparseDtmcPrctlModelChecker.h" +#include "storm/modelchecker/results/ExplicitQuantitativeCheckResult.h" +#include "storm/settings/SettingsManager.h" +#include "storm/settings/modules/GeneralSettings.h" +#include "storm/settings/SettingMemento.h" +#include "storm/parser/AutoParser.h" +#include "storm/parser/PrismParser.h" +#include "storm/builder/ExplicitModelBuilder.h" +#include "storm/storage/expressions/ExpressionManager.h" + +#include "storm/environment/solver/SolverEnvironment.h" + +TEST(ExplicitDtmcPrctlModelCheckerTest, Die) { + std::shared_ptr<storm::models::sparse::Model<double>> abstractModel = storm::parser::AutoParser<>::parseModel(STORM_TEST_RESOURCES_DIR "/tra/die.tra", STORM_TEST_RESOURCES_DIR "/lab/die.lab", "", STORM_TEST_RESOURCES_DIR "/rew/die.coin_flips.trans.rew"); + + storm::Environment env; + double const precision = 1e-6; + // Increase precision a little to get more accurate results + env.solver().setLinearEquationSolverPrecision(storm::utility::convertNumber<storm::RationalNumber>(1e-8)); + + // A parser that we use for conveniently constructing the formulas. + + auto expManager = std::make_shared<storm::expressions::ExpressionManager>(); + storm::parser::FormulaParser formulaParser(expManager); + + ASSERT_EQ(abstractModel->getType(), storm::models::ModelType::Dtmc); + + std::shared_ptr<storm::models::sparse::Dtmc<double>> dtmc = abstractModel->as<storm::models::sparse::Dtmc<double>>(); + + ASSERT_EQ(dtmc->getNumberOfStates(), 13ull); + ASSERT_EQ(dtmc->getNumberOfTransitions(), 20ull); + + storm::modelchecker::SparseDtmcPrctlModelChecker<storm::models::sparse::Dtmc<double>> checker(*dtmc); + + std::shared_ptr<storm::logic::Formula const> formula = formulaParser.parseSingleFormulaFromString("P=? [F \"one\"]"); + + std::unique_ptr<storm::modelchecker::CheckResult> result = checker.check(env, *formula); + storm::modelchecker::ExplicitQuantitativeCheckResult<double>& quantitativeResult1 = result->asExplicitQuantitativeCheckResult<double>(); + + EXPECT_NEAR(1.0 / 6.0, quantitativeResult1[0], precision); + + formula = formulaParser.parseSingleFormulaFromString("P=? [F \"two\"]"); + + result = checker.check(env, *formula); + storm::modelchecker::ExplicitQuantitativeCheckResult<double>& quantitativeResult2 = result->asExplicitQuantitativeCheckResult<double>(); + + EXPECT_NEAR(1.0 / 6.0, quantitativeResult2[0], precision); + + formula = formulaParser.parseSingleFormulaFromString("P=? [F \"three\"]"); + + result = checker.check(env, *formula); + storm::modelchecker::ExplicitQuantitativeCheckResult<double>& quantitativeResult3 = result->asExplicitQuantitativeCheckResult<double>(); + + EXPECT_NEAR(1.0 / 6.0, quantitativeResult3[0], precision); + + formula = formulaParser.parseSingleFormulaFromString("R=? [F \"done\"]"); + + result = checker.check(env, *formula); + storm::modelchecker::ExplicitQuantitativeCheckResult<double>& quantitativeResult4 = result->asExplicitQuantitativeCheckResult<double>(); + + EXPECT_NEAR(11.0 / 3.0, quantitativeResult4[0], precision); +} + +TEST(ExplicitDtmcPrctlModelCheckerTest, Crowds) { + + storm::Environment env; + double const precision = 1e-6; + // Increase precision a little to get more accurate results + env.solver().setLinearEquationSolverPrecision(storm::utility::convertNumber<storm::RationalNumber>(1e-8)); + + + std::shared_ptr<storm::models::sparse::Model<double>> abstractModel = storm::parser::AutoParser<>::parseModel(STORM_TEST_RESOURCES_DIR "/tra/crowds5_5.tra", STORM_TEST_RESOURCES_DIR "/lab/crowds5_5.lab", "", ""); + + ASSERT_EQ(abstractModel->getType(), storm::models::ModelType::Dtmc); + + // A parser that we use for conveniently constructing the formulas. + + auto expManager = std::make_shared<storm::expressions::ExpressionManager>(); + storm::parser::FormulaParser formulaParser(expManager); + + std::shared_ptr<storm::models::sparse::Dtmc<double>> dtmc = abstractModel->as<storm::models::sparse::Dtmc<double>>(); + + ASSERT_EQ(8607ull, dtmc->getNumberOfStates()); + ASSERT_EQ(15113ull, dtmc->getNumberOfTransitions()); + + storm::modelchecker::SparseDtmcPrctlModelChecker<storm::models::sparse::Dtmc<double>> checker(*dtmc); + + std::shared_ptr<storm::logic::Formula const> formula = formulaParser.parseSingleFormulaFromString("P=? [F \"observe0Greater1\"]"); + + std::unique_ptr<storm::modelchecker::CheckResult> result = checker.check(env, *formula); + storm::modelchecker::ExplicitQuantitativeCheckResult<double>& quantitativeResult1 = result->asExplicitQuantitativeCheckResult<double>(); + + EXPECT_NEAR(0.3328800375801578281, quantitativeResult1[0], precision); + + formula = formulaParser.parseSingleFormulaFromString("P=? [F \"observeIGreater1\"]"); + + result = checker.check(env, *formula); + storm::modelchecker::ExplicitQuantitativeCheckResult<double>& quantitativeResult2 = result->asExplicitQuantitativeCheckResult<double>(); + + EXPECT_NEAR(0.1522194965, quantitativeResult2[0], precision); + + formula = formulaParser.parseSingleFormulaFromString("P=? [F \"observeOnlyTrueSender\"]"); + + result = checker.check(env, *formula); + storm::modelchecker::ExplicitQuantitativeCheckResult<double>& quantitativeResult3 = result->asExplicitQuantitativeCheckResult<double>(); + + EXPECT_NEAR(0.32153724292835045, quantitativeResult3[0], precision); +} + +TEST(ExplicitDtmcPrctlModelCheckerTest, SynchronousLeader) { + storm::Environment env; + double const precision = 1e-6; + // Increase precision a little to get more accurate results + env.solver().setLinearEquationSolverPrecision(storm::utility::convertNumber<storm::RationalNumber>(1e-8)); + + std::shared_ptr<storm::models::sparse::Model<double>> abstractModel = storm::parser::AutoParser<>::parseModel(STORM_TEST_RESOURCES_DIR "/tra/leader4_8.tra", STORM_TEST_RESOURCES_DIR "/lab/leader4_8.lab", "", STORM_TEST_RESOURCES_DIR "/rew/leader4_8.pick.trans.rew"); + + ASSERT_EQ(abstractModel->getType(), storm::models::ModelType::Dtmc); + + // A parser that we use for conveniently constructing the formulas. + + auto expManager = std::make_shared<storm::expressions::ExpressionManager>(); + storm::parser::FormulaParser formulaParser(expManager); + + std::shared_ptr<storm::models::sparse::Dtmc<double>> dtmc = abstractModel->as<storm::models::sparse::Dtmc<double>>(); + + ASSERT_EQ(12400ull, dtmc->getNumberOfStates()); + ASSERT_EQ(16495ull, dtmc->getNumberOfTransitions()); + + storm::modelchecker::SparseDtmcPrctlModelChecker<storm::models::sparse::Dtmc<double>> checker(*dtmc); + + std::shared_ptr<storm::logic::Formula const> formula = formulaParser.parseSingleFormulaFromString("P=? [F \"elected\"]"); + + std::unique_ptr<storm::modelchecker::CheckResult> result = checker.check(env, *formula); + storm::modelchecker::ExplicitQuantitativeCheckResult<double>& quantitativeResult1 = result->asExplicitQuantitativeCheckResult<double>(); + + EXPECT_NEAR(1.0, quantitativeResult1[0], precision); + + formula = formulaParser.parseSingleFormulaFromString("P=? [F<=20 \"elected\"]"); + + result = checker.check(env, *formula); + storm::modelchecker::ExplicitQuantitativeCheckResult<double>& quantitativeResult2 = result->asExplicitQuantitativeCheckResult<double>(); + + EXPECT_NEAR(0.9999965911265462636, quantitativeResult2[0], precision); + + formula = formulaParser.parseSingleFormulaFromString("R=? [F \"elected\"]"); + + result = checker.check(env, *formula); + storm::modelchecker::ExplicitQuantitativeCheckResult<double>& quantitativeResult3 = result->asExplicitQuantitativeCheckResult<double>(); + + EXPECT_NEAR(1.0448979591836789, quantitativeResult3[0], precision); +} diff --git a/src/test/storm/modelchecker/ExplicitMdpPrctlModelCheckerTest.cpp b/src/test/storm/modelchecker/ExplicitMdpPrctlModelCheckerTest.cpp index 2db2b5703..91db98302 100644 --- a/src/test/storm/modelchecker/ExplicitMdpPrctlModelCheckerTest.cpp +++ b/src/test/storm/modelchecker/ExplicitMdpPrctlModelCheckerTest.cpp @@ -7,12 +7,9 @@ #include "storm/models/sparse/StandardRewardModel.h" #include "storm/modelchecker/prctl/SparseMdpPrctlModelChecker.h" #include "storm/modelchecker/results/ExplicitQuantitativeCheckResult.h" -#include "storm/settings/SettingsManager.h" -#include "storm/settings/modules/GeneralSettings.h" #include "storm/environment/solver/MinMaxSolverEnvironment.h" -#include "storm/settings/modules/NativeEquationSolverSettings.h" #include "storm/parser/AutoParser.h" #include "storm/parser/PrismParser.h" #include "storm/builder/ExplicitModelBuilder.h" @@ -20,8 +17,9 @@ TEST(ExplicitMdpPrctlModelCheckerTest, Dice) { std::shared_ptr<storm::models::sparse::Model<double>> abstractModel = storm::parser::AutoParser<>::parseModel(STORM_TEST_RESOURCES_DIR "/tra/two_dice.tra", STORM_TEST_RESOURCES_DIR "/lab/two_dice.lab", "", STORM_TEST_RESOURCES_DIR "/rew/two_dice.flip.trans.rew"); storm::Environment env; + double const precision = 1e-6; // Increase precision a little to get more accurate results - env.solver().minMax().setPrecision(env.solver().minMax().getPrecision() * storm::utility::convertNumber<storm::RationalNumber>(1e-2)); + env.solver().minMax().setPrecision(storm::utility::convertNumber<storm::RationalNumber>(1e-8)); // A parser that we use for conveniently constructing the formulas. storm::parser::FormulaParser formulaParser; @@ -40,56 +38,56 @@ TEST(ExplicitMdpPrctlModelCheckerTest, Dice) { std::unique_ptr<storm::modelchecker::CheckResult> result = checker.check(env, *formula); storm::modelchecker::ExplicitQuantitativeCheckResult<double>& quantitativeResult1 = result->asExplicitQuantitativeCheckResult<double>(); - EXPECT_NEAR(1.0/36.0, quantitativeResult1[0], storm::settings::getModule<storm::settings::modules::NativeEquationSolverSettings>().getPrecision()); + EXPECT_NEAR(1.0/36.0, quantitativeResult1[0], precision); formula = formulaParser.parseSingleFormulaFromString("Pmax=? [F \"two\"]"); result = checker.check(env, *formula); storm::modelchecker::ExplicitQuantitativeCheckResult<double>& quantitativeResult2 = result->asExplicitQuantitativeCheckResult<double>(); - EXPECT_NEAR(1.0/36.0, quantitativeResult2[0], storm::settings::getModule<storm::settings::modules::NativeEquationSolverSettings>().getPrecision()); + EXPECT_NEAR(1.0/36.0, quantitativeResult2[0], precision); formula = formulaParser.parseSingleFormulaFromString("Pmin=? [F \"three\"]"); result = checker.check(env, *formula); storm::modelchecker::ExplicitQuantitativeCheckResult<double>& quantitativeResult3 = result->asExplicitQuantitativeCheckResult<double>(); - EXPECT_NEAR(2.0/36.0, quantitativeResult3[0], storm::settings::getModule<storm::settings::modules::NativeEquationSolverSettings>().getPrecision()); + EXPECT_NEAR(2.0/36.0, quantitativeResult3[0], precision); formula = formulaParser.parseSingleFormulaFromString("Pmax=? [F \"three\"]"); result = checker.check(env, *formula); storm::modelchecker::ExplicitQuantitativeCheckResult<double>& quantitativeResult4 = result->asExplicitQuantitativeCheckResult<double>(); - EXPECT_NEAR(2.0/36.0, quantitativeResult4[0], storm::settings::getModule<storm::settings::modules::NativeEquationSolverSettings>().getPrecision()); + EXPECT_NEAR(2.0/36.0, quantitativeResult4[0], precision); formula = formulaParser.parseSingleFormulaFromString("Pmin=? [F \"four\"]"); result = checker.check(env, *formula); storm::modelchecker::ExplicitQuantitativeCheckResult<double>& quantitativeResult5 = result->asExplicitQuantitativeCheckResult<double>(); - EXPECT_NEAR(3.0/36.0, quantitativeResult5[0], storm::settings::getModule<storm::settings::modules::NativeEquationSolverSettings>().getPrecision()); + EXPECT_NEAR(3.0/36.0, quantitativeResult5[0], precision); formula = formulaParser.parseSingleFormulaFromString("Pmax=? [F \"four\"]"); result = checker.check(env, *formula); storm::modelchecker::ExplicitQuantitativeCheckResult<double>& quantitativeResult6 = result->asExplicitQuantitativeCheckResult<double>(); - EXPECT_NEAR(3.0/36.0, quantitativeResult6[0], storm::settings::getModule<storm::settings::modules::NativeEquationSolverSettings>().getPrecision()); + EXPECT_NEAR(3.0/36.0, quantitativeResult6[0], precision); formula = formulaParser.parseSingleFormulaFromString("Rmin=? [F \"done\"]"); result = checker.check(env, *formula); storm::modelchecker::ExplicitQuantitativeCheckResult<double>& quantitativeResult7 = result->asExplicitQuantitativeCheckResult<double>(); - EXPECT_NEAR(22.0/3.0, quantitativeResult7[0], storm::settings::getModule<storm::settings::modules::NativeEquationSolverSettings>().getPrecision()); + EXPECT_NEAR(22.0/3.0, quantitativeResult7[0], precision); formula = formulaParser.parseSingleFormulaFromString("Rmax=? [F \"done\"]"); result = checker.check(env, *formula); storm::modelchecker::ExplicitQuantitativeCheckResult<double>& quantitativeResult8 = result->asExplicitQuantitativeCheckResult<double>(); - EXPECT_NEAR(22.0/3.0, quantitativeResult8[0], storm::settings::getModule<storm::settings::modules::NativeEquationSolverSettings>().getPrecision()); + EXPECT_NEAR(22.0/3.0, quantitativeResult8[0], precision); abstractModel = storm::parser::AutoParser<>::parseModel(STORM_TEST_RESOURCES_DIR "/tra/two_dice.tra", STORM_TEST_RESOURCES_DIR "/lab/two_dice.lab", STORM_TEST_RESOURCES_DIR "/rew/two_dice.flip.state.rew", ""); @@ -104,14 +102,14 @@ TEST(ExplicitMdpPrctlModelCheckerTest, Dice) { result = stateRewardModelChecker.check(env, *formula); storm::modelchecker::ExplicitQuantitativeCheckResult<double>& quantitativeResult9 = result->asExplicitQuantitativeCheckResult<double>(); - EXPECT_NEAR(22.0/3.0, quantitativeResult9[0], storm::settings::getModule<storm::settings::modules::NativeEquationSolverSettings>().getPrecision()); + EXPECT_NEAR(22.0/3.0, quantitativeResult9[0], precision); formula = formulaParser.parseSingleFormulaFromString("Rmax=? [F \"done\"]"); result = stateRewardModelChecker.check(env, *formula); storm::modelchecker::ExplicitQuantitativeCheckResult<double>& quantitativeResult10 = result->asExplicitQuantitativeCheckResult<double>(); - EXPECT_NEAR(22.0/3.0, quantitativeResult10[0], storm::settings::getModule<storm::settings::modules::NativeEquationSolverSettings>().getPrecision()); + EXPECT_NEAR(22.0/3.0, quantitativeResult10[0], precision); abstractModel = storm::parser::AutoParser<>::parseModel(STORM_TEST_RESOURCES_DIR "/tra/two_dice.tra", STORM_TEST_RESOURCES_DIR "/lab/two_dice.lab", STORM_TEST_RESOURCES_DIR "/rew/two_dice.flip.state.rew", STORM_TEST_RESOURCES_DIR "/rew/two_dice.flip.trans.rew"); @@ -126,20 +124,21 @@ TEST(ExplicitMdpPrctlModelCheckerTest, Dice) { result = stateAndTransitionRewardModelChecker.check(env, *formula); storm::modelchecker::ExplicitQuantitativeCheckResult<double>& quantitativeResult11 = result->asExplicitQuantitativeCheckResult<double>(); - EXPECT_NEAR(44.0/3.0, quantitativeResult11[0], storm::settings::getModule<storm::settings::modules::NativeEquationSolverSettings>().getPrecision()); + EXPECT_NEAR(44.0/3.0, quantitativeResult11[0], precision); formula = formulaParser.parseSingleFormulaFromString("Rmax=? [F \"done\"]"); result = stateAndTransitionRewardModelChecker.check(env, *formula); storm::modelchecker::ExplicitQuantitativeCheckResult<double>& quantitativeResult12 = result->asExplicitQuantitativeCheckResult<double>(); - EXPECT_NEAR(44.0/3.0, quantitativeResult12[0], storm::settings::getModule<storm::settings::modules::NativeEquationSolverSettings>().getPrecision()); + EXPECT_NEAR(44.0/3.0, quantitativeResult12[0], precision); } TEST(ExplicitMdpPrctlModelCheckerTest, AsynchronousLeader) { storm::Environment env; + double const precision = 1e-6; // Increase precision a little to get more accurate results - env.solver().minMax().setPrecision(env.solver().minMax().getPrecision() * storm::utility::convertNumber<storm::RationalNumber>(1e-2)); + env.solver().minMax().setPrecision(storm::utility::convertNumber<storm::RationalNumber>(1e-8)); std::shared_ptr<storm::models::sparse::Model<double>> abstractModel = storm::parser::AutoParser<>::parseModel(STORM_TEST_RESOURCES_DIR "/tra/leader4.tra", STORM_TEST_RESOURCES_DIR "/lab/leader4.lab", "", STORM_TEST_RESOURCES_DIR "/rew/leader4.trans.rew"); @@ -160,41 +159,41 @@ TEST(ExplicitMdpPrctlModelCheckerTest, AsynchronousLeader) { std::unique_ptr<storm::modelchecker::CheckResult> result = checker.check(env, *formula); storm::modelchecker::ExplicitQuantitativeCheckResult<double>& quantitativeResult1 = result->asExplicitQuantitativeCheckResult<double>(); - EXPECT_NEAR(1.0, quantitativeResult1[0], storm::settings::getModule<storm::settings::modules::NativeEquationSolverSettings>().getPrecision()); + EXPECT_NEAR(1.0, quantitativeResult1[0], precision); formula = formulaParser.parseSingleFormulaFromString("Pmax=? [F \"elected\"]"); result = checker.check(env, *formula); storm::modelchecker::ExplicitQuantitativeCheckResult<double>& quantitativeResult2 = result->asExplicitQuantitativeCheckResult<double>(); - EXPECT_NEAR(1.0, quantitativeResult2[0], storm::settings::getModule<storm::settings::modules::NativeEquationSolverSettings>().getPrecision()); + EXPECT_NEAR(1.0, quantitativeResult2[0], precision); formula = formulaParser.parseSingleFormulaFromString("Pmin=? [F<=25 \"elected\"]"); result = checker.check(env, *formula); storm::modelchecker::ExplicitQuantitativeCheckResult<double>& quantitativeResult3 = result->asExplicitQuantitativeCheckResult<double>(); - EXPECT_NEAR(1.0/16.0, quantitativeResult3[0], storm::settings::getModule<storm::settings::modules::NativeEquationSolverSettings>().getPrecision()); + EXPECT_NEAR(1.0/16.0, quantitativeResult3[0], precision); formula = formulaParser.parseSingleFormulaFromString("Pmax=? [F<=25 \"elected\"]"); result = checker.check(env, *formula); storm::modelchecker::ExplicitQuantitativeCheckResult<double>& quantitativeResult4 = result->asExplicitQuantitativeCheckResult<double>(); - EXPECT_NEAR(1.0/16.0, quantitativeResult4[0], storm::settings::getModule<storm::settings::modules::NativeEquationSolverSettings>().getPrecision()); + EXPECT_NEAR(1.0/16.0, quantitativeResult4[0], precision); formula = formulaParser.parseSingleFormulaFromString("Rmin=? [F \"elected\"]"); result = checker.check(env, *formula); storm::modelchecker::ExplicitQuantitativeCheckResult<double>& quantitativeResult5 = result->asExplicitQuantitativeCheckResult<double>(); - EXPECT_NEAR(30.0/7.0, quantitativeResult5[0], storm::settings::getModule<storm::settings::modules::NativeEquationSolverSettings>().getPrecision()); + EXPECT_NEAR(30.0/7.0, quantitativeResult5[0], precision); formula = formulaParser.parseSingleFormulaFromString("Rmax=? [F \"elected\"]"); result = checker.check(env, *formula); storm::modelchecker::ExplicitQuantitativeCheckResult<double>& quantitativeResult6 = result->asExplicitQuantitativeCheckResult<double>(); - EXPECT_NEAR(30.0/7.0, quantitativeResult6[0], storm::settings::getModule<storm::settings::modules::NativeEquationSolverSettings>().getPrecision()); + EXPECT_NEAR(30.0/7.0, quantitativeResult6[0], precision); } diff --git a/src/test/storm/modelchecker/GmmxxCtmcCslModelCheckerTest.cpp b/src/test/storm/modelchecker/GmmxxCtmcCslModelCheckerTest.cpp deleted file mode 100644 index 62f77d023..000000000 --- a/src/test/storm/modelchecker/GmmxxCtmcCslModelCheckerTest.cpp +++ /dev/null @@ -1,255 +0,0 @@ -#include "gtest/gtest.h" -#include "storm-config.h" -#include "storm/settings/SettingMemento.h" -#include "storm/parser/PrismParser.h" -#include "storm/parser/FormulaParser.h" -#include "storm/logic/Formulas.h" -#include "storm/builder/ExplicitModelBuilder.h" - -#include "storm/solver/GmmxxLinearEquationSolver.h" -#include "storm/models/sparse/StandardRewardModel.h" -#include "storm/modelchecker/csl/SparseCtmcCslModelChecker.h" -#include "storm/modelchecker/results/ExplicitQuantitativeCheckResult.h" - -#include "storm/settings/SettingsManager.h" -#include "storm/settings/modules/GeneralSettings.h" - -#include "storm/settings/modules/NativeEquationSolverSettings.h" -#include "storm/settings/modules/GmmxxEquationSolverSettings.h" - -#include "storm/storage/expressions/ExpressionManager.h" - -TEST(GmmxxCtmcCslModelCheckerTest, Cluster) { - // Parse the model description. - storm::prism::Program program = storm::parser::PrismParser::parse(STORM_TEST_RESOURCES_DIR "/ctmc/cluster2.sm", true); - storm::parser::FormulaParser formulaParser(program.getManager().getSharedPointer()); - std::shared_ptr<storm::logic::Formula const> formula(nullptr); - - // Build the model. - storm::generator::NextStateGeneratorOptions options; - std::shared_ptr<storm::models::sparse::Model<double>> model = storm::builder::ExplicitModelBuilder<double>(program, storm::generator::NextStateGeneratorOptions(false, true). addRewardModel("num_repairs")).build(); - ASSERT_EQ(storm::models::ModelType::Ctmc, model->getType()); - std::shared_ptr<storm::models::sparse::Ctmc<double>> ctmc = model->as<storm::models::sparse::Ctmc<double>>(); - uint_fast64_t initialState = *ctmc->getInitialStates().begin(); - - // Create model checker. - storm::modelchecker::SparseCtmcCslModelChecker<storm::models::sparse::Ctmc<double>> modelchecker(*ctmc, std::make_unique<storm::solver::GmmxxLinearEquationSolverFactory<double>>()); - - // Start checking properties. - formula = formulaParser.parseSingleFormulaFromString("P=? [ F<=100 !\"minimum\"]"); - std::unique_ptr<storm::modelchecker::CheckResult> checkResult = modelchecker.check(*formula); - - ASSERT_TRUE(checkResult->isExplicitQuantitativeCheckResult()); - storm::modelchecker::ExplicitQuantitativeCheckResult<double> quantitativeCheckResult1 = checkResult->asExplicitQuantitativeCheckResult<double>(); - EXPECT_NEAR(5.5461254704419085E-5, quantitativeCheckResult1[initialState], storm::settings::getModule<storm::settings::modules::GeneralSettings>().getPrecision()); - - formula = formulaParser.parseSingleFormulaFromString("P=? [ F[100,100] !\"minimum\"]"); - checkResult = modelchecker.check(*formula); - - ASSERT_TRUE(checkResult->isExplicitQuantitativeCheckResult()); - storm::modelchecker::ExplicitQuantitativeCheckResult<double> quantitativeCheckResult2 = checkResult->asExplicitQuantitativeCheckResult<double>(); - EXPECT_NEAR(2.3397873548343415E-6, quantitativeCheckResult2[initialState], storm::settings::getModule<storm::settings::modules::GeneralSettings>().getPrecision()); - - formula = formulaParser.parseSingleFormulaFromString("P=? [ F[100,2000] !\"minimum\"]"); - checkResult = modelchecker.check(*formula); - - ASSERT_TRUE(checkResult->isExplicitQuantitativeCheckResult()); - storm::modelchecker::ExplicitQuantitativeCheckResult<double> quantitativeCheckResult3 = checkResult->asExplicitQuantitativeCheckResult<double>(); - EXPECT_NEAR(0.001105335651670241, quantitativeCheckResult3[initialState], storm::settings::getModule<storm::settings::modules::GeneralSettings>().getPrecision()); - - formula = formulaParser.parseSingleFormulaFromString("P=? [ \"minimum\" U<=10 \"premium\"]"); - checkResult = modelchecker.check(*formula); - - ASSERT_TRUE(checkResult->isExplicitQuantitativeCheckResult()); - storm::modelchecker::ExplicitQuantitativeCheckResult<double> quantitativeCheckResult4 = checkResult->asExplicitQuantitativeCheckResult<double>(); - EXPECT_NEAR(1, quantitativeCheckResult4[initialState], storm::settings::getModule<storm::settings::modules::GeneralSettings>().getPrecision()); - - formula = formulaParser.parseSingleFormulaFromString("P=? [ !\"minimum\" U>=1 \"minimum\"]"); - checkResult = modelchecker.check(*formula); - - ASSERT_TRUE(checkResult->isExplicitQuantitativeCheckResult()); - storm::modelchecker::ExplicitQuantitativeCheckResult<double> quantitativeCheckResult5 = checkResult->asExplicitQuantitativeCheckResult<double>(); - EXPECT_NEAR(0, quantitativeCheckResult5[initialState], storm::settings::getModule<storm::settings::modules::GeneralSettings>().getPrecision()); - - formula = formulaParser.parseSingleFormulaFromString("P=? [ \"minimum\" U>=1 !\"minimum\"]"); - checkResult = modelchecker.check(*formula); - - ASSERT_TRUE(checkResult->isExplicitQuantitativeCheckResult()); - storm::modelchecker::ExplicitQuantitativeCheckResult<double> quantitativeCheckResult6 = checkResult->asExplicitQuantitativeCheckResult<double>(); - EXPECT_NEAR(0.9999999033633374, quantitativeCheckResult6[initialState], storm::settings::getModule<storm::settings::modules::GeneralSettings>().getPrecision()); - - formula = formulaParser.parseSingleFormulaFromString("R=? [C<=100]"); - checkResult = modelchecker.check(*formula); - - ASSERT_TRUE(checkResult->isExplicitQuantitativeCheckResult()); - storm::modelchecker::ExplicitQuantitativeCheckResult<double> quantitativeCheckResult7 = checkResult->asExplicitQuantitativeCheckResult<double>(); - EXPECT_NEAR(0.8602815057967503, quantitativeCheckResult7[initialState], storm::settings::getModule<storm::settings::modules::GeneralSettings>().getPrecision()); - - formula = formulaParser.parseSingleFormulaFromString("LRA=? [\"minimum\"]"); - checkResult = modelchecker.check(*formula); - - ASSERT_TRUE(checkResult->isExplicitQuantitativeCheckResult()); - storm::modelchecker::ExplicitQuantitativeCheckResult<double> quantitativeCheckResult8 = checkResult->asExplicitQuantitativeCheckResult<double>(); - EXPECT_NEAR(0.99999766034263426, quantitativeCheckResult8[initialState], storm::settings::getModule<storm::settings::modules::GeneralSettings>().getPrecision()); -} - -TEST(GmmxxCtmcCslModelCheckerTest, Embedded) { - // Parse the model description. - storm::prism::Program program = storm::parser::PrismParser::parse(STORM_TEST_RESOURCES_DIR "/ctmc/embedded2.sm", true); - storm::parser::FormulaParser formulaParser(program.getManager().getSharedPointer()); - std::shared_ptr<storm::logic::Formula const> formula(nullptr); - - // Build the model. - std::shared_ptr<storm::models::sparse::Model<double>> model = storm::builder::ExplicitModelBuilder<double>(program, storm::generator::NextStateGeneratorOptions(false, true). addRewardModel("up")).build(); - ASSERT_EQ(storm::models::ModelType::Ctmc, model->getType()); - std::shared_ptr<storm::models::sparse::Ctmc<double>> ctmc = model->as<storm::models::sparse::Ctmc<double>>(); - uint_fast64_t initialState = *ctmc->getInitialStates().begin(); - - // Create model checker. - storm::modelchecker::SparseCtmcCslModelChecker<storm::models::sparse::Ctmc<double>> modelchecker(*ctmc, std::make_unique<storm::solver::GmmxxLinearEquationSolverFactory<double>>()); - - // Start checking properties. - formula = formulaParser.parseSingleFormulaFromString("P=? [ F<=10000 \"down\"]"); - std::unique_ptr<storm::modelchecker::CheckResult> checkResult = modelchecker.check(*formula); - - ASSERT_TRUE(checkResult->isExplicitQuantitativeCheckResult()); - storm::modelchecker::ExplicitQuantitativeCheckResult<double> quantitativeCheckResult1 = checkResult->asExplicitQuantitativeCheckResult<double>(); - EXPECT_NEAR(0.0019216435246119591, quantitativeCheckResult1[initialState], storm::settings::getModule<storm::settings::modules::GeneralSettings>().getPrecision()); - - formula = formulaParser.parseSingleFormulaFromString("P=? [ !\"down\" U<=10000 \"fail_actuators\"]"); - checkResult = modelchecker.check(*formula); - - ASSERT_TRUE(checkResult->isExplicitQuantitativeCheckResult()); - storm::modelchecker::ExplicitQuantitativeCheckResult<double> quantitativeCheckResult2 = checkResult->asExplicitQuantitativeCheckResult<double>(); - EXPECT_NEAR(3.7079151806696567E-6, quantitativeCheckResult2[initialState], storm::settings::getModule<storm::settings::modules::GeneralSettings>().getPrecision()); - - formula = formulaParser.parseSingleFormulaFromString("P=? [ !\"down\" U<=10000 \"fail_io\"]"); - checkResult = modelchecker.check(*formula); - - ASSERT_TRUE(checkResult->isExplicitQuantitativeCheckResult()); - storm::modelchecker::ExplicitQuantitativeCheckResult<double> quantitativeCheckResult3 = checkResult->asExplicitQuantitativeCheckResult<double>(); - EXPECT_NEAR(0.001556839327673734, quantitativeCheckResult3[initialState], storm::settings::getModule<storm::settings::modules::GeneralSettings>().getPrecision()); - - formula = formulaParser.parseSingleFormulaFromString("P=? [ !\"down\" U<=10000 \"fail_sensors\"]"); - checkResult = modelchecker.check(*formula); - - ASSERT_TRUE(checkResult->isExplicitQuantitativeCheckResult()); - storm::modelchecker::ExplicitQuantitativeCheckResult<double> quantitativeCheckResult4 = checkResult->asExplicitQuantitativeCheckResult<double>(); - EXPECT_NEAR(4.429620626755424E-5, quantitativeCheckResult4[initialState], storm::settings::getModule<storm::settings::modules::GeneralSettings>().getPrecision()); - - formula = formulaParser.parseSingleFormulaFromString("R=? [C<=10000]"); - checkResult = modelchecker.check(*formula); - - ASSERT_TRUE(checkResult->isExplicitQuantitativeCheckResult()); - storm::modelchecker::ExplicitQuantitativeCheckResult<double> quantitativeCheckResult5 = checkResult->asExplicitQuantitativeCheckResult<double>(); - EXPECT_NEAR(2.7745274082080154, quantitativeCheckResult5[initialState], storm::settings::getModule<storm::settings::modules::GeneralSettings>().getPrecision()); - - formula = formulaParser.parseSingleFormulaFromString("LRA=? [\"fail_sensors\"]"); - checkResult = modelchecker.check(*formula); - - ASSERT_TRUE(checkResult->isExplicitQuantitativeCheckResult()); - storm::modelchecker::ExplicitQuantitativeCheckResult<double> quantitativeCheckResult6 = checkResult->asExplicitQuantitativeCheckResult<double>(); - EXPECT_NEAR(0.93458866427696596, quantitativeCheckResult6[initialState], storm::settings::getModule<storm::settings::modules::GeneralSettings>().getPrecision()); -} - -TEST(GmmxxCtmcCslModelCheckerTest, Polling) { - // Parse the model description. - storm::prism::Program program = storm::parser::PrismParser::parse(STORM_TEST_RESOURCES_DIR "/ctmc/polling2.sm", true); - storm::parser::FormulaParser formulaParser(program.getManager().getSharedPointer()); - std::shared_ptr<storm::logic::Formula const> formula(nullptr); - - // Build the model. - std::shared_ptr<storm::models::sparse::Model<double>> model = storm::builder::ExplicitModelBuilder<double>(program, storm::generator::NextStateGeneratorOptions(false, true)).build(); - ASSERT_EQ(storm::models::ModelType::Ctmc, model->getType()); - std::shared_ptr<storm::models::sparse::Ctmc<double>> ctmc = model->as<storm::models::sparse::Ctmc<double>>(); - uint_fast64_t initialState = *ctmc->getInitialStates().begin(); - - // Create model checker. - storm::modelchecker::SparseCtmcCslModelChecker<storm::models::sparse::Ctmc<double>> modelchecker(*ctmc, std::make_unique<storm::solver::GmmxxLinearEquationSolverFactory<double>>()); - - // Start checking properties. - formula = formulaParser.parseSingleFormulaFromString("P=?[ F<=10 \"target\"]"); - std::unique_ptr<storm::modelchecker::CheckResult> checkResult = modelchecker.check(*formula); - - ASSERT_TRUE(checkResult->isExplicitQuantitativeCheckResult()); - storm::modelchecker::ExplicitQuantitativeCheckResult<double> quantitativeCheckResult1 = checkResult->asExplicitQuantitativeCheckResult<double>(); - EXPECT_NEAR(1, quantitativeCheckResult1[initialState], storm::settings::getModule<storm::settings::modules::GeneralSettings>().getPrecision()); - - formula = formulaParser.parseSingleFormulaFromString("LRA=?[\"target\"]"); - checkResult = modelchecker.check(*formula); - - ASSERT_TRUE(checkResult->isExplicitQuantitativeCheckResult()); - storm::modelchecker::ExplicitQuantitativeCheckResult<double> quantitativeCheckResult2 = checkResult->asExplicitQuantitativeCheckResult<double>(); - EXPECT_NEAR(0.20079750055570736, quantitativeCheckResult2[initialState], storm::settings::getModule<storm::settings::modules::GeneralSettings>().getPrecision()); -} - -TEST(GmmxxCtmcCslModelCheckerTest, Fms) { - // No properties to check at this point. -} - -TEST(GmmxxCtmcCslModelCheckerTest, Tandem) { - - // Parse the model description. - storm::prism::Program program = storm::parser::PrismParser::parse(STORM_TEST_RESOURCES_DIR "/ctmc/tandem5.sm", true); - storm::parser::FormulaParser formulaParser(program.getManager().getSharedPointer()); - std::shared_ptr<storm::logic::Formula const> formula(nullptr); - - // Build the model. - std::shared_ptr<storm::models::sparse::Model<double>> model = storm::builder::ExplicitModelBuilder<double>(program, storm::generator::NextStateGeneratorOptions(false, true). addRewardModel("customers")).build(); - ASSERT_EQ(storm::models::ModelType::Ctmc, model->getType()); - std::shared_ptr<storm::models::sparse::Ctmc<double>> ctmc = model->as<storm::models::sparse::Ctmc<double>>(); - uint_fast64_t initialState = *ctmc->getInitialStates().begin(); - - // Create model checker. - storm::modelchecker::SparseCtmcCslModelChecker<storm::models::sparse::Ctmc<double>> modelchecker(*ctmc, std::make_unique<storm::solver::GmmxxLinearEquationSolverFactory<double>>()); - - // Start checking properties. - formula = formulaParser.parseSingleFormulaFromString("P=? [ F<=10 \"network_full\" ]"); - std::unique_ptr<storm::modelchecker::CheckResult> checkResult = modelchecker.check(*formula); - - ASSERT_TRUE(checkResult->isExplicitQuantitativeCheckResult()); - storm::modelchecker::ExplicitQuantitativeCheckResult<double> quantitativeCheckResult1 = checkResult->asExplicitQuantitativeCheckResult<double>(); - EXPECT_NEAR(0.015446370562428037, quantitativeCheckResult1[initialState], storm::settings::getModule<storm::settings::modules::GeneralSettings>().getPrecision()); - - formula = formulaParser.parseSingleFormulaFromString("P=? [ F<=10 \"first_queue_full\" ]"); - checkResult = modelchecker.check(*formula); - - ASSERT_TRUE(checkResult->isExplicitQuantitativeCheckResult()); - storm::modelchecker::ExplicitQuantitativeCheckResult<double> quantitativeCheckResult2 = checkResult->asExplicitQuantitativeCheckResult<double>(); - EXPECT_NEAR(0.999999837225515, quantitativeCheckResult2[initialState], storm::settings::getModule<storm::settings::modules::GeneralSettings>().getPrecision()); - - formula = formulaParser.parseSingleFormulaFromString("P=? [\"second_queue_full\" U<=1 !\"second_queue_full\"]"); - checkResult = modelchecker.check(*formula); - - ASSERT_TRUE(checkResult->isExplicitQuantitativeCheckResult()); - storm::modelchecker::ExplicitQuantitativeCheckResult<double> quantitativeCheckResult3 = checkResult->asExplicitQuantitativeCheckResult<double>(); - EXPECT_NEAR(1, quantitativeCheckResult3[initialState], storm::settings::getModule<storm::settings::modules::GeneralSettings>().getPrecision()); - - formula = formulaParser.parseSingleFormulaFromString("R=? [I=10]"); - checkResult = modelchecker.check(*formula); - - ASSERT_TRUE(checkResult->isExplicitQuantitativeCheckResult()); - storm::modelchecker::ExplicitQuantitativeCheckResult<double> quantitativeCheckResult4 = checkResult->asExplicitQuantitativeCheckResult<double>(); - EXPECT_NEAR(5.679243850315877, quantitativeCheckResult4[initialState], storm::settings::getModule<storm::settings::modules::GeneralSettings>().getPrecision()); - - formula = formulaParser.parseSingleFormulaFromString("R=? [C<=10]"); - checkResult = modelchecker.check(*formula); - - ASSERT_TRUE(checkResult->isExplicitQuantitativeCheckResult()); - storm::modelchecker::ExplicitQuantitativeCheckResult<double> quantitativeCheckResult5 = checkResult->asExplicitQuantitativeCheckResult<double>(); - EXPECT_NEAR(55.44792186036232, quantitativeCheckResult5[initialState], storm::settings::getModule<storm::settings::modules::GeneralSettings>().getPrecision()); - - formula = formulaParser.parseSingleFormulaFromString("R=? [F \"first_queue_full\"&\"second_queue_full\"]"); - checkResult = modelchecker.check(*formula); - - ASSERT_TRUE(checkResult->isExplicitQuantitativeCheckResult()); - storm::modelchecker::ExplicitQuantitativeCheckResult<double> quantitativeCheckResult6 = checkResult->asExplicitQuantitativeCheckResult<double>(); - EXPECT_NEAR(262.85103661561755, quantitativeCheckResult6[initialState], storm::settings::getModule<storm::settings::modules::GeneralSettings>().getPrecision()); - - formula = formulaParser.parseSingleFormulaFromString("LRA=? [\"first_queue_full\"]"); - checkResult = modelchecker.check(*formula); - - ASSERT_TRUE(checkResult->isExplicitQuantitativeCheckResult()); - storm::modelchecker::ExplicitQuantitativeCheckResult<double> quantitativeCheckResult7 = checkResult->asExplicitQuantitativeCheckResult<double>(); - EXPECT_NEAR(0.9100373532, quantitativeCheckResult7[initialState], storm::settings::getModule<storm::settings::modules::GeneralSettings>().getPrecision()); -} diff --git a/src/test/storm/modelchecker/GmmxxDtmcPrctlModelCheckerTest.cpp b/src/test/storm/modelchecker/GmmxxDtmcPrctlModelCheckerTest.cpp deleted file mode 100644 index 5535edf4f..000000000 --- a/src/test/storm/modelchecker/GmmxxDtmcPrctlModelCheckerTest.cpp +++ /dev/null @@ -1,333 +0,0 @@ -#include "gtest/gtest.h" -#include "storm-config.h" - -#include "storm/parser/FormulaParser.h" -#include "storm/logic/Formulas.h" -#include "storm/solver/GmmxxLinearEquationSolver.h" -#include "storm/models/sparse/StandardRewardModel.h" -#include "storm/modelchecker/prctl/SparseDtmcPrctlModelChecker.h" -#include "storm/modelchecker/results/ExplicitQuantitativeCheckResult.h" -#include "storm/settings/SettingsManager.h" -#include "storm/settings/modules/GeneralSettings.h" -#include "storm/settings/modules/GmmxxEquationSolverSettings.h" -#include "storm/settings/modules/NativeEquationSolverSettings.h" -#include "storm/settings/SettingMemento.h" -#include "storm/parser/AutoParser.h" -#include "storm/parser/PrismParser.h" -#include "storm/builder/ExplicitModelBuilder.h" -#include "storm/storage/expressions/ExpressionManager.h" - -TEST(GmmxxDtmcPrctlModelCheckerTest, Die) { - std::shared_ptr<storm::models::sparse::Model<double>> abstractModel = storm::parser::AutoParser<>::parseModel(STORM_TEST_RESOURCES_DIR "/tra/die.tra", STORM_TEST_RESOURCES_DIR "/lab/die.lab", "", STORM_TEST_RESOURCES_DIR "/rew/die.coin_flips.trans.rew"); - - // A parser that we use for conveniently constructing the formulas. - auto expManager = std::make_shared<storm::expressions::ExpressionManager>(); - storm::parser::FormulaParser formulaParser(expManager); - - ASSERT_EQ(abstractModel->getType(), storm::models::ModelType::Dtmc); - - std::shared_ptr<storm::models::sparse::Dtmc<double>> dtmc = abstractModel->as<storm::models::sparse::Dtmc<double>>(); - - ASSERT_EQ(dtmc->getNumberOfStates(), 13ull); - ASSERT_EQ(dtmc->getNumberOfTransitions(), 20ull); - - storm::modelchecker::SparseDtmcPrctlModelChecker<storm::models::sparse::Dtmc<double>> checker(*dtmc, std::make_unique<storm::solver::GmmxxLinearEquationSolverFactory<double>>()); - - std::shared_ptr<storm::logic::Formula const> formula = formulaParser.parseSingleFormulaFromString("P=? [F \"one\"]"); - - std::unique_ptr<storm::modelchecker::CheckResult> result = checker.check(*formula); - storm::modelchecker::ExplicitQuantitativeCheckResult<double>& quantitativeResult1 = result->asExplicitQuantitativeCheckResult<double>(); - - EXPECT_NEAR(1.0 / 6.0, quantitativeResult1[0], storm::settings::getModule<storm::settings::modules::GmmxxEquationSolverSettings>().getPrecision()); - - formula = formulaParser.parseSingleFormulaFromString("P=? [F \"two\"]"); - - result = checker.check(*formula); - storm::modelchecker::ExplicitQuantitativeCheckResult<double>& quantitativeResult2 = result->asExplicitQuantitativeCheckResult<double>(); - - EXPECT_NEAR(1.0 / 6.0, quantitativeResult2[0], storm::settings::getModule<storm::settings::modules::GmmxxEquationSolverSettings>().getPrecision()); - - formula = formulaParser.parseSingleFormulaFromString("P=? [F \"three\"]"); - - result = checker.check(*formula); - storm::modelchecker::ExplicitQuantitativeCheckResult<double>& quantitativeResult3 = result->asExplicitQuantitativeCheckResult<double>(); - - EXPECT_NEAR(1.0 / 6.0, quantitativeResult3[0], storm::settings::getModule<storm::settings::modules::GmmxxEquationSolverSettings>().getPrecision()); - - formula = formulaParser.parseSingleFormulaFromString("R=? [F \"done\"]"); - - result = checker.check(*formula); - storm::modelchecker::ExplicitQuantitativeCheckResult<double>& quantitativeResult4 = result->asExplicitQuantitativeCheckResult<double>(); - - EXPECT_NEAR(11.0 / 3.0, quantitativeResult4[0], storm::settings::getModule<storm::settings::modules::GmmxxEquationSolverSettings>().getPrecision()); -} - -TEST(GmmxxDtmcPrctlModelCheckerTest, Crowds) { - std::shared_ptr<storm::models::sparse::Model<double>> abstractModel = storm::parser::AutoParser<>::parseModel(STORM_TEST_RESOURCES_DIR "/tra/crowds5_5.tra", STORM_TEST_RESOURCES_DIR "/lab/crowds5_5.lab", "", ""); - - ASSERT_EQ(abstractModel->getType(), storm::models::ModelType::Dtmc); - - // A parser that we use for conveniently constructing the formulas. - - auto expManager = std::make_shared<storm::expressions::ExpressionManager>(); - storm::parser::FormulaParser formulaParser(expManager); - - std::shared_ptr<storm::models::sparse::Dtmc<double>> dtmc = abstractModel->as<storm::models::sparse::Dtmc<double>>(); - - ASSERT_EQ(8607ull, dtmc->getNumberOfStates()); - ASSERT_EQ(15113ull, dtmc->getNumberOfTransitions()); - - storm::modelchecker::SparseDtmcPrctlModelChecker<storm::models::sparse::Dtmc<double>> checker(*dtmc, std::make_unique<storm::solver::GmmxxLinearEquationSolverFactory<double>>()); - - std::shared_ptr<storm::logic::Formula const> formula = formulaParser.parseSingleFormulaFromString("P=? [F \"observe0Greater1\"]"); - - std::unique_ptr<storm::modelchecker::CheckResult> result = checker.check(*formula); - storm::modelchecker::ExplicitQuantitativeCheckResult<double>& quantitativeResult1 = result->asExplicitQuantitativeCheckResult<double>(); - - EXPECT_NEAR(0.3328800375801578281, quantitativeResult1[0], storm::settings::getModule<storm::settings::modules::GmmxxEquationSolverSettings>().getPrecision()); - - formula = formulaParser.parseSingleFormulaFromString("P=? [F \"observeIGreater1\"]"); - - result = checker.check(*formula); - storm::modelchecker::ExplicitQuantitativeCheckResult<double>& quantitativeResult2 = result->asExplicitQuantitativeCheckResult<double>(); - - EXPECT_NEAR(0.1522194965, quantitativeResult2[0], storm::settings::getModule<storm::settings::modules::GmmxxEquationSolverSettings>().getPrecision()); - - formula = formulaParser.parseSingleFormulaFromString("P=? [F \"observeOnlyTrueSender\"]"); - - result = checker.check(*formula); - storm::modelchecker::ExplicitQuantitativeCheckResult<double>& quantitativeResult3 = result->asExplicitQuantitativeCheckResult<double>(); - - EXPECT_NEAR(0.32153724292835045, quantitativeResult3[0], storm::settings::getModule<storm::settings::modules::GmmxxEquationSolverSettings>().getPrecision()); -} - -TEST(GmmxxDtmcPrctlModelCheckerTest, SynchronousLeader) { - std::shared_ptr<storm::models::sparse::Model<double>> abstractModel = storm::parser::AutoParser<>::parseModel(STORM_TEST_RESOURCES_DIR "/tra/leader4_8.tra", STORM_TEST_RESOURCES_DIR "/lab/leader4_8.lab", "", STORM_TEST_RESOURCES_DIR "/rew/leader4_8.pick.trans.rew"); - - ASSERT_EQ(abstractModel->getType(), storm::models::ModelType::Dtmc); - - // A parser that we use for conveniently constructing the formulas. - - auto expManager = std::make_shared<storm::expressions::ExpressionManager>(); - storm::parser::FormulaParser formulaParser(expManager); - - std::shared_ptr<storm::models::sparse::Dtmc<double>> dtmc = abstractModel->as<storm::models::sparse::Dtmc<double>>(); - - ASSERT_EQ(12400ull, dtmc->getNumberOfStates()); - ASSERT_EQ(16495ull, dtmc->getNumberOfTransitions()); - - storm::modelchecker::SparseDtmcPrctlModelChecker<storm::models::sparse::Dtmc<double>> checker(*dtmc, std::make_unique<storm::solver::GmmxxLinearEquationSolverFactory<double>>()); - - std::shared_ptr<storm::logic::Formula const> formula = formulaParser.parseSingleFormulaFromString("P=? [F \"elected\"]"); - - std::unique_ptr<storm::modelchecker::CheckResult> result = checker.check(*formula); - storm::modelchecker::ExplicitQuantitativeCheckResult<double>& quantitativeResult1 = result->asExplicitQuantitativeCheckResult<double>(); - - EXPECT_NEAR(1.0, quantitativeResult1[0], storm::settings::getModule<storm::settings::modules::GmmxxEquationSolverSettings>().getPrecision()); - - formula = formulaParser.parseSingleFormulaFromString("P=? [F<=20 \"elected\"]"); - - result = checker.check(*formula); - storm::modelchecker::ExplicitQuantitativeCheckResult<double>& quantitativeResult2 = result->asExplicitQuantitativeCheckResult<double>(); - - EXPECT_NEAR(0.9999965911265462636, quantitativeResult2[0], storm::settings::getModule<storm::settings::modules::GmmxxEquationSolverSettings>().getPrecision()); - - formula = formulaParser.parseSingleFormulaFromString("R=? [F \"elected\"]"); - - result = checker.check(*formula); - storm::modelchecker::ExplicitQuantitativeCheckResult<double>& quantitativeResult3 = result->asExplicitQuantitativeCheckResult<double>(); - - EXPECT_NEAR(1.044879046, quantitativeResult3[0], storm::settings::getModule<storm::settings::modules::GmmxxEquationSolverSettings>().getPrecision()); -} - -TEST(GmmxxDtmcPrctlModelCheckerTest, LRASingleBscc) { - storm::storage::SparseMatrixBuilder<double> matrixBuilder; - std::shared_ptr<storm::models::sparse::Dtmc<double>> dtmc; - - // A parser that we use for conveniently constructing the formulas. - - auto expManager = std::make_shared<storm::expressions::ExpressionManager>(); - storm::parser::FormulaParser formulaParser(expManager); - - { - matrixBuilder = storm::storage::SparseMatrixBuilder<double>(2, 2, 2); - matrixBuilder.addNextValue(0, 1, 1.); - matrixBuilder.addNextValue(1, 0, 1.); - storm::storage::SparseMatrix<double> transitionMatrix = matrixBuilder.build(); - - storm::models::sparse::StateLabeling ap(2); - ap.addLabel("a"); - ap.addLabelToState("a", 1); - - dtmc.reset(new storm::models::sparse::Dtmc<double>(transitionMatrix, ap)); - - storm::modelchecker::SparseDtmcPrctlModelChecker<storm::models::sparse::Dtmc<double>> checker(*dtmc, std::make_unique<storm::solver::GmmxxLinearEquationSolverFactory<double>>()); - - std::shared_ptr<storm::logic::Formula const> formula = formulaParser.parseSingleFormulaFromString("LRA=? [\"a\"]"); - - std::unique_ptr<storm::modelchecker::CheckResult> result = checker.check(*formula); - storm::modelchecker::ExplicitQuantitativeCheckResult<double>& quantitativeResult1 = result->asExplicitQuantitativeCheckResult<double>(); - - EXPECT_NEAR(.5, quantitativeResult1[0], storm::settings::getModule<storm::settings::modules::NativeEquationSolverSettings>().getPrecision()); - EXPECT_NEAR(.5, quantitativeResult1[1], storm::settings::getModule<storm::settings::modules::NativeEquationSolverSettings>().getPrecision()); - } - { - matrixBuilder = storm::storage::SparseMatrixBuilder<double>(2, 2, 4); - matrixBuilder.addNextValue(0, 0, .5); - matrixBuilder.addNextValue(0, 1, .5); - matrixBuilder.addNextValue(1, 0, .5); - matrixBuilder.addNextValue(1, 1, .5); - storm::storage::SparseMatrix<double> transitionMatrix = matrixBuilder.build(); - - storm::models::sparse::StateLabeling ap(2); - ap.addLabel("a"); - ap.addLabelToState("a", 1); - - dtmc.reset(new storm::models::sparse::Dtmc<double>(transitionMatrix, ap)); - - storm::modelchecker::SparseDtmcPrctlModelChecker<storm::models::sparse::Dtmc<double>> checker(*dtmc, std::make_unique<storm::solver::GmmxxLinearEquationSolverFactory<double>>()); - - std::shared_ptr<storm::logic::Formula const> formula = formulaParser.parseSingleFormulaFromString("LRA=? [\"a\"]"); - - std::unique_ptr<storm::modelchecker::CheckResult> result = checker.check(*formula); - storm::modelchecker::ExplicitQuantitativeCheckResult<double>& quantitativeResult1 = result->asExplicitQuantitativeCheckResult<double>(); - - EXPECT_NEAR(.5, quantitativeResult1[0], storm::settings::getModule<storm::settings::modules::NativeEquationSolverSettings>().getPrecision()); - EXPECT_NEAR(.5, quantitativeResult1[1], storm::settings::getModule<storm::settings::modules::NativeEquationSolverSettings>().getPrecision()); - } - - { - matrixBuilder = storm::storage::SparseMatrixBuilder<double>(3, 3, 3); - matrixBuilder.addNextValue(0, 1, 1); - matrixBuilder.addNextValue(1, 2, 1); - matrixBuilder.addNextValue(2, 0, 1); - storm::storage::SparseMatrix<double> transitionMatrix = matrixBuilder.build(); - - storm::models::sparse::StateLabeling ap(3); - ap.addLabel("a"); - ap.addLabelToState("a", 2); - - dtmc.reset(new storm::models::sparse::Dtmc<double>(transitionMatrix, ap)); - - storm::modelchecker::SparseDtmcPrctlModelChecker<storm::models::sparse::Dtmc<double>> checker(*dtmc, std::make_unique<storm::solver::GmmxxLinearEquationSolverFactory<double>>()); - - std::shared_ptr<storm::logic::Formula const> formula = formulaParser.parseSingleFormulaFromString("LRA=? [\"a\"]"); - - std::unique_ptr<storm::modelchecker::CheckResult> result = checker.check(*formula); - storm::modelchecker::ExplicitQuantitativeCheckResult<double>& quantitativeResult1 = result->asExplicitQuantitativeCheckResult<double>(); - - EXPECT_NEAR(1. / 3., quantitativeResult1[0], storm::settings::getModule<storm::settings::modules::NativeEquationSolverSettings>().getPrecision()); - EXPECT_NEAR(1. / 3., quantitativeResult1[1], storm::settings::getModule<storm::settings::modules::NativeEquationSolverSettings>().getPrecision()); - EXPECT_NEAR(1. / 3., quantitativeResult1[2], storm::settings::getModule<storm::settings::modules::NativeEquationSolverSettings>().getPrecision()); - } -} - -TEST(GmmxxDtmcPrctlModelCheckerTest, LRA) { - storm::storage::SparseMatrixBuilder<double> matrixBuilder; - std::shared_ptr<storm::models::sparse::Dtmc<double>> dtmc; - - // A parser that we use for conveniently constructing the formulas. - - auto expManager = std::make_shared<storm::expressions::ExpressionManager>(); - storm::parser::FormulaParser formulaParser(expManager); - - { - matrixBuilder = storm::storage::SparseMatrixBuilder<double>(15, 15, 20, true); - matrixBuilder.addNextValue(0, 1, 1); - matrixBuilder.addNextValue(1, 4, 0.7); - matrixBuilder.addNextValue(1, 6, 0.3); - matrixBuilder.addNextValue(2, 0, 1); - - matrixBuilder.addNextValue(3, 5, 0.8); - matrixBuilder.addNextValue(3, 9, 0.2); - matrixBuilder.addNextValue(4, 3, 1); - matrixBuilder.addNextValue(5, 3, 1); - - matrixBuilder.addNextValue(6, 7, 1); - matrixBuilder.addNextValue(7, 8, 1); - matrixBuilder.addNextValue(8, 6, 1); - - matrixBuilder.addNextValue(9, 10, 1); - matrixBuilder.addNextValue(10, 9, 1); - matrixBuilder.addNextValue(11, 9, 1); - - matrixBuilder.addNextValue(12, 5, 0.4); - matrixBuilder.addNextValue(12, 8, 0.3); - matrixBuilder.addNextValue(12, 11, 0.3); - - matrixBuilder.addNextValue(13, 7, 0.7); - matrixBuilder.addNextValue(13, 12, 0.3); - - matrixBuilder.addNextValue(14, 12, 1); - - storm::storage::SparseMatrix<double> transitionMatrix = matrixBuilder.build(); - - storm::models::sparse::StateLabeling ap(15); - ap.addLabel("a"); - ap.addLabelToState("a", 1); - ap.addLabelToState("a", 4); - ap.addLabelToState("a", 5); - ap.addLabelToState("a", 7); - ap.addLabelToState("a", 11); - ap.addLabelToState("a", 13); - ap.addLabelToState("a", 14); - - dtmc.reset(new storm::models::sparse::Dtmc<double>(transitionMatrix, ap)); - - storm::modelchecker::SparseDtmcPrctlModelChecker<storm::models::sparse::Dtmc<double>> checker(*dtmc, std::make_unique<storm::solver::GmmxxLinearEquationSolverFactory<double>>()); - - std::shared_ptr<storm::logic::Formula const> formula = formulaParser.parseSingleFormulaFromString("LRA=? [\"a\"]"); - - std::unique_ptr<storm::modelchecker::CheckResult> result = checker.check(*formula); - storm::modelchecker::ExplicitQuantitativeCheckResult<double>& quantitativeResult1 = result->asExplicitQuantitativeCheckResult<double>(); - - EXPECT_NEAR(0.3 / 3., quantitativeResult1[0], storm::settings::getModule<storm::settings::modules::NativeEquationSolverSettings>().getPrecision()); - EXPECT_NEAR(0.0, quantitativeResult1[3], storm::settings::getModule<storm::settings::modules::NativeEquationSolverSettings>().getPrecision()); - EXPECT_NEAR(1. / 3., quantitativeResult1[6], storm::settings::getModule<storm::settings::modules::NativeEquationSolverSettings>().getPrecision()); - EXPECT_NEAR(0.0, quantitativeResult1[9], storm::settings::getModule<storm::settings::modules::NativeEquationSolverSettings>().getPrecision()); - EXPECT_NEAR(0.3 / 3., quantitativeResult1[12], storm::settings::getModule<storm::settings::modules::NativeEquationSolverSettings>().getPrecision()); - EXPECT_NEAR(.79 / 3., quantitativeResult1[13], storm::settings::getModule<storm::settings::modules::NativeEquationSolverSettings>().getPrecision()); - EXPECT_NEAR(0.3 / 3., quantitativeResult1[14], storm::settings::getModule<storm::settings::modules::NativeEquationSolverSettings>().getPrecision()); - } -} - -TEST(GmmxxDtmcPrctlModelCheckerTest, Conditional) { - storm::prism::Program program = storm::parser::PrismParser::parse(STORM_TEST_RESOURCES_DIR "/dtmc/test_conditional.pm"); - - std::shared_ptr<storm::models::sparse::Model<double>> model = storm::builder::ExplicitModelBuilder<double>(program, storm::generator::NextStateGeneratorOptions(true, true)).build(); - ASSERT_TRUE(model->getType() == storm::models::ModelType::Dtmc); - ASSERT_EQ(4ul, model->getNumberOfStates()); - ASSERT_EQ(5ul, model->getNumberOfTransitions()); - - std::shared_ptr<storm::models::sparse::Dtmc<double>> dtmc = model->as<storm::models::sparse::Dtmc<double>>(); - - storm::modelchecker::SparseDtmcPrctlModelChecker<storm::models::sparse::Dtmc<double>> checker(*dtmc, std::make_unique<storm::solver::GmmxxLinearEquationSolverFactory<double>>()); - - // A parser that we use for conveniently constructing the formulas. - - auto expManager = std::make_shared<storm::expressions::ExpressionManager>(); - storm::parser::FormulaParser formulaParser(expManager); - std::shared_ptr<storm::logic::Formula const> formula = formulaParser.parseSingleFormulaFromString("P=? [F \"target\"]"); - - std::unique_ptr<storm::modelchecker::CheckResult> result = checker.check(*formula); - storm::modelchecker::ExplicitQuantitativeCheckResult<double>& quantitativeResult1 = result->asExplicitQuantitativeCheckResult<double>(); - EXPECT_NEAR(0.5, quantitativeResult1[0], storm::settings::getModule<storm::settings::modules::NativeEquationSolverSettings>().getPrecision()); - - formula = formulaParser.parseSingleFormulaFromString("P=? [F \"target\" || F \"condition\"]"); - - result = checker.check(*formula); - storm::modelchecker::ExplicitQuantitativeCheckResult<double>& quantitativeResult2 = result->asExplicitQuantitativeCheckResult<double>(); - EXPECT_NEAR(storm::utility::one<double>(), quantitativeResult2[0], storm::settings::getModule<storm::settings::modules::NativeEquationSolverSettings>().getPrecision()); - - formula = formulaParser.parseSingleFormulaFromString("R=? [F \"target\"]"); - - result = checker.check(*formula); - storm::modelchecker::ExplicitQuantitativeCheckResult<double>& quantitativeResult3 = result->asExplicitQuantitativeCheckResult<double>(); - EXPECT_EQ(storm::utility::infinity<double>(), quantitativeResult3[0]); - - formula = formulaParser.parseSingleFormulaFromString("R=? [F \"target\" || F \"condition\"]"); - - result = checker.check(*formula); - storm::modelchecker::ExplicitQuantitativeCheckResult<double>& quantitativeResult4 = result->asExplicitQuantitativeCheckResult<double>(); - EXPECT_NEAR(storm::utility::one<double>(), quantitativeResult4[0], storm::settings::getModule<storm::settings::modules::NativeEquationSolverSettings>().getPrecision()); -} diff --git a/src/test/storm/modelchecker/GmmxxHybridCtmcCslModelCheckerTest.cpp b/src/test/storm/modelchecker/GmmxxHybridCtmcCslModelCheckerTest.cpp deleted file mode 100644 index 821bf9297..000000000 --- a/src/test/storm/modelchecker/GmmxxHybridCtmcCslModelCheckerTest.cpp +++ /dev/null @@ -1,614 +0,0 @@ -#include "gtest/gtest.h" -#include "storm-config.h" -#include "storm/settings/SettingMemento.h" -#include "storm/parser/PrismParser.h" -#include "storm/parser/FormulaParser.h" -#include "storm/logic/Formulas.h" -#include "storm/builder/DdPrismModelBuilder.h" -#include "storm/storage/dd/DdType.h" -#include "storm/storage/SymbolicModelDescription.h" - -#include "storm/solver/GmmxxLinearEquationSolver.h" -#include "storm/models/symbolic/StandardRewardModel.h" -#include "storm/modelchecker/csl/HybridCtmcCslModelChecker.h" -#include "storm/modelchecker/results/HybridQuantitativeCheckResult.h" -#include "storm/modelchecker/results/SymbolicQualitativeCheckResult.h" -#include "storm/modelchecker/results/SymbolicQuantitativeCheckResult.h" - -#include "storm/settings/SettingsManager.h" -#include "storm/settings/modules/GeneralSettings.h" -#include "storm/settings/modules/GmmxxEquationSolverSettings.h" - -#include "storm/settings/modules/NativeEquationSolverSettings.h" -#include "storm/storage/expressions/ExpressionManager.h" - -TEST(GmmxxHybridCtmcCslModelCheckerTest, Cluster_Cudd) { - - // Parse the model description. - storm::storage::SymbolicModelDescription modelDescription = storm::parser::PrismParser::parse(STORM_TEST_RESOURCES_DIR "/ctmc/cluster2.sm", true); - storm::prism::Program program = modelDescription.preprocess().asPrismProgram(); - storm::parser::FormulaParser formulaParser(program.getManager().getSharedPointer()); - std::shared_ptr<storm::logic::Formula const> formula(nullptr); - - // Build the model. -#ifdef WINDOWS - storm::builder::DdPrismModelBuilder<storm::dd::DdType::CUDD>::Options options; -#else - typename storm::builder::DdPrismModelBuilder<storm::dd::DdType::CUDD>::Options options; -#endif - options.buildAllRewardModels = false; - options.rewardModelsToBuild.insert("num_repairs"); - std::shared_ptr<storm::models::symbolic::Model<storm::dd::DdType::CUDD>> model = storm::builder::DdPrismModelBuilder<storm::dd::DdType::CUDD>().build(program, options); - ASSERT_EQ(storm::models::ModelType::Ctmc, model->getType()); - std::shared_ptr<storm::models::symbolic::Ctmc<storm::dd::DdType::CUDD>> ctmc = model->as<storm::models::symbolic::Ctmc<storm::dd::DdType::CUDD>>(); - - // Create model checker. - storm::modelchecker::HybridCtmcCslModelChecker<storm::models::symbolic::Ctmc<storm::dd::DdType::CUDD, double>> modelchecker(*ctmc, std::make_unique<storm::solver::GmmxxLinearEquationSolverFactory<double>>()); - - // Start checking properties. - formula = formulaParser.parseSingleFormulaFromString("P=? [ F<=100 !\"minimum\"]"); - std::unique_ptr<storm::modelchecker::CheckResult> checkResult = modelchecker.check(*formula); - - ASSERT_TRUE(checkResult->isHybridQuantitativeCheckResult()); - checkResult->filter(storm::modelchecker::SymbolicQualitativeCheckResult<storm::dd::DdType::CUDD>(ctmc->getReachableStates(), ctmc->getInitialStates())); - storm::modelchecker::HybridQuantitativeCheckResult<storm::dd::DdType::CUDD> quantitativeCheckResult1 = checkResult->asHybridQuantitativeCheckResult<storm::dd::DdType::CUDD, double>(); - EXPECT_NEAR(5.5461254704419085E-5, quantitativeCheckResult1.getMin(), storm::settings::getModule<storm::settings::modules::GeneralSettings>().getPrecision()); - EXPECT_NEAR(5.5461254704419085E-5, quantitativeCheckResult1.getMax(), storm::settings::getModule<storm::settings::modules::GeneralSettings>().getPrecision()); - - formula = formulaParser.parseSingleFormulaFromString("P=? [ F[100,100] !\"minimum\"]"); - checkResult = modelchecker.check(*formula); - - ASSERT_TRUE(checkResult->isHybridQuantitativeCheckResult()); - checkResult->filter(storm::modelchecker::SymbolicQualitativeCheckResult<storm::dd::DdType::CUDD>(ctmc->getReachableStates(), ctmc->getInitialStates())); - storm::modelchecker::HybridQuantitativeCheckResult<storm::dd::DdType::CUDD> quantitativeCheckResult2 = checkResult->asHybridQuantitativeCheckResult<storm::dd::DdType::CUDD, double>(); - EXPECT_NEAR(2.3397873548343415E-6, quantitativeCheckResult2.getMin(), storm::settings::getModule<storm::settings::modules::GeneralSettings>().getPrecision()); - EXPECT_NEAR(2.3397873548343415E-6, quantitativeCheckResult2.getMax(), storm::settings::getModule<storm::settings::modules::GeneralSettings>().getPrecision()); - - formula = formulaParser.parseSingleFormulaFromString("P=? [ F[100,2000] !\"minimum\"]"); - checkResult = modelchecker.check(*formula); - - ASSERT_TRUE(checkResult->isHybridQuantitativeCheckResult()); - checkResult->filter(storm::modelchecker::SymbolicQualitativeCheckResult<storm::dd::DdType::CUDD>(ctmc->getReachableStates(), ctmc->getInitialStates())); - storm::modelchecker::HybridQuantitativeCheckResult<storm::dd::DdType::CUDD> quantitativeCheckResult3 = checkResult->asHybridQuantitativeCheckResult<storm::dd::DdType::CUDD, double>(); - EXPECT_NEAR(0.001105335651670241, quantitativeCheckResult3.getMin(), storm::settings::getModule<storm::settings::modules::GeneralSettings>().getPrecision()); - EXPECT_NEAR(0.001105335651670241, quantitativeCheckResult3.getMax(), storm::settings::getModule<storm::settings::modules::GeneralSettings>().getPrecision()); - - formula = formulaParser.parseSingleFormulaFromString("P=? [ \"minimum\" U<=10 \"premium\"]"); - checkResult = modelchecker.check(*formula); - - ASSERT_TRUE(checkResult->isHybridQuantitativeCheckResult()); - checkResult->filter(storm::modelchecker::SymbolicQualitativeCheckResult<storm::dd::DdType::CUDD>(ctmc->getReachableStates(), ctmc->getInitialStates())); - storm::modelchecker::HybridQuantitativeCheckResult<storm::dd::DdType::CUDD> quantitativeCheckResult4 = checkResult->asHybridQuantitativeCheckResult<storm::dd::DdType::CUDD, double>(); - EXPECT_NEAR(1, quantitativeCheckResult4.getMin(), storm::settings::getModule<storm::settings::modules::GeneralSettings>().getPrecision()); - EXPECT_NEAR(1, quantitativeCheckResult4.getMax(), storm::settings::getModule<storm::settings::modules::GeneralSettings>().getPrecision()); - - formula = formulaParser.parseSingleFormulaFromString("P=? [ !\"minimum\" U>=1 \"minimum\"]"); - checkResult = modelchecker.check(*formula); - - ASSERT_TRUE(checkResult->isHybridQuantitativeCheckResult()); - checkResult->filter(storm::modelchecker::SymbolicQualitativeCheckResult<storm::dd::DdType::CUDD>(ctmc->getReachableStates(), ctmc->getInitialStates())); - storm::modelchecker::HybridQuantitativeCheckResult<storm::dd::DdType::CUDD> quantitativeCheckResult5 = checkResult->asHybridQuantitativeCheckResult<storm::dd::DdType::CUDD, double>(); - EXPECT_NEAR(0, quantitativeCheckResult5.getMin(), storm::settings::getModule<storm::settings::modules::GeneralSettings>().getPrecision()); - EXPECT_NEAR(0, quantitativeCheckResult5.getMax(), storm::settings::getModule<storm::settings::modules::GeneralSettings>().getPrecision()); - - formula = formulaParser.parseSingleFormulaFromString("P=? [ \"minimum\" U>=1 !\"minimum\"]"); - checkResult = modelchecker.check(*formula); - - ASSERT_TRUE(checkResult->isHybridQuantitativeCheckResult()); - checkResult->filter(storm::modelchecker::SymbolicQualitativeCheckResult<storm::dd::DdType::CUDD>(ctmc->getReachableStates(), ctmc->getInitialStates())); - storm::modelchecker::HybridQuantitativeCheckResult<storm::dd::DdType::CUDD> quantitativeCheckResult6 = checkResult->asHybridQuantitativeCheckResult<storm::dd::DdType::CUDD, double>(); - EXPECT_NEAR(0.9999999033633374, quantitativeCheckResult6.getMin(), storm::settings::getModule<storm::settings::modules::GeneralSettings>().getPrecision()); - EXPECT_NEAR(0.9999999033633374, quantitativeCheckResult6.getMax(), storm::settings::getModule<storm::settings::modules::GeneralSettings>().getPrecision()); - - formula = formulaParser.parseSingleFormulaFromString("R=? [C<=100]"); - checkResult = modelchecker.check(*formula); - - ASSERT_TRUE(checkResult->isHybridQuantitativeCheckResult()); - checkResult->filter(storm::modelchecker::SymbolicQualitativeCheckResult<storm::dd::DdType::CUDD>(ctmc->getReachableStates(), ctmc->getInitialStates())); - storm::modelchecker::HybridQuantitativeCheckResult<storm::dd::DdType::CUDD> quantitativeCheckResult7 = checkResult->asHybridQuantitativeCheckResult<storm::dd::DdType::CUDD, double>(); - EXPECT_NEAR(0.8602815057967503, quantitativeCheckResult7.getMin(), storm::settings::getModule<storm::settings::modules::GeneralSettings>().getPrecision()); - EXPECT_NEAR(0.8602815057967503, quantitativeCheckResult7.getMax(), storm::settings::getModule<storm::settings::modules::GeneralSettings>().getPrecision()); - - formula = formulaParser.parseSingleFormulaFromString("LRA=? [\"minimum\"]"); - checkResult = modelchecker.check(*formula); - - checkResult->filter(storm::modelchecker::SymbolicQualitativeCheckResult<storm::dd::DdType::CUDD>(ctmc->getReachableStates(), ctmc->getInitialStates())); - storm::modelchecker::HybridQuantitativeCheckResult<storm::dd::DdType::CUDD> quantitativeCheckResult8 = checkResult->asHybridQuantitativeCheckResult<storm::dd::DdType::CUDD, double>(); - EXPECT_NEAR(0.99999766034263426, quantitativeCheckResult8.getMin(), storm::settings::getModule<storm::settings::modules::GeneralSettings>().getPrecision()); - EXPECT_NEAR(0.99999766034263426, quantitativeCheckResult8.getMax(), storm::settings::getModule<storm::settings::modules::GeneralSettings>().getPrecision()); -} - -TEST(GmmxxHybridCtmcCslModelCheckerTest, Cluster_Sylvan) { - // Parse the model description. - storm::storage::SymbolicModelDescription modelDescription = storm::parser::PrismParser::parse(STORM_TEST_RESOURCES_DIR "/ctmc/cluster2.sm", true); - storm::prism::Program program = modelDescription.preprocess().asPrismProgram(); - storm::parser::FormulaParser formulaParser(program.getManager().getSharedPointer()); - std::shared_ptr<storm::logic::Formula const> formula(nullptr); - - // Build the model. -#ifdef WINDOWS - storm::builder::DdPrismModelBuilder<storm::dd::DdType::Sylvan>::Options options; -#else - typename storm::builder::DdPrismModelBuilder<storm::dd::DdType::Sylvan>::Options options; -#endif - options.buildAllRewardModels = false; - options.rewardModelsToBuild.insert("num_repairs"); - std::shared_ptr<storm::models::symbolic::Model<storm::dd::DdType::Sylvan>> model = storm::builder::DdPrismModelBuilder<storm::dd::DdType::Sylvan>().build(program, options); - ASSERT_EQ(storm::models::ModelType::Ctmc, model->getType()); - std::shared_ptr<storm::models::symbolic::Ctmc<storm::dd::DdType::Sylvan>> ctmc = model->as<storm::models::symbolic::Ctmc<storm::dd::DdType::Sylvan>>(); - - // Create model checker. - storm::modelchecker::HybridCtmcCslModelChecker<storm::models::symbolic::Ctmc<storm::dd::DdType::Sylvan, double>> modelchecker(*ctmc, std::make_unique<storm::solver::GmmxxLinearEquationSolverFactory<double>>()); - - // Start checking properties. - formula = formulaParser.parseSingleFormulaFromString("P=? [ F<=100 !\"minimum\"]"); - std::unique_ptr<storm::modelchecker::CheckResult> checkResult = modelchecker.check(*formula); - - ASSERT_TRUE(checkResult->isHybridQuantitativeCheckResult()); - checkResult->filter(storm::modelchecker::SymbolicQualitativeCheckResult<storm::dd::DdType::Sylvan>(ctmc->getReachableStates(), ctmc->getInitialStates())); - storm::modelchecker::HybridQuantitativeCheckResult<storm::dd::DdType::Sylvan> quantitativeCheckResult1 = checkResult->asHybridQuantitativeCheckResult<storm::dd::DdType::Sylvan, double>(); - EXPECT_NEAR(5.5461254704419085E-5, quantitativeCheckResult1.getMin(), storm::settings::getModule<storm::settings::modules::GeneralSettings>().getPrecision()); - EXPECT_NEAR(5.5461254704419085E-5, quantitativeCheckResult1.getMax(), storm::settings::getModule<storm::settings::modules::GeneralSettings>().getPrecision()); - - formula = formulaParser.parseSingleFormulaFromString("P=? [ F[100,100] !\"minimum\"]"); - checkResult = modelchecker.check(*formula); - - ASSERT_TRUE(checkResult->isHybridQuantitativeCheckResult()); - checkResult->filter(storm::modelchecker::SymbolicQualitativeCheckResult<storm::dd::DdType::Sylvan>(ctmc->getReachableStates(), ctmc->getInitialStates())); - storm::modelchecker::HybridQuantitativeCheckResult<storm::dd::DdType::Sylvan> quantitativeCheckResult2 = checkResult->asHybridQuantitativeCheckResult<storm::dd::DdType::Sylvan, double>(); - EXPECT_NEAR(2.3397873548343415E-6, quantitativeCheckResult2.getMin(), storm::settings::getModule<storm::settings::modules::GeneralSettings>().getPrecision()); - EXPECT_NEAR(2.3397873548343415E-6, quantitativeCheckResult2.getMax(), storm::settings::getModule<storm::settings::modules::GeneralSettings>().getPrecision()); - - formula = formulaParser.parseSingleFormulaFromString("P=? [ F[100,2000] !\"minimum\"]"); - checkResult = modelchecker.check(*formula); - - ASSERT_TRUE(checkResult->isHybridQuantitativeCheckResult()); - checkResult->filter(storm::modelchecker::SymbolicQualitativeCheckResult<storm::dd::DdType::Sylvan>(ctmc->getReachableStates(), ctmc->getInitialStates())); - storm::modelchecker::HybridQuantitativeCheckResult<storm::dd::DdType::Sylvan> quantitativeCheckResult3 = checkResult->asHybridQuantitativeCheckResult<storm::dd::DdType::Sylvan, double>(); - EXPECT_NEAR(0.001105335651670241, quantitativeCheckResult3.getMin(), storm::settings::getModule<storm::settings::modules::GeneralSettings>().getPrecision()); - EXPECT_NEAR(0.001105335651670241, quantitativeCheckResult3.getMax(), storm::settings::getModule<storm::settings::modules::GeneralSettings>().getPrecision()); - - formula = formulaParser.parseSingleFormulaFromString("P=? [ \"minimum\" U<=10 \"premium\"]"); - checkResult = modelchecker.check(*formula); - - ASSERT_TRUE(checkResult->isHybridQuantitativeCheckResult()); - checkResult->filter(storm::modelchecker::SymbolicQualitativeCheckResult<storm::dd::DdType::Sylvan>(ctmc->getReachableStates(), ctmc->getInitialStates())); - storm::modelchecker::HybridQuantitativeCheckResult<storm::dd::DdType::Sylvan> quantitativeCheckResult4 = checkResult->asHybridQuantitativeCheckResult<storm::dd::DdType::Sylvan, double>(); - EXPECT_NEAR(1, quantitativeCheckResult4.getMin(), storm::settings::getModule<storm::settings::modules::GeneralSettings>().getPrecision()); - EXPECT_NEAR(1, quantitativeCheckResult4.getMax(), storm::settings::getModule<storm::settings::modules::GeneralSettings>().getPrecision()); - - formula = formulaParser.parseSingleFormulaFromString("P=? [ !\"minimum\" U>=1 \"minimum\"]"); - checkResult = modelchecker.check(*formula); - - ASSERT_TRUE(checkResult->isHybridQuantitativeCheckResult()); - checkResult->filter(storm::modelchecker::SymbolicQualitativeCheckResult<storm::dd::DdType::Sylvan>(ctmc->getReachableStates(), ctmc->getInitialStates())); - storm::modelchecker::HybridQuantitativeCheckResult<storm::dd::DdType::Sylvan> quantitativeCheckResult5 = checkResult->asHybridQuantitativeCheckResult<storm::dd::DdType::Sylvan, double>(); - EXPECT_NEAR(0, quantitativeCheckResult5.getMin(), storm::settings::getModule<storm::settings::modules::GeneralSettings>().getPrecision()); - EXPECT_NEAR(0, quantitativeCheckResult5.getMax(), storm::settings::getModule<storm::settings::modules::GeneralSettings>().getPrecision()); - - formula = formulaParser.parseSingleFormulaFromString("P=? [ \"minimum\" U>=1 !\"minimum\"]"); - checkResult = modelchecker.check(*formula); - - ASSERT_TRUE(checkResult->isHybridQuantitativeCheckResult()); - checkResult->filter(storm::modelchecker::SymbolicQualitativeCheckResult<storm::dd::DdType::Sylvan>(ctmc->getReachableStates(), ctmc->getInitialStates())); - storm::modelchecker::HybridQuantitativeCheckResult<storm::dd::DdType::Sylvan> quantitativeCheckResult6 = checkResult->asHybridQuantitativeCheckResult<storm::dd::DdType::Sylvan, double>(); - EXPECT_NEAR(0.9999999033633374, quantitativeCheckResult6.getMin(), storm::settings::getModule<storm::settings::modules::GeneralSettings>().getPrecision()); - EXPECT_NEAR(0.9999999033633374, quantitativeCheckResult6.getMax(), storm::settings::getModule<storm::settings::modules::GeneralSettings>().getPrecision()); - - formula = formulaParser.parseSingleFormulaFromString("R=? [C<=100]"); - checkResult = modelchecker.check(*formula); - - ASSERT_TRUE(checkResult->isHybridQuantitativeCheckResult()); - checkResult->filter(storm::modelchecker::SymbolicQualitativeCheckResult<storm::dd::DdType::Sylvan>(ctmc->getReachableStates(), ctmc->getInitialStates())); - storm::modelchecker::HybridQuantitativeCheckResult<storm::dd::DdType::Sylvan> quantitativeCheckResult7 = checkResult->asHybridQuantitativeCheckResult<storm::dd::DdType::Sylvan, double>(); - EXPECT_NEAR(0.8602815057967503, quantitativeCheckResult7.getMin(), storm::settings::getModule<storm::settings::modules::GeneralSettings>().getPrecision()); - EXPECT_NEAR(0.8602815057967503, quantitativeCheckResult7.getMax(), storm::settings::getModule<storm::settings::modules::GeneralSettings>().getPrecision()); - - formula = formulaParser.parseSingleFormulaFromString("LRA=? [\"minimum\"]"); - checkResult = modelchecker.check(*formula); - - checkResult->filter(storm::modelchecker::SymbolicQualitativeCheckResult<storm::dd::DdType::Sylvan>(ctmc->getReachableStates(), ctmc->getInitialStates())); - storm::modelchecker::HybridQuantitativeCheckResult<storm::dd::DdType::Sylvan> quantitativeCheckResult8 = checkResult->asHybridQuantitativeCheckResult<storm::dd::DdType::Sylvan, double>(); - EXPECT_NEAR(0.99999766034263426, quantitativeCheckResult8.getMin(), storm::settings::getModule<storm::settings::modules::GeneralSettings>().getPrecision()); - EXPECT_NEAR(0.99999766034263426, quantitativeCheckResult8.getMax(), storm::settings::getModule<storm::settings::modules::GeneralSettings>().getPrecision()); -} - -TEST(GmmxxHybridCtmcCslModelCheckerTest, Embedded_Cudd) { - // Parse the model description. - storm::storage::SymbolicModelDescription modelDescription = storm::parser::PrismParser::parse(STORM_TEST_RESOURCES_DIR "/ctmc/embedded2.sm", true); - storm::prism::Program program = modelDescription.preprocess().asPrismProgram(); - storm::parser::FormulaParser formulaParser(program.getManager().getSharedPointer()); - std::shared_ptr<storm::logic::Formula const> formula(nullptr); - - // Build the model. -#ifdef WINDOWS - storm::builder::DdPrismModelBuilder<storm::dd::DdType::CUDD>::Options options; -#else - typename storm::builder::DdPrismModelBuilder<storm::dd::DdType::CUDD>::Options options; -#endif - options.buildAllRewardModels = false; - options.rewardModelsToBuild.insert("up"); - std::shared_ptr<storm::models::symbolic::Model<storm::dd::DdType::CUDD>> model = storm::builder::DdPrismModelBuilder<storm::dd::DdType::CUDD>().build(program, options); - ASSERT_EQ(storm::models::ModelType::Ctmc, model->getType()); - std::shared_ptr<storm::models::symbolic::Ctmc<storm::dd::DdType::CUDD>> ctmc = model->as<storm::models::symbolic::Ctmc<storm::dd::DdType::CUDD>>(); - - // Create model checker. - storm::modelchecker::HybridCtmcCslModelChecker<storm::models::symbolic::Ctmc<storm::dd::DdType::CUDD, double>> modelchecker(*ctmc, std::make_unique<storm::solver::GmmxxLinearEquationSolverFactory<double>>()); - - // Start checking properties. - formula = formulaParser.parseSingleFormulaFromString("P=? [ F<=10000 \"down\"]"); - std::unique_ptr<storm::modelchecker::CheckResult> checkResult = modelchecker.check(*formula); - - ASSERT_TRUE(checkResult->isHybridQuantitativeCheckResult()); - checkResult->filter(storm::modelchecker::SymbolicQualitativeCheckResult<storm::dd::DdType::CUDD>(ctmc->getReachableStates(), ctmc->getInitialStates())); - storm::modelchecker::HybridQuantitativeCheckResult<storm::dd::DdType::CUDD> quantitativeCheckResult1 = checkResult->asHybridQuantitativeCheckResult<storm::dd::DdType::CUDD, double>(); - EXPECT_NEAR(0.0019216435246119591, quantitativeCheckResult1.getMin(), storm::settings::getModule<storm::settings::modules::GeneralSettings>().getPrecision()); - EXPECT_NEAR(0.0019216435246119591, quantitativeCheckResult1.getMax(), storm::settings::getModule<storm::settings::modules::GeneralSettings>().getPrecision()); - - formula = formulaParser.parseSingleFormulaFromString("P=? [ !\"down\" U<=10000 \"fail_actuators\"]"); - checkResult = modelchecker.check(*formula); - - ASSERT_TRUE(checkResult->isHybridQuantitativeCheckResult()); - checkResult->filter(storm::modelchecker::SymbolicQualitativeCheckResult<storm::dd::DdType::CUDD>(ctmc->getReachableStates(), ctmc->getInitialStates())); - storm::modelchecker::HybridQuantitativeCheckResult<storm::dd::DdType::CUDD> quantitativeCheckResult2 = checkResult->asHybridQuantitativeCheckResult<storm::dd::DdType::CUDD, double>(); - EXPECT_NEAR(3.7079151806696567E-6, quantitativeCheckResult2.getMin(), storm::settings::getModule<storm::settings::modules::GeneralSettings>().getPrecision()); - EXPECT_NEAR(3.7079151806696567E-6, quantitativeCheckResult2.getMax(), storm::settings::getModule<storm::settings::modules::GeneralSettings>().getPrecision()); - - formula = formulaParser.parseSingleFormulaFromString("P=? [ !\"down\" U<=10000 \"fail_io\"]"); - checkResult = modelchecker.check(*formula); - - ASSERT_TRUE(checkResult->isHybridQuantitativeCheckResult()); - checkResult->filter(storm::modelchecker::SymbolicQualitativeCheckResult<storm::dd::DdType::CUDD>(ctmc->getReachableStates(), ctmc->getInitialStates())); - storm::modelchecker::HybridQuantitativeCheckResult<storm::dd::DdType::CUDD> quantitativeCheckResult3 = checkResult->asHybridQuantitativeCheckResult<storm::dd::DdType::CUDD, double>(); - EXPECT_NEAR(0.001556839327673734, quantitativeCheckResult3.getMin(), storm::settings::getModule<storm::settings::modules::GeneralSettings>().getPrecision()); - EXPECT_NEAR(0.001556839327673734, quantitativeCheckResult3.getMax(), storm::settings::getModule<storm::settings::modules::GeneralSettings>().getPrecision()); - - formula = formulaParser.parseSingleFormulaFromString("P=? [ !\"down\" U<=10000 \"fail_sensors\"]"); - checkResult = modelchecker.check(*formula); - - ASSERT_TRUE(checkResult->isHybridQuantitativeCheckResult()); - checkResult->filter(storm::modelchecker::SymbolicQualitativeCheckResult<storm::dd::DdType::CUDD>(ctmc->getReachableStates(), ctmc->getInitialStates())); - storm::modelchecker::HybridQuantitativeCheckResult<storm::dd::DdType::CUDD> quantitativeCheckResult4 = checkResult->asHybridQuantitativeCheckResult<storm::dd::DdType::CUDD, double>(); - EXPECT_NEAR(4.429620626755424E-5, quantitativeCheckResult4.getMin(), storm::settings::getModule<storm::settings::modules::GeneralSettings>().getPrecision()); - EXPECT_NEAR(4.429620626755424E-5, quantitativeCheckResult4.getMax(), storm::settings::getModule<storm::settings::modules::GeneralSettings>().getPrecision()); - - formula = formulaParser.parseSingleFormulaFromString("R=? [C<=10000]"); - checkResult = modelchecker.check(*formula); - - ASSERT_TRUE(checkResult->isHybridQuantitativeCheckResult()); - checkResult->filter(storm::modelchecker::SymbolicQualitativeCheckResult<storm::dd::DdType::CUDD>(ctmc->getReachableStates(), ctmc->getInitialStates())); - storm::modelchecker::HybridQuantitativeCheckResult<storm::dd::DdType::CUDD> quantitativeCheckResult5 = checkResult->asHybridQuantitativeCheckResult<storm::dd::DdType::CUDD, double>(); - EXPECT_NEAR(2.7745274082080154, quantitativeCheckResult5.getMin(), storm::settings::getModule<storm::settings::modules::GeneralSettings>().getPrecision()); - EXPECT_NEAR(2.7745274082080154, quantitativeCheckResult5.getMax(), storm::settings::getModule<storm::settings::modules::GeneralSettings>().getPrecision()); - - formula = formulaParser.parseSingleFormulaFromString("LRA=? [\"fail_sensors\"]"); - checkResult = modelchecker.check(*formula); - - checkResult->filter(storm::modelchecker::SymbolicQualitativeCheckResult<storm::dd::DdType::CUDD>(ctmc->getReachableStates(), ctmc->getInitialStates())); - storm::modelchecker::HybridQuantitativeCheckResult<storm::dd::DdType::CUDD> quantitativeCheckResult6 = checkResult->asHybridQuantitativeCheckResult<storm::dd::DdType::CUDD, double>(); - EXPECT_NEAR(0.934586179, quantitativeCheckResult6.getMin(), storm::settings::getModule<storm::settings::modules::GeneralSettings>().getPrecision()); - EXPECT_NEAR(0.934586179, quantitativeCheckResult6.getMax(), storm::settings::getModule<storm::settings::modules::GeneralSettings>().getPrecision()); -} - -TEST(GmmxxHybridCtmcCslModelCheckerTest, Embedded_Sylvan) { - // Parse the model description. - storm::storage::SymbolicModelDescription modelDescription = storm::parser::PrismParser::parse(STORM_TEST_RESOURCES_DIR "/ctmc/embedded2.sm", true); - storm::prism::Program program = modelDescription.preprocess().asPrismProgram(); - storm::parser::FormulaParser formulaParser(program.getManager().getSharedPointer()); - std::shared_ptr<storm::logic::Formula const> formula(nullptr); - - // Build the model. -#ifdef WINDOWS - storm::builder::DdPrismModelBuilder<storm::dd::DdType::Sylvan>::Options options; -#else - typename storm::builder::DdPrismModelBuilder<storm::dd::DdType::Sylvan>::Options options; -#endif - options.buildAllRewardModels = false; - options.rewardModelsToBuild.insert("up"); - std::shared_ptr<storm::models::symbolic::Model<storm::dd::DdType::Sylvan>> model = storm::builder::DdPrismModelBuilder<storm::dd::DdType::Sylvan>().build(program, options); - ASSERT_EQ(storm::models::ModelType::Ctmc, model->getType()); - std::shared_ptr<storm::models::symbolic::Ctmc<storm::dd::DdType::Sylvan>> ctmc = model->as<storm::models::symbolic::Ctmc<storm::dd::DdType::Sylvan>>(); - - // Create model checker. - storm::modelchecker::HybridCtmcCslModelChecker<storm::models::symbolic::Ctmc<storm::dd::DdType::Sylvan, double>> modelchecker(*ctmc, std::make_unique<storm::solver::GmmxxLinearEquationSolverFactory<double>>()); - - // Start checking properties. - formula = formulaParser.parseSingleFormulaFromString("P=? [ F<=10000 \"down\"]"); - std::unique_ptr<storm::modelchecker::CheckResult> checkResult = modelchecker.check(*formula); - - ASSERT_TRUE(checkResult->isHybridQuantitativeCheckResult()); - checkResult->filter(storm::modelchecker::SymbolicQualitativeCheckResult<storm::dd::DdType::Sylvan>(ctmc->getReachableStates(), ctmc->getInitialStates())); - storm::modelchecker::HybridQuantitativeCheckResult<storm::dd::DdType::Sylvan> quantitativeCheckResult1 = checkResult->asHybridQuantitativeCheckResult<storm::dd::DdType::Sylvan, double>(); - EXPECT_NEAR(0.0019216435246119591, quantitativeCheckResult1.getMin(), storm::settings::getModule<storm::settings::modules::GeneralSettings>().getPrecision()); - EXPECT_NEAR(0.0019216435246119591, quantitativeCheckResult1.getMax(), storm::settings::getModule<storm::settings::modules::GeneralSettings>().getPrecision()); - - formula = formulaParser.parseSingleFormulaFromString("P=? [ !\"down\" U<=10000 \"fail_actuators\"]"); - checkResult = modelchecker.check(*formula); - - ASSERT_TRUE(checkResult->isHybridQuantitativeCheckResult()); - checkResult->filter(storm::modelchecker::SymbolicQualitativeCheckResult<storm::dd::DdType::Sylvan>(ctmc->getReachableStates(), ctmc->getInitialStates())); - storm::modelchecker::HybridQuantitativeCheckResult<storm::dd::DdType::Sylvan> quantitativeCheckResult2 = checkResult->asHybridQuantitativeCheckResult<storm::dd::DdType::Sylvan, double>(); - EXPECT_NEAR(3.7079151806696567E-6, quantitativeCheckResult2.getMin(), storm::settings::getModule<storm::settings::modules::GeneralSettings>().getPrecision()); - EXPECT_NEAR(3.7079151806696567E-6, quantitativeCheckResult2.getMax(), storm::settings::getModule<storm::settings::modules::GeneralSettings>().getPrecision()); - - formula = formulaParser.parseSingleFormulaFromString("P=? [ !\"down\" U<=10000 \"fail_io\"]"); - checkResult = modelchecker.check(*formula); - - ASSERT_TRUE(checkResult->isHybridQuantitativeCheckResult()); - checkResult->filter(storm::modelchecker::SymbolicQualitativeCheckResult<storm::dd::DdType::Sylvan>(ctmc->getReachableStates(), ctmc->getInitialStates())); - storm::modelchecker::HybridQuantitativeCheckResult<storm::dd::DdType::Sylvan> quantitativeCheckResult3 = checkResult->asHybridQuantitativeCheckResult<storm::dd::DdType::Sylvan, double>(); - EXPECT_NEAR(0.001556839327673734, quantitativeCheckResult3.getMin(), storm::settings::getModule<storm::settings::modules::GeneralSettings>().getPrecision()); - EXPECT_NEAR(0.001556839327673734, quantitativeCheckResult3.getMax(), storm::settings::getModule<storm::settings::modules::GeneralSettings>().getPrecision()); - - formula = formulaParser.parseSingleFormulaFromString("P=? [ !\"down\" U<=10000 \"fail_sensors\"]"); - checkResult = modelchecker.check(*formula); - - ASSERT_TRUE(checkResult->isHybridQuantitativeCheckResult()); - checkResult->filter(storm::modelchecker::SymbolicQualitativeCheckResult<storm::dd::DdType::Sylvan>(ctmc->getReachableStates(), ctmc->getInitialStates())); - storm::modelchecker::HybridQuantitativeCheckResult<storm::dd::DdType::Sylvan> quantitativeCheckResult4 = checkResult->asHybridQuantitativeCheckResult<storm::dd::DdType::Sylvan, double>(); - EXPECT_NEAR(4.429620626755424E-5, quantitativeCheckResult4.getMin(), storm::settings::getModule<storm::settings::modules::GeneralSettings>().getPrecision()); - EXPECT_NEAR(4.429620626755424E-5, quantitativeCheckResult4.getMax(), storm::settings::getModule<storm::settings::modules::GeneralSettings>().getPrecision()); - - formula = formulaParser.parseSingleFormulaFromString("R=? [C<=10000]"); - checkResult = modelchecker.check(*formula); - - ASSERT_TRUE(checkResult->isHybridQuantitativeCheckResult()); - checkResult->filter(storm::modelchecker::SymbolicQualitativeCheckResult<storm::dd::DdType::Sylvan>(ctmc->getReachableStates(), ctmc->getInitialStates())); - storm::modelchecker::HybridQuantitativeCheckResult<storm::dd::DdType::Sylvan> quantitativeCheckResult5 = checkResult->asHybridQuantitativeCheckResult<storm::dd::DdType::Sylvan, double>(); - EXPECT_NEAR(2.7745274082080154, quantitativeCheckResult5.getMin(), storm::settings::getModule<storm::settings::modules::GeneralSettings>().getPrecision()); - EXPECT_NEAR(2.7745274082080154, quantitativeCheckResult5.getMax(), storm::settings::getModule<storm::settings::modules::GeneralSettings>().getPrecision()); - - formula = formulaParser.parseSingleFormulaFromString("LRA=? [\"fail_sensors\"]"); - checkResult = modelchecker.check(*formula); - - checkResult->filter(storm::modelchecker::SymbolicQualitativeCheckResult<storm::dd::DdType::Sylvan>(ctmc->getReachableStates(), ctmc->getInitialStates())); - storm::modelchecker::HybridQuantitativeCheckResult<storm::dd::DdType::Sylvan> quantitativeCheckResult6 = checkResult->asHybridQuantitativeCheckResult<storm::dd::DdType::Sylvan, double>(); - EXPECT_NEAR(0.934586179, quantitativeCheckResult6.getMin(), storm::settings::getModule<storm::settings::modules::GeneralSettings>().getPrecision()); - EXPECT_NEAR(0.934586179, quantitativeCheckResult6.getMax(), storm::settings::getModule<storm::settings::modules::GeneralSettings>().getPrecision()); -} - -TEST(GmmxxHybridCtmcCslModelCheckerTest, Polling_Cudd) { - // Parse the model description. - storm::storage::SymbolicModelDescription modelDescription = storm::parser::PrismParser::parse(STORM_TEST_RESOURCES_DIR "/ctmc/polling2.sm", true); - storm::prism::Program program = modelDescription.preprocess().asPrismProgram(); - storm::parser::FormulaParser formulaParser(program.getManager().getSharedPointer()); - std::shared_ptr<storm::logic::Formula const> formula(nullptr); - - // Build the model. - std::shared_ptr<storm::models::symbolic::Model<storm::dd::DdType::CUDD>> model = storm::builder::DdPrismModelBuilder<storm::dd::DdType::CUDD>().build(program); - ASSERT_EQ(storm::models::ModelType::Ctmc, model->getType()); - std::shared_ptr<storm::models::symbolic::Ctmc<storm::dd::DdType::CUDD>> ctmc = model->as<storm::models::symbolic::Ctmc<storm::dd::DdType::CUDD>>(); - - // Create model checker. - storm::modelchecker::HybridCtmcCslModelChecker<storm::models::symbolic::Ctmc<storm::dd::DdType::CUDD, double>> modelchecker(*ctmc, std::make_unique<storm::solver::GmmxxLinearEquationSolverFactory<double>>()); - - // Start checking properties. - formula = formulaParser.parseSingleFormulaFromString("P=?[ F<=10 \"target\"]"); - std::unique_ptr<storm::modelchecker::CheckResult> checkResult = modelchecker.check(*formula); - - ASSERT_TRUE(checkResult->isHybridQuantitativeCheckResult()); - checkResult->filter(storm::modelchecker::SymbolicQualitativeCheckResult<storm::dd::DdType::CUDD>(ctmc->getReachableStates(), ctmc->getInitialStates())); - storm::modelchecker::HybridQuantitativeCheckResult<storm::dd::DdType::CUDD> quantitativeCheckResult1 = checkResult->asHybridQuantitativeCheckResult<storm::dd::DdType::CUDD, double>(); - EXPECT_NEAR(1, quantitativeCheckResult1.getMin(), storm::settings::getModule<storm::settings::modules::GeneralSettings>().getPrecision()); - EXPECT_NEAR(1, quantitativeCheckResult1.getMax(), storm::settings::getModule<storm::settings::modules::GeneralSettings>().getPrecision()); - - formula = formulaParser.parseSingleFormulaFromString("LRA=? [\"target\"]"); - checkResult = modelchecker.check(*formula); - - checkResult->filter(storm::modelchecker::SymbolicQualitativeCheckResult<storm::dd::DdType::CUDD>(ctmc->getReachableStates(), ctmc->getInitialStates())); - storm::modelchecker::HybridQuantitativeCheckResult<storm::dd::DdType::CUDD> quantitativeCheckResult2 = checkResult->asHybridQuantitativeCheckResult<storm::dd::DdType::CUDD, double>(); - EXPECT_NEAR(0.20079750055570736, quantitativeCheckResult2.getMin(), storm::settings::getModule<storm::settings::modules::GeneralSettings>().getPrecision()); - EXPECT_NEAR(0.20079750055570736, quantitativeCheckResult2.getMax(), storm::settings::getModule<storm::settings::modules::GeneralSettings>().getPrecision()); -} - -TEST(GmmxxHybridCtmcCslModelCheckerTest, Polling_Sylvan) { - - // Parse the model description. - storm::storage::SymbolicModelDescription modelDescription = storm::parser::PrismParser::parse(STORM_TEST_RESOURCES_DIR "/ctmc/polling2.sm", true); - storm::prism::Program program = modelDescription.preprocess().asPrismProgram(); - storm::parser::FormulaParser formulaParser(program.getManager().getSharedPointer()); - std::shared_ptr<storm::logic::Formula const> formula(nullptr); - - // Build the model. - std::shared_ptr<storm::models::symbolic::Model<storm::dd::DdType::Sylvan>> model = storm::builder::DdPrismModelBuilder<storm::dd::DdType::Sylvan>().build(program); - ASSERT_EQ(storm::models::ModelType::Ctmc, model->getType()); - std::shared_ptr<storm::models::symbolic::Ctmc<storm::dd::DdType::Sylvan>> ctmc = model->as<storm::models::symbolic::Ctmc<storm::dd::DdType::Sylvan>>(); - - // Create model checker. - storm::modelchecker::HybridCtmcCslModelChecker<storm::models::symbolic::Ctmc<storm::dd::DdType::Sylvan, double>> modelchecker(*ctmc, std::make_unique<storm::solver::GmmxxLinearEquationSolverFactory<double>>()); - - // Start checking properties. - formula = formulaParser.parseSingleFormulaFromString("P=?[ F<=10 \"target\"]"); - std::unique_ptr<storm::modelchecker::CheckResult> checkResult = modelchecker.check(*formula); - - ASSERT_TRUE(checkResult->isHybridQuantitativeCheckResult()); - checkResult->filter(storm::modelchecker::SymbolicQualitativeCheckResult<storm::dd::DdType::Sylvan>(ctmc->getReachableStates(), ctmc->getInitialStates())); - storm::modelchecker::HybridQuantitativeCheckResult<storm::dd::DdType::Sylvan> quantitativeCheckResult1 = checkResult->asHybridQuantitativeCheckResult<storm::dd::DdType::Sylvan, double>(); - EXPECT_NEAR(1, quantitativeCheckResult1.getMin(), storm::settings::getModule<storm::settings::modules::GeneralSettings>().getPrecision()); - EXPECT_NEAR(1, quantitativeCheckResult1.getMax(), storm::settings::getModule<storm::settings::modules::GeneralSettings>().getPrecision()); - - formula = formulaParser.parseSingleFormulaFromString("LRA=? [\"target\"]"); - checkResult = modelchecker.check(*formula); - - checkResult->filter(storm::modelchecker::SymbolicQualitativeCheckResult<storm::dd::DdType::Sylvan>(ctmc->getReachableStates(), ctmc->getInitialStates())); - storm::modelchecker::HybridQuantitativeCheckResult<storm::dd::DdType::Sylvan> quantitativeCheckResult2 = checkResult->asHybridQuantitativeCheckResult<storm::dd::DdType::Sylvan, double>(); - EXPECT_NEAR(0.20079750055570736, quantitativeCheckResult2.getMin(), storm::settings::getModule<storm::settings::modules::GeneralSettings>().getPrecision()); - EXPECT_NEAR(0.20079750055570736, quantitativeCheckResult2.getMax(), storm::settings::getModule<storm::settings::modules::GeneralSettings>().getPrecision()); -} - -TEST(GmmxxHybridCtmcCslModelCheckerTest, Fms) { - - // No properties to check at this point. -} - -TEST(GmmxxHybridCtmcCslModelCheckerTest, Tandem_Cudd) { - // Parse the model description. - storm::storage::SymbolicModelDescription modelDescription = storm::parser::PrismParser::parse(STORM_TEST_RESOURCES_DIR "/ctmc/tandem5.sm", true); - storm::prism::Program program = modelDescription.preprocess().asPrismProgram(); - storm::parser::FormulaParser formulaParser(program.getManager().getSharedPointer()); - std::shared_ptr<storm::logic::Formula const> formula(nullptr); - - // Build the model with the customers reward structure. -#ifdef WINDOWS - storm::builder::DdPrismModelBuilder<storm::dd::DdType::CUDD>::Options options; -#else - typename storm::builder::DdPrismModelBuilder<storm::dd::DdType::CUDD>::Options options; -#endif - options.buildAllRewardModels = false; - options.rewardModelsToBuild.insert("customers"); - std::shared_ptr<storm::models::symbolic::Model<storm::dd::DdType::CUDD>> model = storm::builder::DdPrismModelBuilder<storm::dd::DdType::CUDD>().build(program, options); - ASSERT_EQ(storm::models::ModelType::Ctmc, model->getType()); - std::shared_ptr<storm::models::symbolic::Ctmc<storm::dd::DdType::CUDD>> ctmc = model->as<storm::models::symbolic::Ctmc<storm::dd::DdType::CUDD>>(); - - // Create model checker. - storm::modelchecker::HybridCtmcCslModelChecker<storm::models::symbolic::Ctmc<storm::dd::DdType::CUDD, double>> modelchecker(*ctmc, std::make_unique<storm::solver::GmmxxLinearEquationSolverFactory<double>>()); - - // Start checking properties. - formula = formulaParser.parseSingleFormulaFromString("P=? [ F<=10 \"network_full\" ]"); - std::unique_ptr<storm::modelchecker::CheckResult> checkResult = modelchecker.check(*formula); - - ASSERT_TRUE(checkResult->isHybridQuantitativeCheckResult()); - checkResult->filter(storm::modelchecker::SymbolicQualitativeCheckResult<storm::dd::DdType::CUDD>(ctmc->getReachableStates(), ctmc->getInitialStates())); - storm::modelchecker::HybridQuantitativeCheckResult<storm::dd::DdType::CUDD> quantitativeCheckResult1 = checkResult->asHybridQuantitativeCheckResult<storm::dd::DdType::CUDD, double>(); - EXPECT_NEAR(0.015446370562428037, quantitativeCheckResult1.getMin(), storm::settings::getModule<storm::settings::modules::GeneralSettings>().getPrecision()); - EXPECT_NEAR(0.015446370562428037, quantitativeCheckResult1.getMax(), storm::settings::getModule<storm::settings::modules::GeneralSettings>().getPrecision()); - - formula = formulaParser.parseSingleFormulaFromString("P=? [ F<=10 \"first_queue_full\" ]"); - checkResult = modelchecker.check(*formula); - - ASSERT_TRUE(checkResult->isHybridQuantitativeCheckResult()); - checkResult->filter(storm::modelchecker::SymbolicQualitativeCheckResult<storm::dd::DdType::CUDD>(ctmc->getReachableStates(), ctmc->getInitialStates())); - storm::modelchecker::HybridQuantitativeCheckResult<storm::dd::DdType::CUDD> quantitativeCheckResult2 = checkResult->asHybridQuantitativeCheckResult<storm::dd::DdType::CUDD, double>(); - EXPECT_NEAR(0.999999837225515, quantitativeCheckResult2.getMin(), storm::settings::getModule<storm::settings::modules::GeneralSettings>().getPrecision()); - EXPECT_NEAR(0.999999837225515, quantitativeCheckResult2.getMax(), storm::settings::getModule<storm::settings::modules::GeneralSettings>().getPrecision()); - - formula = formulaParser.parseSingleFormulaFromString("P=? [\"second_queue_full\" U<=1 !\"second_queue_full\"]"); - checkResult = modelchecker.check(*formula); - - ASSERT_TRUE(checkResult->isHybridQuantitativeCheckResult()); - checkResult->filter(storm::modelchecker::SymbolicQualitativeCheckResult<storm::dd::DdType::CUDD>(ctmc->getReachableStates(), ctmc->getInitialStates())); - storm::modelchecker::HybridQuantitativeCheckResult<storm::dd::DdType::CUDD> quantitativeCheckResult3 = checkResult->asHybridQuantitativeCheckResult<storm::dd::DdType::CUDD, double>(); - EXPECT_NEAR(1, quantitativeCheckResult3.getMin(), storm::settings::getModule<storm::settings::modules::GeneralSettings>().getPrecision()); - EXPECT_NEAR(1, quantitativeCheckResult3.getMax(), storm::settings::getModule<storm::settings::modules::GeneralSettings>().getPrecision()); - - formula = formulaParser.parseSingleFormulaFromString("R=? [I=10]"); - checkResult = modelchecker.check(*formula); - - ASSERT_TRUE(checkResult->isHybridQuantitativeCheckResult()); - checkResult->filter(storm::modelchecker::SymbolicQualitativeCheckResult<storm::dd::DdType::CUDD>(ctmc->getReachableStates(), ctmc->getInitialStates())); - storm::modelchecker::HybridQuantitativeCheckResult<storm::dd::DdType::CUDD> quantitativeCheckResult4 = checkResult->asHybridQuantitativeCheckResult<storm::dd::DdType::CUDD, double>(); - EXPECT_NEAR(5.679243850315877, quantitativeCheckResult4.getMin(), storm::settings::getModule<storm::settings::modules::GeneralSettings>().getPrecision()); - EXPECT_NEAR(5.679243850315877, quantitativeCheckResult4.getMax(), storm::settings::getModule<storm::settings::modules::GeneralSettings>().getPrecision()); - - formula = formulaParser.parseSingleFormulaFromString("R=? [C<=10]"); - checkResult = modelchecker.check(*formula); - - ASSERT_TRUE(checkResult->isHybridQuantitativeCheckResult()); - checkResult->filter(storm::modelchecker::SymbolicQualitativeCheckResult<storm::dd::DdType::CUDD>(ctmc->getReachableStates(), ctmc->getInitialStates())); - storm::modelchecker::HybridQuantitativeCheckResult<storm::dd::DdType::CUDD> quantitativeCheckResult5 = checkResult->asHybridQuantitativeCheckResult<storm::dd::DdType::CUDD, double>(); - EXPECT_NEAR(55.44792186036232, quantitativeCheckResult5.getMin(), storm::settings::getModule<storm::settings::modules::GeneralSettings>().getPrecision()); - EXPECT_NEAR(55.44792186036232, quantitativeCheckResult5.getMax(), storm::settings::getModule<storm::settings::modules::GeneralSettings>().getPrecision()); - - formula = formulaParser.parseSingleFormulaFromString("R=? [F \"first_queue_full\"&\"second_queue_full\"]"); - checkResult = modelchecker.check(*formula); - - ASSERT_TRUE(checkResult->isHybridQuantitativeCheckResult()); - checkResult->filter(storm::modelchecker::SymbolicQualitativeCheckResult<storm::dd::DdType::CUDD>(ctmc->getReachableStates(), ctmc->getInitialStates())); - storm::modelchecker::HybridQuantitativeCheckResult<storm::dd::DdType::CUDD> quantitativeCheckResult6 = checkResult->asHybridQuantitativeCheckResult<storm::dd::DdType::CUDD, double>(); - EXPECT_NEAR(262.85103498583413, quantitativeCheckResult6.getMin(), storm::settings::getModule<storm::settings::modules::GeneralSettings>().getPrecision()); - EXPECT_NEAR(262.85103498583413, quantitativeCheckResult6.getMax(), storm::settings::getModule<storm::settings::modules::GeneralSettings>().getPrecision()); - - formula = formulaParser.parseSingleFormulaFromString("LRA=? [\"first_queue_full\"]"); - checkResult = modelchecker.check(*formula); - - checkResult->filter(storm::modelchecker::SymbolicQualitativeCheckResult<storm::dd::DdType::CUDD>(ctmc->getReachableStates(), ctmc->getInitialStates())); - storm::modelchecker::HybridQuantitativeCheckResult<storm::dd::DdType::CUDD> quantitativeCheckResult7 = checkResult->asHybridQuantitativeCheckResult<storm::dd::DdType::CUDD, double>(); - EXPECT_NEAR(0.9100373532, quantitativeCheckResult7.getMin(), storm::settings::getModule<storm::settings::modules::GeneralSettings>().getPrecision()); - EXPECT_NEAR(0.9100373532, quantitativeCheckResult7.getMax(), storm::settings::getModule<storm::settings::modules::GeneralSettings>().getPrecision()); -} - -TEST(GmmxxHybridCtmcCslModelCheckerTest, Tandem_Sylvan) { - // Parse the model description. - storm::storage::SymbolicModelDescription modelDescription = storm::parser::PrismParser::parse(STORM_TEST_RESOURCES_DIR "/ctmc/tandem5.sm", true); - storm::prism::Program program = modelDescription.preprocess().asPrismProgram(); - storm::parser::FormulaParser formulaParser(program.getManager().getSharedPointer()); - std::shared_ptr<storm::logic::Formula const> formula(nullptr); - - // Build the model with the customers reward structure. -#ifdef WINDOWS - storm::builder::DdPrismModelBuilder<storm::dd::DdType::Sylvan>::Options options; -#else - typename storm::builder::DdPrismModelBuilder<storm::dd::DdType::Sylvan>::Options options; -#endif - options.buildAllRewardModels = false; - options.rewardModelsToBuild.insert("customers"); - std::shared_ptr<storm::models::symbolic::Model<storm::dd::DdType::Sylvan>> model = storm::builder::DdPrismModelBuilder<storm::dd::DdType::Sylvan>().build(program, options); - ASSERT_EQ(storm::models::ModelType::Ctmc, model->getType()); - std::shared_ptr<storm::models::symbolic::Ctmc<storm::dd::DdType::Sylvan>> ctmc = model->as<storm::models::symbolic::Ctmc<storm::dd::DdType::Sylvan>>(); - - // Create model checker. - storm::modelchecker::HybridCtmcCslModelChecker<storm::models::symbolic::Ctmc<storm::dd::DdType::Sylvan, double>> modelchecker(*ctmc, std::make_unique<storm::solver::GmmxxLinearEquationSolverFactory<double>>()); - - // Start checking properties. - formula = formulaParser.parseSingleFormulaFromString("P=? [ F<=10 \"network_full\" ]"); - std::unique_ptr<storm::modelchecker::CheckResult> checkResult = modelchecker.check(*formula); - - ASSERT_TRUE(checkResult->isHybridQuantitativeCheckResult()); - checkResult->filter(storm::modelchecker::SymbolicQualitativeCheckResult<storm::dd::DdType::Sylvan>(ctmc->getReachableStates(), ctmc->getInitialStates())); - storm::modelchecker::HybridQuantitativeCheckResult<storm::dd::DdType::Sylvan> quantitativeCheckResult1 = checkResult->asHybridQuantitativeCheckResult<storm::dd::DdType::Sylvan, double>(); - EXPECT_NEAR(0.015446370562428037, quantitativeCheckResult1.getMin(), storm::settings::getModule<storm::settings::modules::GeneralSettings>().getPrecision()); - EXPECT_NEAR(0.015446370562428037, quantitativeCheckResult1.getMax(), storm::settings::getModule<storm::settings::modules::GeneralSettings>().getPrecision()); - - formula = formulaParser.parseSingleFormulaFromString("P=? [ F<=10 \"first_queue_full\" ]"); - checkResult = modelchecker.check(*formula); - - ASSERT_TRUE(checkResult->isHybridQuantitativeCheckResult()); - checkResult->filter(storm::modelchecker::SymbolicQualitativeCheckResult<storm::dd::DdType::Sylvan>(ctmc->getReachableStates(), ctmc->getInitialStates())); - storm::modelchecker::HybridQuantitativeCheckResult<storm::dd::DdType::Sylvan> quantitativeCheckResult2 = checkResult->asHybridQuantitativeCheckResult<storm::dd::DdType::Sylvan, double>(); - EXPECT_NEAR(0.999999837225515, quantitativeCheckResult2.getMin(), storm::settings::getModule<storm::settings::modules::GeneralSettings>().getPrecision()); - EXPECT_NEAR(0.999999837225515, quantitativeCheckResult2.getMax(), storm::settings::getModule<storm::settings::modules::GeneralSettings>().getPrecision()); - - formula = formulaParser.parseSingleFormulaFromString("P=? [\"second_queue_full\" U<=1 !\"second_queue_full\"]"); - checkResult = modelchecker.check(*formula); - - ASSERT_TRUE(checkResult->isHybridQuantitativeCheckResult()); - checkResult->filter(storm::modelchecker::SymbolicQualitativeCheckResult<storm::dd::DdType::Sylvan>(ctmc->getReachableStates(), ctmc->getInitialStates())); - storm::modelchecker::HybridQuantitativeCheckResult<storm::dd::DdType::Sylvan> quantitativeCheckResult3 = checkResult->asHybridQuantitativeCheckResult<storm::dd::DdType::Sylvan, double>(); - EXPECT_NEAR(1, quantitativeCheckResult3.getMin(), storm::settings::getModule<storm::settings::modules::GeneralSettings>().getPrecision()); - EXPECT_NEAR(1, quantitativeCheckResult3.getMax(), storm::settings::getModule<storm::settings::modules::GeneralSettings>().getPrecision()); - - formula = formulaParser.parseSingleFormulaFromString("R=? [I=10]"); - checkResult = modelchecker.check(*formula); - - ASSERT_TRUE(checkResult->isHybridQuantitativeCheckResult()); - checkResult->filter(storm::modelchecker::SymbolicQualitativeCheckResult<storm::dd::DdType::Sylvan>(ctmc->getReachableStates(), ctmc->getInitialStates())); - storm::modelchecker::HybridQuantitativeCheckResult<storm::dd::DdType::Sylvan> quantitativeCheckResult4 = checkResult->asHybridQuantitativeCheckResult<storm::dd::DdType::Sylvan, double>(); - EXPECT_NEAR(5.679243850315877, quantitativeCheckResult4.getMin(), storm::settings::getModule<storm::settings::modules::GeneralSettings>().getPrecision()); - EXPECT_NEAR(5.679243850315877, quantitativeCheckResult4.getMax(), storm::settings::getModule<storm::settings::modules::GeneralSettings>().getPrecision()); - - formula = formulaParser.parseSingleFormulaFromString("R=? [C<=10]"); - checkResult = modelchecker.check(*formula); - - ASSERT_TRUE(checkResult->isHybridQuantitativeCheckResult()); - checkResult->filter(storm::modelchecker::SymbolicQualitativeCheckResult<storm::dd::DdType::Sylvan>(ctmc->getReachableStates(), ctmc->getInitialStates())); - storm::modelchecker::HybridQuantitativeCheckResult<storm::dd::DdType::Sylvan> quantitativeCheckResult5 = checkResult->asHybridQuantitativeCheckResult<storm::dd::DdType::Sylvan, double>(); - EXPECT_NEAR(55.44792186036232, quantitativeCheckResult5.getMin(), storm::settings::getModule<storm::settings::modules::GeneralSettings>().getPrecision()); - EXPECT_NEAR(55.44792186036232, quantitativeCheckResult5.getMax(), storm::settings::getModule<storm::settings::modules::GeneralSettings>().getPrecision()); - - formula = formulaParser.parseSingleFormulaFromString("R=? [F \"first_queue_full\"&\"second_queue_full\"]"); - checkResult = modelchecker.check(*formula); - - ASSERT_TRUE(checkResult->isHybridQuantitativeCheckResult()); - checkResult->filter(storm::modelchecker::SymbolicQualitativeCheckResult<storm::dd::DdType::Sylvan>(ctmc->getReachableStates(), ctmc->getInitialStates())); - storm::modelchecker::HybridQuantitativeCheckResult<storm::dd::DdType::Sylvan> quantitativeCheckResult6 = checkResult->asHybridQuantitativeCheckResult<storm::dd::DdType::Sylvan, double>(); - EXPECT_NEAR(262.85103498583413, quantitativeCheckResult6.getMin(), storm::settings::getModule<storm::settings::modules::GeneralSettings>().getPrecision()); - EXPECT_NEAR(262.85103498583413, quantitativeCheckResult6.getMax(), storm::settings::getModule<storm::settings::modules::GeneralSettings>().getPrecision()); - - formula = formulaParser.parseSingleFormulaFromString("LRA=? [\"first_queue_full\"]"); - checkResult = modelchecker.check(*formula); - - checkResult->filter(storm::modelchecker::SymbolicQualitativeCheckResult<storm::dd::DdType::Sylvan>(ctmc->getReachableStates(), ctmc->getInitialStates())); - storm::modelchecker::HybridQuantitativeCheckResult<storm::dd::DdType::Sylvan> quantitativeCheckResult7 = checkResult->asHybridQuantitativeCheckResult<storm::dd::DdType::Sylvan, double>(); - EXPECT_NEAR(0.9100373532, quantitativeCheckResult7.getMin(), storm::settings::getModule<storm::settings::modules::GeneralSettings>().getPrecision()); - EXPECT_NEAR(0.9100373532, quantitativeCheckResult7.getMax(), storm::settings::getModule<storm::settings::modules::GeneralSettings>().getPrecision()); -} diff --git a/src/test/storm/modelchecker/GmmxxHybridDtmcPrctlModelCheckerTest.cpp b/src/test/storm/modelchecker/GmmxxHybridDtmcPrctlModelCheckerTest.cpp deleted file mode 100644 index 2b41266a5..000000000 --- a/src/test/storm/modelchecker/GmmxxHybridDtmcPrctlModelCheckerTest.cpp +++ /dev/null @@ -1,353 +0,0 @@ -#include "gtest/gtest.h" -#include "storm-config.h" - -#include "storm/parser/FormulaParser.h" -#include "storm/logic/Formulas.h" -#include "storm/solver/GmmxxLinearEquationSolver.h" -#include "storm/modelchecker/prctl/HybridDtmcPrctlModelChecker.h" -#include "storm/modelchecker/results/HybridQuantitativeCheckResult.h" -#include "storm/modelchecker/results/SymbolicQualitativeCheckResult.h" -#include "storm/modelchecker/results/SymbolicQuantitativeCheckResult.h" -#include "storm/parser/PrismParser.h" -#include "storm/builder/DdPrismModelBuilder.h" -#include "storm/models/symbolic/Dtmc.h" -#include "storm/models/symbolic/StandardRewardModel.h" -#include "storm/storage/SymbolicModelDescription.h" -#include "storm/storage/expressions/ExpressionManager.h" -#include "storm/settings/SettingsManager.h" -#include "storm/settings/modules/GeneralSettings.h" -#include "storm/settings/modules/GmmxxEquationSolverSettings.h" -#include "storm/settings/modules/NativeEquationSolverSettings.h" - - -TEST(GmmxxHybridDtmcPrctlModelCheckerTest, Die_Cudd) { - storm::storage::SymbolicModelDescription modelDescription = storm::parser::PrismParser::parse(STORM_TEST_RESOURCES_DIR "/dtmc/die.pm"); - storm::prism::Program program = modelDescription.preprocess().asPrismProgram(); - - // A parser that we use for conveniently constructing the formulas. - - auto expManager = std::make_shared<storm::expressions::ExpressionManager>(); - storm::parser::FormulaParser formulaParser(expManager); - - // Build the die model with its reward model. -#ifdef WINDOWS - storm::builder::DdPrismModelBuilder<storm::dd::DdType::CUDD>::Options options; -#else - typename storm::builder::DdPrismModelBuilder<storm::dd::DdType::CUDD>::Options options; -#endif - options.buildAllRewardModels = false; - options.rewardModelsToBuild.insert("coin_flips"); - std::shared_ptr<storm::models::symbolic::Model<storm::dd::DdType::CUDD>> model = storm::builder::DdPrismModelBuilder<storm::dd::DdType::CUDD>().build(program, options); - EXPECT_EQ(13ul, model->getNumberOfStates()); - EXPECT_EQ(20ul, model->getNumberOfTransitions()); - - ASSERT_EQ(model->getType(), storm::models::ModelType::Dtmc); - - std::shared_ptr<storm::models::symbolic::Dtmc<storm::dd::DdType::CUDD>> dtmc = model->as<storm::models::symbolic::Dtmc<storm::dd::DdType::CUDD>>(); - - storm::modelchecker::HybridDtmcPrctlModelChecker<storm::models::symbolic::Dtmc<storm::dd::DdType::CUDD, double>> checker(*dtmc, std::make_unique<storm::solver::GmmxxLinearEquationSolverFactory<double>>()); - - std::shared_ptr<storm::logic::Formula const> formula = formulaParser.parseSingleFormulaFromString("P=? [F \"one\"]"); - - std::unique_ptr<storm::modelchecker::CheckResult> result = checker.check(*formula); - result->filter(storm::modelchecker::SymbolicQualitativeCheckResult<storm::dd::DdType::CUDD>(model->getReachableStates(), model->getInitialStates())); - storm::modelchecker::HybridQuantitativeCheckResult<storm::dd::DdType::CUDD>& quantitativeResult1 = result->asHybridQuantitativeCheckResult<storm::dd::DdType::CUDD, double>(); - - EXPECT_NEAR(1.0/6.0, quantitativeResult1.getMin(), storm::settings::getModule<storm::settings::modules::GmmxxEquationSolverSettings>().getPrecision()); - EXPECT_NEAR(1.0/6.0, quantitativeResult1.getMax(), storm::settings::getModule<storm::settings::modules::GmmxxEquationSolverSettings>().getPrecision()); - - formula = formulaParser.parseSingleFormulaFromString("P=? [F \"two\"]"); - - result = checker.check(*formula); - result->filter(storm::modelchecker::SymbolicQualitativeCheckResult<storm::dd::DdType::CUDD>(model->getReachableStates(), model->getInitialStates())); - storm::modelchecker::HybridQuantitativeCheckResult<storm::dd::DdType::CUDD>& quantitativeResult2 = result->asHybridQuantitativeCheckResult<storm::dd::DdType::CUDD, double>(); - - EXPECT_NEAR(1.0/6.0, quantitativeResult2.getMin(), storm::settings::getModule<storm::settings::modules::GmmxxEquationSolverSettings>().getPrecision()); - EXPECT_NEAR(1.0/6.0, quantitativeResult2.getMax(), storm::settings::getModule<storm::settings::modules::GmmxxEquationSolverSettings>().getPrecision()); - - formula = formulaParser.parseSingleFormulaFromString("P=? [F \"three\"]"); - - result = checker.check(*formula); - result->filter(storm::modelchecker::SymbolicQualitativeCheckResult<storm::dd::DdType::CUDD>(model->getReachableStates(), model->getInitialStates())); - storm::modelchecker::HybridQuantitativeCheckResult<storm::dd::DdType::CUDD>& quantitativeResult3 = result->asHybridQuantitativeCheckResult<storm::dd::DdType::CUDD, double>(); - - EXPECT_NEAR(1.0/6.0, quantitativeResult3.getMin(), storm::settings::getModule<storm::settings::modules::GmmxxEquationSolverSettings>().getPrecision()); - EXPECT_NEAR(1.0/6.0, quantitativeResult3.getMax(), storm::settings::getModule<storm::settings::modules::GmmxxEquationSolverSettings>().getPrecision()); - - formula = formulaParser.parseSingleFormulaFromString("R=? [F \"done\"]"); - - result = checker.check(*formula); - result->filter(storm::modelchecker::SymbolicQualitativeCheckResult<storm::dd::DdType::CUDD>(model->getReachableStates(), model->getInitialStates())); - storm::modelchecker::HybridQuantitativeCheckResult<storm::dd::DdType::CUDD>& quantitativeResult4 = result->asHybridQuantitativeCheckResult<storm::dd::DdType::CUDD, double>(); - - EXPECT_NEAR(11.0/3.0, quantitativeResult4.getMin(), storm::settings::getModule<storm::settings::modules::GmmxxEquationSolverSettings>().getPrecision()); - EXPECT_NEAR(11.0/3.0, quantitativeResult4.getMax(), storm::settings::getModule<storm::settings::modules::GmmxxEquationSolverSettings>().getPrecision()); -} - -TEST(GmmxxHybridDtmcPrctlModelCheckerTest, Die_Sylvan) { - storm::storage::SymbolicModelDescription modelDescription = storm::parser::PrismParser::parse(STORM_TEST_RESOURCES_DIR "/dtmc/die.pm"); - storm::prism::Program program = modelDescription.preprocess().asPrismProgram(); - - // A parser that we use for conveniently constructing the formulas. - - auto expManager = std::make_shared<storm::expressions::ExpressionManager>(); - storm::parser::FormulaParser formulaParser(expManager); - - // Build the die model with its reward model. -#ifdef WINDOWS - storm::builder::DdPrismModelBuilder<storm::dd::DdType::Sylvan>::Options options; -#else - typename storm::builder::DdPrismModelBuilder<storm::dd::DdType::Sylvan>::Options options; -#endif - options.buildAllRewardModels = false; - options.rewardModelsToBuild.insert("coin_flips"); - std::shared_ptr<storm::models::symbolic::Model<storm::dd::DdType::Sylvan>> model = storm::builder::DdPrismModelBuilder<storm::dd::DdType::Sylvan>().build(program, options); - EXPECT_EQ(13ul, model->getNumberOfStates()); - EXPECT_EQ(20ul, model->getNumberOfTransitions()); - - ASSERT_EQ(model->getType(), storm::models::ModelType::Dtmc); - - std::shared_ptr<storm::models::symbolic::Dtmc<storm::dd::DdType::Sylvan>> dtmc = model->as<storm::models::symbolic::Dtmc<storm::dd::DdType::Sylvan>>(); - - storm::modelchecker::HybridDtmcPrctlModelChecker<storm::models::symbolic::Dtmc<storm::dd::DdType::Sylvan, double>> checker(*dtmc, std::make_unique<storm::solver::GmmxxLinearEquationSolverFactory<double>>()); - - std::shared_ptr<storm::logic::Formula const> formula = formulaParser.parseSingleFormulaFromString("P=? [F \"one\"]"); - - std::unique_ptr<storm::modelchecker::CheckResult> result = checker.check(*formula); - result->filter(storm::modelchecker::SymbolicQualitativeCheckResult<storm::dd::DdType::Sylvan>(model->getReachableStates(), model->getInitialStates())); - storm::modelchecker::HybridQuantitativeCheckResult<storm::dd::DdType::Sylvan>& quantitativeResult1 = result->asHybridQuantitativeCheckResult<storm::dd::DdType::Sylvan, double>(); - - EXPECT_NEAR(1.0/6.0, quantitativeResult1.getMin(), storm::settings::getModule<storm::settings::modules::GmmxxEquationSolverSettings>().getPrecision()); - EXPECT_NEAR(1.0/6.0, quantitativeResult1.getMax(), storm::settings::getModule<storm::settings::modules::GmmxxEquationSolverSettings>().getPrecision()); - - formula = formulaParser.parseSingleFormulaFromString("P=? [F \"two\"]"); - - result = checker.check(*formula); - result->filter(storm::modelchecker::SymbolicQualitativeCheckResult<storm::dd::DdType::Sylvan>(model->getReachableStates(), model->getInitialStates())); - storm::modelchecker::HybridQuantitativeCheckResult<storm::dd::DdType::Sylvan>& quantitativeResult2 = result->asHybridQuantitativeCheckResult<storm::dd::DdType::Sylvan, double>(); - - EXPECT_NEAR(1.0/6.0, quantitativeResult2.getMin(), storm::settings::getModule<storm::settings::modules::GmmxxEquationSolverSettings>().getPrecision()); - EXPECT_NEAR(1.0/6.0, quantitativeResult2.getMax(), storm::settings::getModule<storm::settings::modules::GmmxxEquationSolverSettings>().getPrecision()); - - formula = formulaParser.parseSingleFormulaFromString("P=? [F \"three\"]"); - - result = checker.check(*formula); - result->filter(storm::modelchecker::SymbolicQualitativeCheckResult<storm::dd::DdType::Sylvan>(model->getReachableStates(), model->getInitialStates())); - storm::modelchecker::HybridQuantitativeCheckResult<storm::dd::DdType::Sylvan>& quantitativeResult3 = result->asHybridQuantitativeCheckResult<storm::dd::DdType::Sylvan, double>(); - - EXPECT_NEAR(1.0/6.0, quantitativeResult3.getMin(), storm::settings::getModule<storm::settings::modules::GmmxxEquationSolverSettings>().getPrecision()); - EXPECT_NEAR(1.0/6.0, quantitativeResult3.getMax(), storm::settings::getModule<storm::settings::modules::GmmxxEquationSolverSettings>().getPrecision()); - - formula = formulaParser.parseSingleFormulaFromString("R=? [F \"done\"]"); - - result = checker.check(*formula); - result->filter(storm::modelchecker::SymbolicQualitativeCheckResult<storm::dd::DdType::Sylvan>(model->getReachableStates(), model->getInitialStates())); - storm::modelchecker::HybridQuantitativeCheckResult<storm::dd::DdType::Sylvan>& quantitativeResult4 = result->asHybridQuantitativeCheckResult<storm::dd::DdType::Sylvan, double>(); - - EXPECT_NEAR(11.0/3.0, quantitativeResult4.getMin(), storm::settings::getModule<storm::settings::modules::GmmxxEquationSolverSettings>().getPrecision()); - EXPECT_NEAR(11.0/3.0, quantitativeResult4.getMax(), storm::settings::getModule<storm::settings::modules::GmmxxEquationSolverSettings>().getPrecision()); -} - -TEST(GmmxxHybridDtmcPrctlModelCheckerTest, Crowds_Cudd) { - storm::storage::SymbolicModelDescription modelDescription = storm::parser::PrismParser::parse(STORM_TEST_RESOURCES_DIR "/dtmc/crowds-5-5.pm"); - storm::prism::Program program = modelDescription.preprocess().asPrismProgram(); - - // A parser that we use for conveniently constructing the formulas. - - auto expManager = std::make_shared<storm::expressions::ExpressionManager>(); - storm::parser::FormulaParser formulaParser(expManager); - - std::shared_ptr<storm::models::symbolic::Model<storm::dd::DdType::CUDD>> model = storm::builder::DdPrismModelBuilder<storm::dd::DdType::CUDD>().build(program); - EXPECT_EQ(8607ul, model->getNumberOfStates()); - EXPECT_EQ(15113ul, model->getNumberOfTransitions()); - - ASSERT_EQ(model->getType(), storm::models::ModelType::Dtmc); - - std::shared_ptr<storm::models::symbolic::Dtmc<storm::dd::DdType::CUDD>> dtmc = model->as<storm::models::symbolic::Dtmc<storm::dd::DdType::CUDD>>(); - - storm::modelchecker::HybridDtmcPrctlModelChecker<storm::models::symbolic::Dtmc<storm::dd::DdType::CUDD, double>> checker(*dtmc, std::make_unique<storm::solver::GmmxxLinearEquationSolverFactory<double>>()); - - std::shared_ptr<storm::logic::Formula const> formula = formulaParser.parseSingleFormulaFromString("P=? [F \"observe0Greater1\"]"); - - std::unique_ptr<storm::modelchecker::CheckResult> result = checker.check(*formula); - result->filter(storm::modelchecker::SymbolicQualitativeCheckResult<storm::dd::DdType::CUDD>(model->getReachableStates(), model->getInitialStates())); - storm::modelchecker::HybridQuantitativeCheckResult<storm::dd::DdType::CUDD>& quantitativeResult1 = result->asHybridQuantitativeCheckResult<storm::dd::DdType::CUDD, double>(); - - EXPECT_NEAR(0.3328800375801578281, quantitativeResult1.getMin(), storm::settings::getModule<storm::settings::modules::GmmxxEquationSolverSettings>().getPrecision()); - EXPECT_NEAR(0.3328800375801578281, quantitativeResult1.getMax(), storm::settings::getModule<storm::settings::modules::GmmxxEquationSolverSettings>().getPrecision()); - - formula = formulaParser.parseSingleFormulaFromString("P=? [F \"observeIGreater1\"]"); - - result = checker.check(*formula); - result->filter(storm::modelchecker::SymbolicQualitativeCheckResult<storm::dd::DdType::CUDD>(model->getReachableStates(), model->getInitialStates())); - storm::modelchecker::HybridQuantitativeCheckResult<storm::dd::DdType::CUDD>& quantitativeResult2 = result->asHybridQuantitativeCheckResult<storm::dd::DdType::CUDD, double>(); - - EXPECT_NEAR(0.1522194965, quantitativeResult2.getMin(), storm::settings::getModule<storm::settings::modules::GmmxxEquationSolverSettings>().getPrecision()); - EXPECT_NEAR(0.1522194965, quantitativeResult2.getMax(), storm::settings::getModule<storm::settings::modules::GmmxxEquationSolverSettings>().getPrecision()); - - formula = formulaParser.parseSingleFormulaFromString("P=? [F \"observeOnlyTrueSender\"]"); - - result = checker.check(*formula); - result->filter(storm::modelchecker::SymbolicQualitativeCheckResult<storm::dd::DdType::CUDD>(model->getReachableStates(), model->getInitialStates())); - storm::modelchecker::HybridQuantitativeCheckResult<storm::dd::DdType::CUDD>& quantitativeResult3 = result->asHybridQuantitativeCheckResult<storm::dd::DdType::CUDD, double>(); - - EXPECT_NEAR(0.32153724292835045, quantitativeResult3.getMin(), storm::settings::getModule<storm::settings::modules::GmmxxEquationSolverSettings>().getPrecision()); - EXPECT_NEAR(0.32153724292835045, quantitativeResult3.getMax(), storm::settings::getModule<storm::settings::modules::GmmxxEquationSolverSettings>().getPrecision()); -} - -TEST(GmmxxHybridDtmcPrctlModelCheckerTest, Crowds_Sylvan) { - storm::storage::SymbolicModelDescription modelDescription = storm::parser::PrismParser::parse(STORM_TEST_RESOURCES_DIR "/dtmc/crowds-5-5.pm"); - storm::prism::Program program = modelDescription.preprocess().asPrismProgram(); - - // A parser that we use for conveniently constructing the formulas. - - auto expManager = std::make_shared<storm::expressions::ExpressionManager>(); - storm::parser::FormulaParser formulaParser(expManager); - - std::shared_ptr<storm::models::symbolic::Model<storm::dd::DdType::Sylvan>> model = storm::builder::DdPrismModelBuilder<storm::dd::DdType::Sylvan>().build(program); - EXPECT_EQ(8607ul, model->getNumberOfStates()); - EXPECT_EQ(15113ul, model->getNumberOfTransitions()); - - ASSERT_EQ(model->getType(), storm::models::ModelType::Dtmc); - - std::shared_ptr<storm::models::symbolic::Dtmc<storm::dd::DdType::Sylvan>> dtmc = model->as<storm::models::symbolic::Dtmc<storm::dd::DdType::Sylvan>>(); - - storm::modelchecker::HybridDtmcPrctlModelChecker<storm::models::symbolic::Dtmc<storm::dd::DdType::Sylvan, double>> checker(*dtmc, std::make_unique<storm::solver::GmmxxLinearEquationSolverFactory<double>>()); - - std::shared_ptr<storm::logic::Formula const> formula = formulaParser.parseSingleFormulaFromString("P=? [F \"observe0Greater1\"]"); - - std::unique_ptr<storm::modelchecker::CheckResult> result = checker.check(*formula); - result->filter(storm::modelchecker::SymbolicQualitativeCheckResult<storm::dd::DdType::Sylvan>(model->getReachableStates(), model->getInitialStates())); - storm::modelchecker::HybridQuantitativeCheckResult<storm::dd::DdType::Sylvan>& quantitativeResult1 = result->asHybridQuantitativeCheckResult<storm::dd::DdType::Sylvan, double>(); - - EXPECT_NEAR(0.3328800375801578281, quantitativeResult1.getMin(), storm::settings::getModule<storm::settings::modules::GmmxxEquationSolverSettings>().getPrecision()); - EXPECT_NEAR(0.3328800375801578281, quantitativeResult1.getMax(), storm::settings::getModule<storm::settings::modules::GmmxxEquationSolverSettings>().getPrecision()); - - formula = formulaParser.parseSingleFormulaFromString("P=? [F \"observeIGreater1\"]"); - - result = checker.check(*formula); - result->filter(storm::modelchecker::SymbolicQualitativeCheckResult<storm::dd::DdType::Sylvan>(model->getReachableStates(), model->getInitialStates())); - storm::modelchecker::HybridQuantitativeCheckResult<storm::dd::DdType::Sylvan>& quantitativeResult2 = result->asHybridQuantitativeCheckResult<storm::dd::DdType::Sylvan, double>(); - - EXPECT_NEAR(0.1522194965, quantitativeResult2.getMin(), storm::settings::getModule<storm::settings::modules::GmmxxEquationSolverSettings>().getPrecision()); - EXPECT_NEAR(0.1522194965, quantitativeResult2.getMax(), storm::settings::getModule<storm::settings::modules::GmmxxEquationSolverSettings>().getPrecision()); - - formula = formulaParser.parseSingleFormulaFromString("P=? [F \"observeOnlyTrueSender\"]"); - - result = checker.check(*formula); - result->filter(storm::modelchecker::SymbolicQualitativeCheckResult<storm::dd::DdType::Sylvan>(model->getReachableStates(), model->getInitialStates())); - storm::modelchecker::HybridQuantitativeCheckResult<storm::dd::DdType::Sylvan>& quantitativeResult3 = result->asHybridQuantitativeCheckResult<storm::dd::DdType::Sylvan, double>(); - - EXPECT_NEAR(0.32153724292835045, quantitativeResult3.getMin(), storm::settings::getModule<storm::settings::modules::GmmxxEquationSolverSettings>().getPrecision()); - EXPECT_NEAR(0.32153724292835045, quantitativeResult3.getMax(), storm::settings::getModule<storm::settings::modules::GmmxxEquationSolverSettings>().getPrecision()); -} - -TEST(GmmxxHybridDtmcPrctlModelCheckerTest, SynchronousLeader_Cudd) { - storm::storage::SymbolicModelDescription modelDescription = storm::parser::PrismParser::parse(STORM_TEST_RESOURCES_DIR "/dtmc/leader-3-5.pm"); - storm::prism::Program program = modelDescription.preprocess().asPrismProgram(); - - // A parser that we use for conveniently constructing the formulas. - - auto expManager = std::make_shared<storm::expressions::ExpressionManager>(); - storm::parser::FormulaParser formulaParser(expManager); - - // Build the die model with its reward model. -#ifdef WINDOWS - storm::builder::DdPrismModelBuilder<storm::dd::DdType::CUDD>::Options options; -#else - typename storm::builder::DdPrismModelBuilder<storm::dd::DdType::CUDD>::Options options; -#endif - options.buildAllRewardModels = false; - options.rewardModelsToBuild.insert("num_rounds"); - std::shared_ptr<storm::models::symbolic::Model<storm::dd::DdType::CUDD>> model = storm::builder::DdPrismModelBuilder<storm::dd::DdType::CUDD>().build(program, options); - EXPECT_EQ(273ul, model->getNumberOfStates()); - EXPECT_EQ(397ul, model->getNumberOfTransitions()); - - ASSERT_EQ(model->getType(), storm::models::ModelType::Dtmc); - - std::shared_ptr<storm::models::symbolic::Dtmc<storm::dd::DdType::CUDD>> dtmc = model->as<storm::models::symbolic::Dtmc<storm::dd::DdType::CUDD>>(); - - storm::modelchecker::HybridDtmcPrctlModelChecker<storm::models::symbolic::Dtmc<storm::dd::DdType::CUDD, double>> checker(*dtmc, std::make_unique<storm::solver::GmmxxLinearEquationSolverFactory<double>>()); - - std::shared_ptr<storm::logic::Formula const> formula = formulaParser.parseSingleFormulaFromString("P=? [F \"elected\"]"); - - std::unique_ptr<storm::modelchecker::CheckResult> result = checker.check(*formula); - result->filter(storm::modelchecker::SymbolicQualitativeCheckResult<storm::dd::DdType::CUDD>(model->getReachableStates(), model->getInitialStates())); - storm::modelchecker::SymbolicQuantitativeCheckResult<storm::dd::DdType::CUDD>& quantitativeResult1 = result->asSymbolicQuantitativeCheckResult<storm::dd::DdType::CUDD, double>(); - - EXPECT_NEAR(1.0, quantitativeResult1.getMin(), storm::settings::getModule<storm::settings::modules::GmmxxEquationSolverSettings>().getPrecision()); - EXPECT_NEAR(1.0, quantitativeResult1.getMax(), storm::settings::getModule<storm::settings::modules::GmmxxEquationSolverSettings>().getPrecision()); - - formula = formulaParser.parseSingleFormulaFromString("P=? [F<=20 \"elected\"]"); - - result = checker.check(*formula); - result->filter(storm::modelchecker::SymbolicQualitativeCheckResult<storm::dd::DdType::CUDD>(model->getReachableStates(), model->getInitialStates())); - storm::modelchecker::HybridQuantitativeCheckResult<storm::dd::DdType::CUDD>& quantitativeResult2 = result->asHybridQuantitativeCheckResult<storm::dd::DdType::CUDD, double>(); - - EXPECT_NEAR(0.99999989760000074, quantitativeResult2.getMin(), storm::settings::getModule<storm::settings::modules::GmmxxEquationSolverSettings>().getPrecision()); - EXPECT_NEAR(0.99999989760000074, quantitativeResult2.getMax(), storm::settings::getModule<storm::settings::modules::GmmxxEquationSolverSettings>().getPrecision()); - - formula = formulaParser.parseSingleFormulaFromString("R=? [F \"elected\"]"); - - result = checker.check(*formula); - result->filter(storm::modelchecker::SymbolicQualitativeCheckResult<storm::dd::DdType::CUDD>(model->getReachableStates(), model->getInitialStates())); - storm::modelchecker::HybridQuantitativeCheckResult<storm::dd::DdType::CUDD>& quantitativeResult3 = result->asHybridQuantitativeCheckResult<storm::dd::DdType::CUDD, double>(); - - EXPECT_NEAR(1.0416666666666643, quantitativeResult3.getMin(), storm::settings::getModule<storm::settings::modules::GmmxxEquationSolverSettings>().getPrecision()); - EXPECT_NEAR(1.0416666666666643, quantitativeResult3.getMax(), storm::settings::getModule<storm::settings::modules::GmmxxEquationSolverSettings>().getPrecision()); -} - -TEST(GmmxxHybridDtmcPrctlModelCheckerTest, SynchronousLeader_Sylvan) { - storm::storage::SymbolicModelDescription modelDescription = storm::parser::PrismParser::parse(STORM_TEST_RESOURCES_DIR "/dtmc/leader-3-5.pm"); - storm::prism::Program program = modelDescription.preprocess().asPrismProgram(); - - // A parser that we use for conveniently constructing the formulas. - - auto expManager = std::make_shared<storm::expressions::ExpressionManager>(); - storm::parser::FormulaParser formulaParser(expManager); - - // Build the die model with its reward model. -#ifdef WINDOWS - storm::builder::DdPrismModelBuilder<storm::dd::DdType::Sylvan>::Options options; -#else - typename storm::builder::DdPrismModelBuilder<storm::dd::DdType::Sylvan>::Options options; -#endif - options.buildAllRewardModels = false; - options.rewardModelsToBuild.insert("num_rounds"); - std::shared_ptr<storm::models::symbolic::Model<storm::dd::DdType::Sylvan>> model = storm::builder::DdPrismModelBuilder<storm::dd::DdType::Sylvan>().build(program, options); - EXPECT_EQ(273ul, model->getNumberOfStates()); - EXPECT_EQ(397ul, model->getNumberOfTransitions()); - - ASSERT_EQ(model->getType(), storm::models::ModelType::Dtmc); - - std::shared_ptr<storm::models::symbolic::Dtmc<storm::dd::DdType::Sylvan>> dtmc = model->as<storm::models::symbolic::Dtmc<storm::dd::DdType::Sylvan>>(); - - storm::modelchecker::HybridDtmcPrctlModelChecker<storm::models::symbolic::Dtmc<storm::dd::DdType::Sylvan, double>> checker(*dtmc, std::make_unique<storm::solver::GmmxxLinearEquationSolverFactory<double>>()); - - std::shared_ptr<storm::logic::Formula const> formula = formulaParser.parseSingleFormulaFromString("P=? [F \"elected\"]"); - - std::unique_ptr<storm::modelchecker::CheckResult> result = checker.check(*formula); - result->filter(storm::modelchecker::SymbolicQualitativeCheckResult<storm::dd::DdType::Sylvan>(model->getReachableStates(), model->getInitialStates())); - storm::modelchecker::SymbolicQuantitativeCheckResult<storm::dd::DdType::Sylvan>& quantitativeResult1 = result->asSymbolicQuantitativeCheckResult<storm::dd::DdType::Sylvan, double>(); - - EXPECT_NEAR(1.0, quantitativeResult1.getMin(), storm::settings::getModule<storm::settings::modules::GmmxxEquationSolverSettings>().getPrecision()); - EXPECT_NEAR(1.0, quantitativeResult1.getMax(), storm::settings::getModule<storm::settings::modules::GmmxxEquationSolverSettings>().getPrecision()); - - formula = formulaParser.parseSingleFormulaFromString("P=? [F<=20 \"elected\"]"); - - result = checker.check(*formula); - result->filter(storm::modelchecker::SymbolicQualitativeCheckResult<storm::dd::DdType::Sylvan>(model->getReachableStates(), model->getInitialStates())); - storm::modelchecker::HybridQuantitativeCheckResult<storm::dd::DdType::Sylvan>& quantitativeResult2 = result->asHybridQuantitativeCheckResult<storm::dd::DdType::Sylvan, double>(); - - EXPECT_NEAR(0.99999989760000074, quantitativeResult2.getMin(), storm::settings::getModule<storm::settings::modules::GmmxxEquationSolverSettings>().getPrecision()); - EXPECT_NEAR(0.99999989760000074, quantitativeResult2.getMax(), storm::settings::getModule<storm::settings::modules::GmmxxEquationSolverSettings>().getPrecision()); - - formula = formulaParser.parseSingleFormulaFromString("R=? [F \"elected\"]"); - - result = checker.check(*formula); - result->filter(storm::modelchecker::SymbolicQualitativeCheckResult<storm::dd::DdType::Sylvan>(model->getReachableStates(), model->getInitialStates())); - storm::modelchecker::HybridQuantitativeCheckResult<storm::dd::DdType::Sylvan>& quantitativeResult3 = result->asHybridQuantitativeCheckResult<storm::dd::DdType::Sylvan, double>(); - - EXPECT_NEAR(1.0416666666666643, quantitativeResult3.getMin(), storm::settings::getModule<storm::settings::modules::GmmxxEquationSolverSettings>().getPrecision()); - EXPECT_NEAR(1.0416666666666643, quantitativeResult3.getMax(), storm::settings::getModule<storm::settings::modules::GmmxxEquationSolverSettings>().getPrecision()); -} diff --git a/src/test/storm/modelchecker/LraDtmcPrctlModelCheckerTest.cpp b/src/test/storm/modelchecker/LraDtmcPrctlModelCheckerTest.cpp new file mode 100644 index 000000000..ee1d88c30 --- /dev/null +++ b/src/test/storm/modelchecker/LraDtmcPrctlModelCheckerTest.cpp @@ -0,0 +1,268 @@ +#include "gtest/gtest.h" +#include "storm-config.h" +#include "test/storm_gtest.h" + +#include "storm/parser/FormulaParser.h" +#include "storm/settings/SettingMemento.h" +#include "storm/logic/Formulas.h" +#include "storm/solver/NativeLinearEquationSolver.h" +#include "storm/models/sparse/StandardRewardModel.h" +#include "storm/modelchecker/prctl/SparseDtmcPrctlModelChecker.h" +#include "storm/modelchecker/results/ExplicitQuantitativeCheckResult.h" +#include "storm/settings/SettingsManager.h" +#include "storm/solver/NativeLinearEquationSolver.h" +#include "storm/settings/modules/GeneralSettings.h" + +#include "storm/environment/solver/NativeSolverEnvironment.h" +#include "storm/environment/solver/EigenSolverEnvironment.h" +#include "storm/environment/solver/GmmxxSolverEnvironment.h" + +#include "storm/parser/AutoParser.h" +#include "storm/builder/ExplicitModelBuilder.h" + +namespace { + + class GmmxxDoubleGmresEnvironment { + public: + typedef storm::RationalNumber ValueType; + static const bool isExact = false; + static storm::Environment createEnvironment() { + storm::Environment env; + env.solver().setLinearEquationSolverType(storm::solver::EquationSolverType::Gmmxx); + env.solver().gmmxx().setMethod(storm::solver::GmmxxLinearEquationSolverMethod::Gmres); + env.solver().gmmxx().setPreconditioner(storm::solver::GmmxxLinearEquationSolverPreconditioner::Ilu); + env.solver().gmmxx().setPrecision(storm::utility::convertNumber<ValueType>(1e-8)); + return env; + } + }; + + class EigenDoubleDGmresEnvironment { + public: + typedef storm::RationalNumber ValueType; + static const bool isExact = false; + static storm::Environment createEnvironment() { + storm::Environment env; + env.solver().setLinearEquationSolverType(storm::solver::EquationSolverType::Eigen); + env.solver().eigen().setMethod(storm::solver::EigenLinearEquationSolverMethod::DGmres); + env.solver().eigen().setPreconditioner(storm::solver::EigenLinearEquationSolverPreconditioner::Ilu); + env.solver().eigen().setPrecision(storm::utility::convertNumber<ValueType>(1e-8)); + return env; + } + }; + + class EigenRationalLUEnvironment { + public: + typedef storm::RationalNumber ValueType; + static const bool isExact = true; + static storm::Environment createEnvironment() { + storm::Environment env; + env.solver().setLinearEquationSolverType(storm::solver::EquationSolverType::Eigen); + env.solver().eigen().setMethod(storm::solver::EigenLinearEquationSolverMethod::SparseLU); + return env; + } + }; + + class NativeSorEnvironment { + public: + typedef double ValueType; + static const bool isExact = false; + static storm::Environment createEnvironment() { + storm::Environment env; + env.solver().setLinearEquationSolverType(storm::solver::EquationSolverType::Native); + env.solver().native().setMethod(storm::solver::NativeLinearEquationSolverMethod::SOR); + env.solver().native().setSorOmega(storm::utility::convertNumber<ValueType>(0.9)); + env.solver().native().setPrecision(storm::utility::convertNumber<storm::RationalNumber>(1e-8)); + return env; + } + }; + + class NativeWalkerChaeEnvironment { + public: + typedef double ValueType; + static const bool isExact = false; + static storm::Environment createEnvironment() { + storm::Environment env; + env.solver().setLinearEquationSolverType(storm::solver::EquationSolverType::Native); + env.solver().native().setMethod(storm::solver::NativeLinearEquationSolverMethod::WalkerChae); + env.solver().native().setPrecision(storm::utility::convertNumber<storm::RationalNumber>(1e-8)); + env.solver().native().setMaximalNumberOfIterations(50000); + return env; + } + }; + + template<typename TestType> + class LraDtmcPrctlModelCheckerTest : public ::testing::Test { + public: + typedef typename TestType::ValueType ValueType; + LraDtmcPrctlModelCheckerTest() : _environment(TestType::createEnvironment()) {} + storm::Environment const& env() const { return _environment; } + ValueType parseNumber(std::string const& input) const { return storm::utility::convertNumber<ValueType>(input);} + ValueType precision() const { return TestType::isExact ? parseNumber("0") : parseNumber("1e-6");} + + private: + storm::Environment _environment; + }; + + typedef ::testing::Types< + GmmxxDoubleGmresEnvironment, + EigenDoubleDGmresEnvironment, + EigenRationalLUEnvironment, + NativeSorEnvironment, + NativeWalkerChaeEnvironment + > TestingTypes; + + TYPED_TEST_CASE(LraDtmcPrctlModelCheckerTest, TestingTypes); + + + + TYPED_TEST(LraDtmcPrctlModelCheckerTest, LRASingleBscc) { + typedef typename TestFixture::ValueType ValueType; + + storm::storage::SparseMatrixBuilder<ValueType> matrixBuilder; + std::shared_ptr<storm::models::sparse::Dtmc<ValueType>> dtmc; + + // A parser that we use for conveniently constructing the formulas. + storm::parser::FormulaParser formulaParser; + + { + matrixBuilder = storm::storage::SparseMatrixBuilder<ValueType>(2, 2, 2); + matrixBuilder.addNextValue(0, 1, this->parseNumber("1")); + matrixBuilder.addNextValue(1, 0, this->parseNumber("1")); + storm::storage::SparseMatrix<ValueType> transitionMatrix = matrixBuilder.build(); + + storm::models::sparse::StateLabeling ap(2); + ap.addLabel("a"); + ap.addLabelToState("a", 1); + + dtmc.reset(new storm::models::sparse::Dtmc<ValueType>(transitionMatrix, ap)); + + storm::modelchecker::SparseDtmcPrctlModelChecker<storm::models::sparse::Dtmc<ValueType>> checker(*dtmc); + + std::shared_ptr<storm::logic::Formula const> formula = formulaParser.parseSingleFormulaFromString("LRA=? [\"a\"]"); + + std::unique_ptr<storm::modelchecker::CheckResult> result = checker.check(this->env(), *formula); + storm::modelchecker::ExplicitQuantitativeCheckResult<ValueType>& quantitativeResult1 = result->asExplicitQuantitativeCheckResult<ValueType>(); + + EXPECT_NEAR(this->parseNumber("0.5"), quantitativeResult1[0], this->precision()); + EXPECT_NEAR(this->parseNumber("0.5"), quantitativeResult1[1], this->precision()); + } + { + matrixBuilder = storm::storage::SparseMatrixBuilder<ValueType>(2, 2, 4); + matrixBuilder.addNextValue(0, 0, this->parseNumber("0.5")); + matrixBuilder.addNextValue(0, 1, this->parseNumber("0.5")); + matrixBuilder.addNextValue(1, 0, this->parseNumber("0.5")); + matrixBuilder.addNextValue(1, 1, this->parseNumber("0.5")); + storm::storage::SparseMatrix<ValueType> transitionMatrix = matrixBuilder.build(); + + storm::models::sparse::StateLabeling ap(2); + ap.addLabel("a"); + ap.addLabelToState("a", 1); + + dtmc.reset(new storm::models::sparse::Dtmc<ValueType>(transitionMatrix, ap)); + + storm::modelchecker::SparseDtmcPrctlModelChecker<storm::models::sparse::Dtmc<ValueType>> checker(*dtmc); + + std::shared_ptr<storm::logic::Formula const> formula = formulaParser.parseSingleFormulaFromString("LRA=? [\"a\"]"); + + std::unique_ptr<storm::modelchecker::CheckResult> result = checker.check(this->env(), *formula); + storm::modelchecker::ExplicitQuantitativeCheckResult<ValueType>& quantitativeResult1 = result->asExplicitQuantitativeCheckResult<ValueType>(); + + EXPECT_NEAR(this->parseNumber("0.5"), quantitativeResult1[0], this->precision()); + EXPECT_NEAR(this->parseNumber("0.5"), quantitativeResult1[1], this->precision()); + } + + { + matrixBuilder = storm::storage::SparseMatrixBuilder<ValueType>(3, 3, 3); + matrixBuilder.addNextValue(0, 1, this->parseNumber("1")); + matrixBuilder.addNextValue(1, 2, this->parseNumber("1")); + matrixBuilder.addNextValue(2, 0, this->parseNumber("1")); + storm::storage::SparseMatrix<ValueType> transitionMatrix = matrixBuilder.build(); + + storm::models::sparse::StateLabeling ap(3); + ap.addLabel("a"); + ap.addLabelToState("a", 2); + + dtmc.reset(new storm::models::sparse::Dtmc<ValueType>(transitionMatrix, ap)); + + storm::modelchecker::SparseDtmcPrctlModelChecker<storm::models::sparse::Dtmc<ValueType>> checker(*dtmc); + + std::shared_ptr<storm::logic::Formula const> formula = formulaParser.parseSingleFormulaFromString("LRA=? [\"a\"]"); + + std::unique_ptr<storm::modelchecker::CheckResult> result = checker.check(this->env(), *formula); + storm::modelchecker::ExplicitQuantitativeCheckResult<ValueType>& quantitativeResult1 = result->asExplicitQuantitativeCheckResult<ValueType>(); + + EXPECT_NEAR(this->parseNumber("1/3"), quantitativeResult1[0], this->precision()); + EXPECT_NEAR(this->parseNumber("1/3"), quantitativeResult1[1], this->precision()); + EXPECT_NEAR(this->parseNumber("1/3"), quantitativeResult1[2], this->precision()); + } + } + + TYPED_TEST(LraDtmcPrctlModelCheckerTest, LRA) { + typedef typename TestFixture::ValueType ValueType; + + storm::storage::SparseMatrixBuilder<ValueType> matrixBuilder; + std::shared_ptr<storm::models::sparse::Dtmc<ValueType>> dtmc; + + // A parser that we use for conveniently constructing the formulas. + storm::parser::FormulaParser formulaParser; + + { + matrixBuilder = storm::storage::SparseMatrixBuilder<ValueType>(15, 15, 20, true); + matrixBuilder.addNextValue(0, 1, this->parseNumber("1")); + matrixBuilder.addNextValue(1, 4, this->parseNumber("0.7")); + matrixBuilder.addNextValue(1, 6, this->parseNumber("0.3")); + matrixBuilder.addNextValue(2, 0, this->parseNumber("1")); + + matrixBuilder.addNextValue(3, 5, this->parseNumber("0.8")); + matrixBuilder.addNextValue(3, 9, this->parseNumber("0.2")); + matrixBuilder.addNextValue(4, 3, this->parseNumber("1")); + matrixBuilder.addNextValue(5, 3, this->parseNumber("1")); + + matrixBuilder.addNextValue(6, 7, this->parseNumber("1")); + matrixBuilder.addNextValue(7, 8, this->parseNumber("1")); + matrixBuilder.addNextValue(8, 6, this->parseNumber("1")); + + matrixBuilder.addNextValue(9, 10, this->parseNumber("1")); + matrixBuilder.addNextValue(10, 9, this->parseNumber("1")); + matrixBuilder.addNextValue(11, 9, this->parseNumber("1")); + + matrixBuilder.addNextValue(12, 5, this->parseNumber("0.4")); + matrixBuilder.addNextValue(12, 8, this->parseNumber("0.3")); + matrixBuilder.addNextValue(12, 11, this->parseNumber("0.3")); + + matrixBuilder.addNextValue(13, 7, this->parseNumber("0.7")); + matrixBuilder.addNextValue(13, 12, this->parseNumber("0.3")); + + matrixBuilder.addNextValue(14, 12, this->parseNumber("1")); + + storm::storage::SparseMatrix<ValueType> transitionMatrix = matrixBuilder.build(); + + storm::models::sparse::StateLabeling ap(15); + ap.addLabel("a"); + ap.addLabelToState("a", 1); + ap.addLabelToState("a", 4); + ap.addLabelToState("a", 5); + ap.addLabelToState("a", 7); + ap.addLabelToState("a", 11); + ap.addLabelToState("a", 13); + ap.addLabelToState("a", 14); + + dtmc.reset(new storm::models::sparse::Dtmc<ValueType>(transitionMatrix, ap)); + + storm::modelchecker::SparseDtmcPrctlModelChecker<storm::models::sparse::Dtmc<ValueType>> checker(*dtmc); + + std::shared_ptr<storm::logic::Formula const> formula = formulaParser.parseSingleFormulaFromString("LRA=? [\"a\"]"); + + std::unique_ptr<storm::modelchecker::CheckResult> result = checker.check(this->env(), *formula); + storm::modelchecker::ExplicitQuantitativeCheckResult<ValueType>& quantitativeResult1 = result->asExplicitQuantitativeCheckResult<ValueType>(); + + EXPECT_NEAR(this->parseNumber("1/10"), quantitativeResult1[0], this->precision()); + EXPECT_NEAR(this->parseNumber("0"), quantitativeResult1[3], this->precision()); + EXPECT_NEAR(this->parseNumber("1/3"), quantitativeResult1[6], this->precision()); + EXPECT_NEAR(this->parseNumber("0"), quantitativeResult1[9], this->precision()); + EXPECT_NEAR(this->parseNumber("1/10"), quantitativeResult1[12], this->precision()); + EXPECT_NEAR(this->parseNumber("79/300"), quantitativeResult1[13], this->precision()); + EXPECT_NEAR(this->parseNumber("1/10"), quantitativeResult1[14], this->precision()); + } + } +} \ No newline at end of file diff --git a/src/test/storm/modelchecker/MdpPrctlModelCheckerTest.cpp b/src/test/storm/modelchecker/MdpPrctlModelCheckerTest.cpp index 758c9bd74..04dd3076a 100644 --- a/src/test/storm/modelchecker/MdpPrctlModelCheckerTest.cpp +++ b/src/test/storm/modelchecker/MdpPrctlModelCheckerTest.cpp @@ -50,6 +50,7 @@ namespace { env.solver().setForceSoundness(true); env.solver().minMax().setMethod(storm::solver::MinMaxMethod::ValueIteration); env.solver().minMax().setPrecision(storm::utility::convertNumber<storm::RationalNumber>(1e-6)); + env.solver().minMax().setRelativeTerminationCriterion(false); return env; } }; @@ -119,6 +120,7 @@ namespace { env.solver().setForceSoundness(true); env.solver().minMax().setMethod(storm::solver::MinMaxMethod::ValueIteration); env.solver().minMax().setPrecision(storm::utility::convertNumber<storm::RationalNumber>(1e-6)); + env.solver().minMax().setRelativeTerminationCriterion(false); return env; } }; diff --git a/src/test/storm/modelchecker/NativeCtmcCslModelCheckerTest.cpp b/src/test/storm/modelchecker/NativeCtmcCslModelCheckerTest.cpp deleted file mode 100644 index 246ac41ca..000000000 --- a/src/test/storm/modelchecker/NativeCtmcCslModelCheckerTest.cpp +++ /dev/null @@ -1,226 +0,0 @@ -#include "gtest/gtest.h" -#include "storm-config.h" -#include "storm/settings/SettingMemento.h" -#include "storm/parser/PrismParser.h" -#include "storm/parser/FormulaParser.h" -#include "storm/logic/Formulas.h" -#include "storm/builder/ExplicitModelBuilder.h" - -#include "storm/solver/NativeLinearEquationSolver.h" -#include "storm/models/sparse/StandardRewardModel.h" -#include "storm/modelchecker/csl/SparseCtmcCslModelChecker.h" -#include "storm/modelchecker/results/ExplicitQuantitativeCheckResult.h" -#include "storm/settings/SettingsManager.h" -#include "storm/settings/modules/NativeEquationSolverSettings.h" - -#include "storm/settings/modules/GeneralSettings.h" - -TEST(NativeCtmcCslModelCheckerTest, Cluster) { - // Parse the model description. - storm::prism::Program program = storm::parser::PrismParser::parse(STORM_TEST_RESOURCES_DIR "/ctmc/cluster2.sm", true); - storm::parser::FormulaParser formulaParser(program); - std::shared_ptr<storm::logic::Formula const> formula(nullptr); - - // Build the model. - std::shared_ptr<storm::models::sparse::Model<double>> model = storm::builder::ExplicitModelBuilder<double>(program, storm::generator::NextStateGeneratorOptions(false, true). addRewardModel("num_repairs")).build(); - ASSERT_EQ(storm::models::ModelType::Ctmc, model->getType()); - std::shared_ptr<storm::models::sparse::Ctmc<double>> ctmc = model->as<storm::models::sparse::Ctmc<double>>(); - uint_fast64_t initialState = *ctmc->getInitialStates().begin(); - - // Create model checker. - storm::modelchecker::SparseCtmcCslModelChecker<storm::models::sparse::Ctmc<double>> modelchecker(*ctmc, std::make_unique<storm::solver::NativeLinearEquationSolverFactory<double>>()); - - // Start checking properties. - formula = formulaParser.parseSingleFormulaFromString("P=? [ F<=100 !\"minimum\"]"); - std::unique_ptr<storm::modelchecker::CheckResult> checkResult = modelchecker.check(*formula); - - ASSERT_TRUE(checkResult->isExplicitQuantitativeCheckResult()); - storm::modelchecker::ExplicitQuantitativeCheckResult<double> quantitativeCheckResult1 = checkResult->asExplicitQuantitativeCheckResult<double>(); - EXPECT_NEAR(5.5461254704419085E-5, quantitativeCheckResult1[initialState], storm::settings::getModule<storm::settings::modules::GeneralSettings>().getPrecision()); - - formula = formulaParser.parseSingleFormulaFromString("P=? [ F[100,100] !\"minimum\"]"); - checkResult = modelchecker.check(*formula); - - ASSERT_TRUE(checkResult->isExplicitQuantitativeCheckResult()); - storm::modelchecker::ExplicitQuantitativeCheckResult<double> quantitativeCheckResult2 = checkResult->asExplicitQuantitativeCheckResult<double>(); - EXPECT_NEAR(2.3397873548343415E-6, quantitativeCheckResult2[initialState], storm::settings::getModule<storm::settings::modules::GeneralSettings>().getPrecision()); - - formula = formulaParser.parseSingleFormulaFromString("P=? [ F[100,2000] !\"minimum\"]"); - checkResult = modelchecker.check(*formula); - - ASSERT_TRUE(checkResult->isExplicitQuantitativeCheckResult()); - storm::modelchecker::ExplicitQuantitativeCheckResult<double> quantitativeCheckResult3 = checkResult->asExplicitQuantitativeCheckResult<double>(); - EXPECT_NEAR(0.001105335651670241, quantitativeCheckResult3[initialState], storm::settings::getModule<storm::settings::modules::GeneralSettings>().getPrecision()); - - formula = formulaParser.parseSingleFormulaFromString("P=? [ \"minimum\" U<=10 \"premium\"]"); - checkResult = modelchecker.check(*formula); - - ASSERT_TRUE(checkResult->isExplicitQuantitativeCheckResult()); - storm::modelchecker::ExplicitQuantitativeCheckResult<double> quantitativeCheckResult4 = checkResult->asExplicitQuantitativeCheckResult<double>(); - EXPECT_NEAR(1, quantitativeCheckResult4[initialState], storm::settings::getModule<storm::settings::modules::GeneralSettings>().getPrecision()); - - formula = formulaParser.parseSingleFormulaFromString("P=? [ !\"minimum\" U>=1 \"minimum\"]"); - checkResult = modelchecker.check(*formula); - - ASSERT_TRUE(checkResult->isExplicitQuantitativeCheckResult()); - storm::modelchecker::ExplicitQuantitativeCheckResult<double> quantitativeCheckResult5 = checkResult->asExplicitQuantitativeCheckResult<double>(); - EXPECT_NEAR(0, quantitativeCheckResult5[initialState], storm::settings::getModule<storm::settings::modules::GeneralSettings>().getPrecision()); - - formula = formulaParser.parseSingleFormulaFromString("P=? [ \"minimum\" U>=1 !\"minimum\"]"); - checkResult = modelchecker.check(*formula); - - ASSERT_TRUE(checkResult->isExplicitQuantitativeCheckResult()); - storm::modelchecker::ExplicitQuantitativeCheckResult<double> quantitativeCheckResult6 = checkResult->asExplicitQuantitativeCheckResult<double>(); - EXPECT_NEAR(0.9999999033633374, quantitativeCheckResult6[initialState], storm::settings::getModule<storm::settings::modules::GeneralSettings>().getPrecision()); - - formula = formulaParser.parseSingleFormulaFromString("R=? [C<=100]"); - checkResult = modelchecker.check(*formula); - - ASSERT_TRUE(checkResult->isExplicitQuantitativeCheckResult()); - storm::modelchecker::ExplicitQuantitativeCheckResult<double> quantitativeCheckResult7 = checkResult->asExplicitQuantitativeCheckResult<double>(); - EXPECT_NEAR(0.8602815057967503, quantitativeCheckResult7[initialState], storm::settings::getModule<storm::settings::modules::GeneralSettings>().getPrecision()); -} - -TEST(NativeCtmcCslModelCheckerTest, Embedded) { - - // Parse the model description. - storm::prism::Program program = storm::parser::PrismParser::parse(STORM_TEST_RESOURCES_DIR "/ctmc/embedded2.sm", true); - storm::parser::FormulaParser formulaParser(program); - std::shared_ptr<storm::logic::Formula const> formula(nullptr); - - // Build the model. - storm::generator::NextStateGeneratorOptions options; - options.addRewardModel("up").setBuildAllLabels(); - std::shared_ptr<storm::models::sparse::Model<double>> model = storm::builder::ExplicitModelBuilder<double>(program, options).build(); - ASSERT_EQ(storm::models::ModelType::Ctmc, model->getType()); - std::shared_ptr<storm::models::sparse::Ctmc<double>> ctmc = model->as<storm::models::sparse::Ctmc<double>>(); - uint_fast64_t initialState = *ctmc->getInitialStates().begin(); - - // Create model checker. - storm::modelchecker::SparseCtmcCslModelChecker<storm::models::sparse::Ctmc<double>> modelchecker(*ctmc, std::make_unique<storm::solver::NativeLinearEquationSolverFactory<double>>()); - - // Start checking properties. - formula = formulaParser.parseSingleFormulaFromString("P=? [ F<=10000 \"down\"]"); - std::unique_ptr<storm::modelchecker::CheckResult> checkResult = modelchecker.check(*formula); - - ASSERT_TRUE(checkResult->isExplicitQuantitativeCheckResult()); - storm::modelchecker::ExplicitQuantitativeCheckResult<double> quantitativeCheckResult1 = checkResult->asExplicitQuantitativeCheckResult<double>(); - EXPECT_NEAR(0.0019216435246119591, quantitativeCheckResult1[initialState], storm::settings::getModule<storm::settings::modules::GeneralSettings>().getPrecision()); - - formula = formulaParser.parseSingleFormulaFromString("P=? [ !\"down\" U<=10000 \"fail_actuators\"]"); - checkResult = modelchecker.check(*formula); - - ASSERT_TRUE(checkResult->isExplicitQuantitativeCheckResult()); - storm::modelchecker::ExplicitQuantitativeCheckResult<double> quantitativeCheckResult2 = checkResult->asExplicitQuantitativeCheckResult<double>(); - EXPECT_NEAR(3.7079151806696567E-6, quantitativeCheckResult2[initialState], storm::settings::getModule<storm::settings::modules::GeneralSettings>().getPrecision()); - - formula = formulaParser.parseSingleFormulaFromString("P=? [ !\"down\" U<=10000 \"fail_io\"]"); - checkResult = modelchecker.check(*formula); - - ASSERT_TRUE(checkResult->isExplicitQuantitativeCheckResult()); - storm::modelchecker::ExplicitQuantitativeCheckResult<double> quantitativeCheckResult3 = checkResult->asExplicitQuantitativeCheckResult<double>(); - EXPECT_NEAR(0.001556839327673734, quantitativeCheckResult3[initialState], storm::settings::getModule<storm::settings::modules::GeneralSettings>().getPrecision()); - - formula = formulaParser.parseSingleFormulaFromString("P=? [ !\"down\" U<=10000 \"fail_sensors\"]"); - checkResult = modelchecker.check(*formula); - - ASSERT_TRUE(checkResult->isExplicitQuantitativeCheckResult()); - storm::modelchecker::ExplicitQuantitativeCheckResult<double> quantitativeCheckResult4 = checkResult->asExplicitQuantitativeCheckResult<double>(); - EXPECT_NEAR(4.429620626755424E-5, quantitativeCheckResult4[initialState], storm::settings::getModule<storm::settings::modules::GeneralSettings>().getPrecision()); - - formula = formulaParser.parseSingleFormulaFromString("R=? [C<=10000]"); - checkResult = modelchecker.check(*formula); - - ASSERT_TRUE(checkResult->isExplicitQuantitativeCheckResult()); - storm::modelchecker::ExplicitQuantitativeCheckResult<double> quantitativeCheckResult5 = checkResult->asExplicitQuantitativeCheckResult<double>(); - EXPECT_NEAR(2.7745274082080154, quantitativeCheckResult5[initialState], storm::settings::getModule<storm::settings::modules::GeneralSettings>().getPrecision()); -} - -TEST(NativeCtmcCslModelCheckerTest, Polling) { - // Parse the model description. - storm::prism::Program program = storm::parser::PrismParser::parse(STORM_TEST_RESOURCES_DIR "/ctmc/polling2.sm", true); - storm::parser::FormulaParser formulaParser(program); - std::shared_ptr<storm::logic::Formula const> formula(nullptr); - - // Build the model. - std::shared_ptr<storm::models::sparse::Model<double>> model = storm::builder::ExplicitModelBuilder<double>(program, storm::generator::NextStateGeneratorOptions(false, true)).build(); - ASSERT_EQ(storm::models::ModelType::Ctmc, model->getType()); - std::shared_ptr<storm::models::sparse::Ctmc<double>> ctmc = model->as<storm::models::sparse::Ctmc<double>>(); - uint_fast64_t initialState = *ctmc->getInitialStates().begin(); - - // Create model checker. - storm::modelchecker::SparseCtmcCslModelChecker<storm::models::sparse::Ctmc<double>> modelchecker(*ctmc, std::make_unique<storm::solver::NativeLinearEquationSolverFactory<double>>()); - - // Start checking properties. - formula = formulaParser.parseSingleFormulaFromString("P=?[ F<=10 \"target\"]"); - std::unique_ptr<storm::modelchecker::CheckResult> checkResult = modelchecker.check(*formula); - - ASSERT_TRUE(checkResult->isExplicitQuantitativeCheckResult()); - storm::modelchecker::ExplicitQuantitativeCheckResult<double> quantitativeCheckResult1 = checkResult->asExplicitQuantitativeCheckResult<double>(); - EXPECT_NEAR(1, quantitativeCheckResult1[initialState], storm::settings::getModule<storm::settings::modules::GeneralSettings>().getPrecision()); -} - -TEST(NativeCtmcCslModelCheckerTest, Fms) { - - // No properties to check at this point. -} - -TEST(NativeCtmcCslModelCheckerTest, Tandem) { - - // Parse the model description. - storm::prism::Program program = storm::parser::PrismParser::parse(STORM_TEST_RESOURCES_DIR "/ctmc/tandem5.sm", true); - storm::parser::FormulaParser formulaParser(program); - std::shared_ptr<storm::logic::Formula const> formula(nullptr); - - // Build the model with the customers reward structure. - std::shared_ptr<storm::models::sparse::Model<double>> model = storm::builder::ExplicitModelBuilder<double>(program, storm::generator::NextStateGeneratorOptions(false, true).addRewardModel("customers")).build(); - ASSERT_EQ(storm::models::ModelType::Ctmc, model->getType()); - std::shared_ptr<storm::models::sparse::Ctmc<double>> ctmc = model->as<storm::models::sparse::Ctmc<double>>(); - uint_fast64_t initialState = *ctmc->getInitialStates().begin(); - - // Create model checker. - storm::modelchecker::SparseCtmcCslModelChecker<storm::models::sparse::Ctmc<double>> modelchecker(*ctmc, std::make_unique<storm::solver::NativeLinearEquationSolverFactory<double>>()); - - // Start checking properties. - formula = formulaParser.parseSingleFormulaFromString("P=? [ F<=10 \"network_full\" ]"); - std::unique_ptr<storm::modelchecker::CheckResult> checkResult = modelchecker.check(*formula); - - ASSERT_TRUE(checkResult->isExplicitQuantitativeCheckResult()); - storm::modelchecker::ExplicitQuantitativeCheckResult<double> quantitativeCheckResult1 = checkResult->asExplicitQuantitativeCheckResult<double>(); - EXPECT_NEAR(0.015446370562428037, quantitativeCheckResult1[initialState], storm::settings::getModule<storm::settings::modules::GeneralSettings>().getPrecision()); - - formula = formulaParser.parseSingleFormulaFromString("P=? [ F<=10 \"first_queue_full\" ]"); - checkResult = modelchecker.check(*formula); - - ASSERT_TRUE(checkResult->isExplicitQuantitativeCheckResult()); - storm::modelchecker::ExplicitQuantitativeCheckResult<double> quantitativeCheckResult2 = checkResult->asExplicitQuantitativeCheckResult<double>(); - EXPECT_NEAR(0.999999837225515, quantitativeCheckResult2[initialState], storm::settings::getModule<storm::settings::modules::GeneralSettings>().getPrecision()); - - formula = formulaParser.parseSingleFormulaFromString("P=? [\"second_queue_full\" U<=1 !\"second_queue_full\"]"); - checkResult = modelchecker.check(*formula); - - ASSERT_TRUE(checkResult->isExplicitQuantitativeCheckResult()); - storm::modelchecker::ExplicitQuantitativeCheckResult<double> quantitativeCheckResult3 = checkResult->asExplicitQuantitativeCheckResult<double>(); - EXPECT_NEAR(1, quantitativeCheckResult3[initialState], storm::settings::getModule<storm::settings::modules::GeneralSettings>().getPrecision()); - - formula = formulaParser.parseSingleFormulaFromString("R=? [I=10]"); - checkResult = modelchecker.check(*formula); - - ASSERT_TRUE(checkResult->isExplicitQuantitativeCheckResult()); - storm::modelchecker::ExplicitQuantitativeCheckResult<double> quantitativeCheckResult4 = checkResult->asExplicitQuantitativeCheckResult<double>(); - EXPECT_NEAR(5.679243850315877, quantitativeCheckResult4[initialState], storm::settings::getModule<storm::settings::modules::GeneralSettings>().getPrecision()); - - formula = formulaParser.parseSingleFormulaFromString("R=? [C<=10]"); - checkResult = modelchecker.check(*formula); - - ASSERT_TRUE(checkResult->isExplicitQuantitativeCheckResult()); - storm::modelchecker::ExplicitQuantitativeCheckResult<double> quantitativeCheckResult5 = checkResult->asExplicitQuantitativeCheckResult<double>(); - EXPECT_NEAR(55.44792186036232, quantitativeCheckResult5[initialState], storm::settings::getModule<storm::settings::modules::GeneralSettings>().getPrecision()); - - formula = formulaParser.parseSingleFormulaFromString("R=? [F \"first_queue_full\"&\"second_queue_full\"]"); - checkResult = modelchecker.check(*formula); - - ASSERT_TRUE(checkResult->isExplicitQuantitativeCheckResult()); - storm::modelchecker::ExplicitQuantitativeCheckResult<double> quantitativeCheckResult6 = checkResult->asExplicitQuantitativeCheckResult<double>(); - EXPECT_NEAR(262.78584491454814, quantitativeCheckResult6[initialState], storm::settings::getModule<storm::settings::modules::GeneralSettings>().getPrecision()); -} diff --git a/src/test/storm/modelchecker/NativeDtmcPrctlModelCheckerTest.cpp b/src/test/storm/modelchecker/NativeDtmcPrctlModelCheckerTest.cpp deleted file mode 100644 index 24e72c778..000000000 --- a/src/test/storm/modelchecker/NativeDtmcPrctlModelCheckerTest.cpp +++ /dev/null @@ -1,294 +0,0 @@ -#include "gtest/gtest.h" -#include "storm-config.h" - -#include "storm/parser/FormulaParser.h" -#include "storm/settings/SettingMemento.h" -#include "storm/logic/Formulas.h" -#include "storm/solver/NativeLinearEquationSolver.h" -#include "storm/models/sparse/StandardRewardModel.h" -#include "storm/modelchecker/prctl/SparseDtmcPrctlModelChecker.h" -#include "storm/modelchecker/results/ExplicitQuantitativeCheckResult.h" -#include "storm/settings/SettingsManager.h" -#include "storm/solver/NativeLinearEquationSolver.h" -#include "storm/settings/modules/GeneralSettings.h" - -#include "storm/settings/modules/NativeEquationSolverSettings.h" -#include "storm/settings/SettingMemento.h" -#include "storm/parser/AutoParser.h" - -TEST(NativeDtmcPrctlModelCheckerTest, Die) { - std::shared_ptr<storm::models::sparse::Model<double>> abstractModel = storm::parser::AutoParser<>::parseModel(STORM_TEST_RESOURCES_DIR "/tra/die.tra", STORM_TEST_RESOURCES_DIR "/lab/die.lab", "", STORM_TEST_RESOURCES_DIR "/rew/die.coin_flips.trans.rew"); - - // A parser that we use for conveniently constructing the formulas. - storm::parser::FormulaParser formulaParser; - - ASSERT_EQ(abstractModel->getType(), storm::models::ModelType::Dtmc); - - std::shared_ptr<storm::models::sparse::Dtmc<double>> dtmc = abstractModel->as<storm::models::sparse::Dtmc<double>>(); - - ASSERT_EQ(dtmc->getNumberOfStates(), 13ull); - ASSERT_EQ(dtmc->getNumberOfTransitions(), 20ull); - - storm::modelchecker::SparseDtmcPrctlModelChecker<storm::models::sparse::Dtmc<double>> checker(*dtmc, std::make_unique<storm::solver::NativeLinearEquationSolverFactory<double>>()); - - std::shared_ptr<storm::logic::Formula const> formula = formulaParser.parseSingleFormulaFromString("P=? [F \"one\"]"); - - std::unique_ptr<storm::modelchecker::CheckResult> result = checker.check(*formula); - storm::modelchecker::ExplicitQuantitativeCheckResult<double>& quantitativeResult1 = result->asExplicitQuantitativeCheckResult<double>(); - - EXPECT_NEAR(1.0/6.0, quantitativeResult1[0], storm::settings::getModule<storm::settings::modules::NativeEquationSolverSettings>().getPrecision()); - - formula = formulaParser.parseSingleFormulaFromString("P=? [F \"two\"]"); - - result = checker.check(*formula); - storm::modelchecker::ExplicitQuantitativeCheckResult<double>& quantitativeResult2 = result->asExplicitQuantitativeCheckResult<double>(); - - EXPECT_NEAR(1.0/6.0, quantitativeResult2[0], storm::settings::getModule<storm::settings::modules::NativeEquationSolverSettings>().getPrecision()); - - formula = formulaParser.parseSingleFormulaFromString("P=? [F \"three\"]"); - - result = checker.check(*formula); - storm::modelchecker::ExplicitQuantitativeCheckResult<double>& quantitativeResult3 = result->asExplicitQuantitativeCheckResult<double>(); - - EXPECT_NEAR(1.0/6.0, quantitativeResult3[0], storm::settings::getModule<storm::settings::modules::NativeEquationSolverSettings>().getPrecision()); - - formula = formulaParser.parseSingleFormulaFromString("R=? [F \"done\"]"); - - result = checker.check(*formula); - storm::modelchecker::ExplicitQuantitativeCheckResult<double>& quantitativeResult4 = result->asExplicitQuantitativeCheckResult<double>(); - - EXPECT_NEAR(3.6666650772094727, quantitativeResult4[0], storm::settings::getModule<storm::settings::modules::NativeEquationSolverSettings>().getPrecision()); -} - -TEST(NativeDtmcPrctlModelCheckerTest, Crowds) { - std::shared_ptr<storm::models::sparse::Model<double>> abstractModel = storm::parser::AutoParser<>::parseModel(STORM_TEST_RESOURCES_DIR "/tra/crowds5_5.tra", STORM_TEST_RESOURCES_DIR "/lab/crowds5_5.lab", "", ""); - - ASSERT_EQ(abstractModel->getType(), storm::models::ModelType::Dtmc); - - // A parser that we use for conveniently constructing the formulas. - storm::parser::FormulaParser formulaParser; - - std::shared_ptr<storm::models::sparse::Dtmc<double>> dtmc = abstractModel->as<storm::models::sparse::Dtmc<double>>(); - - ASSERT_EQ(8607ull, dtmc->getNumberOfStates()); - ASSERT_EQ(15113ull, dtmc->getNumberOfTransitions()); - - storm::modelchecker::SparseDtmcPrctlModelChecker<storm::models::sparse::Dtmc<double>> checker(*dtmc, std::make_unique<storm::solver::NativeLinearEquationSolverFactory<double>>()); - - std::shared_ptr<storm::logic::Formula const> formula = formulaParser.parseSingleFormulaFromString("P=? [F \"observe0Greater1\"]"); - - std::unique_ptr<storm::modelchecker::CheckResult> result = checker.check(*formula); - storm::modelchecker::ExplicitQuantitativeCheckResult<double>& quantitativeResult1 = result->asExplicitQuantitativeCheckResult<double>(); - - EXPECT_NEAR(0.33288205191646525, quantitativeResult1[0], storm::settings::getModule<storm::settings::modules::NativeEquationSolverSettings>().getPrecision()); - - formula = formulaParser.parseSingleFormulaFromString("P=? [F \"observeIGreater1\"]"); - - result = checker.check(*formula); - storm::modelchecker::ExplicitQuantitativeCheckResult<double>& quantitativeResult2 = result->asExplicitQuantitativeCheckResult<double>(); - - EXPECT_NEAR(0.15222066094730619, quantitativeResult2[0], storm::settings::getModule<storm::settings::modules::NativeEquationSolverSettings>().getPrecision()); - - formula = formulaParser.parseSingleFormulaFromString("P=? [F \"observeOnlyTrueSender\"]"); - - result = checker.check(*formula); - storm::modelchecker::ExplicitQuantitativeCheckResult<double>& quantitativeResult3 = result->asExplicitQuantitativeCheckResult<double>(); - - EXPECT_NEAR(0.32153900158185761, quantitativeResult3[0], storm::settings::getModule<storm::settings::modules::NativeEquationSolverSettings>().getPrecision()); -} - -TEST(NativeDtmcPrctlModelCheckerTest, SynchronousLeader) { - std::shared_ptr<storm::models::sparse::Model<double>> abstractModel = storm::parser::AutoParser<>::parseModel(STORM_TEST_RESOURCES_DIR "/tra/leader4_8.tra", STORM_TEST_RESOURCES_DIR "/lab/leader4_8.lab", "", STORM_TEST_RESOURCES_DIR "/rew/leader4_8.pick.trans.rew"); - - ASSERT_EQ(abstractModel->getType(), storm::models::ModelType::Dtmc); - - // A parser that we use for conveniently constructing the formulas. - storm::parser::FormulaParser formulaParser; - - std::shared_ptr<storm::models::sparse::Dtmc<double>> dtmc = abstractModel->as<storm::models::sparse::Dtmc<double>>(); - - ASSERT_EQ(12400ull, dtmc->getNumberOfStates()); - ASSERT_EQ(16495ull, dtmc->getNumberOfTransitions()); - - storm::modelchecker::SparseDtmcPrctlModelChecker<storm::models::sparse::Dtmc<double>> checker(*dtmc, std::make_unique<storm::solver::NativeLinearEquationSolverFactory<double>>()); - - std::shared_ptr<storm::logic::Formula const> formula = formulaParser.parseSingleFormulaFromString("P=? [F \"elected\"]"); - - std::unique_ptr<storm::modelchecker::CheckResult> result = checker.check(*formula); - storm::modelchecker::ExplicitQuantitativeCheckResult<double>& quantitativeResult1 = result->asExplicitQuantitativeCheckResult<double>(); - - EXPECT_NEAR(1.0, quantitativeResult1[0], storm::settings::getModule<storm::settings::modules::NativeEquationSolverSettings>().getPrecision()); - - formula = formulaParser.parseSingleFormulaFromString("P=? [F<=20 \"elected\"]"); - - result = checker.check(*formula); - storm::modelchecker::ExplicitQuantitativeCheckResult<double>& quantitativeResult2 = result->asExplicitQuantitativeCheckResult<double>(); - - EXPECT_NEAR(0.9999965911265462636, quantitativeResult2[0], storm::settings::getModule<storm::settings::modules::NativeEquationSolverSettings>().getPrecision()); - - formula = formulaParser.parseSingleFormulaFromString("R=? [F \"elected\"]"); - - result = checker.check(*formula); - storm::modelchecker::ExplicitQuantitativeCheckResult<double>& quantitativeResult3 = result->asExplicitQuantitativeCheckResult<double>(); - - EXPECT_NEAR(1.0448979589010925, quantitativeResult3[0], storm::settings::getModule<storm::settings::modules::NativeEquationSolverSettings>().getPrecision()); -} - -TEST(NativeDtmcPrctlModelCheckerTest, LRASingleBscc) { - storm::storage::SparseMatrixBuilder<double> matrixBuilder; - std::shared_ptr<storm::models::sparse::Dtmc<double>> dtmc; - - // A parser that we use for conveniently constructing the formulas. - storm::parser::FormulaParser formulaParser; - - { - matrixBuilder = storm::storage::SparseMatrixBuilder<double>(2, 2, 2); - matrixBuilder.addNextValue(0, 1, 1.); - matrixBuilder.addNextValue(1, 0, 1.); - storm::storage::SparseMatrix<double> transitionMatrix = matrixBuilder.build(); - - storm::models::sparse::StateLabeling ap(2); - ap.addLabel("a"); - ap.addLabelToState("a", 1); - - dtmc.reset(new storm::models::sparse::Dtmc<double>(transitionMatrix, ap)); - - auto factory = std::make_unique<storm::solver::NativeLinearEquationSolverFactory<double>>(); - factory->getSettings().setSolutionMethod(storm::solver::NativeLinearEquationSolverSettings<double>::SolutionMethod::SOR); - factory->getSettings().setOmega(0.9); - storm::modelchecker::SparseDtmcPrctlModelChecker<storm::models::sparse::Dtmc<double>> checker(*dtmc, std::move(factory)); - - std::shared_ptr<storm::logic::Formula const> formula = formulaParser.parseSingleFormulaFromString("LRA=? [\"a\"]"); - - std::unique_ptr<storm::modelchecker::CheckResult> result = checker.check(*formula); - storm::modelchecker::ExplicitQuantitativeCheckResult<double>& quantitativeResult1 = result->asExplicitQuantitativeCheckResult<double>(); - - EXPECT_NEAR(.5, quantitativeResult1[0], storm::settings::getModule<storm::settings::modules::NativeEquationSolverSettings>().getPrecision()); - EXPECT_NEAR(.5, quantitativeResult1[1], storm::settings::getModule<storm::settings::modules::NativeEquationSolverSettings>().getPrecision()); - } - { - matrixBuilder = storm::storage::SparseMatrixBuilder<double>(2, 2, 4); - matrixBuilder.addNextValue(0, 0, .5); - matrixBuilder.addNextValue(0, 1, .5); - matrixBuilder.addNextValue(1, 0, .5); - matrixBuilder.addNextValue(1, 1, .5); - storm::storage::SparseMatrix<double> transitionMatrix = matrixBuilder.build(); - - storm::models::sparse::StateLabeling ap(2); - ap.addLabel("a"); - ap.addLabelToState("a", 1); - - dtmc.reset(new storm::models::sparse::Dtmc<double>(transitionMatrix, ap)); - - auto factory = std::make_unique<storm::solver::NativeLinearEquationSolverFactory<double>>(); - factory->getSettings().setSolutionMethod(storm::solver::NativeLinearEquationSolverSettings<double>::SolutionMethod::SOR); - factory->getSettings().setOmega(0.9); - storm::modelchecker::SparseDtmcPrctlModelChecker<storm::models::sparse::Dtmc<double>> checker(*dtmc, std::move(factory)); - - std::shared_ptr<storm::logic::Formula const> formula = formulaParser.parseSingleFormulaFromString("LRA=? [\"a\"]"); - - std::unique_ptr<storm::modelchecker::CheckResult> result = checker.check(*formula); - storm::modelchecker::ExplicitQuantitativeCheckResult<double>& quantitativeResult1 = result->asExplicitQuantitativeCheckResult<double>(); - - EXPECT_NEAR(.5, quantitativeResult1[0], storm::settings::getModule<storm::settings::modules::NativeEquationSolverSettings>().getPrecision()); - EXPECT_NEAR(.5, quantitativeResult1[1], storm::settings::getModule<storm::settings::modules::NativeEquationSolverSettings>().getPrecision()); - } - - { - matrixBuilder = storm::storage::SparseMatrixBuilder<double>(3, 3, 3); - matrixBuilder.addNextValue(0, 1, 1); - matrixBuilder.addNextValue(1, 2, 1); - matrixBuilder.addNextValue(2, 0, 1); - storm::storage::SparseMatrix<double> transitionMatrix = matrixBuilder.build(); - - storm::models::sparse::StateLabeling ap(3); - ap.addLabel("a"); - ap.addLabelToState("a", 2); - - dtmc.reset(new storm::models::sparse::Dtmc<double>(transitionMatrix, ap)); - - auto factory = std::make_unique<storm::solver::NativeLinearEquationSolverFactory<double>>(); - factory->getSettings().setSolutionMethod(storm::solver::NativeLinearEquationSolverSettings<double>::SolutionMethod::WalkerChae); - storm::modelchecker::SparseDtmcPrctlModelChecker<storm::models::sparse::Dtmc<double>> checker(*dtmc, std::move(factory)); - - std::shared_ptr<storm::logic::Formula const> formula = formulaParser.parseSingleFormulaFromString("LRA=? [\"a\"]"); - - std::unique_ptr<storm::modelchecker::CheckResult> result = checker.check(*formula); - storm::modelchecker::ExplicitQuantitativeCheckResult<double>& quantitativeResult1 = result->asExplicitQuantitativeCheckResult<double>(); - - EXPECT_NEAR(1. / 3., quantitativeResult1[0], storm::settings::getModule<storm::settings::modules::NativeEquationSolverSettings>().getPrecision()); - EXPECT_NEAR(1. / 3., quantitativeResult1[1], storm::settings::getModule<storm::settings::modules::NativeEquationSolverSettings>().getPrecision()); - EXPECT_NEAR(1. / 3., quantitativeResult1[2], storm::settings::getModule<storm::settings::modules::NativeEquationSolverSettings>().getPrecision()); - } -} - -TEST(NativeDtmcPrctlModelCheckerTest, LRA) { - storm::storage::SparseMatrixBuilder<double> matrixBuilder; - std::shared_ptr<storm::models::sparse::Dtmc<double>> dtmc; - - // A parser that we use for conveniently constructing the formulas. - storm::parser::FormulaParser formulaParser; - - { - matrixBuilder = storm::storage::SparseMatrixBuilder<double>(15, 15, 20, true); - matrixBuilder.addNextValue(0, 1, 1); - matrixBuilder.addNextValue(1, 4, 0.7); - matrixBuilder.addNextValue(1, 6, 0.3); - matrixBuilder.addNextValue(2, 0, 1); - - matrixBuilder.addNextValue(3, 5, 0.8); - matrixBuilder.addNextValue(3, 9, 0.2); - matrixBuilder.addNextValue(4, 3, 1); - matrixBuilder.addNextValue(5, 3, 1); - - matrixBuilder.addNextValue(6, 7, 1); - matrixBuilder.addNextValue(7, 8, 1); - matrixBuilder.addNextValue(8, 6, 1); - - matrixBuilder.addNextValue(9, 10, 1); - matrixBuilder.addNextValue(10, 9, 1); - matrixBuilder.addNextValue(11, 9, 1); - - matrixBuilder.addNextValue(12, 5, 0.4); - matrixBuilder.addNextValue(12, 8, 0.3); - matrixBuilder.addNextValue(12, 11, 0.3); - - matrixBuilder.addNextValue(13, 7, 0.7); - matrixBuilder.addNextValue(13, 12, 0.3); - - matrixBuilder.addNextValue(14, 12, 1); - - storm::storage::SparseMatrix<double> transitionMatrix = matrixBuilder.build(); - - storm::models::sparse::StateLabeling ap(15); - ap.addLabel("a"); - ap.addLabelToState("a", 1); - ap.addLabelToState("a", 4); - ap.addLabelToState("a", 5); - ap.addLabelToState("a", 7); - ap.addLabelToState("a", 11); - ap.addLabelToState("a", 13); - ap.addLabelToState("a", 14); - - dtmc.reset(new storm::models::sparse::Dtmc<double>(transitionMatrix, ap)); - - auto factory = std::make_unique<storm::solver::NativeLinearEquationSolverFactory<double>>(); - factory->getSettings().setSolutionMethod(storm::solver::NativeLinearEquationSolverSettings<double>::SolutionMethod::WalkerChae); - factory->getSettings().setPrecision(1e-7); - factory->getSettings().setMaximalNumberOfIterations(50000); - storm::modelchecker::SparseDtmcPrctlModelChecker<storm::models::sparse::Dtmc<double>> checker(*dtmc, std::move(factory)); - - std::shared_ptr<storm::logic::Formula const> formula = formulaParser.parseSingleFormulaFromString("LRA=? [\"a\"]"); - - std::unique_ptr<storm::modelchecker::CheckResult> result = checker.check(*formula); - storm::modelchecker::ExplicitQuantitativeCheckResult<double>& quantitativeResult1 = result->asExplicitQuantitativeCheckResult<double>(); - - EXPECT_NEAR(0.3 / 3., quantitativeResult1[0], storm::settings::getModule<storm::settings::modules::NativeEquationSolverSettings>().getPrecision()); - EXPECT_NEAR(0.0, quantitativeResult1[3], storm::settings::getModule<storm::settings::modules::NativeEquationSolverSettings>().getPrecision()); - EXPECT_NEAR(1. / 3., quantitativeResult1[6], storm::settings::getModule<storm::settings::modules::NativeEquationSolverSettings>().getPrecision()); - EXPECT_NEAR(0.0, quantitativeResult1[9], storm::settings::getModule<storm::settings::modules::NativeEquationSolverSettings>().getPrecision()); - EXPECT_NEAR(0.3/3., quantitativeResult1[12], storm::settings::getModule<storm::settings::modules::NativeEquationSolverSettings>().getPrecision()); - EXPECT_NEAR(.79 / 3., quantitativeResult1[13], storm::settings::getModule<storm::settings::modules::NativeEquationSolverSettings>().getPrecision()); - EXPECT_NEAR(0.3 / 3., quantitativeResult1[14], storm::settings::getModule<storm::settings::modules::NativeEquationSolverSettings>().getPrecision()); - } -} diff --git a/src/test/storm/modelchecker/NativeHybridCtmcCslModelCheckerTest.cpp b/src/test/storm/modelchecker/NativeHybridCtmcCslModelCheckerTest.cpp deleted file mode 100644 index f8aa35701..000000000 --- a/src/test/storm/modelchecker/NativeHybridCtmcCslModelCheckerTest.cpp +++ /dev/null @@ -1,617 +0,0 @@ -#include "gtest/gtest.h" -#include "storm-config.h" -#include "storm/settings/SettingMemento.h" -#include "storm/parser/PrismParser.h" -#include "storm/parser/FormulaParser.h" -#include "storm/logic/Formulas.h" -#include "storm/builder/DdPrismModelBuilder.h" -#include "storm/storage/dd/DdType.h" -#include "storm/storage/SymbolicModelDescription.h" - -#include "storm/solver/NativeLinearEquationSolver.h" -#include "storm/models/symbolic/StandardRewardModel.h" -#include "storm/modelchecker/csl/HybridCtmcCslModelChecker.h" -#include "storm/modelchecker/results/HybridQuantitativeCheckResult.h" -#include "storm/modelchecker/results/SymbolicQualitativeCheckResult.h" -#include "storm/modelchecker/results/SymbolicQuantitativeCheckResult.h" - -#include "storm/settings/SettingsManager.h" -#include "storm/settings/modules/GeneralSettings.h" - -#include "storm/settings/modules/NativeEquationSolverSettings.h" - -TEST(NativeHybridCtmcCslModelCheckerTest, Cluster_Cudd) { - // Parse the model description. - storm::storage::SymbolicModelDescription modelDescription = storm::parser::PrismParser::parse(STORM_TEST_RESOURCES_DIR "/ctmc/cluster2.sm", true); - storm::prism::Program program = modelDescription.preprocess().asPrismProgram(); - storm::parser::FormulaParser formulaParser(program); - std::shared_ptr<storm::logic::Formula const> formula(nullptr); - - // Build the model. -#ifdef WINDOWS - storm::builder::DdPrismModelBuilder<storm::dd::DdType::CUDD>::Options options; -#else - typename storm::builder::DdPrismModelBuilder<storm::dd::DdType::CUDD>::Options options; -#endif - options.buildAllRewardModels = false; - options.rewardModelsToBuild.insert("num_repairs"); - std::shared_ptr<storm::models::symbolic::Model<storm::dd::DdType::CUDD>> model = storm::builder::DdPrismModelBuilder<storm::dd::DdType::CUDD>().build(program, options); - ASSERT_EQ(storm::models::ModelType::Ctmc, model->getType()); - std::shared_ptr<storm::models::symbolic::Ctmc<storm::dd::DdType::CUDD>> ctmc = model->as<storm::models::symbolic::Ctmc<storm::dd::DdType::CUDD>>(); - - // Create model checker. - storm::modelchecker::HybridCtmcCslModelChecker<storm::models::symbolic::Ctmc<storm::dd::DdType::CUDD, double>> modelchecker(*ctmc, std::make_unique<storm::solver::NativeLinearEquationSolverFactory<double>>()); - - // Start checking properties. - formula = formulaParser.parseSingleFormulaFromString("P=? [ F<=100 !\"minimum\"]"); - std::unique_ptr<storm::modelchecker::CheckResult> checkResult = modelchecker.check(*formula); - - ASSERT_TRUE(checkResult->isHybridQuantitativeCheckResult()); - checkResult->filter(storm::modelchecker::SymbolicQualitativeCheckResult<storm::dd::DdType::CUDD>(ctmc->getReachableStates(), ctmc->getInitialStates())); - storm::modelchecker::HybridQuantitativeCheckResult<storm::dd::DdType::CUDD> quantitativeCheckResult1 = checkResult->asHybridQuantitativeCheckResult<storm::dd::DdType::CUDD, double>(); - EXPECT_NEAR(5.5461254704419085E-5, quantitativeCheckResult1.getMin(), storm::settings::getModule<storm::settings::modules::GeneralSettings>().getPrecision()); - EXPECT_NEAR(5.5461254704419085E-5, quantitativeCheckResult1.getMax(), storm::settings::getModule<storm::settings::modules::GeneralSettings>().getPrecision()); - - formula = formulaParser.parseSingleFormulaFromString("P=? [ F[100,100] !\"minimum\"]"); - checkResult = modelchecker.check(*formula); - - ASSERT_TRUE(checkResult->isHybridQuantitativeCheckResult()); - checkResult->filter(storm::modelchecker::SymbolicQualitativeCheckResult<storm::dd::DdType::CUDD>(ctmc->getReachableStates(), ctmc->getInitialStates())); - storm::modelchecker::HybridQuantitativeCheckResult<storm::dd::DdType::CUDD> quantitativeCheckResult2 = checkResult->asHybridQuantitativeCheckResult<storm::dd::DdType::CUDD, double>(); - EXPECT_NEAR(2.3397873548343415E-6, quantitativeCheckResult2.getMin(), storm::settings::getModule<storm::settings::modules::GeneralSettings>().getPrecision()); - EXPECT_NEAR(2.3397873548343415E-6, quantitativeCheckResult2.getMax(), storm::settings::getModule<storm::settings::modules::GeneralSettings>().getPrecision()); - - formula = formulaParser.parseSingleFormulaFromString("P=? [ F[100,2000] !\"minimum\"]"); - checkResult = modelchecker.check(*formula); - - ASSERT_TRUE(checkResult->isHybridQuantitativeCheckResult()); - checkResult->filter(storm::modelchecker::SymbolicQualitativeCheckResult<storm::dd::DdType::CUDD>(ctmc->getReachableStates(), ctmc->getInitialStates())); - storm::modelchecker::HybridQuantitativeCheckResult<storm::dd::DdType::CUDD> quantitativeCheckResult3 = checkResult->asHybridQuantitativeCheckResult<storm::dd::DdType::CUDD, double>(); - EXPECT_NEAR(0.001105335651670241, quantitativeCheckResult3.getMin(), storm::settings::getModule<storm::settings::modules::GeneralSettings>().getPrecision()); - EXPECT_NEAR(0.001105335651670241, quantitativeCheckResult3.getMax(), storm::settings::getModule<storm::settings::modules::GeneralSettings>().getPrecision()); - - formula = formulaParser.parseSingleFormulaFromString("P=? [ \"minimum\" U<=10 \"premium\"]"); - checkResult = modelchecker.check(*formula); - - ASSERT_TRUE(checkResult->isHybridQuantitativeCheckResult()); - checkResult->filter(storm::modelchecker::SymbolicQualitativeCheckResult<storm::dd::DdType::CUDD>(ctmc->getReachableStates(), ctmc->getInitialStates())); - storm::modelchecker::HybridQuantitativeCheckResult<storm::dd::DdType::CUDD> quantitativeCheckResult4 = checkResult->asHybridQuantitativeCheckResult<storm::dd::DdType::CUDD, double>(); - EXPECT_NEAR(1, quantitativeCheckResult4.getMin(), storm::settings::getModule<storm::settings::modules::GeneralSettings>().getPrecision()); - EXPECT_NEAR(1, quantitativeCheckResult4.getMax(), storm::settings::getModule<storm::settings::modules::GeneralSettings>().getPrecision()); - - formula = formulaParser.parseSingleFormulaFromString("P=? [ !\"minimum\" U>=1 \"minimum\"]"); - checkResult = modelchecker.check(*formula); - - ASSERT_TRUE(checkResult->isHybridQuantitativeCheckResult()); - checkResult->filter(storm::modelchecker::SymbolicQualitativeCheckResult<storm::dd::DdType::CUDD>(ctmc->getReachableStates(), ctmc->getInitialStates())); - storm::modelchecker::HybridQuantitativeCheckResult<storm::dd::DdType::CUDD> quantitativeCheckResult5 = checkResult->asHybridQuantitativeCheckResult<storm::dd::DdType::CUDD, double>(); - EXPECT_NEAR(0, quantitativeCheckResult5.getMin(), storm::settings::getModule<storm::settings::modules::GeneralSettings>().getPrecision()); - EXPECT_NEAR(0, quantitativeCheckResult5.getMax(), storm::settings::getModule<storm::settings::modules::GeneralSettings>().getPrecision()); - - formula = formulaParser.parseSingleFormulaFromString("P=? [ \"minimum\" U>=1 !\"minimum\"]"); - checkResult = modelchecker.check(*formula); - - ASSERT_TRUE(checkResult->isHybridQuantitativeCheckResult()); - checkResult->filter(storm::modelchecker::SymbolicQualitativeCheckResult<storm::dd::DdType::CUDD>(ctmc->getReachableStates(), ctmc->getInitialStates())); - storm::modelchecker::HybridQuantitativeCheckResult<storm::dd::DdType::CUDD> quantitativeCheckResult6 = checkResult->asHybridQuantitativeCheckResult<storm::dd::DdType::CUDD, double>(); - EXPECT_NEAR(0.9999999033633374, quantitativeCheckResult6.getMin(), storm::settings::getModule<storm::settings::modules::GeneralSettings>().getPrecision()); - EXPECT_NEAR(0.9999999033633374, quantitativeCheckResult6.getMax(), storm::settings::getModule<storm::settings::modules::GeneralSettings>().getPrecision()); - - formula = formulaParser.parseSingleFormulaFromString("R=? [C<=100]"); - checkResult = modelchecker.check(*formula); - - ASSERT_TRUE(checkResult->isHybridQuantitativeCheckResult()); - checkResult->filter(storm::modelchecker::SymbolicQualitativeCheckResult<storm::dd::DdType::CUDD>(ctmc->getReachableStates(), ctmc->getInitialStates())); - storm::modelchecker::HybridQuantitativeCheckResult<storm::dd::DdType::CUDD> quantitativeCheckResult7 = checkResult->asHybridQuantitativeCheckResult<storm::dd::DdType::CUDD, double>(); - EXPECT_NEAR(0.8602815057967503, quantitativeCheckResult7.getMin(), storm::settings::getModule<storm::settings::modules::GeneralSettings>().getPrecision()); - EXPECT_NEAR(0.8602815057967503, quantitativeCheckResult7.getMax(), storm::settings::getModule<storm::settings::modules::GeneralSettings>().getPrecision()); - - formula = formulaParser.parseSingleFormulaFromString("LRA=? [\"minimum\"]"); - checkResult = modelchecker.check(*formula); - - checkResult->filter(storm::modelchecker::SymbolicQualitativeCheckResult<storm::dd::DdType::CUDD>(ctmc->getReachableStates(), ctmc->getInitialStates())); - storm::modelchecker::HybridQuantitativeCheckResult<storm::dd::DdType::CUDD> quantitativeCheckResult8 = checkResult->asHybridQuantitativeCheckResult<storm::dd::DdType::CUDD, double>(); - EXPECT_NEAR(0.99979112284455396, quantitativeCheckResult8.getMin(), storm::settings::getModule<storm::settings::modules::GeneralSettings>().getPrecision()); - EXPECT_NEAR(0.99979112284455396, quantitativeCheckResult8.getMax(), storm::settings::getModule<storm::settings::modules::GeneralSettings>().getPrecision()); -} - -TEST(NativeHybridCtmcCslModelCheckerTest, Cluster_Sylvan) { - // Parse the model description. - storm::storage::SymbolicModelDescription modelDescription = storm::parser::PrismParser::parse(STORM_TEST_RESOURCES_DIR "/ctmc/cluster2.sm", true); - storm::prism::Program program = modelDescription.preprocess().asPrismProgram(); - storm::parser::FormulaParser formulaParser(program); - std::shared_ptr<storm::logic::Formula const> formula(nullptr); - - // Build the model. -#ifdef WINDOWS - storm::builder::DdPrismModelBuilder<storm::dd::DdType::Sylvan>::Options options; -#else - typename storm::builder::DdPrismModelBuilder<storm::dd::DdType::Sylvan>::Options options; -#endif - options.buildAllRewardModels = false; - options.rewardModelsToBuild.insert("num_repairs"); - std::shared_ptr<storm::models::symbolic::Model<storm::dd::DdType::Sylvan>> model = storm::builder::DdPrismModelBuilder<storm::dd::DdType::Sylvan>().build(program, options); - ASSERT_EQ(storm::models::ModelType::Ctmc, model->getType()); - std::shared_ptr<storm::models::symbolic::Ctmc<storm::dd::DdType::Sylvan>> ctmc = model->as<storm::models::symbolic::Ctmc<storm::dd::DdType::Sylvan>>(); - - // Create model checker. - storm::modelchecker::HybridCtmcCslModelChecker<storm::models::symbolic::Ctmc<storm::dd::DdType::Sylvan, double>> modelchecker(*ctmc, std::make_unique<storm::solver::NativeLinearEquationSolverFactory<double>>()); - - // Start checking properties. - formula = formulaParser.parseSingleFormulaFromString("P=? [ F<=100 !\"minimum\"]"); - std::unique_ptr<storm::modelchecker::CheckResult> checkResult = modelchecker.check(*formula); - - ASSERT_TRUE(checkResult->isHybridQuantitativeCheckResult()); - checkResult->filter(storm::modelchecker::SymbolicQualitativeCheckResult<storm::dd::DdType::Sylvan>(ctmc->getReachableStates(), ctmc->getInitialStates())); - storm::modelchecker::HybridQuantitativeCheckResult<storm::dd::DdType::Sylvan> quantitativeCheckResult1 = checkResult->asHybridQuantitativeCheckResult<storm::dd::DdType::Sylvan, double>(); - EXPECT_NEAR(5.5461254704419085E-5, quantitativeCheckResult1.getMin(), storm::settings::getModule<storm::settings::modules::GeneralSettings>().getPrecision()); - EXPECT_NEAR(5.5461254704419085E-5, quantitativeCheckResult1.getMax(), storm::settings::getModule<storm::settings::modules::GeneralSettings>().getPrecision()); - - formula = formulaParser.parseSingleFormulaFromString("P=? [ F[100,100] !\"minimum\"]"); - checkResult = modelchecker.check(*formula); - - ASSERT_TRUE(checkResult->isHybridQuantitativeCheckResult()); - checkResult->filter(storm::modelchecker::SymbolicQualitativeCheckResult<storm::dd::DdType::Sylvan>(ctmc->getReachableStates(), ctmc->getInitialStates())); - storm::modelchecker::HybridQuantitativeCheckResult<storm::dd::DdType::Sylvan> quantitativeCheckResult2 = checkResult->asHybridQuantitativeCheckResult<storm::dd::DdType::Sylvan, double>(); - EXPECT_NEAR(2.3397873548343415E-6, quantitativeCheckResult2.getMin(), storm::settings::getModule<storm::settings::modules::GeneralSettings>().getPrecision()); - EXPECT_NEAR(2.3397873548343415E-6, quantitativeCheckResult2.getMax(), storm::settings::getModule<storm::settings::modules::GeneralSettings>().getPrecision()); - - formula = formulaParser.parseSingleFormulaFromString("P=? [ F[100,2000] !\"minimum\"]"); - checkResult = modelchecker.check(*formula); - - ASSERT_TRUE(checkResult->isHybridQuantitativeCheckResult()); - checkResult->filter(storm::modelchecker::SymbolicQualitativeCheckResult<storm::dd::DdType::Sylvan>(ctmc->getReachableStates(), ctmc->getInitialStates())); - storm::modelchecker::HybridQuantitativeCheckResult<storm::dd::DdType::Sylvan> quantitativeCheckResult3 = checkResult->asHybridQuantitativeCheckResult<storm::dd::DdType::Sylvan, double>(); - EXPECT_NEAR(0.001105335651670241, quantitativeCheckResult3.getMin(), storm::settings::getModule<storm::settings::modules::GeneralSettings>().getPrecision()); - EXPECT_NEAR(0.001105335651670241, quantitativeCheckResult3.getMax(), storm::settings::getModule<storm::settings::modules::GeneralSettings>().getPrecision()); - - formula = formulaParser.parseSingleFormulaFromString("P=? [ \"minimum\" U<=10 \"premium\"]"); - checkResult = modelchecker.check(*formula); - - ASSERT_TRUE(checkResult->isHybridQuantitativeCheckResult()); - checkResult->filter(storm::modelchecker::SymbolicQualitativeCheckResult<storm::dd::DdType::Sylvan>(ctmc->getReachableStates(), ctmc->getInitialStates())); - storm::modelchecker::HybridQuantitativeCheckResult<storm::dd::DdType::Sylvan> quantitativeCheckResult4 = checkResult->asHybridQuantitativeCheckResult<storm::dd::DdType::Sylvan, double>(); - EXPECT_NEAR(1, quantitativeCheckResult4.getMin(), storm::settings::getModule<storm::settings::modules::GeneralSettings>().getPrecision()); - EXPECT_NEAR(1, quantitativeCheckResult4.getMax(), storm::settings::getModule<storm::settings::modules::GeneralSettings>().getPrecision()); - - formula = formulaParser.parseSingleFormulaFromString("P=? [ !\"minimum\" U>=1 \"minimum\"]"); - checkResult = modelchecker.check(*formula); - - ASSERT_TRUE(checkResult->isHybridQuantitativeCheckResult()); - checkResult->filter(storm::modelchecker::SymbolicQualitativeCheckResult<storm::dd::DdType::Sylvan>(ctmc->getReachableStates(), ctmc->getInitialStates())); - storm::modelchecker::HybridQuantitativeCheckResult<storm::dd::DdType::Sylvan> quantitativeCheckResult5 = checkResult->asHybridQuantitativeCheckResult<storm::dd::DdType::Sylvan, double>(); - EXPECT_NEAR(0, quantitativeCheckResult5.getMin(), storm::settings::getModule<storm::settings::modules::GeneralSettings>().getPrecision()); - EXPECT_NEAR(0, quantitativeCheckResult5.getMax(), storm::settings::getModule<storm::settings::modules::GeneralSettings>().getPrecision()); - - formula = formulaParser.parseSingleFormulaFromString("P=? [ \"minimum\" U>=1 !\"minimum\"]"); - checkResult = modelchecker.check(*formula); - - ASSERT_TRUE(checkResult->isHybridQuantitativeCheckResult()); - checkResult->filter(storm::modelchecker::SymbolicQualitativeCheckResult<storm::dd::DdType::Sylvan>(ctmc->getReachableStates(), ctmc->getInitialStates())); - storm::modelchecker::HybridQuantitativeCheckResult<storm::dd::DdType::Sylvan> quantitativeCheckResult6 = checkResult->asHybridQuantitativeCheckResult<storm::dd::DdType::Sylvan, double>(); - EXPECT_NEAR(0.9999999033633374, quantitativeCheckResult6.getMin(), storm::settings::getModule<storm::settings::modules::GeneralSettings>().getPrecision()); - EXPECT_NEAR(0.9999999033633374, quantitativeCheckResult6.getMax(), storm::settings::getModule<storm::settings::modules::GeneralSettings>().getPrecision()); - - formula = formulaParser.parseSingleFormulaFromString("R=? [C<=100]"); - checkResult = modelchecker.check(*formula); - - ASSERT_TRUE(checkResult->isHybridQuantitativeCheckResult()); - checkResult->filter(storm::modelchecker::SymbolicQualitativeCheckResult<storm::dd::DdType::Sylvan>(ctmc->getReachableStates(), ctmc->getInitialStates())); - storm::modelchecker::HybridQuantitativeCheckResult<storm::dd::DdType::Sylvan> quantitativeCheckResult7 = checkResult->asHybridQuantitativeCheckResult<storm::dd::DdType::Sylvan, double>(); - EXPECT_NEAR(0.8602815057967503, quantitativeCheckResult7.getMin(), storm::settings::getModule<storm::settings::modules::GeneralSettings>().getPrecision()); - EXPECT_NEAR(0.8602815057967503, quantitativeCheckResult7.getMax(), storm::settings::getModule<storm::settings::modules::GeneralSettings>().getPrecision()); - - formula = formulaParser.parseSingleFormulaFromString("LRA=? [\"minimum\"]"); - checkResult = modelchecker.check(*formula); - - checkResult->filter(storm::modelchecker::SymbolicQualitativeCheckResult<storm::dd::DdType::Sylvan>(ctmc->getReachableStates(), ctmc->getInitialStates())); - storm::modelchecker::HybridQuantitativeCheckResult<storm::dd::DdType::Sylvan> quantitativeCheckResult8 = checkResult->asHybridQuantitativeCheckResult<storm::dd::DdType::Sylvan, double>(); - EXPECT_NEAR(0.99979112284455396, quantitativeCheckResult8.getMin(), storm::settings::getModule<storm::settings::modules::GeneralSettings>().getPrecision()); - EXPECT_NEAR(0.99979112284455396, quantitativeCheckResult8.getMax(), storm::settings::getModule<storm::settings::modules::GeneralSettings>().getPrecision()); -} - -TEST(NativeHybridCtmcCslModelCheckerTest, Embedded_Cudd) { - // Parse the model description. - storm::storage::SymbolicModelDescription modelDescription = storm::parser::PrismParser::parse(STORM_TEST_RESOURCES_DIR "/ctmc/embedded2.sm", true); - storm::prism::Program program = modelDescription.preprocess().asPrismProgram(); - storm::parser::FormulaParser formulaParser(program); - std::shared_ptr<storm::logic::Formula const> formula(nullptr); - - // Build the model. -#ifdef WINDOWS - storm::builder::DdPrismModelBuilder<storm::dd::DdType::CUDD>::Options options; -#else - typename storm::builder::DdPrismModelBuilder<storm::dd::DdType::CUDD>::Options options; -#endif - options.buildAllRewardModels = false; - options.rewardModelsToBuild.insert("up"); - std::shared_ptr<storm::models::symbolic::Model<storm::dd::DdType::CUDD>> model = storm::builder::DdPrismModelBuilder<storm::dd::DdType::CUDD>().build(program, options); - ASSERT_EQ(storm::models::ModelType::Ctmc, model->getType()); - std::shared_ptr<storm::models::symbolic::Ctmc<storm::dd::DdType::CUDD>> ctmc = model->as<storm::models::symbolic::Ctmc<storm::dd::DdType::CUDD>>(); - - // Create model checker. - storm::modelchecker::HybridCtmcCslModelChecker<storm::models::symbolic::Ctmc<storm::dd::DdType::CUDD, double>> modelchecker(*ctmc, std::make_unique<storm::solver::NativeLinearEquationSolverFactory<double>>()); - - // Start checking properties. - formula = formulaParser.parseSingleFormulaFromString("P=? [ F<=10000 \"down\"]"); - std::unique_ptr<storm::modelchecker::CheckResult> checkResult = modelchecker.check(*formula); - - ASSERT_TRUE(checkResult->isHybridQuantitativeCheckResult()); - checkResult->filter(storm::modelchecker::SymbolicQualitativeCheckResult<storm::dd::DdType::CUDD>(ctmc->getReachableStates(), ctmc->getInitialStates())); - storm::modelchecker::HybridQuantitativeCheckResult<storm::dd::DdType::CUDD> quantitativeCheckResult1 = checkResult->asHybridQuantitativeCheckResult<storm::dd::DdType::CUDD, double>(); - EXPECT_NEAR(0.0019216435246119591, quantitativeCheckResult1.getMin(), storm::settings::getModule<storm::settings::modules::GeneralSettings>().getPrecision()); - EXPECT_NEAR(0.0019216435246119591, quantitativeCheckResult1.getMax(), storm::settings::getModule<storm::settings::modules::GeneralSettings>().getPrecision()); - - formula = formulaParser.parseSingleFormulaFromString("P=? [ !\"down\" U<=10000 \"fail_actuators\"]"); - checkResult = modelchecker.check(*formula); - - ASSERT_TRUE(checkResult->isHybridQuantitativeCheckResult()); - checkResult->filter(storm::modelchecker::SymbolicQualitativeCheckResult<storm::dd::DdType::CUDD>(ctmc->getReachableStates(), ctmc->getInitialStates())); - storm::modelchecker::HybridQuantitativeCheckResult<storm::dd::DdType::CUDD> quantitativeCheckResult2 = checkResult->asHybridQuantitativeCheckResult<storm::dd::DdType::CUDD, double>(); - EXPECT_NEAR(3.7079151806696567E-6, quantitativeCheckResult2.getMin(), storm::settings::getModule<storm::settings::modules::GeneralSettings>().getPrecision()); - EXPECT_NEAR(3.7079151806696567E-6, quantitativeCheckResult2.getMax(), storm::settings::getModule<storm::settings::modules::GeneralSettings>().getPrecision()); - - formula = formulaParser.parseSingleFormulaFromString("P=? [ !\"down\" U<=10000 \"fail_io\"]"); - checkResult = modelchecker.check(*formula); - - ASSERT_TRUE(checkResult->isHybridQuantitativeCheckResult()); - checkResult->filter(storm::modelchecker::SymbolicQualitativeCheckResult<storm::dd::DdType::CUDD>(ctmc->getReachableStates(), ctmc->getInitialStates())); - storm::modelchecker::HybridQuantitativeCheckResult<storm::dd::DdType::CUDD> quantitativeCheckResult3 = checkResult->asHybridQuantitativeCheckResult<storm::dd::DdType::CUDD, double>(); - EXPECT_NEAR(0.001556839327673734, quantitativeCheckResult3.getMin(), storm::settings::getModule<storm::settings::modules::GeneralSettings>().getPrecision()); - EXPECT_NEAR(0.001556839327673734, quantitativeCheckResult3.getMax(), storm::settings::getModule<storm::settings::modules::GeneralSettings>().getPrecision()); - - formula = formulaParser.parseSingleFormulaFromString("P=? [ !\"down\" U<=10000 \"fail_sensors\"]"); - checkResult = modelchecker.check(*formula); - - ASSERT_TRUE(checkResult->isHybridQuantitativeCheckResult()); - checkResult->filter(storm::modelchecker::SymbolicQualitativeCheckResult<storm::dd::DdType::CUDD>(ctmc->getReachableStates(), ctmc->getInitialStates())); - storm::modelchecker::HybridQuantitativeCheckResult<storm::dd::DdType::CUDD> quantitativeCheckResult4 = checkResult->asHybridQuantitativeCheckResult<storm::dd::DdType::CUDD, double>(); - EXPECT_NEAR(4.429620626755424E-5, quantitativeCheckResult4.getMin(), storm::settings::getModule<storm::settings::modules::GeneralSettings>().getPrecision()); - EXPECT_NEAR(4.429620626755424E-5, quantitativeCheckResult4.getMax(), storm::settings::getModule<storm::settings::modules::GeneralSettings>().getPrecision()); - - formula = formulaParser.parseSingleFormulaFromString("R=? [C<=10000]"); - checkResult = modelchecker.check(*formula); - - ASSERT_TRUE(checkResult->isHybridQuantitativeCheckResult()); - checkResult->filter(storm::modelchecker::SymbolicQualitativeCheckResult<storm::dd::DdType::CUDD>(ctmc->getReachableStates(), ctmc->getInitialStates())); - storm::modelchecker::HybridQuantitativeCheckResult<storm::dd::DdType::CUDD> quantitativeCheckResult5 = checkResult->asHybridQuantitativeCheckResult<storm::dd::DdType::CUDD, double>(); - EXPECT_NEAR(2.7745274082080154, quantitativeCheckResult5.getMin(), storm::settings::getModule<storm::settings::modules::GeneralSettings>().getPrecision()); - EXPECT_NEAR(2.7745274082080154, quantitativeCheckResult5.getMax(), storm::settings::getModule<storm::settings::modules::GeneralSettings>().getPrecision()); - - formula = formulaParser.parseSingleFormulaFromString("LRA=? [\"fail_sensors\"]"); - checkResult = modelchecker.check(*formula); - - checkResult->filter(storm::modelchecker::SymbolicQualitativeCheckResult<storm::dd::DdType::CUDD>(ctmc->getReachableStates(), ctmc->getInitialStates())); - storm::modelchecker::HybridQuantitativeCheckResult<storm::dd::DdType::CUDD> quantitativeCheckResult6 = checkResult->asHybridQuantitativeCheckResult<storm::dd::DdType::CUDD, double>(); - EXPECT_NEAR(0.93458777106146362, quantitativeCheckResult6.getMin(), storm::settings::getModule<storm::settings::modules::GeneralSettings>().getPrecision()); - EXPECT_NEAR(0.93458777106146362, quantitativeCheckResult6.getMax(), storm::settings::getModule<storm::settings::modules::GeneralSettings>().getPrecision()); -} - -TEST(NativeHybridCtmcCslModelCheckerTest, Embedded_Sylvan) { - - // Parse the model description. - storm::storage::SymbolicModelDescription modelDescription = storm::parser::PrismParser::parse(STORM_TEST_RESOURCES_DIR "/ctmc/embedded2.sm", true); - storm::prism::Program program = modelDescription.preprocess().asPrismProgram(); - storm::parser::FormulaParser formulaParser(program); - std::shared_ptr<storm::logic::Formula const> formula(nullptr); - - // Build the model. -#ifdef WINDOWS - storm::builder::DdPrismModelBuilder<storm::dd::DdType::Sylvan>::Options options; -#else - typename storm::builder::DdPrismModelBuilder<storm::dd::DdType::Sylvan>::Options options; -#endif - options.buildAllRewardModels = false; - options.rewardModelsToBuild.insert("up"); - std::shared_ptr<storm::models::symbolic::Model<storm::dd::DdType::Sylvan>> model = storm::builder::DdPrismModelBuilder<storm::dd::DdType::Sylvan>().build(program, options); - ASSERT_EQ(storm::models::ModelType::Ctmc, model->getType()); - std::shared_ptr<storm::models::symbolic::Ctmc<storm::dd::DdType::Sylvan>> ctmc = model->as<storm::models::symbolic::Ctmc<storm::dd::DdType::Sylvan>>(); - - // Create model checker. - storm::modelchecker::HybridCtmcCslModelChecker<storm::models::symbolic::Ctmc<storm::dd::DdType::Sylvan, double>> modelchecker(*ctmc, std::make_unique<storm::solver::NativeLinearEquationSolverFactory<double>>()); - - // Start checking properties. - formula = formulaParser.parseSingleFormulaFromString("P=? [ F<=10000 \"down\"]"); - std::unique_ptr<storm::modelchecker::CheckResult> checkResult = modelchecker.check(*formula); - - ASSERT_TRUE(checkResult->isHybridQuantitativeCheckResult()); - checkResult->filter(storm::modelchecker::SymbolicQualitativeCheckResult<storm::dd::DdType::Sylvan>(ctmc->getReachableStates(), ctmc->getInitialStates())); - storm::modelchecker::HybridQuantitativeCheckResult<storm::dd::DdType::Sylvan> quantitativeCheckResult1 = checkResult->asHybridQuantitativeCheckResult<storm::dd::DdType::Sylvan, double>(); - EXPECT_NEAR(0.0019216435246119591, quantitativeCheckResult1.getMin(), storm::settings::getModule<storm::settings::modules::GeneralSettings>().getPrecision()); - EXPECT_NEAR(0.0019216435246119591, quantitativeCheckResult1.getMax(), storm::settings::getModule<storm::settings::modules::GeneralSettings>().getPrecision()); - - formula = formulaParser.parseSingleFormulaFromString("P=? [ !\"down\" U<=10000 \"fail_actuators\"]"); - checkResult = modelchecker.check(*formula); - - ASSERT_TRUE(checkResult->isHybridQuantitativeCheckResult()); - checkResult->filter(storm::modelchecker::SymbolicQualitativeCheckResult<storm::dd::DdType::Sylvan>(ctmc->getReachableStates(), ctmc->getInitialStates())); - storm::modelchecker::HybridQuantitativeCheckResult<storm::dd::DdType::Sylvan> quantitativeCheckResult2 = checkResult->asHybridQuantitativeCheckResult<storm::dd::DdType::Sylvan, double>(); - EXPECT_NEAR(3.7079151806696567E-6, quantitativeCheckResult2.getMin(), storm::settings::getModule<storm::settings::modules::GeneralSettings>().getPrecision()); - EXPECT_NEAR(3.7079151806696567E-6, quantitativeCheckResult2.getMax(), storm::settings::getModule<storm::settings::modules::GeneralSettings>().getPrecision()); - - formula = formulaParser.parseSingleFormulaFromString("P=? [ !\"down\" U<=10000 \"fail_io\"]"); - checkResult = modelchecker.check(*formula); - - ASSERT_TRUE(checkResult->isHybridQuantitativeCheckResult()); - checkResult->filter(storm::modelchecker::SymbolicQualitativeCheckResult<storm::dd::DdType::Sylvan>(ctmc->getReachableStates(), ctmc->getInitialStates())); - storm::modelchecker::HybridQuantitativeCheckResult<storm::dd::DdType::Sylvan> quantitativeCheckResult3 = checkResult->asHybridQuantitativeCheckResult<storm::dd::DdType::Sylvan, double>(); - EXPECT_NEAR(0.001556839327673734, quantitativeCheckResult3.getMin(), storm::settings::getModule<storm::settings::modules::GeneralSettings>().getPrecision()); - EXPECT_NEAR(0.001556839327673734, quantitativeCheckResult3.getMax(), storm::settings::getModule<storm::settings::modules::GeneralSettings>().getPrecision()); - - formula = formulaParser.parseSingleFormulaFromString("P=? [ !\"down\" U<=10000 \"fail_sensors\"]"); - checkResult = modelchecker.check(*formula); - - ASSERT_TRUE(checkResult->isHybridQuantitativeCheckResult()); - checkResult->filter(storm::modelchecker::SymbolicQualitativeCheckResult<storm::dd::DdType::Sylvan>(ctmc->getReachableStates(), ctmc->getInitialStates())); - storm::modelchecker::HybridQuantitativeCheckResult<storm::dd::DdType::Sylvan> quantitativeCheckResult4 = checkResult->asHybridQuantitativeCheckResult<storm::dd::DdType::Sylvan, double>(); - EXPECT_NEAR(4.429620626755424E-5, quantitativeCheckResult4.getMin(), storm::settings::getModule<storm::settings::modules::GeneralSettings>().getPrecision()); - EXPECT_NEAR(4.429620626755424E-5, quantitativeCheckResult4.getMax(), storm::settings::getModule<storm::settings::modules::GeneralSettings>().getPrecision()); - - formula = formulaParser.parseSingleFormulaFromString("R=? [C<=10000]"); - checkResult = modelchecker.check(*formula); - - ASSERT_TRUE(checkResult->isHybridQuantitativeCheckResult()); - checkResult->filter(storm::modelchecker::SymbolicQualitativeCheckResult<storm::dd::DdType::Sylvan>(ctmc->getReachableStates(), ctmc->getInitialStates())); - storm::modelchecker::HybridQuantitativeCheckResult<storm::dd::DdType::Sylvan> quantitativeCheckResult5 = checkResult->asHybridQuantitativeCheckResult<storm::dd::DdType::Sylvan, double>(); - EXPECT_NEAR(2.7745274082080154, quantitativeCheckResult5.getMin(), storm::settings::getModule<storm::settings::modules::GeneralSettings>().getPrecision()); - EXPECT_NEAR(2.7745274082080154, quantitativeCheckResult5.getMax(), storm::settings::getModule<storm::settings::modules::GeneralSettings>().getPrecision()); - - formula = formulaParser.parseSingleFormulaFromString("LRA=? [\"fail_sensors\"]"); - checkResult = modelchecker.check(*formula); - - checkResult->filter(storm::modelchecker::SymbolicQualitativeCheckResult<storm::dd::DdType::Sylvan>(ctmc->getReachableStates(), ctmc->getInitialStates())); - storm::modelchecker::HybridQuantitativeCheckResult<storm::dd::DdType::Sylvan> quantitativeCheckResult6 = checkResult->asHybridQuantitativeCheckResult<storm::dd::DdType::Sylvan, double>(); - EXPECT_NEAR(0.93458777106146362, quantitativeCheckResult6.getMin(), storm::settings::getModule<storm::settings::modules::GeneralSettings>().getPrecision()); - EXPECT_NEAR(0.93458777106146362, quantitativeCheckResult6.getMax(), storm::settings::getModule<storm::settings::modules::GeneralSettings>().getPrecision()); -} - -TEST(NativeHybridCtmcCslModelCheckerTest, Polling_Cudd) { - // Parse the model description. - storm::storage::SymbolicModelDescription modelDescription = storm::parser::PrismParser::parse(STORM_TEST_RESOURCES_DIR "/ctmc/polling2.sm", true); - storm::prism::Program program = modelDescription.preprocess().asPrismProgram(); - storm::parser::FormulaParser formulaParser(program); - std::shared_ptr<storm::logic::Formula const> formula(nullptr); - - // Build the model. - std::shared_ptr<storm::models::symbolic::Model<storm::dd::DdType::CUDD>> model = storm::builder::DdPrismModelBuilder<storm::dd::DdType::CUDD>().build(program); - ASSERT_EQ(storm::models::ModelType::Ctmc, model->getType()); - std::shared_ptr<storm::models::symbolic::Ctmc<storm::dd::DdType::CUDD>> ctmc = model->as<storm::models::symbolic::Ctmc<storm::dd::DdType::CUDD>>(); - - // Create model checker. - storm::modelchecker::HybridCtmcCslModelChecker<storm::models::symbolic::Ctmc<storm::dd::DdType::CUDD, double>> modelchecker(*ctmc, std::make_unique<storm::solver::NativeLinearEquationSolverFactory<double>>()); - - // Start checking properties. - formula = formulaParser.parseSingleFormulaFromString("P=?[ F<=10 \"target\"]"); - std::unique_ptr<storm::modelchecker::CheckResult> checkResult = modelchecker.check(*formula); - - ASSERT_TRUE(checkResult->isHybridQuantitativeCheckResult()); - checkResult->filter(storm::modelchecker::SymbolicQualitativeCheckResult<storm::dd::DdType::CUDD>(ctmc->getReachableStates(), ctmc->getInitialStates())); - storm::modelchecker::HybridQuantitativeCheckResult<storm::dd::DdType::CUDD> quantitativeCheckResult1 = checkResult->asHybridQuantitativeCheckResult<storm::dd::DdType::CUDD, double>(); - EXPECT_NEAR(1, quantitativeCheckResult1.getMin(), storm::settings::getModule<storm::settings::modules::GeneralSettings>().getPrecision()); - EXPECT_NEAR(1, quantitativeCheckResult1.getMax(), storm::settings::getModule<storm::settings::modules::GeneralSettings>().getPrecision()); - - formula = formulaParser.parseSingleFormulaFromString("LRA=? [\"target\"]"); - checkResult = modelchecker.check(*formula); - - checkResult->filter(storm::modelchecker::SymbolicQualitativeCheckResult<storm::dd::DdType::CUDD>(ctmc->getReachableStates(), ctmc->getInitialStates())); - storm::modelchecker::HybridQuantitativeCheckResult<storm::dd::DdType::CUDD> quantitativeCheckResult2 = checkResult->asHybridQuantitativeCheckResult<storm::dd::DdType::CUDD, double>(); - EXPECT_NEAR(0.20079750055570736, quantitativeCheckResult2.getMin(), storm::settings::getModule<storm::settings::modules::GeneralSettings>().getPrecision()); - EXPECT_NEAR(0.20079750055570736, quantitativeCheckResult2.getMax(), storm::settings::getModule<storm::settings::modules::GeneralSettings>().getPrecision()); -} - -TEST(NativeHybridCtmcCslModelCheckerTest, Polling_Sylvan) { - - // Parse the model description. - storm::storage::SymbolicModelDescription modelDescription = storm::parser::PrismParser::parse(STORM_TEST_RESOURCES_DIR "/ctmc/polling2.sm", true); - storm::prism::Program program = modelDescription.preprocess().asPrismProgram(); - storm::parser::FormulaParser formulaParser(program); - std::shared_ptr<storm::logic::Formula const> formula(nullptr); - - // Build the model. - std::shared_ptr<storm::models::symbolic::Model<storm::dd::DdType::Sylvan>> model = storm::builder::DdPrismModelBuilder<storm::dd::DdType::Sylvan>().build(program); - ASSERT_EQ(storm::models::ModelType::Ctmc, model->getType()); - std::shared_ptr<storm::models::symbolic::Ctmc<storm::dd::DdType::Sylvan>> ctmc = model->as<storm::models::symbolic::Ctmc<storm::dd::DdType::Sylvan>>(); - - // Create model checker. - storm::modelchecker::HybridCtmcCslModelChecker<storm::models::symbolic::Ctmc<storm::dd::DdType::Sylvan, double>> modelchecker(*ctmc, std::make_unique<storm::solver::NativeLinearEquationSolverFactory<double>>()); - - // Start checking properties. - formula = formulaParser.parseSingleFormulaFromString("P=?[ F<=10 \"target\"]"); - std::unique_ptr<storm::modelchecker::CheckResult> checkResult = modelchecker.check(*formula); - - ASSERT_TRUE(checkResult->isHybridQuantitativeCheckResult()); - checkResult->filter(storm::modelchecker::SymbolicQualitativeCheckResult<storm::dd::DdType::Sylvan>(ctmc->getReachableStates(), ctmc->getInitialStates())); - storm::modelchecker::HybridQuantitativeCheckResult<storm::dd::DdType::Sylvan> quantitativeCheckResult1 = checkResult->asHybridQuantitativeCheckResult<storm::dd::DdType::Sylvan, double>(); - EXPECT_NEAR(1, quantitativeCheckResult1.getMin(), storm::settings::getModule<storm::settings::modules::GeneralSettings>().getPrecision()); - EXPECT_NEAR(1, quantitativeCheckResult1.getMax(), storm::settings::getModule<storm::settings::modules::GeneralSettings>().getPrecision()); - - formula = formulaParser.parseSingleFormulaFromString("LRA=? [\"target\"]"); - checkResult = modelchecker.check(*formula); - - checkResult->filter(storm::modelchecker::SymbolicQualitativeCheckResult<storm::dd::DdType::Sylvan>(ctmc->getReachableStates(), ctmc->getInitialStates())); - storm::modelchecker::HybridQuantitativeCheckResult<storm::dd::DdType::Sylvan> quantitativeCheckResult2 = checkResult->asHybridQuantitativeCheckResult<storm::dd::DdType::Sylvan, double>(); - EXPECT_NEAR(0.20079750055570736, quantitativeCheckResult2.getMin(), storm::settings::getModule<storm::settings::modules::GeneralSettings>().getPrecision()); - EXPECT_NEAR(0.20079750055570736, quantitativeCheckResult2.getMax(), storm::settings::getModule<storm::settings::modules::GeneralSettings>().getPrecision()); -} - -TEST(NativeHybridCtmcCslModelCheckerTest, Fms) { - - // No properties to check at this point. -} - -TEST(NativeHybridCtmcCslModelCheckerTest, Tandem_Cudd) { - - // Parse the model description. - storm::storage::SymbolicModelDescription modelDescription = storm::parser::PrismParser::parse(STORM_TEST_RESOURCES_DIR "/ctmc/tandem5.sm", true); - storm::prism::Program program = modelDescription.preprocess().asPrismProgram(); - storm::parser::FormulaParser formulaParser(program); - std::shared_ptr<storm::logic::Formula const> formula(nullptr); - - // Build the model with the customers reward structure. -#ifdef WINDOWS - storm::builder::DdPrismModelBuilder<storm::dd::DdType::CUDD>::Options options; -#else - typename storm::builder::DdPrismModelBuilder<storm::dd::DdType::CUDD>::Options options; -#endif - options.buildAllRewardModels = false; - options.rewardModelsToBuild.insert("customers"); - std::shared_ptr<storm::models::symbolic::Model<storm::dd::DdType::CUDD>> model = storm::builder::DdPrismModelBuilder<storm::dd::DdType::CUDD>().build(program, options); - ASSERT_EQ(storm::models::ModelType::Ctmc, model->getType()); - std::shared_ptr<storm::models::symbolic::Ctmc<storm::dd::DdType::CUDD>> ctmc = model->as<storm::models::symbolic::Ctmc<storm::dd::DdType::CUDD>>(); - - // Create model checker. - storm::modelchecker::HybridCtmcCslModelChecker<storm::models::symbolic::Ctmc<storm::dd::DdType::CUDD, double>> modelchecker(*ctmc, std::make_unique<storm::solver::NativeLinearEquationSolverFactory<double>>()); - - // Start checking properties. - formula = formulaParser.parseSingleFormulaFromString("P=? [ F<=10 \"network_full\" ]"); - std::unique_ptr<storm::modelchecker::CheckResult> checkResult = modelchecker.check(*formula); - - ASSERT_TRUE(checkResult->isHybridQuantitativeCheckResult()); - checkResult->filter(storm::modelchecker::SymbolicQualitativeCheckResult<storm::dd::DdType::CUDD>(ctmc->getReachableStates(), ctmc->getInitialStates())); - storm::modelchecker::HybridQuantitativeCheckResult<storm::dd::DdType::CUDD> quantitativeCheckResult1 = checkResult->asHybridQuantitativeCheckResult<storm::dd::DdType::CUDD, double>(); - EXPECT_NEAR(0.015446370562428037, quantitativeCheckResult1.getMin(), storm::settings::getModule<storm::settings::modules::GeneralSettings>().getPrecision()); - EXPECT_NEAR(0.015446370562428037, quantitativeCheckResult1.getMax(), storm::settings::getModule<storm::settings::modules::GeneralSettings>().getPrecision()); - - formula = formulaParser.parseSingleFormulaFromString("P=? [ F<=10 \"first_queue_full\" ]"); - checkResult = modelchecker.check(*formula); - - ASSERT_TRUE(checkResult->isHybridQuantitativeCheckResult()); - checkResult->filter(storm::modelchecker::SymbolicQualitativeCheckResult<storm::dd::DdType::CUDD>(ctmc->getReachableStates(), ctmc->getInitialStates())); - storm::modelchecker::HybridQuantitativeCheckResult<storm::dd::DdType::CUDD> quantitativeCheckResult2 = checkResult->asHybridQuantitativeCheckResult<storm::dd::DdType::CUDD, double>(); - EXPECT_NEAR(0.999999837225515, quantitativeCheckResult2.getMin(), storm::settings::getModule<storm::settings::modules::GeneralSettings>().getPrecision()); - EXPECT_NEAR(0.999999837225515, quantitativeCheckResult2.getMax(), storm::settings::getModule<storm::settings::modules::GeneralSettings>().getPrecision()); - - formula = formulaParser.parseSingleFormulaFromString("P=? [\"second_queue_full\" U<=1 !\"second_queue_full\"]"); - checkResult = modelchecker.check(*formula); - - ASSERT_TRUE(checkResult->isHybridQuantitativeCheckResult()); - checkResult->filter(storm::modelchecker::SymbolicQualitativeCheckResult<storm::dd::DdType::CUDD>(ctmc->getReachableStates(), ctmc->getInitialStates())); - storm::modelchecker::HybridQuantitativeCheckResult<storm::dd::DdType::CUDD> quantitativeCheckResult3 = checkResult->asHybridQuantitativeCheckResult<storm::dd::DdType::CUDD, double>(); - EXPECT_NEAR(1, quantitativeCheckResult3.getMin(), storm::settings::getModule<storm::settings::modules::GeneralSettings>().getPrecision()); - EXPECT_NEAR(1, quantitativeCheckResult3.getMax(), storm::settings::getModule<storm::settings::modules::GeneralSettings>().getPrecision()); - - formula = formulaParser.parseSingleFormulaFromString("R=? [I=10]"); - checkResult = modelchecker.check(*formula); - - ASSERT_TRUE(checkResult->isHybridQuantitativeCheckResult()); - checkResult->filter(storm::modelchecker::SymbolicQualitativeCheckResult<storm::dd::DdType::CUDD>(ctmc->getReachableStates(), ctmc->getInitialStates())); - storm::modelchecker::HybridQuantitativeCheckResult<storm::dd::DdType::CUDD> quantitativeCheckResult4 = checkResult->asHybridQuantitativeCheckResult<storm::dd::DdType::CUDD, double>(); - EXPECT_NEAR(5.679243850315877, quantitativeCheckResult4.getMin(), storm::settings::getModule<storm::settings::modules::GeneralSettings>().getPrecision()); - EXPECT_NEAR(5.679243850315877, quantitativeCheckResult4.getMax(), storm::settings::getModule<storm::settings::modules::GeneralSettings>().getPrecision()); - - formula = formulaParser.parseSingleFormulaFromString("R=? [C<=10]"); - checkResult = modelchecker.check(*formula); - - ASSERT_TRUE(checkResult->isHybridQuantitativeCheckResult()); - checkResult->filter(storm::modelchecker::SymbolicQualitativeCheckResult<storm::dd::DdType::CUDD>(ctmc->getReachableStates(), ctmc->getInitialStates())); - storm::modelchecker::HybridQuantitativeCheckResult<storm::dd::DdType::CUDD> quantitativeCheckResult5 = checkResult->asHybridQuantitativeCheckResult<storm::dd::DdType::CUDD, double>(); - EXPECT_NEAR(55.44792186036232, quantitativeCheckResult5.getMin(), storm::settings::getModule<storm::settings::modules::GeneralSettings>().getPrecision()); - EXPECT_NEAR(55.44792186036232, quantitativeCheckResult5.getMax(), storm::settings::getModule<storm::settings::modules::GeneralSettings>().getPrecision()); - - formula = formulaParser.parseSingleFormulaFromString("R=? [F \"first_queue_full\"&\"second_queue_full\"]"); - checkResult = modelchecker.check(*formula); - - ASSERT_TRUE(checkResult->isHybridQuantitativeCheckResult()); - checkResult->filter(storm::modelchecker::SymbolicQualitativeCheckResult<storm::dd::DdType::CUDD>(ctmc->getReachableStates(), ctmc->getInitialStates())); - storm::modelchecker::HybridQuantitativeCheckResult<storm::dd::DdType::CUDD> quantitativeCheckResult6 = checkResult->asHybridQuantitativeCheckResult<storm::dd::DdType::CUDD, double>(); - EXPECT_NEAR(262.78571505691389, quantitativeCheckResult6.getMin(), storm::settings::getModule<storm::settings::modules::GeneralSettings>().getPrecision()); - EXPECT_NEAR(262.78571505691389, quantitativeCheckResult6.getMax(), storm::settings::getModule<storm::settings::modules::GeneralSettings>().getPrecision()); - - formula = formulaParser.parseSingleFormulaFromString("LRA=? [\"first_queue_full\"]"); - checkResult = modelchecker.check(*formula); - - checkResult->filter(storm::modelchecker::SymbolicQualitativeCheckResult<storm::dd::DdType::CUDD>(ctmc->getReachableStates(), ctmc->getInitialStates())); - storm::modelchecker::HybridQuantitativeCheckResult<storm::dd::DdType::CUDD> quantitativeCheckResult7 = checkResult->asHybridQuantitativeCheckResult<storm::dd::DdType::CUDD, double>(); - - // FIXME: because of divergence, these results are not correct. -// EXPECT_NEAR(0.9100373532, quantitativeCheckResult7.getMin(), storm::settings::getModule<storm::settings::modules::GeneralSettings>().getPrecision()); -// EXPECT_NEAR(0.9100373532, quantitativeCheckResult7.getMax(), storm::settings::getModule<storm::settings::modules::GeneralSettings>().getPrecision()); -} - -TEST(NativeHybridCtmcCslModelCheckerTest, Tandem_Sylvan) { - // Parse the model description. - storm::storage::SymbolicModelDescription modelDescription = storm::parser::PrismParser::parse(STORM_TEST_RESOURCES_DIR "/ctmc/tandem5.sm", true); - storm::prism::Program program = modelDescription.preprocess().asPrismProgram(); - storm::parser::FormulaParser formulaParser(program); - std::shared_ptr<storm::logic::Formula const> formula(nullptr); - - // Build the model with the customers reward structure. -#ifdef WINDOWS - storm::builder::DdPrismModelBuilder<storm::dd::DdType::Sylvan>::Options options; -#else - typename storm::builder::DdPrismModelBuilder<storm::dd::DdType::Sylvan>::Options options; -#endif - options.buildAllRewardModels = false; - options.rewardModelsToBuild.insert("customers"); - std::shared_ptr<storm::models::symbolic::Model<storm::dd::DdType::Sylvan>> model = storm::builder::DdPrismModelBuilder<storm::dd::DdType::Sylvan>().build(program, options); - ASSERT_EQ(storm::models::ModelType::Ctmc, model->getType()); - std::shared_ptr<storm::models::symbolic::Ctmc<storm::dd::DdType::Sylvan>> ctmc = model->as<storm::models::symbolic::Ctmc<storm::dd::DdType::Sylvan>>(); - - // Create model checker. - storm::modelchecker::HybridCtmcCslModelChecker<storm::models::symbolic::Ctmc<storm::dd::DdType::Sylvan, double>> modelchecker(*ctmc, std::make_unique<storm::solver::NativeLinearEquationSolverFactory<double>>()); - - // Start checking properties. - formula = formulaParser.parseSingleFormulaFromString("P=? [ F<=10 \"network_full\" ]"); - std::unique_ptr<storm::modelchecker::CheckResult> checkResult = modelchecker.check(*formula); - - ASSERT_TRUE(checkResult->isHybridQuantitativeCheckResult()); - checkResult->filter(storm::modelchecker::SymbolicQualitativeCheckResult<storm::dd::DdType::Sylvan>(ctmc->getReachableStates(), ctmc->getInitialStates())); - storm::modelchecker::HybridQuantitativeCheckResult<storm::dd::DdType::Sylvan> quantitativeCheckResult1 = checkResult->asHybridQuantitativeCheckResult<storm::dd::DdType::Sylvan, double>(); - EXPECT_NEAR(0.015446370562428037, quantitativeCheckResult1.getMin(), storm::settings::getModule<storm::settings::modules::GeneralSettings>().getPrecision()); - EXPECT_NEAR(0.015446370562428037, quantitativeCheckResult1.getMax(), storm::settings::getModule<storm::settings::modules::GeneralSettings>().getPrecision()); - - formula = formulaParser.parseSingleFormulaFromString("P=? [ F<=10 \"first_queue_full\" ]"); - checkResult = modelchecker.check(*formula); - - ASSERT_TRUE(checkResult->isHybridQuantitativeCheckResult()); - checkResult->filter(storm::modelchecker::SymbolicQualitativeCheckResult<storm::dd::DdType::Sylvan>(ctmc->getReachableStates(), ctmc->getInitialStates())); - storm::modelchecker::HybridQuantitativeCheckResult<storm::dd::DdType::Sylvan> quantitativeCheckResult2 = checkResult->asHybridQuantitativeCheckResult<storm::dd::DdType::Sylvan, double>(); - EXPECT_NEAR(0.999999837225515, quantitativeCheckResult2.getMin(), storm::settings::getModule<storm::settings::modules::GeneralSettings>().getPrecision()); - EXPECT_NEAR(0.999999837225515, quantitativeCheckResult2.getMax(), storm::settings::getModule<storm::settings::modules::GeneralSettings>().getPrecision()); - - formula = formulaParser.parseSingleFormulaFromString("P=? [\"second_queue_full\" U<=1 !\"second_queue_full\"]"); - checkResult = modelchecker.check(*formula); - - ASSERT_TRUE(checkResult->isHybridQuantitativeCheckResult()); - checkResult->filter(storm::modelchecker::SymbolicQualitativeCheckResult<storm::dd::DdType::Sylvan>(ctmc->getReachableStates(), ctmc->getInitialStates())); - storm::modelchecker::HybridQuantitativeCheckResult<storm::dd::DdType::Sylvan> quantitativeCheckResult3 = checkResult->asHybridQuantitativeCheckResult<storm::dd::DdType::Sylvan, double>(); - EXPECT_NEAR(1, quantitativeCheckResult3.getMin(), storm::settings::getModule<storm::settings::modules::GeneralSettings>().getPrecision()); - EXPECT_NEAR(1, quantitativeCheckResult3.getMax(), storm::settings::getModule<storm::settings::modules::GeneralSettings>().getPrecision()); - - formula = formulaParser.parseSingleFormulaFromString("R=? [I=10]"); - checkResult = modelchecker.check(*formula); - - ASSERT_TRUE(checkResult->isHybridQuantitativeCheckResult()); - checkResult->filter(storm::modelchecker::SymbolicQualitativeCheckResult<storm::dd::DdType::Sylvan>(ctmc->getReachableStates(), ctmc->getInitialStates())); - storm::modelchecker::HybridQuantitativeCheckResult<storm::dd::DdType::Sylvan> quantitativeCheckResult4 = checkResult->asHybridQuantitativeCheckResult<storm::dd::DdType::Sylvan, double>(); - EXPECT_NEAR(5.679243850315877, quantitativeCheckResult4.getMin(), storm::settings::getModule<storm::settings::modules::GeneralSettings>().getPrecision()); - EXPECT_NEAR(5.679243850315877, quantitativeCheckResult4.getMax(), storm::settings::getModule<storm::settings::modules::GeneralSettings>().getPrecision()); - - formula = formulaParser.parseSingleFormulaFromString("R=? [C<=10]"); - checkResult = modelchecker.check(*formula); - - ASSERT_TRUE(checkResult->isHybridQuantitativeCheckResult()); - checkResult->filter(storm::modelchecker::SymbolicQualitativeCheckResult<storm::dd::DdType::Sylvan>(ctmc->getReachableStates(), ctmc->getInitialStates())); - storm::modelchecker::HybridQuantitativeCheckResult<storm::dd::DdType::Sylvan> quantitativeCheckResult5 = checkResult->asHybridQuantitativeCheckResult<storm::dd::DdType::Sylvan, double>(); - EXPECT_NEAR(55.44792186036232, quantitativeCheckResult5.getMin(), storm::settings::getModule<storm::settings::modules::GeneralSettings>().getPrecision()); - EXPECT_NEAR(55.44792186036232, quantitativeCheckResult5.getMax(), storm::settings::getModule<storm::settings::modules::GeneralSettings>().getPrecision()); - - formula = formulaParser.parseSingleFormulaFromString("R=? [F \"first_queue_full\"&\"second_queue_full\"]"); - checkResult = modelchecker.check(*formula); - - ASSERT_TRUE(checkResult->isHybridQuantitativeCheckResult()); - checkResult->filter(storm::modelchecker::SymbolicQualitativeCheckResult<storm::dd::DdType::Sylvan>(ctmc->getReachableStates(), ctmc->getInitialStates())); - storm::modelchecker::HybridQuantitativeCheckResult<storm::dd::DdType::Sylvan> quantitativeCheckResult6 = checkResult->asHybridQuantitativeCheckResult<storm::dd::DdType::Sylvan, double>(); - EXPECT_NEAR(262.78571505691389, quantitativeCheckResult6.getMin(), storm::settings::getModule<storm::settings::modules::GeneralSettings>().getPrecision()); - EXPECT_NEAR(262.78571505691389, quantitativeCheckResult6.getMax(), storm::settings::getModule<storm::settings::modules::GeneralSettings>().getPrecision()); - - formula = formulaParser.parseSingleFormulaFromString("LRA=? [\"first_queue_full\"]"); - checkResult = modelchecker.check(*formula); - - checkResult->filter(storm::modelchecker::SymbolicQualitativeCheckResult<storm::dd::DdType::Sylvan>(ctmc->getReachableStates(), ctmc->getInitialStates())); - storm::modelchecker::HybridQuantitativeCheckResult<storm::dd::DdType::Sylvan> quantitativeCheckResult7 = checkResult->asHybridQuantitativeCheckResult<storm::dd::DdType::Sylvan, double>(); - - // FIXME: because of divergence, these results are not correct. -// EXPECT_NEAR(0.9100373532, quantitativeCheckResult7.getMin(), storm::settings::getModule<storm::settings::modules::GeneralSettings>().getPrecision()); -// EXPECT_NEAR(0.9100373532, quantitativeCheckResult7.getMax(), storm::settings::getModule<storm::settings::modules::GeneralSettings>().getPrecision()); -} diff --git a/src/test/storm/modelchecker/NativeHybridDtmcPrctlModelCheckerTest.cpp b/src/test/storm/modelchecker/NativeHybridDtmcPrctlModelCheckerTest.cpp deleted file mode 100644 index 6398b2c1e..000000000 --- a/src/test/storm/modelchecker/NativeHybridDtmcPrctlModelCheckerTest.cpp +++ /dev/null @@ -1,339 +0,0 @@ -#include "gtest/gtest.h" -#include "storm-config.h" - -#include "storm/parser/FormulaParser.h" -#include "storm/logic/Formulas.h" -#include "storm/solver/NativeLinearEquationSolver.h" -#include "storm/storage/SymbolicModelDescription.h" -#include "storm/modelchecker/prctl/HybridDtmcPrctlModelChecker.h" -#include "storm/modelchecker/results/HybridQuantitativeCheckResult.h" -#include "storm/modelchecker/results/SymbolicQualitativeCheckResult.h" -#include "storm/modelchecker/results/SymbolicQuantitativeCheckResult.h" -#include "storm/parser/PrismParser.h" -#include "storm/builder/DdPrismModelBuilder.h" -#include "storm/models/symbolic/StandardRewardModel.h" -#include "storm/models/symbolic/Dtmc.h" -#include "storm/settings/SettingsManager.h" -#include "storm/settings/modules/GeneralSettings.h" -#include "storm/settings/modules/GmmxxEquationSolverSettings.h" -#include "storm/settings/modules/NativeEquationSolverSettings.h" - -TEST(NativeHybridDtmcPrctlModelCheckerTest, Die_Cudd) { - storm::storage::SymbolicModelDescription modelDescription = storm::parser::PrismParser::parse(STORM_TEST_RESOURCES_DIR "/dtmc/die.pm"); - storm::prism::Program program = modelDescription.preprocess().asPrismProgram(); - - // A parser that we use for conveniently constructing the formulas. - storm::parser::FormulaParser formulaParser; - - // Build the die model with its reward model. -#ifdef WINDOWS - storm::builder::DdPrismModelBuilder<storm::dd::DdType::CUDD>::Options options; -#else - typename storm::builder::DdPrismModelBuilder<storm::dd::DdType::CUDD>::Options options; -#endif - options.buildAllRewardModels = false; - options.rewardModelsToBuild.insert("coin_flips"); - std::shared_ptr<storm::models::symbolic::Model<storm::dd::DdType::CUDD>> model = storm::builder::DdPrismModelBuilder<storm::dd::DdType::CUDD>().build(program, options); - EXPECT_EQ(13ul, model->getNumberOfStates()); - EXPECT_EQ(20ul, model->getNumberOfTransitions()); - - ASSERT_EQ(model->getType(), storm::models::ModelType::Dtmc); - - std::shared_ptr<storm::models::symbolic::Dtmc<storm::dd::DdType::CUDD>> dtmc = model->as<storm::models::symbolic::Dtmc<storm::dd::DdType::CUDD>>(); - - storm::modelchecker::HybridDtmcPrctlModelChecker<storm::models::symbolic::Dtmc<storm::dd::DdType::CUDD, double>> checker(*dtmc, std::make_unique<storm::solver::NativeLinearEquationSolverFactory<double>>()); - - std::shared_ptr<storm::logic::Formula const> formula = formulaParser.parseSingleFormulaFromString("P=? [F \"one\"]"); - - std::unique_ptr<storm::modelchecker::CheckResult> result = checker.check(*formula); - result->filter(storm::modelchecker::SymbolicQualitativeCheckResult<storm::dd::DdType::CUDD>(model->getReachableStates(), model->getInitialStates())); - storm::modelchecker::HybridQuantitativeCheckResult<storm::dd::DdType::CUDD>& quantitativeResult1 = result->asHybridQuantitativeCheckResult<storm::dd::DdType::CUDD, double>(); - - EXPECT_NEAR(1.0/6.0, quantitativeResult1.getMin(), storm::settings::getModule<storm::settings::modules::GmmxxEquationSolverSettings>().getPrecision()); - EXPECT_NEAR(1.0/6.0, quantitativeResult1.getMax(), storm::settings::getModule<storm::settings::modules::GmmxxEquationSolverSettings>().getPrecision()); - - formula = formulaParser.parseSingleFormulaFromString("P=? [F \"two\"]"); - - result = checker.check(*formula); - result->filter(storm::modelchecker::SymbolicQualitativeCheckResult<storm::dd::DdType::CUDD>(model->getReachableStates(), model->getInitialStates())); - storm::modelchecker::HybridQuantitativeCheckResult<storm::dd::DdType::CUDD>& quantitativeResult2 = result->asHybridQuantitativeCheckResult<storm::dd::DdType::CUDD, double>(); - - EXPECT_NEAR(1.0/6.0, quantitativeResult2.getMin(), storm::settings::getModule<storm::settings::modules::GmmxxEquationSolverSettings>().getPrecision()); - EXPECT_NEAR(1.0/6.0, quantitativeResult2.getMax(), storm::settings::getModule<storm::settings::modules::GmmxxEquationSolverSettings>().getPrecision()); - - formula = formulaParser.parseSingleFormulaFromString("P=? [F \"three\"]"); - - result = checker.check(*formula); - result->filter(storm::modelchecker::SymbolicQualitativeCheckResult<storm::dd::DdType::CUDD>(model->getReachableStates(), model->getInitialStates())); - storm::modelchecker::HybridQuantitativeCheckResult<storm::dd::DdType::CUDD>& quantitativeResult3 = result->asHybridQuantitativeCheckResult<storm::dd::DdType::CUDD, double>(); - - EXPECT_NEAR(1.0/6.0, quantitativeResult3.getMin(), storm::settings::getModule<storm::settings::modules::GmmxxEquationSolverSettings>().getPrecision()); - EXPECT_NEAR(1.0/6.0, quantitativeResult3.getMax(), storm::settings::getModule<storm::settings::modules::GmmxxEquationSolverSettings>().getPrecision()); - - formula = formulaParser.parseSingleFormulaFromString("R=? [F \"done\"]"); - - result = checker.check(*formula); - result->filter(storm::modelchecker::SymbolicQualitativeCheckResult<storm::dd::DdType::CUDD>(model->getReachableStates(), model->getInitialStates())); - storm::modelchecker::HybridQuantitativeCheckResult<storm::dd::DdType::CUDD>& quantitativeResult4 = result->asHybridQuantitativeCheckResult<storm::dd::DdType::CUDD, double>(); - - EXPECT_NEAR(3.6666646003723145, quantitativeResult4.getMin(), storm::settings::getModule<storm::settings::modules::GmmxxEquationSolverSettings>().getPrecision()); - EXPECT_NEAR(3.6666646003723145, quantitativeResult4.getMax(), storm::settings::getModule<storm::settings::modules::GmmxxEquationSolverSettings>().getPrecision()); -} - -TEST(NativeHybridDtmcPrctlModelCheckerTest, Die_Sylvan) { - storm::storage::SymbolicModelDescription modelDescription = storm::parser::PrismParser::parse(STORM_TEST_RESOURCES_DIR "/dtmc/die.pm"); - storm::prism::Program program = modelDescription.preprocess().asPrismProgram(); - - // A parser that we use for conveniently constructing the formulas. - storm::parser::FormulaParser formulaParser; - - // Build the die model with its reward model. -#ifdef WINDOWS - storm::builder::DdPrismModelBuilder<storm::dd::DdType::Sylvan>::Options options; -#else - typename storm::builder::DdPrismModelBuilder<storm::dd::DdType::Sylvan>::Options options; -#endif - options.buildAllRewardModels = false; - options.rewardModelsToBuild.insert("coin_flips"); - std::shared_ptr<storm::models::symbolic::Model<storm::dd::DdType::Sylvan>> model = storm::builder::DdPrismModelBuilder<storm::dd::DdType::Sylvan>().build(program, options); - EXPECT_EQ(13ul, model->getNumberOfStates()); - EXPECT_EQ(20ul, model->getNumberOfTransitions()); - - ASSERT_EQ(model->getType(), storm::models::ModelType::Dtmc); - - std::shared_ptr<storm::models::symbolic::Dtmc<storm::dd::DdType::Sylvan>> dtmc = model->as<storm::models::symbolic::Dtmc<storm::dd::DdType::Sylvan>>(); - - storm::modelchecker::HybridDtmcPrctlModelChecker<storm::models::symbolic::Dtmc<storm::dd::DdType::Sylvan, double>> checker(*dtmc, std::make_unique<storm::solver::NativeLinearEquationSolverFactory<double>>()); - - std::shared_ptr<storm::logic::Formula const> formula = formulaParser.parseSingleFormulaFromString("P=? [F \"one\"]"); - - std::unique_ptr<storm::modelchecker::CheckResult> result = checker.check(*formula); - result->filter(storm::modelchecker::SymbolicQualitativeCheckResult<storm::dd::DdType::Sylvan>(model->getReachableStates(), model->getInitialStates())); - storm::modelchecker::HybridQuantitativeCheckResult<storm::dd::DdType::Sylvan>& quantitativeResult1 = result->asHybridQuantitativeCheckResult<storm::dd::DdType::Sylvan, double>(); - - EXPECT_NEAR(1.0/6.0, quantitativeResult1.getMin(), storm::settings::getModule<storm::settings::modules::GmmxxEquationSolverSettings>().getPrecision()); - EXPECT_NEAR(1.0/6.0, quantitativeResult1.getMax(), storm::settings::getModule<storm::settings::modules::GmmxxEquationSolverSettings>().getPrecision()); - - formula = formulaParser.parseSingleFormulaFromString("P=? [F \"two\"]"); - - result = checker.check(*formula); - result->filter(storm::modelchecker::SymbolicQualitativeCheckResult<storm::dd::DdType::Sylvan>(model->getReachableStates(), model->getInitialStates())); - storm::modelchecker::HybridQuantitativeCheckResult<storm::dd::DdType::Sylvan>& quantitativeResult2 = result->asHybridQuantitativeCheckResult<storm::dd::DdType::Sylvan, double>(); - - EXPECT_NEAR(1.0/6.0, quantitativeResult2.getMin(), storm::settings::getModule<storm::settings::modules::GmmxxEquationSolverSettings>().getPrecision()); - EXPECT_NEAR(1.0/6.0, quantitativeResult2.getMax(), storm::settings::getModule<storm::settings::modules::GmmxxEquationSolverSettings>().getPrecision()); - - formula = formulaParser.parseSingleFormulaFromString("P=? [F \"three\"]"); - - result = checker.check(*formula); - result->filter(storm::modelchecker::SymbolicQualitativeCheckResult<storm::dd::DdType::Sylvan>(model->getReachableStates(), model->getInitialStates())); - storm::modelchecker::HybridQuantitativeCheckResult<storm::dd::DdType::Sylvan>& quantitativeResult3 = result->asHybridQuantitativeCheckResult<storm::dd::DdType::Sylvan, double>(); - - EXPECT_NEAR(1.0/6.0, quantitativeResult3.getMin(), storm::settings::getModule<storm::settings::modules::GmmxxEquationSolverSettings>().getPrecision()); - EXPECT_NEAR(1.0/6.0, quantitativeResult3.getMax(), storm::settings::getModule<storm::settings::modules::GmmxxEquationSolverSettings>().getPrecision()); - - formula = formulaParser.parseSingleFormulaFromString("R=? [F \"done\"]"); - - result = checker.check(*formula); - result->filter(storm::modelchecker::SymbolicQualitativeCheckResult<storm::dd::DdType::Sylvan>(model->getReachableStates(), model->getInitialStates())); - storm::modelchecker::HybridQuantitativeCheckResult<storm::dd::DdType::Sylvan>& quantitativeResult4 = result->asHybridQuantitativeCheckResult<storm::dd::DdType::Sylvan, double>(); - - EXPECT_NEAR(3.6666646003723145, quantitativeResult4.getMin(), storm::settings::getModule<storm::settings::modules::GmmxxEquationSolverSettings>().getPrecision()); - EXPECT_NEAR(3.6666646003723145, quantitativeResult4.getMax(), storm::settings::getModule<storm::settings::modules::GmmxxEquationSolverSettings>().getPrecision()); -} - -TEST(NativeHybridDtmcPrctlModelCheckerTest, Crowds_Cudd) { - storm::storage::SymbolicModelDescription modelDescription = storm::parser::PrismParser::parse(STORM_TEST_RESOURCES_DIR "/dtmc/crowds-5-5.pm"); - storm::prism::Program program = modelDescription.preprocess().asPrismProgram(); - - // A parser that we use for conveniently constructing the formulas. - storm::parser::FormulaParser formulaParser; - - std::shared_ptr<storm::models::symbolic::Model<storm::dd::DdType::CUDD>> model = storm::builder::DdPrismModelBuilder<storm::dd::DdType::CUDD>().build(program); - EXPECT_EQ(8607ul, model->getNumberOfStates()); - EXPECT_EQ(15113ul, model->getNumberOfTransitions()); - - ASSERT_EQ(model->getType(), storm::models::ModelType::Dtmc); - - std::shared_ptr<storm::models::symbolic::Dtmc<storm::dd::DdType::CUDD>> dtmc = model->as<storm::models::symbolic::Dtmc<storm::dd::DdType::CUDD>>(); - - storm::modelchecker::HybridDtmcPrctlModelChecker<storm::models::symbolic::Dtmc<storm::dd::DdType::CUDD, double>> checker(*dtmc, std::make_unique<storm::solver::NativeLinearEquationSolverFactory<double>>()); - - std::shared_ptr<storm::logic::Formula const> formula = formulaParser.parseSingleFormulaFromString("P=? [F \"observe0Greater1\"]"); - - std::unique_ptr<storm::modelchecker::CheckResult> result = checker.check(*formula); - result->filter(storm::modelchecker::SymbolicQualitativeCheckResult<storm::dd::DdType::CUDD>(model->getReachableStates(), model->getInitialStates())); - storm::modelchecker::HybridQuantitativeCheckResult<storm::dd::DdType::CUDD>& quantitativeResult1 = result->asHybridQuantitativeCheckResult<storm::dd::DdType::CUDD, double>(); - - EXPECT_NEAR(0.33288205191646525, quantitativeResult1.getMin(), storm::settings::getModule<storm::settings::modules::GmmxxEquationSolverSettings>().getPrecision()); - EXPECT_NEAR(0.33288205191646525, quantitativeResult1.getMax(), storm::settings::getModule<storm::settings::modules::GmmxxEquationSolverSettings>().getPrecision()); - - formula = formulaParser.parseSingleFormulaFromString("P=? [F \"observeIGreater1\"]"); - - result = checker.check(*formula); - result->filter(storm::modelchecker::SymbolicQualitativeCheckResult<storm::dd::DdType::CUDD>(model->getReachableStates(), model->getInitialStates())); - storm::modelchecker::HybridQuantitativeCheckResult<storm::dd::DdType::CUDD>& quantitativeResult2 = result->asHybridQuantitativeCheckResult<storm::dd::DdType::CUDD, double>(); - - EXPECT_NEAR(0.15222066094730619, quantitativeResult2.getMin(), storm::settings::getModule<storm::settings::modules::GmmxxEquationSolverSettings>().getPrecision()); - EXPECT_NEAR(0.15222066094730619, quantitativeResult2.getMax(), storm::settings::getModule<storm::settings::modules::GmmxxEquationSolverSettings>().getPrecision()); - - formula = formulaParser.parseSingleFormulaFromString("P=? [F \"observeOnlyTrueSender\"]"); - - result = checker.check(*formula); - result->filter(storm::modelchecker::SymbolicQualitativeCheckResult<storm::dd::DdType::CUDD>(model->getReachableStates(), model->getInitialStates())); - storm::modelchecker::HybridQuantitativeCheckResult<storm::dd::DdType::CUDD>& quantitativeResult3 = result->asHybridQuantitativeCheckResult<storm::dd::DdType::CUDD, double>(); - - EXPECT_NEAR(0.32153900158185761, quantitativeResult3.getMin(), storm::settings::getModule<storm::settings::modules::GmmxxEquationSolverSettings>().getPrecision()); - EXPECT_NEAR(0.32153900158185761, quantitativeResult3.getMax(), storm::settings::getModule<storm::settings::modules::GmmxxEquationSolverSettings>().getPrecision()); -} - -TEST(NativeHybridDtmcPrctlModelCheckerTest, Crowds_Sylvan) { - storm::storage::SymbolicModelDescription modelDescription = storm::parser::PrismParser::parse(STORM_TEST_RESOURCES_DIR "/dtmc/crowds-5-5.pm"); - storm::prism::Program program = modelDescription.preprocess().asPrismProgram(); - - // A parser that we use for conveniently constructing the formulas. - storm::parser::FormulaParser formulaParser; - - std::shared_ptr<storm::models::symbolic::Model<storm::dd::DdType::Sylvan>> model = storm::builder::DdPrismModelBuilder<storm::dd::DdType::Sylvan>().build(program); - EXPECT_EQ(8607ul, model->getNumberOfStates()); - EXPECT_EQ(15113ul, model->getNumberOfTransitions()); - - ASSERT_EQ(model->getType(), storm::models::ModelType::Dtmc); - - std::shared_ptr<storm::models::symbolic::Dtmc<storm::dd::DdType::Sylvan>> dtmc = model->as<storm::models::symbolic::Dtmc<storm::dd::DdType::Sylvan>>(); - - storm::modelchecker::HybridDtmcPrctlModelChecker<storm::models::symbolic::Dtmc<storm::dd::DdType::Sylvan, double>> checker(*dtmc, std::make_unique<storm::solver::NativeLinearEquationSolverFactory<double>>()); - - std::shared_ptr<storm::logic::Formula const> formula = formulaParser.parseSingleFormulaFromString("P=? [F \"observe0Greater1\"]"); - - std::unique_ptr<storm::modelchecker::CheckResult> result = checker.check(*formula); - result->filter(storm::modelchecker::SymbolicQualitativeCheckResult<storm::dd::DdType::Sylvan>(model->getReachableStates(), model->getInitialStates())); - storm::modelchecker::HybridQuantitativeCheckResult<storm::dd::DdType::Sylvan>& quantitativeResult1 = result->asHybridQuantitativeCheckResult<storm::dd::DdType::Sylvan, double>(); - - EXPECT_NEAR(0.33288205191646525, quantitativeResult1.getMin(), storm::settings::getModule<storm::settings::modules::GmmxxEquationSolverSettings>().getPrecision()); - EXPECT_NEAR(0.33288205191646525, quantitativeResult1.getMax(), storm::settings::getModule<storm::settings::modules::GmmxxEquationSolverSettings>().getPrecision()); - - formula = formulaParser.parseSingleFormulaFromString("P=? [F \"observeIGreater1\"]"); - - result = checker.check(*formula); - result->filter(storm::modelchecker::SymbolicQualitativeCheckResult<storm::dd::DdType::Sylvan>(model->getReachableStates(), model->getInitialStates())); - storm::modelchecker::HybridQuantitativeCheckResult<storm::dd::DdType::Sylvan>& quantitativeResult2 = result->asHybridQuantitativeCheckResult<storm::dd::DdType::Sylvan, double>(); - - EXPECT_NEAR(0.15222066094730619, quantitativeResult2.getMin(), storm::settings::getModule<storm::settings::modules::GmmxxEquationSolverSettings>().getPrecision()); - EXPECT_NEAR(0.15222066094730619, quantitativeResult2.getMax(), storm::settings::getModule<storm::settings::modules::GmmxxEquationSolverSettings>().getPrecision()); - - formula = formulaParser.parseSingleFormulaFromString("P=? [F \"observeOnlyTrueSender\"]"); - - result = checker.check(*formula); - result->filter(storm::modelchecker::SymbolicQualitativeCheckResult<storm::dd::DdType::Sylvan>(model->getReachableStates(), model->getInitialStates())); - storm::modelchecker::HybridQuantitativeCheckResult<storm::dd::DdType::Sylvan>& quantitativeResult3 = result->asHybridQuantitativeCheckResult<storm::dd::DdType::Sylvan, double>(); - - EXPECT_NEAR(0.32153900158185761, quantitativeResult3.getMin(), storm::settings::getModule<storm::settings::modules::GmmxxEquationSolverSettings>().getPrecision()); - EXPECT_NEAR(0.32153900158185761, quantitativeResult3.getMax(), storm::settings::getModule<storm::settings::modules::GmmxxEquationSolverSettings>().getPrecision()); -} - -TEST(NativeHybridDtmcPrctlModelCheckerTest, SynchronousLeader_Cudd) { - storm::storage::SymbolicModelDescription modelDescription = storm::parser::PrismParser::parse(STORM_TEST_RESOURCES_DIR "/dtmc/leader-3-5.pm"); - storm::prism::Program program = modelDescription.preprocess().asPrismProgram(); - - // A parser that we use for conveniently constructing the formulas. - storm::parser::FormulaParser formulaParser; - - // Build the die model with its reward model. -#ifdef WINDOWS - storm::builder::DdPrismModelBuilder<storm::dd::DdType::CUDD>::Options options; -#else - typename storm::builder::DdPrismModelBuilder<storm::dd::DdType::CUDD>::Options options; -#endif - options.buildAllRewardModels = false; - options.rewardModelsToBuild.insert("num_rounds"); - std::shared_ptr<storm::models::symbolic::Model<storm::dd::DdType::CUDD>> model = storm::builder::DdPrismModelBuilder<storm::dd::DdType::CUDD>().build(program, options); - EXPECT_EQ(273ul, model->getNumberOfStates()); - EXPECT_EQ(397ul, model->getNumberOfTransitions()); - - ASSERT_EQ(model->getType(), storm::models::ModelType::Dtmc); - - std::shared_ptr<storm::models::symbolic::Dtmc<storm::dd::DdType::CUDD>> dtmc = model->as<storm::models::symbolic::Dtmc<storm::dd::DdType::CUDD>>(); - - storm::modelchecker::HybridDtmcPrctlModelChecker<storm::models::symbolic::Dtmc<storm::dd::DdType::CUDD, double>> checker(*dtmc, std::make_unique<storm::solver::NativeLinearEquationSolverFactory<double>>()); - - std::shared_ptr<storm::logic::Formula const> formula = formulaParser.parseSingleFormulaFromString("P=? [F \"elected\"]"); - - std::unique_ptr<storm::modelchecker::CheckResult> result = checker.check(*formula); - result->filter(storm::modelchecker::SymbolicQualitativeCheckResult<storm::dd::DdType::CUDD>(model->getReachableStates(), model->getInitialStates())); - storm::modelchecker::SymbolicQuantitativeCheckResult<storm::dd::DdType::CUDD>& quantitativeResult1 = result->asSymbolicQuantitativeCheckResult<storm::dd::DdType::CUDD, double>(); - - EXPECT_NEAR(1.0, quantitativeResult1.getMin(), storm::settings::getModule<storm::settings::modules::GmmxxEquationSolverSettings>().getPrecision()); - EXPECT_NEAR(1.0, quantitativeResult1.getMax(), storm::settings::getModule<storm::settings::modules::GmmxxEquationSolverSettings>().getPrecision()); - - formula = formulaParser.parseSingleFormulaFromString("P=? [F<=20 \"elected\"]"); - - result = checker.check(*formula); - result->filter(storm::modelchecker::SymbolicQualitativeCheckResult<storm::dd::DdType::CUDD>(model->getReachableStates(), model->getInitialStates())); - storm::modelchecker::HybridQuantitativeCheckResult<storm::dd::DdType::CUDD>& quantitativeResult2 = result->asHybridQuantitativeCheckResult<storm::dd::DdType::CUDD, double>(); - - EXPECT_NEAR(0.99999989760000074, quantitativeResult2.getMin(), storm::settings::getModule<storm::settings::modules::GmmxxEquationSolverSettings>().getPrecision()); - EXPECT_NEAR(0.99999989760000074, quantitativeResult2.getMax(), storm::settings::getModule<storm::settings::modules::GmmxxEquationSolverSettings>().getPrecision()); - - formula = formulaParser.parseSingleFormulaFromString("R=? [F \"elected\"]"); - - result = checker.check(*formula); - result->filter(storm::modelchecker::SymbolicQualitativeCheckResult<storm::dd::DdType::CUDD>(model->getReachableStates(), model->getInitialStates())); - storm::modelchecker::HybridQuantitativeCheckResult<storm::dd::DdType::CUDD>& quantitativeResult3 = result->asHybridQuantitativeCheckResult<storm::dd::DdType::CUDD, double>(); - - EXPECT_NEAR(1.0416666666666643, quantitativeResult3.getMin(), storm::settings::getModule<storm::settings::modules::GmmxxEquationSolverSettings>().getPrecision()); - EXPECT_NEAR(1.0416666666666643, quantitativeResult3.getMax(), storm::settings::getModule<storm::settings::modules::GmmxxEquationSolverSettings>().getPrecision()); -} - -TEST(NativeHybridDtmcPrctlModelCheckerTest, SynchronousLeader_Sylvan) { - storm::storage::SymbolicModelDescription modelDescription = storm::parser::PrismParser::parse(STORM_TEST_RESOURCES_DIR "/dtmc/leader-3-5.pm"); - storm::prism::Program program = modelDescription.preprocess().asPrismProgram(); - - // A parser that we use for conveniently constructing the formulas. - storm::parser::FormulaParser formulaParser; - - // Build the die model with its reward model. -#ifdef WINDOWS - storm::builder::DdPrismModelBuilder<storm::dd::DdType::Sylvan>::Options options; -#else - typename storm::builder::DdPrismModelBuilder<storm::dd::DdType::Sylvan>::Options options; -#endif - options.buildAllRewardModels = false; - options.rewardModelsToBuild.insert("num_rounds"); - std::shared_ptr<storm::models::symbolic::Model<storm::dd::DdType::Sylvan>> model = storm::builder::DdPrismModelBuilder<storm::dd::DdType::Sylvan>().build(program, options); - EXPECT_EQ(273ul, model->getNumberOfStates()); - EXPECT_EQ(397ul, model->getNumberOfTransitions()); - - ASSERT_EQ(model->getType(), storm::models::ModelType::Dtmc); - - std::shared_ptr<storm::models::symbolic::Dtmc<storm::dd::DdType::Sylvan>> dtmc = model->as<storm::models::symbolic::Dtmc<storm::dd::DdType::Sylvan>>(); - - storm::modelchecker::HybridDtmcPrctlModelChecker<storm::models::symbolic::Dtmc<storm::dd::DdType::Sylvan, double>> checker(*dtmc, std::make_unique<storm::solver::NativeLinearEquationSolverFactory<double>>()); - - std::shared_ptr<storm::logic::Formula const> formula = formulaParser.parseSingleFormulaFromString("P=? [F \"elected\"]"); - - std::unique_ptr<storm::modelchecker::CheckResult> result = checker.check(*formula); - result->filter(storm::modelchecker::SymbolicQualitativeCheckResult<storm::dd::DdType::Sylvan>(model->getReachableStates(), model->getInitialStates())); - storm::modelchecker::SymbolicQuantitativeCheckResult<storm::dd::DdType::Sylvan>& quantitativeResult1 = result->asSymbolicQuantitativeCheckResult<storm::dd::DdType::Sylvan, double>(); - - EXPECT_NEAR(1.0, quantitativeResult1.getMin(), storm::settings::getModule<storm::settings::modules::GmmxxEquationSolverSettings>().getPrecision()); - EXPECT_NEAR(1.0, quantitativeResult1.getMax(), storm::settings::getModule<storm::settings::modules::GmmxxEquationSolverSettings>().getPrecision()); - - formula = formulaParser.parseSingleFormulaFromString("P=? [F<=20 \"elected\"]"); - - result = checker.check(*formula); - result->filter(storm::modelchecker::SymbolicQualitativeCheckResult<storm::dd::DdType::Sylvan>(model->getReachableStates(), model->getInitialStates())); - storm::modelchecker::HybridQuantitativeCheckResult<storm::dd::DdType::Sylvan>& quantitativeResult2 = result->asHybridQuantitativeCheckResult<storm::dd::DdType::Sylvan, double>(); - - EXPECT_NEAR(0.99999989760000074, quantitativeResult2.getMin(), storm::settings::getModule<storm::settings::modules::GmmxxEquationSolverSettings>().getPrecision()); - EXPECT_NEAR(0.99999989760000074, quantitativeResult2.getMax(), storm::settings::getModule<storm::settings::modules::GmmxxEquationSolverSettings>().getPrecision()); - - formula = formulaParser.parseSingleFormulaFromString("R=? [F \"elected\"]"); - - result = checker.check(*formula); - result->filter(storm::modelchecker::SymbolicQualitativeCheckResult<storm::dd::DdType::Sylvan>(model->getReachableStates(), model->getInitialStates())); - storm::modelchecker::HybridQuantitativeCheckResult<storm::dd::DdType::Sylvan>& quantitativeResult3 = result->asHybridQuantitativeCheckResult<storm::dd::DdType::Sylvan, double>(); - - EXPECT_NEAR(1.0416666666666643, quantitativeResult3.getMin(), storm::settings::getModule<storm::settings::modules::GmmxxEquationSolverSettings>().getPrecision()); - EXPECT_NEAR(1.0416666666666643, quantitativeResult3.getMax(), storm::settings::getModule<storm::settings::modules::GmmxxEquationSolverSettings>().getPrecision()); -} diff --git a/src/test/storm/modelchecker/SymbolicDtmcPrctlModelCheckerTest.cpp b/src/test/storm/modelchecker/SymbolicDtmcPrctlModelCheckerTest.cpp deleted file mode 100644 index 97ed361ce..000000000 --- a/src/test/storm/modelchecker/SymbolicDtmcPrctlModelCheckerTest.cpp +++ /dev/null @@ -1,460 +0,0 @@ -#include "gtest/gtest.h" -#include "storm-config.h" - -#include "storm/parser/FormulaParser.h" -#include "storm/logic/Formulas.h" -#include "storm/utility/solver.h" -#include "storm/storage/SymbolicModelDescription.h" -#include "storm/modelchecker/prctl/SymbolicDtmcPrctlModelChecker.h" -#include "storm/modelchecker/results/SymbolicQualitativeCheckResult.h" -#include "storm/modelchecker/results/SymbolicQuantitativeCheckResult.h" -#include "storm/solver/SymbolicEliminationLinearEquationSolver.h" -#include "storm/parser/PrismParser.h" -#include "storm/builder/DdPrismModelBuilder.h" -#include "storm/models/symbolic/StandardRewardModel.h" -#include "storm/models/symbolic/Dtmc.h" -#include "storm/settings/SettingsManager.h" - -#include "storm/settings/modules/NativeEquationSolverSettings.h" - -#include "storm/settings/modules/GeneralSettings.h" - -TEST(SymbolicDtmcPrctlModelCheckerTest, Die_Cudd) { - storm::storage::SymbolicModelDescription modelDescription = storm::parser::PrismParser::parse(STORM_TEST_RESOURCES_DIR "/dtmc/die.pm"); - storm::prism::Program program = modelDescription.preprocess().asPrismProgram(); - - // A parser that we use for conveniently constructing the formulas. - storm::parser::FormulaParser formulaParser; - - // Build the die model with its reward model. -#ifdef WINDOWS - storm::builder::DdPrismModelBuilder<storm::dd::DdType::CUDD>::Options options; -#else - typename storm::builder::DdPrismModelBuilder<storm::dd::DdType::CUDD>::Options options; -#endif - options.buildAllRewardModels = false; - options.rewardModelsToBuild.insert("coin_flips"); - std::shared_ptr<storm::models::symbolic::Model<storm::dd::DdType::CUDD>> model = storm::builder::DdPrismModelBuilder<storm::dd::DdType::CUDD>().build(program, options); - EXPECT_EQ(13ul, model->getNumberOfStates()); - EXPECT_EQ(20ul, model->getNumberOfTransitions()); - - ASSERT_EQ(model->getType(), storm::models::ModelType::Dtmc); - - std::shared_ptr<storm::models::symbolic::Dtmc<storm::dd::DdType::CUDD>> dtmc = model->as<storm::models::symbolic::Dtmc<storm::dd::DdType::CUDD>>(); - - storm::modelchecker::SymbolicDtmcPrctlModelChecker<storm::models::symbolic::Dtmc<storm::dd::DdType::CUDD, double>> checker(*dtmc, std::unique_ptr<storm::solver::SymbolicLinearEquationSolverFactory<storm::dd::DdType::CUDD, double>>(new storm::solver::GeneralSymbolicLinearEquationSolverFactory<storm::dd::DdType::CUDD, double>())); - - std::shared_ptr<storm::logic::Formula const> formula = formulaParser.parseSingleFormulaFromString("P=? [F \"one\"]"); - - std::unique_ptr<storm::modelchecker::CheckResult> result = checker.check(*formula); - result->filter(storm::modelchecker::SymbolicQualitativeCheckResult<storm::dd::DdType::CUDD>(model->getReachableStates(), model->getInitialStates())); - storm::modelchecker::SymbolicQuantitativeCheckResult<storm::dd::DdType::CUDD>& quantitativeResult1 = result->asSymbolicQuantitativeCheckResult<storm::dd::DdType::CUDD, double>(); - - EXPECT_NEAR(1.0/6.0, quantitativeResult1.getMin(), storm::settings::getModule<storm::settings::modules::NativeEquationSolverSettings>().getPrecision()); - EXPECT_NEAR(1.0/6.0, quantitativeResult1.getMax(), storm::settings::getModule<storm::settings::modules::NativeEquationSolverSettings>().getPrecision()); - - formula = formulaParser.parseSingleFormulaFromString("P=? [F \"two\"]"); - - result = checker.check(*formula); - result->filter(storm::modelchecker::SymbolicQualitativeCheckResult<storm::dd::DdType::CUDD>(model->getReachableStates(), model->getInitialStates())); - storm::modelchecker::SymbolicQuantitativeCheckResult<storm::dd::DdType::CUDD>& quantitativeResult2 = result->asSymbolicQuantitativeCheckResult<storm::dd::DdType::CUDD, double>(); - - EXPECT_NEAR(1.0/6.0, quantitativeResult2.getMin(), storm::settings::getModule<storm::settings::modules::NativeEquationSolverSettings>().getPrecision()); - EXPECT_NEAR(1.0/6.0, quantitativeResult2.getMax(), storm::settings::getModule<storm::settings::modules::NativeEquationSolverSettings>().getPrecision()); - - formula = formulaParser.parseSingleFormulaFromString("P=? [F \"three\"]"); - - result = checker.check(*formula); - result->filter(storm::modelchecker::SymbolicQualitativeCheckResult<storm::dd::DdType::CUDD>(model->getReachableStates(), model->getInitialStates())); - storm::modelchecker::SymbolicQuantitativeCheckResult<storm::dd::DdType::CUDD>& quantitativeResult3 = result->asSymbolicQuantitativeCheckResult<storm::dd::DdType::CUDD, double>(); - - EXPECT_NEAR(1.0/6.0, quantitativeResult3.getMin(), storm::settings::getModule<storm::settings::modules::NativeEquationSolverSettings>().getPrecision()); - EXPECT_NEAR(1.0/6.0, quantitativeResult3.getMax(), storm::settings::getModule<storm::settings::modules::NativeEquationSolverSettings>().getPrecision()); - - formula = formulaParser.parseSingleFormulaFromString("R=? [F \"done\"]"); - - result = checker.check(*formula); - result->filter(storm::modelchecker::SymbolicQualitativeCheckResult<storm::dd::DdType::CUDD>(model->getReachableStates(), model->getInitialStates())); - storm::modelchecker::SymbolicQuantitativeCheckResult<storm::dd::DdType::CUDD>& quantitativeResult4 = result->asSymbolicQuantitativeCheckResult<storm::dd::DdType::CUDD, double>(); - - EXPECT_NEAR(3.6666646003723145, quantitativeResult4.getMin(), storm::settings::getModule<storm::settings::modules::NativeEquationSolverSettings>().getPrecision()); - EXPECT_NEAR(3.6666646003723145, quantitativeResult4.getMax(), storm::settings::getModule<storm::settings::modules::NativeEquationSolverSettings>().getPrecision()); -} - -TEST(SymbolicDtmcPrctlModelCheckerTest, Die_Sylvan) { - storm::storage::SymbolicModelDescription modelDescription = storm::parser::PrismParser::parse(STORM_TEST_RESOURCES_DIR "/dtmc/die.pm"); - storm::prism::Program program = modelDescription.preprocess().asPrismProgram(); - - // A parser that we use for conveniently constructing the formulas. - storm::parser::FormulaParser formulaParser; - - // Build the die model with its reward model. -#ifdef WINDOWS - storm::builder::DdPrismModelBuilder<storm::dd::DdType::Sylvan>::Options options; -#else - typename storm::builder::DdPrismModelBuilder<storm::dd::DdType::Sylvan>::Options options; -#endif - options.buildAllRewardModels = false; - options.rewardModelsToBuild.insert("coin_flips"); - std::shared_ptr<storm::models::symbolic::Model<storm::dd::DdType::Sylvan>> model = storm::builder::DdPrismModelBuilder<storm::dd::DdType::Sylvan>().build(program, options); - EXPECT_EQ(13ul, model->getNumberOfStates()); - EXPECT_EQ(20ul, model->getNumberOfTransitions()); - - ASSERT_EQ(model->getType(), storm::models::ModelType::Dtmc); - - std::shared_ptr<storm::models::symbolic::Dtmc<storm::dd::DdType::Sylvan>> dtmc = model->as<storm::models::symbolic::Dtmc<storm::dd::DdType::Sylvan>>(); - - storm::modelchecker::SymbolicDtmcPrctlModelChecker<storm::models::symbolic::Dtmc<storm::dd::DdType::Sylvan, double>> checker(*dtmc, std::unique_ptr<storm::solver::SymbolicLinearEquationSolverFactory<storm::dd::DdType::Sylvan, double>>(new storm::solver::GeneralSymbolicLinearEquationSolverFactory<storm::dd::DdType::Sylvan, double>())); - - std::shared_ptr<storm::logic::Formula const> formula = formulaParser.parseSingleFormulaFromString("P=? [F \"one\"]"); - - std::unique_ptr<storm::modelchecker::CheckResult> result = checker.check(*formula); - result->filter(storm::modelchecker::SymbolicQualitativeCheckResult<storm::dd::DdType::Sylvan>(model->getReachableStates(), model->getInitialStates())); - storm::modelchecker::SymbolicQuantitativeCheckResult<storm::dd::DdType::Sylvan>& quantitativeResult1 = result->asSymbolicQuantitativeCheckResult<storm::dd::DdType::Sylvan, double>(); - - EXPECT_NEAR(1.0/6.0, quantitativeResult1.getMin(), storm::settings::getModule<storm::settings::modules::NativeEquationSolverSettings>().getPrecision()); - EXPECT_NEAR(1.0/6.0, quantitativeResult1.getMax(), storm::settings::getModule<storm::settings::modules::NativeEquationSolverSettings>().getPrecision()); - - formula = formulaParser.parseSingleFormulaFromString("P=? [F \"two\"]"); - - result = checker.check(*formula); - result->filter(storm::modelchecker::SymbolicQualitativeCheckResult<storm::dd::DdType::Sylvan>(model->getReachableStates(), model->getInitialStates())); - storm::modelchecker::SymbolicQuantitativeCheckResult<storm::dd::DdType::Sylvan>& quantitativeResult2 = result->asSymbolicQuantitativeCheckResult<storm::dd::DdType::Sylvan, double>(); - - EXPECT_NEAR(1.0/6.0, quantitativeResult2.getMin(), storm::settings::getModule<storm::settings::modules::NativeEquationSolverSettings>().getPrecision()); - EXPECT_NEAR(1.0/6.0, quantitativeResult2.getMax(), storm::settings::getModule<storm::settings::modules::NativeEquationSolverSettings>().getPrecision()); - - formula = formulaParser.parseSingleFormulaFromString("P=? [F \"three\"]"); - - result = checker.check(*formula); - result->filter(storm::modelchecker::SymbolicQualitativeCheckResult<storm::dd::DdType::Sylvan>(model->getReachableStates(), model->getInitialStates())); - storm::modelchecker::SymbolicQuantitativeCheckResult<storm::dd::DdType::Sylvan>& quantitativeResult3 = result->asSymbolicQuantitativeCheckResult<storm::dd::DdType::Sylvan, double>(); - - EXPECT_NEAR(1.0/6.0, quantitativeResult3.getMin(), storm::settings::getModule<storm::settings::modules::NativeEquationSolverSettings>().getPrecision()); - EXPECT_NEAR(1.0/6.0, quantitativeResult3.getMax(), storm::settings::getModule<storm::settings::modules::NativeEquationSolverSettings>().getPrecision()); - - formula = formulaParser.parseSingleFormulaFromString("R=? [F \"done\"]"); - - result = checker.check(*formula); - result->filter(storm::modelchecker::SymbolicQualitativeCheckResult<storm::dd::DdType::Sylvan>(model->getReachableStates(), model->getInitialStates())); - storm::modelchecker::SymbolicQuantitativeCheckResult<storm::dd::DdType::Sylvan>& quantitativeResult4 = result->asSymbolicQuantitativeCheckResult<storm::dd::DdType::Sylvan, double>(); - - // FIXME: precision is not optimal. - EXPECT_NEAR(3.6666622161865234, quantitativeResult4.getMin(), 10 * storm::settings::getModule<storm::settings::modules::NativeEquationSolverSettings>().getPrecision()); - EXPECT_NEAR(3.6666622161865234, quantitativeResult4.getMax(), 10 * storm::settings::getModule<storm::settings::modules::NativeEquationSolverSettings>().getPrecision()); -} - -TEST(SymbolicDtmcPrctlModelCheckerTest, Die_RationalNumber_Sylvan) { - storm::storage::SymbolicModelDescription modelDescription = storm::parser::PrismParser::parse(STORM_TEST_RESOURCES_DIR "/dtmc/die.pm"); - storm::prism::Program program = modelDescription.preprocess().asPrismProgram(); - - // A parser that we use for conveniently constructing the formulas. - storm::parser::FormulaParser formulaParser; - - // Build the die model with its reward model. - typename storm::builder::DdPrismModelBuilder<storm::dd::DdType::Sylvan, storm::RationalNumber>::Options options; - options.buildAllRewardModels = false; - options.rewardModelsToBuild.insert("coin_flips"); - std::shared_ptr<storm::models::symbolic::Model<storm::dd::DdType::Sylvan, storm::RationalNumber>> model = storm::builder::DdPrismModelBuilder<storm::dd::DdType::Sylvan, storm::RationalNumber>().build(program, options); - EXPECT_EQ(13ul, model->getNumberOfStates()); - EXPECT_EQ(20ul, model->getNumberOfTransitions()); - - ASSERT_EQ(model->getType(), storm::models::ModelType::Dtmc); - - std::shared_ptr<storm::models::symbolic::Dtmc<storm::dd::DdType::Sylvan, storm::RationalNumber>> dtmc = model->as<storm::models::symbolic::Dtmc<storm::dd::DdType::Sylvan, storm::RationalNumber>>(); - - storm::modelchecker::SymbolicDtmcPrctlModelChecker<storm::models::symbolic::Dtmc<storm::dd::DdType::Sylvan, storm::RationalNumber>> checker(*dtmc, std::unique_ptr<storm::solver::SymbolicLinearEquationSolverFactory<storm::dd::DdType::Sylvan, storm::RationalNumber>>(new storm::solver::SymbolicEliminationLinearEquationSolverFactory<storm::dd::DdType::Sylvan, storm::RationalNumber>())); - - std::shared_ptr<storm::logic::Formula const> formula = formulaParser.parseSingleFormulaFromString("P=? [F \"one\"]"); - - std::unique_ptr<storm::modelchecker::CheckResult> result = checker.check(*formula); - result->filter(storm::modelchecker::SymbolicQualitativeCheckResult<storm::dd::DdType::Sylvan>(model->getReachableStates(), model->getInitialStates())); - storm::modelchecker::SymbolicQuantitativeCheckResult<storm::dd::DdType::Sylvan, storm::RationalNumber>& quantitativeResult1 = result->asSymbolicQuantitativeCheckResult<storm::dd::DdType::Sylvan, storm::RationalNumber>(); - - EXPECT_EQ(quantitativeResult1.getMin(), storm::utility::convertNumber<storm::RationalNumber>(std::string("1/6"))); - EXPECT_EQ(quantitativeResult1.getMax(), storm::utility::convertNumber<storm::RationalNumber>(std::string("1/6"))); - - formula = formulaParser.parseSingleFormulaFromString("P=? [F \"two\"]"); - - result = checker.check(*formula); - result->filter(storm::modelchecker::SymbolicQualitativeCheckResult<storm::dd::DdType::Sylvan>(model->getReachableStates(), model->getInitialStates())); - storm::modelchecker::SymbolicQuantitativeCheckResult<storm::dd::DdType::Sylvan, storm::RationalNumber>& quantitativeResult2 = result->asSymbolicQuantitativeCheckResult<storm::dd::DdType::Sylvan, storm::RationalNumber>(); - - EXPECT_EQ(quantitativeResult2.getMin(), storm::utility::convertNumber<storm::RationalNumber>(std::string("1/6"))); - EXPECT_EQ(quantitativeResult2.getMax(), storm::utility::convertNumber<storm::RationalNumber>(std::string("1/6"))); - - formula = formulaParser.parseSingleFormulaFromString("P=? [F \"three\"]"); - - result = checker.check(*formula); - result->filter(storm::modelchecker::SymbolicQualitativeCheckResult<storm::dd::DdType::Sylvan>(model->getReachableStates(), model->getInitialStates())); - storm::modelchecker::SymbolicQuantitativeCheckResult<storm::dd::DdType::Sylvan, storm::RationalNumber>& quantitativeResult3 = result->asSymbolicQuantitativeCheckResult<storm::dd::DdType::Sylvan, storm::RationalNumber>(); - - EXPECT_EQ(quantitativeResult3.getMin(), storm::utility::convertNumber<storm::RationalNumber>(std::string("1/6"))); - EXPECT_EQ(quantitativeResult3.getMax(), storm::utility::convertNumber<storm::RationalNumber>(std::string("1/6"))); - - formula = formulaParser.parseSingleFormulaFromString("R=? [F \"done\"]"); - - result = checker.check(*formula); - result->filter(storm::modelchecker::SymbolicQualitativeCheckResult<storm::dd::DdType::Sylvan>(model->getReachableStates(), model->getInitialStates())); - storm::modelchecker::SymbolicQuantitativeCheckResult<storm::dd::DdType::Sylvan, storm::RationalNumber>& quantitativeResult4 = result->asSymbolicQuantitativeCheckResult<storm::dd::DdType::Sylvan, storm::RationalNumber>(); - - EXPECT_EQ(quantitativeResult4.getMin(), storm::utility::convertNumber<storm::RationalNumber>(std::string("11/3"))); - EXPECT_EQ(quantitativeResult4.getMax(), storm::utility::convertNumber<storm::RationalNumber>(std::string("11/3"))); -} - -TEST(SymbolicDtmcPrctlModelCheckerTest, Die_RationalFunction_Sylvan) { - storm::storage::SymbolicModelDescription modelDescription = storm::parser::PrismParser::parse(STORM_TEST_RESOURCES_DIR "/pdtmc/parametric_die.pm"); - storm::prism::Program program = modelDescription.preprocess().asPrismProgram(); - - // A parser that we use for conveniently constructing the formulas. - storm::parser::FormulaParser formulaParser; - - // Build the die model with its reward model. - typename storm::builder::DdPrismModelBuilder<storm::dd::DdType::Sylvan, storm::RationalFunction>::Options options; - options.buildAllRewardModels = false; - options.rewardModelsToBuild.insert("coin_flips"); - std::shared_ptr<storm::models::symbolic::Model<storm::dd::DdType::Sylvan, storm::RationalFunction>> model = storm::builder::DdPrismModelBuilder<storm::dd::DdType::Sylvan, storm::RationalFunction>().build(program, options); - EXPECT_EQ(13ul, model->getNumberOfStates()); - EXPECT_EQ(20ul, model->getNumberOfTransitions()); - ASSERT_EQ(model->getType(), storm::models::ModelType::Dtmc); - - std::map<storm::RationalFunctionVariable, storm::RationalFunctionCoefficient> instantiation; - std::set<storm::RationalFunctionVariable> variables = model->getParameters(); - ASSERT_EQ(1ull, variables.size()); - instantiation.emplace(*variables.begin(), storm::utility::convertNumber<storm::RationalFunctionCoefficient>(std::string("1/2"))); - - std::shared_ptr<storm::models::symbolic::Dtmc<storm::dd::DdType::Sylvan, storm::RationalFunction>> dtmc = model->as<storm::models::symbolic::Dtmc<storm::dd::DdType::Sylvan, storm::RationalFunction>>(); - - storm::modelchecker::SymbolicDtmcPrctlModelChecker<storm::models::symbolic::Dtmc<storm::dd::DdType::Sylvan, storm::RationalFunction>> checker(*dtmc, std::unique_ptr<storm::solver::SymbolicLinearEquationSolverFactory<storm::dd::DdType::Sylvan, storm::RationalFunction>>(new storm::solver::SymbolicEliminationLinearEquationSolverFactory<storm::dd::DdType::Sylvan, storm::RationalFunction>())); - - std::shared_ptr<storm::logic::Formula const> formula = formulaParser.parseSingleFormulaFromString("P=? [F \"one\"]"); - - std::unique_ptr<storm::modelchecker::CheckResult> result = checker.check(*formula); - result->filter(storm::modelchecker::SymbolicQualitativeCheckResult<storm::dd::DdType::Sylvan>(model->getReachableStates(), model->getInitialStates())); - storm::modelchecker::SymbolicQuantitativeCheckResult<storm::dd::DdType::Sylvan, storm::RationalFunction>& quantitativeResult1 = result->asSymbolicQuantitativeCheckResult<storm::dd::DdType::Sylvan, storm::RationalFunction>(); - - EXPECT_EQ(storm::utility::convertNumber<storm::RationalFunctionCoefficient>(quantitativeResult1.sum().evaluate(instantiation)), storm::utility::convertNumber<storm::RationalFunctionCoefficient>(std::string("1/6"))); - - formula = formulaParser.parseSingleFormulaFromString("P=? [F \"two\"]"); - - result = checker.check(*formula); - result->filter(storm::modelchecker::SymbolicQualitativeCheckResult<storm::dd::DdType::Sylvan>(model->getReachableStates(), model->getInitialStates())); - storm::modelchecker::SymbolicQuantitativeCheckResult<storm::dd::DdType::Sylvan, storm::RationalFunction>& quantitativeResult2 = result->asSymbolicQuantitativeCheckResult<storm::dd::DdType::Sylvan, storm::RationalFunction>(); - - EXPECT_EQ(storm::utility::convertNumber<storm::RationalFunctionCoefficient>(quantitativeResult2.sum().evaluate(instantiation)), storm::utility::convertNumber<storm::RationalFunctionCoefficient>(std::string("1/6"))); - - formula = formulaParser.parseSingleFormulaFromString("P=? [F \"three\"]"); - - result = checker.check(*formula); - result->filter(storm::modelchecker::SymbolicQualitativeCheckResult<storm::dd::DdType::Sylvan>(model->getReachableStates(), model->getInitialStates())); - storm::modelchecker::SymbolicQuantitativeCheckResult<storm::dd::DdType::Sylvan, storm::RationalFunction>& quantitativeResult3 = result->asSymbolicQuantitativeCheckResult<storm::dd::DdType::Sylvan, storm::RationalFunction>(); - - EXPECT_EQ(storm::utility::convertNumber<storm::RationalFunctionCoefficient>(quantitativeResult3.sum().evaluate(instantiation)), storm::utility::convertNumber<storm::RationalFunctionCoefficient>(std::string("1/6"))); - - formula = formulaParser.parseSingleFormulaFromString("R=? [F \"done\"]"); - - result = checker.check(*formula); - result->filter(storm::modelchecker::SymbolicQualitativeCheckResult<storm::dd::DdType::Sylvan>(model->getReachableStates(), model->getInitialStates())); - storm::modelchecker::SymbolicQuantitativeCheckResult<storm::dd::DdType::Sylvan, storm::RationalFunction>& quantitativeResult4 = result->asSymbolicQuantitativeCheckResult<storm::dd::DdType::Sylvan, storm::RationalFunction>(); - - EXPECT_EQ(storm::utility::convertNumber<storm::RationalFunctionCoefficient>(quantitativeResult4.sum().evaluate(instantiation)), storm::utility::convertNumber<storm::RationalFunctionCoefficient>(std::string("11/3"))); -} - -TEST(SymbolicDtmcPrctlModelCheckerTest, Crowds_Cudd) { - storm::storage::SymbolicModelDescription modelDescription = storm::parser::PrismParser::parse(STORM_TEST_RESOURCES_DIR "/dtmc/crowds-5-5.pm"); - storm::prism::Program program = modelDescription.preprocess().asPrismProgram(); - - // A parser that we use for conveniently constructing the formulas. - storm::parser::FormulaParser formulaParser; - - std::shared_ptr<storm::models::symbolic::Model<storm::dd::DdType::CUDD>> model = storm::builder::DdPrismModelBuilder<storm::dd::DdType::CUDD>().build(program); - EXPECT_EQ(8607ul, model->getNumberOfStates()); - EXPECT_EQ(15113ul, model->getNumberOfTransitions()); - - ASSERT_EQ(model->getType(), storm::models::ModelType::Dtmc); - - std::shared_ptr<storm::models::symbolic::Dtmc<storm::dd::DdType::CUDD>> dtmc = model->as<storm::models::symbolic::Dtmc<storm::dd::DdType::CUDD>>(); - - storm::modelchecker::SymbolicDtmcPrctlModelChecker<storm::models::symbolic::Dtmc<storm::dd::DdType::CUDD, double>> checker(*dtmc, std::unique_ptr<storm::solver::SymbolicLinearEquationSolverFactory<storm::dd::DdType::CUDD, double>>(new storm::solver::GeneralSymbolicLinearEquationSolverFactory<storm::dd::DdType::CUDD, double>())); - - std::shared_ptr<storm::logic::Formula const> formula = formulaParser.parseSingleFormulaFromString("P=? [F \"observe0Greater1\"]"); - - std::unique_ptr<storm::modelchecker::CheckResult> result = checker.check(*formula); - result->filter(storm::modelchecker::SymbolicQualitativeCheckResult<storm::dd::DdType::CUDD>(model->getReachableStates(), model->getInitialStates())); - storm::modelchecker::SymbolicQuantitativeCheckResult<storm::dd::DdType::CUDD>& quantitativeResult1 = result->asSymbolicQuantitativeCheckResult<storm::dd::DdType::CUDD, double>(); - - EXPECT_NEAR(0.3328777473921436, quantitativeResult1.getMin(), storm::settings::getModule<storm::settings::modules::NativeEquationSolverSettings>().getPrecision()); - EXPECT_NEAR(0.3328777473921436, quantitativeResult1.getMax(), storm::settings::getModule<storm::settings::modules::NativeEquationSolverSettings>().getPrecision()); - - formula = formulaParser.parseSingleFormulaFromString("P=? [F \"observeIGreater1\"]"); - - result = checker.check(*formula); - result->filter(storm::modelchecker::SymbolicQualitativeCheckResult<storm::dd::DdType::CUDD>(model->getReachableStates(), model->getInitialStates())); - storm::modelchecker::SymbolicQuantitativeCheckResult<storm::dd::DdType::CUDD>& quantitativeResult2 = result->asSymbolicQuantitativeCheckResult<storm::dd::DdType::CUDD, double>(); - - EXPECT_NEAR(0.15221847380560186, quantitativeResult2.getMin(), storm::settings::getModule<storm::settings::modules::NativeEquationSolverSettings>().getPrecision()); - EXPECT_NEAR(0.15221847380560186, quantitativeResult2.getMax(), storm::settings::getModule<storm::settings::modules::NativeEquationSolverSettings>().getPrecision()); - - formula = formulaParser.parseSingleFormulaFromString("P=? [F \"observeOnlyTrueSender\"]"); - - result = checker.check(*formula); - result->filter(storm::modelchecker::SymbolicQualitativeCheckResult<storm::dd::DdType::CUDD>(model->getReachableStates(), model->getInitialStates())); - storm::modelchecker::SymbolicQuantitativeCheckResult<storm::dd::DdType::CUDD>& quantitativeResult3 = result->asSymbolicQuantitativeCheckResult<storm::dd::DdType::CUDD, double>(); - - EXPECT_NEAR(0.32153516079959443, quantitativeResult3.getMin(), storm::settings::getModule<storm::settings::modules::NativeEquationSolverSettings>().getPrecision()); - EXPECT_NEAR(0.32153516079959443, quantitativeResult3.getMax(), storm::settings::getModule<storm::settings::modules::NativeEquationSolverSettings>().getPrecision()); -} - -TEST(SymbolicDtmcPrctlModelCheckerTest, Crowds_Sylvan) { - storm::storage::SymbolicModelDescription modelDescription = storm::parser::PrismParser::parse(STORM_TEST_RESOURCES_DIR "/dtmc/crowds-5-5.pm"); - storm::prism::Program program = modelDescription.preprocess().asPrismProgram(); - - // A parser that we use for conveniently constructing the formulas. - storm::parser::FormulaParser formulaParser; - - std::shared_ptr<storm::models::symbolic::Model<storm::dd::DdType::Sylvan>> model = storm::builder::DdPrismModelBuilder<storm::dd::DdType::Sylvan>().build(program); - EXPECT_EQ(8607ul, model->getNumberOfStates()); - EXPECT_EQ(15113ul, model->getNumberOfTransitions()); - - ASSERT_EQ(model->getType(), storm::models::ModelType::Dtmc); - - std::shared_ptr<storm::models::symbolic::Dtmc<storm::dd::DdType::Sylvan>> dtmc = model->as<storm::models::symbolic::Dtmc<storm::dd::DdType::Sylvan>>(); - - storm::modelchecker::SymbolicDtmcPrctlModelChecker<storm::models::symbolic::Dtmc<storm::dd::DdType::Sylvan, double>> checker(*dtmc, std::unique_ptr<storm::solver::SymbolicLinearEquationSolverFactory<storm::dd::DdType::Sylvan, double>>(new storm::solver::GeneralSymbolicLinearEquationSolverFactory<storm::dd::DdType::Sylvan, double>())); - - std::shared_ptr<storm::logic::Formula const> formula = formulaParser.parseSingleFormulaFromString("P=? [F \"observe0Greater1\"]"); - - std::unique_ptr<storm::modelchecker::CheckResult> result = checker.check(*formula); - result->filter(storm::modelchecker::SymbolicQualitativeCheckResult<storm::dd::DdType::Sylvan>(model->getReachableStates(), model->getInitialStates())); - storm::modelchecker::SymbolicQuantitativeCheckResult<storm::dd::DdType::Sylvan>& quantitativeResult1 = result->asSymbolicQuantitativeCheckResult<storm::dd::DdType::Sylvan, double>(); - - // FIXME: precision not optimal. - EXPECT_NEAR(0.33288236360191303, quantitativeResult1.getMin(), 10 * storm::settings::getModule<storm::settings::modules::NativeEquationSolverSettings>().getPrecision()); - EXPECT_NEAR(0.33288236360191303, quantitativeResult1.getMax(), 10 * storm::settings::getModule<storm::settings::modules::NativeEquationSolverSettings>().getPrecision()); - - formula = formulaParser.parseSingleFormulaFromString("P=? [F \"observeIGreater1\"]"); - - result = checker.check(*formula); - result->filter(storm::modelchecker::SymbolicQualitativeCheckResult<storm::dd::DdType::Sylvan>(model->getReachableStates(), model->getInitialStates())); - storm::modelchecker::SymbolicQuantitativeCheckResult<storm::dd::DdType::Sylvan>& quantitativeResult2 = result->asSymbolicQuantitativeCheckResult<storm::dd::DdType::Sylvan, double>(); - - // FIXME: precision not optimal. - EXPECT_NEAR(0.15222081144084315, quantitativeResult2.getMin(), 10 * storm::settings::getModule<storm::settings::modules::NativeEquationSolverSettings>().getPrecision()); - EXPECT_NEAR(0.15222081144084315, quantitativeResult2.getMax(), 10 * storm::settings::getModule<storm::settings::modules::NativeEquationSolverSettings>().getPrecision()); - - formula = formulaParser.parseSingleFormulaFromString("P=? [F \"observeOnlyTrueSender\"]"); - - result = checker.check(*formula); - result->filter(storm::modelchecker::SymbolicQualitativeCheckResult<storm::dd::DdType::Sylvan>(model->getReachableStates(), model->getInitialStates())); - storm::modelchecker::SymbolicQuantitativeCheckResult<storm::dd::DdType::Sylvan>& quantitativeResult3 = result->asSymbolicQuantitativeCheckResult<storm::dd::DdType::Sylvan, double>(); - - // FIXME: precision not optimal. - EXPECT_NEAR(0.3215392962289586, quantitativeResult3.getMin(), 10 * storm::settings::getModule<storm::settings::modules::NativeEquationSolverSettings>().getPrecision()); - EXPECT_NEAR(0.3215392962289586, quantitativeResult3.getMax(), 10 * storm::settings::getModule<storm::settings::modules::NativeEquationSolverSettings>().getPrecision()); -} - -TEST(SymbolicDtmcPrctlModelCheckerTest, SynchronousLeader_Cudd) { - storm::storage::SymbolicModelDescription modelDescription = storm::parser::PrismParser::parse(STORM_TEST_RESOURCES_DIR "/dtmc/leader-3-5.pm"); - storm::prism::Program program = modelDescription.preprocess().asPrismProgram(); - - // A parser that we use for conveniently constructing the formulas. - storm::parser::FormulaParser formulaParser; - - // Build the die model with its reward model. -#ifdef WINDOWS - storm::builder::DdPrismModelBuilder<storm::dd::DdType::CUDD>::Options options; -#else - typename storm::builder::DdPrismModelBuilder<storm::dd::DdType::CUDD>::Options options; -#endif - options.buildAllRewardModels = false; - options.rewardModelsToBuild.insert("num_rounds"); - std::shared_ptr<storm::models::symbolic::Model<storm::dd::DdType::CUDD>> model = storm::builder::DdPrismModelBuilder<storm::dd::DdType::CUDD>().build(program, options); - EXPECT_EQ(273ul, model->getNumberOfStates()); - EXPECT_EQ(397ul, model->getNumberOfTransitions()); - - ASSERT_EQ(model->getType(), storm::models::ModelType::Dtmc); - - std::shared_ptr<storm::models::symbolic::Dtmc<storm::dd::DdType::CUDD>> dtmc = model->as<storm::models::symbolic::Dtmc<storm::dd::DdType::CUDD>>(); - - storm::modelchecker::SymbolicDtmcPrctlModelChecker<storm::models::symbolic::Dtmc<storm::dd::DdType::CUDD, double>> checker(*dtmc, std::unique_ptr<storm::solver::SymbolicLinearEquationSolverFactory<storm::dd::DdType::CUDD, double>>(new storm::solver::GeneralSymbolicLinearEquationSolverFactory<storm::dd::DdType::CUDD, double>())); - - std::shared_ptr<storm::logic::Formula const> formula = formulaParser.parseSingleFormulaFromString("P=? [F \"elected\"]"); - - std::unique_ptr<storm::modelchecker::CheckResult> result = checker.check(*formula); - result->filter(storm::modelchecker::SymbolicQualitativeCheckResult<storm::dd::DdType::CUDD>(model->getReachableStates(), model->getInitialStates())); - storm::modelchecker::SymbolicQuantitativeCheckResult<storm::dd::DdType::CUDD>& quantitativeResult1 = result->asSymbolicQuantitativeCheckResult<storm::dd::DdType::CUDD, double>(); - - EXPECT_NEAR(1.0, quantitativeResult1.getMin(), storm::settings::getModule<storm::settings::modules::NativeEquationSolverSettings>().getPrecision()); - EXPECT_NEAR(1.0, quantitativeResult1.getMax(), storm::settings::getModule<storm::settings::modules::NativeEquationSolverSettings>().getPrecision()); - - formula = formulaParser.parseSingleFormulaFromString("P=? [F<=20 \"elected\"]"); - - result = checker.check(*formula); - result->filter(storm::modelchecker::SymbolicQualitativeCheckResult<storm::dd::DdType::CUDD>(model->getReachableStates(), model->getInitialStates())); - storm::modelchecker::SymbolicQuantitativeCheckResult<storm::dd::DdType::CUDD>& quantitativeResult2 = result->asSymbolicQuantitativeCheckResult<storm::dd::DdType::CUDD, double>(); - - EXPECT_NEAR(0.99999989760000074, quantitativeResult2.getMin(), storm::settings::getModule<storm::settings::modules::NativeEquationSolverSettings>().getPrecision()); - EXPECT_NEAR(0.99999989760000074, quantitativeResult2.getMax(), storm::settings::getModule<storm::settings::modules::NativeEquationSolverSettings>().getPrecision()); - - formula = formulaParser.parseSingleFormulaFromString("R=? [F \"elected\"]"); - - result = checker.check(*formula); - result->filter(storm::modelchecker::SymbolicQualitativeCheckResult<storm::dd::DdType::CUDD>(model->getReachableStates(), model->getInitialStates())); - storm::modelchecker::SymbolicQuantitativeCheckResult<storm::dd::DdType::CUDD>& quantitativeResult3 = result->asSymbolicQuantitativeCheckResult<storm::dd::DdType::CUDD, double>(); - - EXPECT_NEAR(1.0416666666666643, quantitativeResult3.getMin(), storm::settings::getModule<storm::settings::modules::NativeEquationSolverSettings>().getPrecision()); - EXPECT_NEAR(1.0416666666666643, quantitativeResult3.getMax(), storm::settings::getModule<storm::settings::modules::NativeEquationSolverSettings>().getPrecision()); -} - -TEST(SymbolicDtmcPrctlModelCheckerTest, SynchronousLeader_Sylvan) { - storm::storage::SymbolicModelDescription modelDescription = storm::parser::PrismParser::parse(STORM_TEST_RESOURCES_DIR "/dtmc/leader-3-5.pm"); - storm::prism::Program program = modelDescription.preprocess().asPrismProgram(); - - // A parser that we use for conveniently constructing the formulas. - storm::parser::FormulaParser formulaParser; - - // Build the die model with its reward model. -#ifdef WINDOWS - storm::builder::DdPrismModelBuilder<storm::dd::DdType::Sylvan>::Options options; -#else - typename storm::builder::DdPrismModelBuilder<storm::dd::DdType::Sylvan>::Options options; -#endif - options.buildAllRewardModels = false; - options.rewardModelsToBuild.insert("num_rounds"); - std::shared_ptr<storm::models::symbolic::Model<storm::dd::DdType::Sylvan>> model = storm::builder::DdPrismModelBuilder<storm::dd::DdType::Sylvan>().build(program, options); - EXPECT_EQ(273ul, model->getNumberOfStates()); - EXPECT_EQ(397ul, model->getNumberOfTransitions()); - - ASSERT_EQ(model->getType(), storm::models::ModelType::Dtmc); - - std::shared_ptr<storm::models::symbolic::Dtmc<storm::dd::DdType::Sylvan>> dtmc = model->as<storm::models::symbolic::Dtmc<storm::dd::DdType::Sylvan>>(); - - storm::modelchecker::SymbolicDtmcPrctlModelChecker<storm::models::symbolic::Dtmc<storm::dd::DdType::Sylvan, double>> checker(*dtmc, std::unique_ptr<storm::solver::SymbolicLinearEquationSolverFactory<storm::dd::DdType::Sylvan, double>>(new storm::solver::GeneralSymbolicLinearEquationSolverFactory<storm::dd::DdType::Sylvan, double>())); - - std::shared_ptr<storm::logic::Formula const> formula = formulaParser.parseSingleFormulaFromString("P=? [F \"elected\"]"); - - std::unique_ptr<storm::modelchecker::CheckResult> result = checker.check(*formula); - result->filter(storm::modelchecker::SymbolicQualitativeCheckResult<storm::dd::DdType::Sylvan>(model->getReachableStates(), model->getInitialStates())); - storm::modelchecker::SymbolicQuantitativeCheckResult<storm::dd::DdType::Sylvan>& quantitativeResult1 = result->asSymbolicQuantitativeCheckResult<storm::dd::DdType::Sylvan, double>(); - - EXPECT_NEAR(1.0, quantitativeResult1.getMin(), storm::settings::getModule<storm::settings::modules::NativeEquationSolverSettings>().getPrecision()); - EXPECT_NEAR(1.0, quantitativeResult1.getMax(), storm::settings::getModule<storm::settings::modules::NativeEquationSolverSettings>().getPrecision()); - - formula = formulaParser.parseSingleFormulaFromString("P=? [F<=20 \"elected\"]"); - - result = checker.check(*formula); - result->filter(storm::modelchecker::SymbolicQualitativeCheckResult<storm::dd::DdType::Sylvan>(model->getReachableStates(), model->getInitialStates())); - storm::modelchecker::SymbolicQuantitativeCheckResult<storm::dd::DdType::Sylvan>& quantitativeResult2 = result->asSymbolicQuantitativeCheckResult<storm::dd::DdType::Sylvan, double>(); - - EXPECT_NEAR(0.99999989760000074, quantitativeResult2.getMin(), storm::settings::getModule<storm::settings::modules::NativeEquationSolverSettings>().getPrecision()); - EXPECT_NEAR(0.99999989760000074, quantitativeResult2.getMax(), storm::settings::getModule<storm::settings::modules::NativeEquationSolverSettings>().getPrecision()); - - formula = formulaParser.parseSingleFormulaFromString("R=? [F \"elected\"]"); - - result = checker.check(*formula); - result->filter(storm::modelchecker::SymbolicQualitativeCheckResult<storm::dd::DdType::Sylvan>(model->getReachableStates(), model->getInitialStates())); - storm::modelchecker::SymbolicQuantitativeCheckResult<storm::dd::DdType::Sylvan>& quantitativeResult3 = result->asSymbolicQuantitativeCheckResult<storm::dd::DdType::Sylvan, double>(); - - EXPECT_NEAR(1.0416666666666643, quantitativeResult3.getMin(), storm::settings::getModule<storm::settings::modules::NativeEquationSolverSettings>().getPrecision()); - EXPECT_NEAR(1.0416666666666643, quantitativeResult3.getMax(), storm::settings::getModule<storm::settings::modules::NativeEquationSolverSettings>().getPrecision()); -}