added methods reduce and repeatedMultiplyAndReduceWithChoices to Multiplier.* to store the choiceValues between multiply and reduce

Also fixed the call to goal isShieldingTask in SMG Helpers

src/storm/modelchecker/rpatl/helper/SparseSmgRpatlHelper.cpp

@@ -41,8 +41,7 @@ namespace storm {
                 }
 
                 viHelper.performValueIteration(env, x, b, goal.direction());
-                //if(goal.isShieldingTask()) {
-                if(true) {
+                if(goal.isShieldingTask()) {
                     viHelper.getChoiceValues(env, x, constrainedChoiceValues);
                 }
                 viHelper.fillResultVector(x, relevantStates, psiStates);
@@ -107,13 +106,12 @@ namespace storm {
                 // create multiplier and execute the calculation for 1 step
                 auto multiplier = storm::solver::MultiplierFactory<ValueType>().create(env, transitionMatrix);
                 std::vector<ValueType> choiceValues = std::vector<ValueType>(transitionMatrix.getRowCount(), storm::utility::zero<ValueType>());
-
-                //if(goal.isShieldingTask()) {
-                if (true) {
+                if (goal.isShieldingTask()) {
                     multiplier->multiply(env, x, &b, choiceValues);
-                }
+                    multiplier->reduce(env, goal.direction(), choiceValues, transitionMatrix.getRowGroupIndices(), x, &statesOfCoalition);
+                } else {
                     multiplier->multiplyAndReduce(env, goal.direction(), x, &b, x, nullptr, &statesOfCoalition);
-
+                }
                 return SMGSparseModelCheckingHelperReturnType<ValueType>(std::move(x), std::move(allStates), nullptr, std::move(choiceValues));
             }
 

src/storm/solver/Multiplier.cpp

@@ -68,12 +68,46 @@ namespace storm {
             }
         }
 
+        template<typename ValueType>
+        void Multiplier<ValueType>::repeatedMultiplyAndReduceWithChoices(Environment const& env, OptimizationDirection const& dir, std::vector<ValueType>& x, std::vector<ValueType> const* b, uint64_t n, storm::storage::BitVector const* dirOverride, std::vector<ValueType>& choiceValues, std::vector<storm::storage::SparseMatrix<double>::index_type> rowGroupIndices) const {
+            storm::utility::ProgressMeasurement progress("multiplications");
+            progress.setMaxCount(n);
+            progress.startNewMeasurement(0);
+            for (uint64_t i = 0; i < n; ++i) {
+
+                multiply(env, x, b, choiceValues);
+                reduce(env, dir, choiceValues, rowGroupIndices, x);
+
+                multiplyAndReduce(env, dir, x, b, x);
+                if (storm::utility::resources::isTerminate()) {
+                    STORM_LOG_WARN("Aborting after " << i << " of " << n << " multiplications");
+                    break;
+                }
+            }
+        }
+
         template<typename ValueType>
         void Multiplier<ValueType>::multiplyRow2(uint64_t const& rowIndex, std::vector<ValueType> const& x1, ValueType& val1, std::vector<ValueType> const& x2, ValueType& val2) const {
             multiplyRow(rowIndex, x1, val1);
             multiplyRow(rowIndex, x2, val2);
         }
 
+        template<typename ValueType>
+        void Multiplier<ValueType>::reduce(Environment const& env, OptimizationDirection const& dir, std::vector<ValueType> const& choiceValues, std::vector<storm::storage::SparseMatrix<double>::index_type> rowGroupIndices, std::vector<ValueType>& result, storm::storage::BitVector const* dirOverride) const {
+            auto choice_it = choiceValues.begin();
+            for(uint state = 0; state < rowGroupIndices.size() - 1; state++) {
+                uint rowGroupSize = rowGroupIndices[state + 1] - rowGroupIndices[state];
+                if((dir == storm::OptimizationDirection::Minimize && !dirOverride->get(state)) || (dir == storm::OptimizationDirection::Maximize && dirOverride->get(state))) {
+                    result.at(state) = *std::min_element(choice_it, choice_it + rowGroupSize);
+                    choice_it += rowGroupSize;
+                }
+                else {
+                    result.at(state) = *std::max_element(choice_it, choice_it + rowGroupSize);
+                    choice_it += rowGroupSize;
+                }
+            }
+        }
+
         template<typename ValueType>
         std::unique_ptr<Multiplier<ValueType>> MultiplierFactory<ValueType>::create(Environment const& env, storm::storage::SparseMatrix<ValueType> const& matrix) {
             auto type = env.solver().multiplier().getType();

src/storm/solver/Multiplier.h

@@ -8,6 +8,8 @@
 
 #include "storm/solver/OptimizationDirection.h"
 #include "storm/solver/MultiplicationStyle.h"
+#include "storm/storage/SparseMatrix.h"
+
 
 namespace storm {
 
@@ -119,6 +121,8 @@ namespace storm {
              */
             void repeatedMultiplyAndReduce(Environment const& env, OptimizationDirection const& dir, std::vector<ValueType>& x, std::vector<ValueType> const* b, uint64_t n, storm::storage::BitVector const* dirOverride = nullptr) const;
 
+            void repeatedMultiplyAndReduceWithChoices(const Environment &env, const OptimizationDirection &dir, std::vector<ValueType> &x, const std::vector<ValueType> *b, uint64_t n, const storage::BitVector *dirOverride, std::vector<ValueType> &choiceValues, std::vector<unsigned long> rowGroupIndices) const;
+
             /*!
              * Multiplies the row with the given index with x and adds the result to the provided value
              * @param rowIndex The index of the considered row
@@ -137,9 +141,12 @@ namespace storm {
              */
             virtual void multiplyRow2(uint64_t const& rowIndex, std::vector<ValueType> const& x1, ValueType& val1, std::vector<ValueType> const& x2, ValueType& val2) const;
 
+            void reduce(Environment const& env, OptimizationDirection const& dir, std::vector<ValueType> const& choiceValues, std::vector<storm::storage::SparseMatrix<double>::index_type> rowGroupIndices, std::vector<ValueType>& result, storm::storage::BitVector const* dirOverride = nullptr) const;
+
         protected:
             mutable std::unique_ptr<std::vector<ValueType>> cachedVector;
             storm::storage::SparseMatrix<ValueType> const& matrix;
+
         };
 
         template<typename ValueType>