added reward accumulation to formulas

src/storm/logic/BoundedUntilFormula.cpp

@@ -285,7 +285,11 @@ namespace storm {
                         out << ", ";
                     }
                     if (this->getTimeBoundReference(i).isRewardBound()) {
-                        out << "rew{\"" << this->getTimeBoundReference(i).getRewardName() << "\"}";
+                        out << "rew";
+                        if (this->getTimeBoundReference(i).hasRewardAccumulation()) {
+                            out << "[" << this->getTimeBoundReference(i).getRewardAccumulation() << "]";
+                        }
+                        out << "{\"" << this->getTimeBoundReference(i).getRewardName() << "\"}";
                     } else if (this->getTimeBoundReference(i).isStepBound()) {
                         out << "steps";
                   //} else if (this->getTimeBoundReference(i).isStepBound())

src/storm/logic/CloneVisitor.cpp

@@ -70,7 +70,11 @@ namespace storm {
         
         boost::any CloneVisitor::visit(EventuallyFormula const& f, boost::any const& data) const {
             std::shared_ptr<Formula> subformula = boost::any_cast<std::shared_ptr<Formula>>(f.getSubformula().accept(*this, data));
-            return std::static_pointer_cast<Formula>(std::make_shared<EventuallyFormula>(subformula, f.getContext()));
+            if (f.hasRewardAccumulation()) {
+                return std::static_pointer_cast<Formula>(std::make_shared<EventuallyFormula>(subformula, f.getContext(), f.getRewardAccumulation()));
+            } else {
+                return std::static_pointer_cast<Formula>(std::make_shared<EventuallyFormula>(subformula, f.getContext()));
+            }
         }
         
         boost::any CloneVisitor::visit(TimeOperatorFormula const& f, boost::any const& data) const {

src/storm/logic/CumulativeRewardFormula.cpp

@@ -9,11 +9,11 @@
 
 namespace storm {
     namespace logic {
-        CumulativeRewardFormula::CumulativeRewardFormula(TimeBound const& bound, TimeBoundReference const& timeBoundReference) : timeBoundReferences({timeBoundReference}), bounds({bound}) {
+        CumulativeRewardFormula::CumulativeRewardFormula(TimeBound const& bound, TimeBoundReference const& timeBoundReference, boost::optional<RewardAccumulation> rewardAccumulation) : timeBoundReferences({timeBoundReference}), bounds({bound}), rewardAccumulation(rewardAccumulation) {
             // Intentionally left empty.
         }
 
-        CumulativeRewardFormula::CumulativeRewardFormula(std::vector<TimeBound> const& bounds, std::vector<TimeBoundReference> const& timeBoundReferences) : timeBoundReferences(timeBoundReferences), bounds(bounds) {
+        CumulativeRewardFormula::CumulativeRewardFormula(std::vector<TimeBound> const& bounds, std::vector<TimeBoundReference> const& timeBoundReferences, boost::optional<RewardAccumulation> rewardAccumulation) : timeBoundReferences(timeBoundReferences), bounds(bounds), rewardAccumulation(rewardAccumulation) {
 
             STORM_LOG_ASSERT(this->timeBoundReferences.size() == this->bounds.size(), "Number of time bounds and number of time bound references does not match.");
             STORM_LOG_ASSERT(!this->timeBoundReferences.empty(), "No time bounds given.");
@@ -137,12 +137,24 @@ namespace storm {
             STORM_LOG_THROW(!bound.containsVariables(), storm::exceptions::InvalidOperationException, "Cannot evaluate time-bound '" << bound << "' as it contains undefined constants.");
         }
         
+        bool CumulativeRewardFormula::hasRewardAccumulation() const {
+            return rewardAccumulation.is_initialized();
+        }
+        
+        RewardAccumulation const& CumulativeRewardFormula::getRewardAccumulation() const {
+            return rewardAccumulation.get();
+        }
+        
+        
         std::shared_ptr<CumulativeRewardFormula const> CumulativeRewardFormula::restrictToDimension(unsigned i) const {
             return std::make_shared<CumulativeRewardFormula const>(bounds.at(i), getTimeBoundReference(i));
         }
         
         std::ostream& CumulativeRewardFormula::writeToStream(std::ostream& out) const {
             out << "C";
+            if (hasRewardAccumulation()) {
+                out << "[" << getRewardAccumulation() << "]";
+            }
             if (this->isMultiDimensional()) {
                 out << "^{";
             }
@@ -151,7 +163,11 @@ namespace storm {
                     out << ", ";
                 }
                 if (this->getTimeBoundReference(i).isRewardBound()) {
-                    out << "rew{\"" << this->getTimeBoundReference(i).getRewardName() << "\"}";
+                    out << "rew";
+                    if (this->getTimeBoundReference(i).hasRewardAccumulation()) {
+                        out << "[" << this->getTimeBoundReference(i).getRewardAccumulation() << "]";
+                    }
+                    out << "{\"" << this->getTimeBoundReference(i).getRewardName() << "\"}";
                 } else if (this->getTimeBoundReference(i).isStepBound()) {
                     out << "steps";
               //} else if (this->getTimeBoundReference(i).isStepBound())

src/storm/logic/CumulativeRewardFormula.h

@@ -10,8 +10,8 @@ namespace storm {
     namespace logic {
         class CumulativeRewardFormula : public PathFormula {
         public:
-            CumulativeRewardFormula(TimeBound const& bound, TimeBoundReference const& timeBoundReference = TimeBoundReference(TimeBoundType::Time));
-            CumulativeRewardFormula(std::vector<TimeBound> const& bounds, std::vector<TimeBoundReference> const& timeBoundReferences);
+            CumulativeRewardFormula(TimeBound const& bound, TimeBoundReference const& timeBoundReference = TimeBoundReference(TimeBoundType::Time), boost::optional<RewardAccumulation> rewardAccumulation = boost::none);
+            CumulativeRewardFormula(std::vector<TimeBound> const& bounds, std::vector<TimeBoundReference> const& timeBoundReferences, boost::optional<RewardAccumulation> rewardAccumulation = boost::none);
             
             virtual ~CumulativeRewardFormula() = default;
 
@@ -47,6 +47,9 @@ namespace storm {
             template <typename ValueType>
             ValueType getNonStrictBound() const;
             
+            bool hasRewardAccumulation() const;
+            RewardAccumulation const& getRewardAccumulation() const;
+            
             std::shared_ptr<CumulativeRewardFormula const> restrictToDimension(unsigned i) const;
             
         private:
@@ -54,6 +57,8 @@ namespace storm {
 
             std::vector<TimeBoundReference> timeBoundReferences;
             std::vector<TimeBound> bounds;
+            boost::optional<RewardAccumulation> rewardAccumulation;
+
         };
     }
 }

src/storm/logic/EventuallyFormula.cpp

@@ -6,7 +6,7 @@
 
 namespace storm {
     namespace logic {
-        EventuallyFormula::EventuallyFormula(std::shared_ptr<Formula const> const& subformula, FormulaContext context) : UnaryPathFormula(subformula), context(context) {
+        EventuallyFormula::EventuallyFormula(std::shared_ptr<Formula const> const& subformula, FormulaContext context, boost::optional<RewardAccumulation> rewardAccumulation) : UnaryPathFormula(subformula), context(context), rewardAccumulation(rewardAccumulation) {
             STORM_LOG_THROW(context == FormulaContext::Probability || context == FormulaContext::Reward || context == FormulaContext::Time, storm::exceptions::InvalidPropertyException, "Invalid context for formula.");
         }
         
@@ -42,6 +42,14 @@ namespace storm {
             return this->isReachabilityTimeFormula();
         }
         
+        bool EventuallyFormula::hasRewardAccumulation() const {
+            return rewardAccumulation.is_initialized();
+        }
+        
+        RewardAccumulation const& EventuallyFormula::getRewardAccumulation() const {
+            return rewardAccumulation.get();
+        }
+        
         boost::any EventuallyFormula::accept(FormulaVisitor const& visitor, boost::any const& data) const {
             return visitor.visit(*this, data);
         }
@@ -49,6 +57,9 @@ namespace storm {
         std::ostream& EventuallyFormula::writeToStream(std::ostream& out) const {
             out << "F ";
             this->getSubformula().writeToStream(out);
+            if (hasRewardAccumulation()) {
+                out << "[" << getRewardAccumulation() << "]";
+            }
             return out;
         }
     }

src/storm/logic/EventuallyFormula.h

@@ -1,14 +1,17 @@
 #ifndef STORM_LOGIC_EVENTUALLYFORMULA_H_
 #define STORM_LOGIC_EVENTUALLYFORMULA_H_
 
+#include <boost/optional.hpp>
+
 #include "storm/logic/UnaryPathFormula.h"
 #include "storm/logic/FormulaContext.h"
+#include "storm/logic/RewardAccumulation.h"
 
 namespace storm {
     namespace logic {
         class EventuallyFormula : public UnaryPathFormula {
         public:            
-            EventuallyFormula(std::shared_ptr<Formula const> const& subformula, FormulaContext context = FormulaContext::Probability);
+            EventuallyFormula(std::shared_ptr<Formula const> const& subformula, FormulaContext context = FormulaContext::Probability, boost::optional<RewardAccumulation> rewardAccumulation = boost::none);
             
             virtual ~EventuallyFormula() {
                 // Intentionally left empty.
@@ -27,9 +30,12 @@ namespace storm {
             virtual boost::any accept(FormulaVisitor const& visitor, boost::any const& data) const override;
 
             virtual std::ostream& writeToStream(std::ostream& out) const override;
+            bool hasRewardAccumulation() const;
+            RewardAccumulation const& getRewardAccumulation() const;
             
         private:
             FormulaContext context;
+            boost::optional<RewardAccumulation> rewardAccumulation;
         };
     }
 }

src/storm/logic/RewardAccumulation.cpp

@@ -0,0 +1,47 @@
+#include "storm/logic/RewardAccumulation.h"
+
+namespace storm {
+    namespace logic {
+        
+        RewardAccumulation::RewardAccumulation(bool steps, bool time, bool exit) : steps(steps), time(time), exit(exit){
+            // Intentionally left empty
+        }
+        
+        bool RewardAccumulation::isStepsSet() const {
+            return steps;
+        }
+        
+        bool RewardAccumulation::isTimeSet() const {
+            return time;
+        }
+        
+        bool RewardAccumulation::isExitSet() const {
+            return exit;
+        }
+
+        std::ostream& operator<<(std::ostream& out, RewardAccumulation const& acc) {
+            bool hasEntry = false;
+            if (acc.isStepsSet()) {
+                out << "steps";
+                hasEntry = true;
+            }
+            if (acc.isTimeSet()) {
+                if (hasEntry) {
+                    out << ", ";
+                }
+                out << "time";
+                hasEntry = true;
+            }
+            if (acc.isExitSet()) {
+                if (hasEntry) {
+                    out << ", ";
+                }
+                out << "exit";
+                hasEntry = true;
+            }
+            
+            return out;
+        }
+        
+    }
+}

src/storm/logic/RewardAccumulation.h

@@ -0,0 +1,24 @@
+#pragma once
+#include <iostream>
+
+namespace storm {
+    namespace logic {
+        
+        class RewardAccumulation {
+        public:
+            RewardAccumulation(bool steps, bool time, bool exit);
+            RewardAccumulation(RewardAccumulation const& other) = default;
+            
+            bool isStepsSet() const; // If set, choice rewards and transition rewards are accumulated upon taking the transition
+            bool isTimeSet() const; // If set, state rewards are accumulated over time (assuming 0 time passes in discrete-time model states)
+            bool isExitSet() const; // If set, state rewards are accumulated upon exiting the state
+            
+        private:
+            bool time, steps, exit;
+        };
+
+        std::ostream& operator<<(std::ostream& out, RewardAccumulation const& acc);
+
+    }
+}
+

src/storm/logic/TimeBoundType.h

@@ -1,5 +1,9 @@
 #pragma once
 
+#include <boost/optional.hpp>
+
+#include "storm/logic/RewardAccumulation.h"
+
 namespace storm {
     namespace logic {
 
@@ -13,14 +17,15 @@ namespace storm {
         class TimeBoundReference {
             TimeBoundType type;
             std::string rewardName;
-
+            boost::optional<RewardAccumulation> rewardAccumulation;
+            
         public:
             explicit TimeBoundReference(TimeBoundType t) : type(t) {
                 // For rewards, use the other constructor.
                 assert(t != TimeBoundType::Reward);
             }
 
-            explicit TimeBoundReference(std::string const& rewardName) : type(TimeBoundType::Reward), rewardName(rewardName) {
+            explicit TimeBoundReference(std::string const& rewardName, boost::optional<RewardAccumulation> rewardAccumulation = boost::none) : type(TimeBoundType::Reward), rewardName(rewardName), rewardAccumulation(rewardAccumulation) {
                 assert(rewardName != ""); // Empty reward name is reserved.
             }
 
@@ -44,6 +49,17 @@ namespace storm {
                 assert(isRewardBound());
                 return rewardName;
             }
+            
+            bool hasRewardAccumulation() const {
+                assert(isRewardBound());
+                return rewardAccumulation.is_initialized();
+            }
+            
+            RewardAccumulation const& getRewardAccumulation() const {
+                assert(isRewardBound());
+                return rewardAccumulation.get();
+            }
+            
         };
 
 

src/storm/logic/TotalRewardFormula.cpp

@@ -4,7 +4,7 @@
 
 namespace storm {
     namespace logic {
-        TotalRewardFormula::TotalRewardFormula() {
+        TotalRewardFormula::TotalRewardFormula(boost::optional<RewardAccumulation> rewardAccumulation) : rewardAccumulation(rewardAccumulation) {
             // Intentionally left empty.
         }
         
@@ -16,6 +16,14 @@ namespace storm {
             return true;
         }
         
+        bool TotalRewardFormula::hasRewardAccumulation() const {
+            return rewardAccumulation.is_initialized();
+        }
+        
+        RewardAccumulation const& TotalRewardFormula::getRewardAccumulation() const {
+            return rewardAccumulation.get();
+        }
+        
         boost::any TotalRewardFormula::accept(FormulaVisitor const& visitor, boost::any const& data) const {
             return visitor.visit(*this, data);
         }

src/storm/logic/TotalRewardFormula.h

@@ -1,15 +1,16 @@
 #ifndef STORM_LOGIC_TOTALREWARDFORMULA_H_
 #define STORM_LOGIC_TOTALREWARDFORMULA_H_
 
-#include <boost/variant.hpp>
+#include <boost/optional.hpp>
 
+#include "storm/logic/RewardAccumulation.h"
 #include "storm/logic/PathFormula.h"
 
 namespace storm {
     namespace logic {
         class TotalRewardFormula : public PathFormula {
         public:
-            TotalRewardFormula();
+            TotalRewardFormula(boost::optional<RewardAccumulation> rewardAccumulation = boost::none);
             
             virtual ~TotalRewardFormula() {
                 // Intentionally left empty.
@@ -17,11 +18,15 @@ namespace storm {
 
             virtual bool isTotalRewardFormula() const override;
             virtual bool isRewardPathFormula() const override;
-            
+            bool hasRewardAccumulation() const;
+            RewardAccumulation const& getRewardAccumulation() const;
+
             virtual boost::any accept(FormulaVisitor const& visitor, boost::any const& data) const override;
 
             virtual std::ostream& writeToStream(std::ostream& out) const override;
-            
+
+        private:
+            boost::optional<RewardAccumulation> rewardAccumulation;
         };
     }
 }