Factory, Testing Environment (Topological Excluded)

src/storm/solver/IterativeMinMaxLinearEquationSolver.cpp

@@ -229,8 +229,6 @@ namespace storm {
             }
         }
 
-
-
         template<typename ValueType>
         MinMaxLinearEquationSolverRequirements IterativeMinMaxLinearEquationSolver<ValueType>::getRequirements(Environment const& env, boost::optional<storm::solver::OptimizationDirection> const& direction, bool const& hasInitialScheduler) const {
             auto method = getMethod(env, storm::NumberTraits<ValueType>::IsExact);

src/storm/solver/MinMaxLinearEquationSolver.cpp

@@ -203,7 +203,7 @@ namespace storm {
         std::unique_ptr<MinMaxLinearEquationSolver<ValueType>> GeneralMinMaxLinearEquationSolverFactory<ValueType>::create(Environment const& env) const {
             std::unique_ptr<MinMaxLinearEquationSolver<ValueType>> result;
             auto method = env.solver().minMax().getMethod();
-            if (method == MinMaxMethod::ValueIteration || method == MinMaxMethod::PolicyIteration || method == MinMaxMethod::RationalSearch || method == MinMaxMethod::IntervalIteration || method == MinMaxMethod::SoundValueIteration || method == MinMaxMethod::ViToPi) {
+            if (method == MinMaxMethod::ValueIteration || method == MinMaxMethod::PolicyIteration || method == MinMaxMethod::RationalSearch || method == MinMaxMethod::IntervalIteration || method == MinMaxMethod::SoundValueIteration || method == MinMaxMethod::OptimisticValueIteration || method == MinMaxMethod::ViToPi) {
                 result = std::make_unique<IterativeMinMaxLinearEquationSolver<ValueType>>(std::make_unique<GeneralLinearEquationSolverFactory<ValueType>>());
             } else if (method == MinMaxMethod::Topological) {
                 result = std::make_unique<TopologicalMinMaxLinearEquationSolver<ValueType>>();
@@ -222,7 +222,7 @@ namespace storm {
         std::unique_ptr<MinMaxLinearEquationSolver<storm::RationalNumber>> GeneralMinMaxLinearEquationSolverFactory<storm::RationalNumber>::create(Environment const& env) const {
             std::unique_ptr<MinMaxLinearEquationSolver<storm::RationalNumber>> result;
             auto method = env.solver().minMax().getMethod();
-            if (method == MinMaxMethod::ValueIteration || method == MinMaxMethod::PolicyIteration || method == MinMaxMethod::RationalSearch || method == MinMaxMethod::IntervalIteration || method == MinMaxMethod::SoundValueIteration || method == MinMaxMethod::ViToPi) {
+            if (method == MinMaxMethod::ValueIteration || method == MinMaxMethod::PolicyIteration || method == MinMaxMethod::RationalSearch || method == MinMaxMethod::IntervalIteration || method == MinMaxMethod::SoundValueIteration || method == MinMaxMethod::OptimisticValueIteration || method == MinMaxMethod::ViToPi) {
                 result = std::make_unique<IterativeMinMaxLinearEquationSolver<storm::RationalNumber>>(std::make_unique<GeneralLinearEquationSolverFactory<storm::RationalNumber>>());
             } else if (method == MinMaxMethod::LinearProgramming) {
                 result = std::make_unique<LpMinMaxLinearEquationSolver<storm::RationalNumber>>(std::make_unique<storm::utility::solver::LpSolverFactory<storm::RationalNumber>>());

src/storm/solver/SolverSelectionOptions.cpp

@@ -18,6 +18,8 @@ namespace storm {
                     return "intervaliteration";
                 case MinMaxMethod::SoundValueIteration:
                     return "soundvalueiteration";
+                case MinMaxMethod::OptimisticValueIteration:
+                    return "optimisticvalueiteration";
                 case MinMaxMethod::TopologicalCuda:
                     return "topologicalcuda";
                 case MinMaxMethod::ViToPi:

src/storm/solver/SolverSelectionOptions.h

@@ -6,7 +6,7 @@
 
 namespace storm {
     namespace solver {
-        ExtendEnumsWithSelectionField(MinMaxMethod, ValueIteration, OptimisticValueIteration, PolicyIteration, LinearProgramming, Topological, RationalSearch, IntervalIteration, SoundValueIteration, TopologicalCuda, ViToPi)
+        ExtendEnumsWithSelectionField(MinMaxMethod, ValueIteration, PolicyIteration, LinearProgramming, Topological, RationalSearch, IntervalIteration, SoundValueIteration, OptimisticValueIteration, TopologicalCuda, ViToPi)
         ExtendEnumsWithSelectionField(MultiplierType, Native, Gmmxx)
         ExtendEnumsWithSelectionField(GameMethod, PolicyIteration, ValueIteration)
         ExtendEnumsWithSelectionField(LraMethod, LinearProgramming, ValueIteration, GainBiasEquations, LraDistributionEquations)

src/test/storm/modelchecker/prctl/mdp/MdpPrctlModelCheckerTest.cpp

@@ -92,6 +92,7 @@ namespace {
             return env;
         }
     };
+
     class SparseDoubleSoundValueIterationEnvironment {
     public:
         static const storm::dd::DdType ddType = storm::dd::DdType::Sylvan; // Unused for sparse models
@@ -109,6 +110,23 @@ namespace {
         }
     };
     
+    class SparseDoubleOptimisticValueIterationEnvironment {
+    public:
+        static const storm::dd::DdType ddType = storm::dd::DdType::Sylvan; // Unused for sparse models
+        static const MdpEngine engine = MdpEngine::PrismSparse;
+        static const bool isExact = false;
+        typedef double ValueType;
+        typedef storm::models::sparse::Mdp<ValueType> ModelType;
+        static storm::Environment createEnvironment() {
+            storm::Environment env;
+            env.solver().setForceSoundness(true);
+            env.solver().minMax().setMethod(storm::solver::MinMaxMethod::OptimisticValueIteration);
+            env.solver().minMax().setPrecision(storm::utility::convertNumber<storm::RationalNumber>(1e-6));
+            env.solver().minMax().setRelativeTerminationCriterion(false);
+            return env;
+        }
+    };
+
     class SparseDoubleTopologicalValueIterationEnvironment {
     public:
         static const storm::dd::DdType ddType = storm::dd::DdType::Sylvan; // Unused for sparse models
@@ -229,6 +247,22 @@ namespace {
             return env;
         }
     };
+    class HybridCuddDoubleOptimisticValueIterationEnvironment {
+    public:
+        static const storm::dd::DdType ddType = storm::dd::DdType::CUDD;
+        static const MdpEngine engine = MdpEngine::Hybrid;
+        static const bool isExact = false;
+        typedef double ValueType;
+        typedef storm::models::symbolic::Mdp<ddType, ValueType> ModelType;
+        static storm::Environment createEnvironment() {
+            storm::Environment env;
+            env.solver().setForceSoundness(true);
+            env.solver().minMax().setMethod(storm::solver::MinMaxMethod::OptimisticValueIteration);
+            env.solver().minMax().setPrecision(storm::utility::convertNumber<storm::RationalNumber>(1e-6));
+            env.solver().minMax().setRelativeTerminationCriterion(false);
+            return env;
+        }
+    };
     class HybridSylvanRationalPolicyIterationEnvironment {
     public:
         static const storm::dd::DdType ddType = storm::dd::DdType::Sylvan;
@@ -418,6 +452,7 @@ namespace {
             JitSparseDoubleValueIterationEnvironment,
             SparseDoubleIntervalIterationEnvironment,
             SparseDoubleSoundValueIterationEnvironment,
+            SparseDoubleOptimisticValueIterationEnvironment,
             SparseDoubleTopologicalValueIterationEnvironment,
             SparseDoubleTopologicalSoundValueIterationEnvironment,
             SparseRationalPolicyIterationEnvironment,
@@ -426,6 +461,7 @@ namespace {
             HybridCuddDoubleValueIterationEnvironment,
             HybridSylvanDoubleValueIterationEnvironment,
             HybridCuddDoubleSoundValueIterationEnvironment,
+            HybridCuddDoubleOptimisticValueIterationEnvironment,
             HybridSylvanRationalPolicyIterationEnvironment,
             DdCuddDoubleValueIterationEnvironment,
             JaniDdCuddDoubleValueIterationEnvironment,

src/test/storm/solver/MinMaxLinearEquationSolverTest.cpp

@@ -23,6 +23,7 @@ namespace {
             return env;
         }
     };
+
     class DoubleSoundViEnvironment {
     public:
         typedef double ValueType;
@@ -49,6 +50,19 @@ namespace {
         }
     };
 
+    class DoubleOptimisticViEnvironment {
+    public:
+        typedef double ValueType;
+        static const bool isExact = false;
+        static storm::Environment createEnvironment() {
+            storm::Environment env;
+            env.solver().minMax().setMethod(storm::solver::MinMaxMethod::OptimisticValueIteration);
+            env.solver().setForceSoundness(true);
+            env.solver().minMax().setPrecision(storm::utility::convertNumber<storm::RationalNumber>(1e-6));
+            return env;
+        }
+    };
+    
     class DoubleTopologicalViEnvironment {
     public:
         typedef double ValueType;
@@ -124,6 +138,7 @@ namespace {
             DoubleViEnvironment,
             DoubleSoundViEnvironment,
             DoubleIntervalIterationEnvironment,
+            DoubleOptimisticViEnvironment,
             DoubleTopologicalViEnvironment,
             DoubleTopologicalCudaViEnvironment,
             DoublePIEnvironment,