Browse Source
Merge branch 'monolithic-dft' of https://sselab.de/lab9/private/git/storm into monolithic-dft
Merge branch 'monolithic-dft' of https://sselab.de/lab9/private/git/storm into monolithic-dft
Former-commit-id: 3176ffa15c
main
sjunges
9 years ago
151 changed files with 2605 additions and 1340 deletions
-
52CMakeLists.txt
-
9examples/dft/spare_symmetry.dft
-
21resources/3rdparty/CMakeLists.txt
-
9src/adapters/GmmxxAdapter.h
-
6src/builder/DdPrismModelBuilder.cpp
-
2src/builder/ExplicitDFTModelBuilder.h
-
6src/builder/ExplicitPrismModelBuilder.cpp
-
12src/cli/cli.cpp
-
28src/counterexamples/GenerateCounterexample.h
-
44src/counterexamples/MILPMinimalLabelSetGenerator.h
-
42src/counterexamples/PathBasedSubsystemGenerator.h
-
84src/counterexamples/SMTMinimalCommandSetGenerator.h
-
14src/logic/AtomicExpressionFormula.cpp
-
4src/logic/AtomicExpressionFormula.h
-
14src/logic/AtomicLabelFormula.cpp
-
4src/logic/AtomicLabelFormula.h
-
6src/logic/BinaryBooleanStateFormula.cpp
-
2src/logic/BinaryBooleanStateFormula.h
-
38src/logic/BinaryPathFormula.cpp
-
10src/logic/BinaryPathFormula.h
-
38src/logic/BinaryStateFormula.cpp
-
10src/logic/BinaryStateFormula.h
-
22src/logic/BooleanLiteralFormula.cpp
-
6src/logic/BooleanLiteralFormula.h
-
18src/logic/BoundedUntilFormula.cpp
-
7src/logic/BoundedUntilFormula.h
-
59src/logic/ConditionalFormula.cpp
-
43src/logic/ConditionalFormula.h
-
24src/logic/ConditionalPathFormula.cpp
-
25src/logic/ConditionalPathFormula.h
-
10src/logic/CumulativeRewardFormula.cpp
-
9src/logic/CumulativeRewardFormula.h
-
36src/logic/EventuallyFormula.cpp
-
14src/logic/EventuallyFormula.h
-
14src/logic/ExpectedTimeOperatorFormula.cpp
-
8src/logic/ExpectedTimeOperatorFormula.h
-
107src/logic/Formula.cpp
-
122src/logic/Formula.h
-
12src/logic/FormulaContext.h
-
46src/logic/FormulaInformation.cpp
-
34src/logic/FormulaInformation.h
-
85src/logic/FormulaInformationVisitor.cpp
-
38src/logic/FormulaInformationVisitor.h
-
36src/logic/FormulaVisitor.h
-
4src/logic/Formulas.h
-
36src/logic/FormulasForwardDeclarations.h
-
207src/logic/FragmentChecker.cpp
-
39src/logic/FragmentChecker.h
-
359src/logic/FragmentSpecification.cpp
-
153src/logic/FragmentSpecification.h
-
10src/logic/GloballyFormula.cpp
-
5src/logic/GloballyFormula.h
-
10src/logic/InstantaneousRewardFormula.cpp
-
8src/logic/InstantaneousRewardFormula.h
-
14src/logic/LongRunAverageOperatorFormula.cpp
-
4src/logic/LongRunAverageOperatorFormula.h
-
10src/logic/LongRunAverageRewardFormula.cpp
-
12src/logic/LongRunAverageRewardFormula.h
-
8src/logic/NextFormula.cpp
-
5src/logic/NextFormula.h
-
24src/logic/ProbabilityOperatorFormula.cpp
-
8src/logic/ProbabilityOperatorFormula.h
-
35src/logic/ReachabilityRewardFormula.cpp
-
36src/logic/ReachabilityRewardFormula.h
-
20src/logic/RewardOperatorFormula.cpp
-
6src/logic/RewardOperatorFormula.h
-
9src/logic/RewardPathFormula.cpp
-
19src/logic/RewardPathFormula.h
-
6src/logic/UnaryBooleanStateFormula.cpp
-
2src/logic/UnaryBooleanStateFormula.h
-
34src/logic/UnaryPathFormula.cpp
-
9src/logic/UnaryPathFormula.h
-
38src/logic/UnaryStateFormula.cpp
-
10src/logic/UnaryStateFormula.h
-
10src/logic/UntilFormula.cpp
-
3src/logic/UntilFormula.h
-
122src/modelchecker/AbstractModelChecker.cpp
-
9src/modelchecker/AbstractModelChecker.h
-
6src/modelchecker/CheckTask.h
-
10src/modelchecker/csl/HybridCtmcCslModelChecker.cpp
-
2src/modelchecker/csl/HybridCtmcCslModelChecker.h
-
10src/modelchecker/csl/SparseCtmcCslModelChecker.cpp
-
2src/modelchecker/csl/SparseCtmcCslModelChecker.h
-
14src/modelchecker/csl/SparseMarkovAutomatonCslModelChecker.cpp
-
2src/modelchecker/csl/SparseMarkovAutomatonCslModelChecker.h
-
10src/modelchecker/prctl/HybridDtmcPrctlModelChecker.cpp
-
2src/modelchecker/prctl/HybridDtmcPrctlModelChecker.h
-
19src/modelchecker/prctl/HybridMdpPrctlModelChecker.cpp
-
2src/modelchecker/prctl/HybridMdpPrctlModelChecker.h
-
52src/modelchecker/prctl/SparseDtmcPrctlModelChecker.cpp
-
10src/modelchecker/prctl/SparseDtmcPrctlModelChecker.h
-
37src/modelchecker/prctl/SparseMdpPrctlModelChecker.cpp
-
4src/modelchecker/prctl/SparseMdpPrctlModelChecker.h
-
20src/modelchecker/prctl/SymbolicDtmcPrctlModelChecker.cpp
-
2src/modelchecker/prctl/SymbolicDtmcPrctlModelChecker.h
-
19src/modelchecker/prctl/SymbolicMdpPrctlModelChecker.cpp
-
2src/modelchecker/prctl/SymbolicMdpPrctlModelChecker.h
-
120src/modelchecker/prctl/helper/SparseDtmcPrctlHelper.cpp
-
12src/modelchecker/prctl/helper/SparseDtmcPrctlHelper.h
-
14src/modelchecker/prctl/helper/SparseMdpPrctlHelper.cpp
@ -0,0 +1,9 @@ |
|||||
|
toplevel "A"; |
||||
|
"A" and "B" "C"; |
||||
|
"B" wsp "I" "J"; |
||||
|
"C" wsp "K" "L"; |
||||
|
"I" lambda=0.5 dorm=0.3; |
||||
|
"J" lambda=0.5 dorm=0.3; |
||||
|
"K" lambda=0.5 dorm=0.3; |
||||
|
"L" lambda=0.5 dorm=0.3; |
||||
|
|
||||
@ -0,0 +1,59 @@ |
|||||
|
#include "src/logic/ConditionalFormula.h"
|
||||
|
#include "src/logic/FormulaVisitor.h"
|
||||
|
|
||||
|
#include "src/utility/macros.h"
|
||||
|
#include "src/exceptions/InvalidPropertyException.h"
|
||||
|
|
||||
|
namespace storm { |
||||
|
namespace logic { |
||||
|
ConditionalFormula::ConditionalFormula(std::shared_ptr<Formula const> const& subformula, std::shared_ptr<Formula const> const& conditionFormula, FormulaContext context) : subformula(subformula), conditionFormula(conditionFormula), context(context) { |
||||
|
STORM_LOG_THROW(context == FormulaContext::Probability || context == FormulaContext::Reward, storm::exceptions::InvalidPropertyException, "Invalid context for formula."); |
||||
|
} |
||||
|
|
||||
|
Formula const& ConditionalFormula::getSubformula() const { |
||||
|
return *subformula; |
||||
|
} |
||||
|
|
||||
|
Formula const& ConditionalFormula::getConditionFormula() const { |
||||
|
return *conditionFormula; |
||||
|
} |
||||
|
|
||||
|
bool ConditionalFormula::isConditionalProbabilityFormula() const { |
||||
|
return context == FormulaContext::Probability; |
||||
|
} |
||||
|
|
||||
|
bool ConditionalFormula::isConditionalRewardFormula() const { |
||||
|
return context == FormulaContext::Reward; |
||||
|
} |
||||
|
|
||||
|
boost::any ConditionalFormula::accept(FormulaVisitor const& visitor, boost::any const& data) const { |
||||
|
return visitor.visit(*this, data); |
||||
|
} |
||||
|
|
||||
|
std::shared_ptr<Formula> ConditionalFormula::substitute(std::map<storm::expressions::Variable, storm::expressions::Expression> const& substitution) const { |
||||
|
return std::make_shared<ConditionalFormula>(this->getSubformula().substitute(substitution), this->getConditionFormula().substitute(substitution), context); |
||||
|
} |
||||
|
|
||||
|
void ConditionalFormula::gatherAtomicExpressionFormulas(std::vector<std::shared_ptr<AtomicExpressionFormula const>>& atomicExpressionFormulas) const { |
||||
|
this->getSubformula().gatherAtomicExpressionFormulas(atomicExpressionFormulas); |
||||
|
this->getConditionFormula().gatherAtomicExpressionFormulas(atomicExpressionFormulas); |
||||
|
} |
||||
|
|
||||
|
void ConditionalFormula::gatherAtomicLabelFormulas(std::vector<std::shared_ptr<AtomicLabelFormula const>>& atomicLabelFormulas) const { |
||||
|
this->getSubformula().gatherAtomicLabelFormulas(atomicLabelFormulas); |
||||
|
this->getConditionFormula().gatherAtomicLabelFormulas(atomicLabelFormulas); |
||||
|
} |
||||
|
|
||||
|
void ConditionalFormula::gatherReferencedRewardModels(std::set<std::string>& referencedRewardModels) const { |
||||
|
this->getSubformula().gatherReferencedRewardModels(referencedRewardModels); |
||||
|
this->getConditionFormula().gatherReferencedRewardModels(referencedRewardModels); |
||||
|
} |
||||
|
|
||||
|
std::ostream& ConditionalFormula::writeToStream(std::ostream& out) const { |
||||
|
this->getSubformula().writeToStream(out); |
||||
|
out << " || "; |
||||
|
this->getConditionFormula().writeToStream(out); |
||||
|
return out; |
||||
|
} |
||||
|
} |
||||
|
} |
||||
@ -0,0 +1,43 @@ |
|||||
|
#ifndef STORM_LOGIC_CONDITIONALFORMULA_H_ |
||||
|
#define STORM_LOGIC_CONDITIONALFORMULA_H_ |
||||
|
|
||||
|
#include "src/logic/BinaryPathFormula.h" |
||||
|
#include "src/logic/FormulaContext.h" |
||||
|
|
||||
|
namespace storm { |
||||
|
namespace logic { |
||||
|
class ConditionalFormula : public Formula { |
||||
|
public: |
||||
|
enum class Context { Probability, Reward }; |
||||
|
|
||||
|
ConditionalFormula(std::shared_ptr<Formula const> const& subformula, std::shared_ptr<Formula const> const& conditionFormula, FormulaContext context = FormulaContext::Probability); |
||||
|
|
||||
|
virtual ~ConditionalFormula() { |
||||
|
// Intentionally left empty. |
||||
|
} |
||||
|
|
||||
|
Formula const& getSubformula() const; |
||||
|
Formula const& getConditionFormula() const; |
||||
|
|
||||
|
virtual bool isConditionalProbabilityFormula() const override; |
||||
|
virtual bool isConditionalRewardFormula() const override; |
||||
|
|
||||
|
virtual boost::any accept(FormulaVisitor const& visitor, boost::any const& data) const override; |
||||
|
|
||||
|
virtual std::ostream& writeToStream(std::ostream& out) const override; |
||||
|
|
||||
|
virtual std::shared_ptr<Formula> substitute(std::map<storm::expressions::Variable, storm::expressions::Expression> const& substitution) const override; |
||||
|
|
||||
|
virtual void gatherAtomicExpressionFormulas(std::vector<std::shared_ptr<AtomicExpressionFormula const>>& atomicExpressionFormulas) const override; |
||||
|
virtual void gatherAtomicLabelFormulas(std::vector<std::shared_ptr<AtomicLabelFormula const>>& atomicLabelFormulas) const override; |
||||
|
virtual void gatherReferencedRewardModels(std::set<std::string>& referencedRewardModels) const override; |
||||
|
|
||||
|
private: |
||||
|
std::shared_ptr<Formula const> subformula; |
||||
|
std::shared_ptr<Formula const> conditionFormula; |
||||
|
FormulaContext context; |
||||
|
}; |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
#endif /* STORM_LOGIC_CONDITIONALFORMULA_H_ */ |
||||
@ -1,24 +0,0 @@ |
|||||
#include "src/logic/ConditionalPathFormula.h"
|
|
||||
|
|
||||
namespace storm { |
|
||||
namespace logic { |
|
||||
ConditionalPathFormula::ConditionalPathFormula(std::shared_ptr<Formula const> const& leftSubformula, std::shared_ptr<Formula const> const& rightSubformula) : BinaryPathFormula(leftSubformula, rightSubformula) { |
|
||||
// Intentionally left empty.
|
|
||||
} |
|
||||
|
|
||||
bool ConditionalPathFormula::isConditionalPathFormula() const { |
|
||||
return true; |
|
||||
} |
|
||||
|
|
||||
std::shared_ptr<Formula> ConditionalPathFormula::substitute(std::map<storm::expressions::Variable, storm::expressions::Expression> const& substitution) const { |
|
||||
return std::make_shared<ConditionalPathFormula>(this->getLeftSubformula().substitute(substitution), this->getRightSubformula().substitute(substitution)); |
|
||||
} |
|
||||
|
|
||||
std::ostream& ConditionalPathFormula::writeToStream(std::ostream& out) const { |
|
||||
this->getLeftSubformula().writeToStream(out); |
|
||||
out << " || "; |
|
||||
this->getRightSubformula().writeToStream(out); |
|
||||
return out; |
|
||||
} |
|
||||
} |
|
||||
} |
|
||||
@ -1,25 +0,0 @@ |
|||||
#ifndef STORM_LOGIC_CONDITIONALPATHFORMULA_H_ |
|
||||
#define STORM_LOGIC_CONDITIONALPATHFORMULA_H_ |
|
||||
|
|
||||
#include "src/logic/BinaryPathFormula.h" |
|
||||
|
|
||||
namespace storm { |
|
||||
namespace logic { |
|
||||
class ConditionalPathFormula : public BinaryPathFormula { |
|
||||
public: |
|
||||
ConditionalPathFormula(std::shared_ptr<Formula const> const& leftSubformula, std::shared_ptr<Formula const> const& rightSubformula); |
|
||||
|
|
||||
virtual ~ConditionalPathFormula() { |
|
||||
// Intentionally left empty. |
|
||||
} |
|
||||
|
|
||||
virtual bool isConditionalPathFormula() const override; |
|
||||
|
|
||||
virtual std::ostream& writeToStream(std::ostream& out) const override; |
|
||||
|
|
||||
virtual std::shared_ptr<Formula> substitute(std::map<storm::expressions::Variable, storm::expressions::Expression> const& substitution) const override; |
|
||||
}; |
|
||||
} |
|
||||
} |
|
||||
|
|
||||
#endif /* STORM_LOGIC_CONDITIONALPATHFORMULA_H_ */ |
|
||||
@ -0,0 +1,12 @@ |
|||||
|
#ifndef STORM_LOGIC_FORMULACONTEXT_H_ |
||||
|
#define STORM_LOGIC_FORMULACONTEXT_H_ |
||||
|
|
||||
|
namespace storm { |
||||
|
namespace logic { |
||||
|
|
||||
|
enum class FormulaContext { Undefined, Probability, Reward, LongRunAverage, ExpectedTime }; |
||||
|
|
||||
|
} |
||||
|
} |
||||
|
|
||||
|
#endif /* STORM_LOGIC_FORMULACONTEXT_H_ */ |
||||
@ -0,0 +1,46 @@ |
|||||
|
#include "src/logic/FormulaInformation.h"
|
||||
|
|
||||
|
namespace storm { |
||||
|
namespace logic { |
||||
|
FormulaInformation::FormulaInformation() { |
||||
|
this->mContainsRewardOperator = false; |
||||
|
this->mContainsNextFormula = false; |
||||
|
this->mContainsBoundedUntilFormula = false; |
||||
|
} |
||||
|
|
||||
|
bool FormulaInformation::containsRewardOperator() const { |
||||
|
return this->mContainsRewardOperator; |
||||
|
} |
||||
|
|
||||
|
bool FormulaInformation::containsNextFormula() const { |
||||
|
return this->mContainsNextFormula; |
||||
|
} |
||||
|
|
||||
|
bool FormulaInformation::containsBoundedUntilFormula() const { |
||||
|
return this->mContainsBoundedUntilFormula; |
||||
|
} |
||||
|
|
||||
|
FormulaInformation FormulaInformation::join(FormulaInformation const& other) { |
||||
|
FormulaInformation result; |
||||
|
result.mContainsRewardOperator = this->containsRewardOperator() || other.containsRewardOperator(); |
||||
|
result.mContainsNextFormula = this->containsNextFormula() || other.containsNextFormula(); |
||||
|
result.mContainsBoundedUntilFormula = this->containsBoundedUntilFormula() || other.containsBoundedUntilFormula(); |
||||
|
return result; |
||||
|
} |
||||
|
|
||||
|
FormulaInformation& FormulaInformation::setContainsRewardOperator(bool newValue) { |
||||
|
this->mContainsRewardOperator = newValue; |
||||
|
return *this; |
||||
|
} |
||||
|
|
||||
|
FormulaInformation& FormulaInformation::setContainsNextFormula(bool newValue) { |
||||
|
this->mContainsNextFormula = newValue; |
||||
|
return *this; |
||||
|
} |
||||
|
|
||||
|
FormulaInformation& FormulaInformation::setContainsBoundedUntilFormula(bool newValue) { |
||||
|
this->mContainsBoundedUntilFormula = newValue; |
||||
|
return *this; |
||||
|
} |
||||
|
} |
||||
|
} |
||||
@ -0,0 +1,34 @@ |
|||||
|
#ifndef STORM_LOGIC_FORMULAINFORMATION_H_ |
||||
|
#define STORM_LOGIC_FORMULAINFORMATION_H_ |
||||
|
|
||||
|
namespace storm { |
||||
|
namespace logic { |
||||
|
|
||||
|
class FormulaInformation { |
||||
|
public: |
||||
|
FormulaInformation(); |
||||
|
FormulaInformation(FormulaInformation const& other) = default; |
||||
|
FormulaInformation(FormulaInformation&& other) = default; |
||||
|
FormulaInformation& operator=(FormulaInformation const& other) = default; |
||||
|
FormulaInformation& operator=(FormulaInformation&& other) = default; |
||||
|
|
||||
|
bool containsRewardOperator() const; |
||||
|
bool containsNextFormula() const; |
||||
|
bool containsBoundedUntilFormula() const; |
||||
|
|
||||
|
FormulaInformation join(FormulaInformation const& other); |
||||
|
|
||||
|
FormulaInformation& setContainsRewardOperator(bool newValue = true); |
||||
|
FormulaInformation& setContainsNextFormula(bool newValue = true); |
||||
|
FormulaInformation& setContainsBoundedUntilFormula(bool newValue = true); |
||||
|
|
||||
|
private: |
||||
|
bool mContainsRewardOperator; |
||||
|
bool mContainsNextFormula; |
||||
|
bool mContainsBoundedUntilFormula; |
||||
|
}; |
||||
|
|
||||
|
} |
||||
|
} |
||||
|
|
||||
|
#endif /* STORM_LOGIC_FORMULAINFORMATION_H_ */ |
||||
@ -0,0 +1,85 @@ |
|||||
|
#include "src/logic/FormulaInformationVisitor.h"
|
||||
|
|
||||
|
#include "src/logic/Formulas.h"
|
||||
|
|
||||
|
namespace storm { |
||||
|
namespace logic { |
||||
|
FormulaInformation FormulaInformationVisitor::getInformation(Formula const& f) const { |
||||
|
boost::any result = f.accept(*this, boost::any()); |
||||
|
return boost::any_cast<FormulaInformation>(result); |
||||
|
} |
||||
|
|
||||
|
boost::any FormulaInformationVisitor::visit(AtomicExpressionFormula const& f, boost::any const& data) const { |
||||
|
return FormulaInformation(); |
||||
|
} |
||||
|
|
||||
|
boost::any FormulaInformationVisitor::visit(AtomicLabelFormula const& f, boost::any const& data) const { |
||||
|
return FormulaInformation(); |
||||
|
} |
||||
|
|
||||
|
boost::any FormulaInformationVisitor::visit(BinaryBooleanStateFormula const& f, boost::any const& data) const { |
||||
|
return FormulaInformation(); |
||||
|
} |
||||
|
|
||||
|
boost::any FormulaInformationVisitor::visit(BooleanLiteralFormula const& f, boost::any const& data) const { |
||||
|
return FormulaInformation(); |
||||
|
} |
||||
|
|
||||
|
boost::any FormulaInformationVisitor::visit(BoundedUntilFormula const& f, boost::any const& data) const { |
||||
|
return boost::any_cast<FormulaInformation>(f.getLeftSubformula().accept(*this)).join(boost::any_cast<FormulaInformation>(f.getRightSubformula().accept(*this))).setContainsBoundedUntilFormula(); |
||||
|
} |
||||
|
|
||||
|
boost::any FormulaInformationVisitor::visit(ConditionalFormula const& f, boost::any const& data) const { |
||||
|
return boost::any_cast<FormulaInformation>(f.getSubformula().accept(*this)).join(boost::any_cast<FormulaInformation>(f.getConditionFormula().accept(*this))); |
||||
|
} |
||||
|
|
||||
|
boost::any FormulaInformationVisitor::visit(CumulativeRewardFormula const& f, boost::any const& data) const { |
||||
|
return FormulaInformation(); |
||||
|
} |
||||
|
|
||||
|
boost::any FormulaInformationVisitor::visit(EventuallyFormula const& f, boost::any const& data) const { |
||||
|
return f.getSubformula().accept(*this); |
||||
|
} |
||||
|
|
||||
|
boost::any FormulaInformationVisitor::visit(ExpectedTimeOperatorFormula const& f, boost::any const& data) const { |
||||
|
return f.getSubformula().accept(*this); |
||||
|
} |
||||
|
|
||||
|
boost::any FormulaInformationVisitor::visit(GloballyFormula const& f, boost::any const& data) const { |
||||
|
return f.getSubformula().accept(*this); |
||||
|
} |
||||
|
|
||||
|
boost::any FormulaInformationVisitor::visit(InstantaneousRewardFormula const& f, boost::any const& data) const { |
||||
|
return FormulaInformation(); |
||||
|
} |
||||
|
|
||||
|
boost::any FormulaInformationVisitor::visit(LongRunAverageOperatorFormula const& f, boost::any const& data) const { |
||||
|
return f.getSubformula().accept(*this); |
||||
|
} |
||||
|
|
||||
|
boost::any FormulaInformationVisitor::visit(LongRunAverageRewardFormula const& f, boost::any const& data) const { |
||||
|
return FormulaInformation(); |
||||
|
} |
||||
|
|
||||
|
boost::any FormulaInformationVisitor::visit(NextFormula const& f, boost::any const& data) const { |
||||
|
return boost::any_cast<FormulaInformation>(f.getSubformula().accept(*this)).setContainsNextFormula(); |
||||
|
} |
||||
|
|
||||
|
boost::any FormulaInformationVisitor::visit(ProbabilityOperatorFormula const& f, boost::any const& data) const { |
||||
|
return f.getSubformula().accept(*this); |
||||
|
} |
||||
|
|
||||
|
boost::any FormulaInformationVisitor::visit(RewardOperatorFormula const& f, boost::any const& data) const { |
||||
|
return boost::any_cast<FormulaInformation>(f.getSubformula().accept(*this)).setContainsRewardOperator(); |
||||
|
} |
||||
|
|
||||
|
boost::any FormulaInformationVisitor::visit(UnaryBooleanStateFormula const& f, boost::any const& data) const { |
||||
|
return f.getSubformula().accept(*this); |
||||
|
} |
||||
|
|
||||
|
boost::any FormulaInformationVisitor::visit(UntilFormula const& f, boost::any const& data) const { |
||||
|
return boost::any_cast<FormulaInformation>(f.getLeftSubformula().accept(*this)).join(boost::any_cast<FormulaInformation>(f.getRightSubformula().accept(*this))); |
||||
|
} |
||||
|
|
||||
|
} |
||||
|
} |
||||
@ -0,0 +1,38 @@ |
|||||
|
#ifndef STORM_LOGIC_FORMULAINFORMATIONVISITOR_H_ |
||||
|
#define STORM_LOGIC_FORMULAINFORMATIONVISITOR_H_ |
||||
|
|
||||
|
#include "src/logic/FormulaVisitor.h" |
||||
|
#include "src/logic/FormulaInformation.h" |
||||
|
|
||||
|
namespace storm { |
||||
|
namespace logic { |
||||
|
|
||||
|
class FormulaInformationVisitor : public FormulaVisitor { |
||||
|
public: |
||||
|
FormulaInformation getInformation(Formula const& f) const; |
||||
|
|
||||
|
virtual boost::any visit(AtomicExpressionFormula const& f, boost::any const& data) const override; |
||||
|
virtual boost::any visit(AtomicLabelFormula const& f, boost::any const& data) const override; |
||||
|
virtual boost::any visit(BinaryBooleanStateFormula const& f, boost::any const& data) const override; |
||||
|
virtual boost::any visit(BooleanLiteralFormula const& f, boost::any const& data) const override; |
||||
|
virtual boost::any visit(BoundedUntilFormula const& f, boost::any const& data) const override; |
||||
|
virtual boost::any visit(ConditionalFormula const& f, boost::any const& data) const override; |
||||
|
virtual boost::any visit(CumulativeRewardFormula const& f, boost::any const& data) const override; |
||||
|
virtual boost::any visit(EventuallyFormula const& f, boost::any const& data) const override; |
||||
|
virtual boost::any visit(ExpectedTimeOperatorFormula const& f, boost::any const& data) const override; |
||||
|
virtual boost::any visit(GloballyFormula const& f, boost::any const& data) const override; |
||||
|
virtual boost::any visit(InstantaneousRewardFormula const& f, boost::any const& data) const override; |
||||
|
virtual boost::any visit(LongRunAverageOperatorFormula const& f, boost::any const& data) const override; |
||||
|
virtual boost::any visit(LongRunAverageRewardFormula const& f, boost::any const& data) const override; |
||||
|
virtual boost::any visit(NextFormula const& f, boost::any const& data) const override; |
||||
|
virtual boost::any visit(ProbabilityOperatorFormula const& f, boost::any const& data) const override; |
||||
|
virtual boost::any visit(RewardOperatorFormula const& f, boost::any const& data) const override; |
||||
|
virtual boost::any visit(UnaryBooleanStateFormula const& f, boost::any const& data) const override; |
||||
|
virtual boost::any visit(UntilFormula const& f, boost::any const& data) const override; |
||||
|
}; |
||||
|
|
||||
|
} |
||||
|
} |
||||
|
|
||||
|
|
||||
|
#endif /* STORM_LOGIC_FORMULAINFORMATIONVISITOR_H_ */ |
||||
@ -0,0 +1,36 @@ |
|||||
|
#ifndef STORM_LOGIC_FORMULAVISITOR_H_ |
||||
|
#define STORM_LOGIC_FORMULAVISITOR_H_ |
||||
|
|
||||
|
#include <boost/any.hpp> |
||||
|
|
||||
|
#include "src/logic/FormulasForwardDeclarations.h" |
||||
|
|
||||
|
namespace storm { |
||||
|
namespace logic { |
||||
|
|
||||
|
class FormulaVisitor { |
||||
|
public: |
||||
|
virtual boost::any visit(AtomicExpressionFormula const& f, boost::any const& data) const = 0; |
||||
|
virtual boost::any visit(AtomicLabelFormula const& f, boost::any const& data) const = 0; |
||||
|
virtual boost::any visit(BinaryBooleanStateFormula const& f, boost::any const& data) const = 0; |
||||
|
virtual boost::any visit(BooleanLiteralFormula const& f, boost::any const& data) const = 0; |
||||
|
virtual boost::any visit(BoundedUntilFormula const& f, boost::any const& data) const = 0; |
||||
|
virtual boost::any visit(ConditionalFormula const& f, boost::any const& data) const = 0; |
||||
|
virtual boost::any visit(CumulativeRewardFormula const& f, boost::any const& data) const = 0; |
||||
|
virtual boost::any visit(EventuallyFormula const& f, boost::any const& data) const = 0; |
||||
|
virtual boost::any visit(ExpectedTimeOperatorFormula const& f, boost::any const& data) const = 0; |
||||
|
virtual boost::any visit(GloballyFormula const& f, boost::any const& data) const = 0; |
||||
|
virtual boost::any visit(InstantaneousRewardFormula const& f, boost::any const& data) const = 0; |
||||
|
virtual boost::any visit(LongRunAverageOperatorFormula const& f, boost::any const& data) const = 0; |
||||
|
virtual boost::any visit(LongRunAverageRewardFormula const& f, boost::any const& data) const = 0; |
||||
|
virtual boost::any visit(NextFormula const& f, boost::any const& data) const = 0; |
||||
|
virtual boost::any visit(ProbabilityOperatorFormula const& f, boost::any const& data) const = 0; |
||||
|
virtual boost::any visit(RewardOperatorFormula const& f, boost::any const& data) const = 0; |
||||
|
virtual boost::any visit(UnaryBooleanStateFormula const& f, boost::any const& data) const = 0; |
||||
|
virtual boost::any visit(UntilFormula const& f, boost::any const& data) const = 0; |
||||
|
}; |
||||
|
|
||||
|
} |
||||
|
} |
||||
|
|
||||
|
#endif /* STORM_LOGIC_FORMULAVISITOR_H_ */ |
||||
@ -0,0 +1,36 @@ |
|||||
|
#ifndef STORM_LOGIC_FORMULASFORWARDDECLARATIONS_H_ |
||||
|
#define STORM_LOGIC_FORMULASFORWARDDECLARATIONS_H_ |
||||
|
|
||||
|
namespace storm { |
||||
|
namespace logic { |
||||
|
// Forward-declare all formula classes. |
||||
|
class Formula; |
||||
|
class AtomicExpressionFormula; |
||||
|
class AtomicLabelFormula; |
||||
|
class BinaryBooleanStateFormula; |
||||
|
class BinaryPathFormula; |
||||
|
class BinaryStateFormula; |
||||
|
class BooleanLiteralFormula; |
||||
|
class BoundedUntilFormula; |
||||
|
class ConditionalFormula; |
||||
|
class CumulativeRewardFormula; |
||||
|
class EventuallyFormula; |
||||
|
class ExpectedTimeOperatorFormula; |
||||
|
class GloballyFormula; |
||||
|
class InstantaneousRewardFormula; |
||||
|
class LongRunAverageOperatorFormula; |
||||
|
class LongRunAverageRewardFormula; |
||||
|
class NextFormula; |
||||
|
class OperatorFormula; |
||||
|
class PathFormula; |
||||
|
class ProbabilityOperatorFormula; |
||||
|
class RewardOperatorFormula; |
||||
|
class StateFormula; |
||||
|
class UnaryBooleanStateFormula; |
||||
|
class UnaryPathFormula; |
||||
|
class UnaryStateFormula; |
||||
|
class UntilFormula; |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
#endif /* STORM_LOGIC_FORMULASFORWARDDECLARATIONS_H_ */ |
||||
@ -0,0 +1,207 @@ |
|||||
|
#include "src/logic/FragmentChecker.h"
|
||||
|
|
||||
|
#include "src/logic/Formulas.h"
|
||||
|
|
||||
|
namespace storm { |
||||
|
namespace logic { |
||||
|
class InheritedInformation { |
||||
|
public: |
||||
|
InheritedInformation(FragmentSpecification const& fragmentSpecification) : fragmentSpecification(fragmentSpecification) { |
||||
|
// Intentionally left empty.
|
||||
|
} |
||||
|
|
||||
|
FragmentSpecification const& getSpecification() const { |
||||
|
return fragmentSpecification; |
||||
|
} |
||||
|
|
||||
|
private: |
||||
|
FragmentSpecification const& fragmentSpecification; |
||||
|
}; |
||||
|
|
||||
|
bool FragmentChecker::conformsToSpecification(Formula const& f, FragmentSpecification const& specification) const { |
||||
|
boost::any result = f.accept(*this, InheritedInformation(specification)); |
||||
|
return boost::any_cast<bool>(result); |
||||
|
} |
||||
|
|
||||
|
boost::any FragmentChecker::visit(AtomicExpressionFormula const& f, boost::any const& data) const { |
||||
|
InheritedInformation const& inherited = boost::any_cast<InheritedInformation const&>(data); |
||||
|
return inherited.getSpecification().areAtomicExpressionFormulasAllowed(); |
||||
|
} |
||||
|
|
||||
|
boost::any FragmentChecker::visit(AtomicLabelFormula const& f, boost::any const& data) const { |
||||
|
InheritedInformation const& inherited = boost::any_cast<InheritedInformation const&>(data); |
||||
|
return inherited.getSpecification().areAtomicLabelFormulasAllowed(); |
||||
|
} |
||||
|
|
||||
|
boost::any FragmentChecker::visit(BinaryBooleanStateFormula const& f, boost::any const& data) const { |
||||
|
InheritedInformation const& inherited = boost::any_cast<InheritedInformation const&>(data); |
||||
|
bool result = inherited.getSpecification().areBinaryBooleanStateFormulasAllowed(); |
||||
|
result = result && boost::any_cast<bool>(f.getLeftSubformula().accept(*this, data)); |
||||
|
result = result && boost::any_cast<bool>(f.getRightSubformula().accept(*this, data)); |
||||
|
return result; |
||||
|
} |
||||
|
|
||||
|
boost::any FragmentChecker::visit(BooleanLiteralFormula const& f, boost::any const& data) const { |
||||
|
InheritedInformation const& inherited = boost::any_cast<InheritedInformation const&>(data); |
||||
|
return inherited.getSpecification().areBooleanLiteralFormulasAllowed(); |
||||
|
} |
||||
|
|
||||
|
boost::any FragmentChecker::visit(BoundedUntilFormula const& f, boost::any const& data) const { |
||||
|
InheritedInformation const& inherited = boost::any_cast<InheritedInformation const&>(data); |
||||
|
bool result = inherited.getSpecification().areBoundedUntilFormulasAllowed(); |
||||
|
if (!inherited.getSpecification().areNestedPathFormulasAllowed()) { |
||||
|
result = result && !f.getLeftSubformula().isPathFormula(); |
||||
|
result = result && !f.getRightSubformula().isPathFormula(); |
||||
|
} |
||||
|
if (f.hasDiscreteTimeBound()) { |
||||
|
result = result && inherited.getSpecification().areStepBoundedUntilFormulasAllowed(); |
||||
|
} else { |
||||
|
result = result && inherited.getSpecification().areTimeBoundedUntilFormulasAllowed(); |
||||
|
} |
||||
|
result = result && boost::any_cast<bool>(f.getLeftSubformula().accept(*this, data)); |
||||
|
result = result && boost::any_cast<bool>(f.getRightSubformula().accept(*this, data)); |
||||
|
return result; |
||||
|
} |
||||
|
|
||||
|
boost::any FragmentChecker::visit(ConditionalFormula const& f, boost::any const& data) const { |
||||
|
InheritedInformation const& inherited = boost::any_cast<InheritedInformation const&>(data); |
||||
|
bool result = true; |
||||
|
if (f.isConditionalProbabilityFormula()) { |
||||
|
result = result && inherited.getSpecification().areConditionalProbabilityFormulasAllowed(); |
||||
|
} else if (f.isConditionalRewardFormula()) { |
||||
|
result = result && inherited.getSpecification().areConditionalRewardFormulasFormulasAllowed(); |
||||
|
} |
||||
|
if (inherited.getSpecification().areOnlyEventuallyFormuluasInConditionalFormulasAllowed()) { |
||||
|
if (f.isConditionalProbabilityFormula()) { |
||||
|
result = result && f.getSubformula().isEventuallyFormula() && f.getConditionFormula().isEventuallyFormula(); |
||||
|
} else if (f.isConditionalRewardFormula()) { |
||||
|
result = result && f.getSubformula().isReachabilityRewardFormula() && f.getConditionFormula().isEventuallyFormula(); |
||||
|
} |
||||
|
} |
||||
|
result = result && boost::any_cast<bool>(f.getSubformula().accept(*this, data)); |
||||
|
result = result && boost::any_cast<bool>(f.getConditionFormula().accept(*this, data)); |
||||
|
return result; |
||||
|
} |
||||
|
|
||||
|
boost::any FragmentChecker::visit(CumulativeRewardFormula const& f, boost::any const& data) const { |
||||
|
InheritedInformation const& inherited = boost::any_cast<InheritedInformation const&>(data); |
||||
|
return inherited.getSpecification().areCumulativeRewardFormulasAllowed(); |
||||
|
} |
||||
|
|
||||
|
boost::any FragmentChecker::visit(EventuallyFormula const& f, boost::any const& data) const { |
||||
|
InheritedInformation const& inherited = boost::any_cast<InheritedInformation const&>(data); |
||||
|
bool result = true; |
||||
|
if (f.isEventuallyFormula()) { |
||||
|
result = inherited.getSpecification().areEventuallyFormulasAllowed(); |
||||
|
if (!inherited.getSpecification().areNestedPathFormulasAllowed()) { |
||||
|
result = result && !f.getSubformula().isPathFormula(); |
||||
|
} |
||||
|
} else if (f.isReachabilityRewardFormula()) { |
||||
|
result = result && inherited.getSpecification().areReachabilityRewardFormulasAllowed(); |
||||
|
result = result && f.getSubformula().isStateFormula(); |
||||
|
} else if (f.isReachbilityExpectedTimeFormula()) { |
||||
|
result = result && inherited.getSpecification().areReachbilityExpectedTimeFormulasAllowed(); |
||||
|
result = result && f.getSubformula().isStateFormula(); |
||||
|
} |
||||
|
result = result && boost::any_cast<bool>(f.getSubformula().accept(*this, data)); |
||||
|
return result; |
||||
|
} |
||||
|
|
||||
|
boost::any FragmentChecker::visit(ExpectedTimeOperatorFormula const& f, boost::any const& data) const { |
||||
|
InheritedInformation const& inherited = boost::any_cast<InheritedInformation const&>(data); |
||||
|
bool result = inherited.getSpecification().areExpectedTimeOperatorsAllowed(); |
||||
|
result = result && f.getSubformula().isExpectedTimePathFormula(); |
||||
|
if (!inherited.getSpecification().areNestedOperatorsAllowed()) { |
||||
|
result = result && boost::any_cast<bool>(f.getSubformula().accept(*this, InheritedInformation(inherited.getSpecification().copy().setOperatorsAllowed(false)))); |
||||
|
} else { |
||||
|
result = result && boost::any_cast<bool>(f.getSubformula().accept(*this, data)); |
||||
|
} |
||||
|
return result; |
||||
|
} |
||||
|
|
||||
|
boost::any FragmentChecker::visit(GloballyFormula const& f, boost::any const& data) const { |
||||
|
InheritedInformation const& inherited = boost::any_cast<InheritedInformation const&>(data); |
||||
|
bool result = inherited.getSpecification().areGloballyFormulasAllowed(); |
||||
|
if (!inherited.getSpecification().areNestedPathFormulasAllowed()) { |
||||
|
result = result && !f.getSubformula().isPathFormula(); |
||||
|
} |
||||
|
result && boost::any_cast<bool>(f.getSubformula().accept(*this, data)); |
||||
|
return result; |
||||
|
} |
||||
|
|
||||
|
boost::any FragmentChecker::visit(InstantaneousRewardFormula const& f, boost::any const& data) const { |
||||
|
InheritedInformation const& inherited = boost::any_cast<InheritedInformation const&>(data); |
||||
|
return inherited.getSpecification().areInstantaneousRewardFormulasAllowed(); |
||||
|
} |
||||
|
|
||||
|
boost::any FragmentChecker::visit(LongRunAverageOperatorFormula const& f, boost::any const& data) const { |
||||
|
InheritedInformation const& inherited = boost::any_cast<InheritedInformation const&>(data); |
||||
|
bool result = inherited.getSpecification().areLongRunAverageOperatorsAllowed(); |
||||
|
result = result && f.getSubformula().isStateFormula(); |
||||
|
if (!inherited.getSpecification().areNestedOperatorsAllowed()) { |
||||
|
result = result && boost::any_cast<bool>(f.getSubformula().accept(*this, InheritedInformation(inherited.getSpecification().copy().setOperatorsAllowed(false)))); |
||||
|
} else { |
||||
|
result = result && boost::any_cast<bool>(f.getSubformula().accept(*this, data)); |
||||
|
} |
||||
|
return result; |
||||
|
} |
||||
|
|
||||
|
boost::any FragmentChecker::visit(LongRunAverageRewardFormula const& f, boost::any const& data) const { |
||||
|
InheritedInformation const& inherited = boost::any_cast<InheritedInformation const&>(data); |
||||
|
return inherited.getSpecification().areLongRunAverageRewardFormulasAllowed(); |
||||
|
} |
||||
|
|
||||
|
boost::any FragmentChecker::visit(NextFormula const& f, boost::any const& data) const { |
||||
|
InheritedInformation const& inherited = boost::any_cast<InheritedInformation const&>(data); |
||||
|
bool result = inherited.getSpecification().areNextFormulasAllowed(); |
||||
|
if (!inherited.getSpecification().areNestedPathFormulasAllowed()) { |
||||
|
result = result && !f.getSubformula().isPathFormula(); |
||||
|
} |
||||
|
result && boost::any_cast<bool>(f.getSubformula().accept(*this, data)); |
||||
|
return result; |
||||
|
} |
||||
|
|
||||
|
boost::any FragmentChecker::visit(ProbabilityOperatorFormula const& f, boost::any const& data) const { |
||||
|
InheritedInformation const& inherited = boost::any_cast<InheritedInformation const&>(data); |
||||
|
bool result = inherited.getSpecification().areProbabilityOperatorsAllowed(); |
||||
|
result = result && (f.getSubformula().isProbabilityPathFormula() || f.getSubformula().isConditionalProbabilityFormula()); |
||||
|
if (!inherited.getSpecification().areNestedOperatorsAllowed()) { |
||||
|
result = result && boost::any_cast<bool>(f.getSubformula().accept(*this, InheritedInformation(inherited.getSpecification().copy().setOperatorsAllowed(false)))); |
||||
|
} else { |
||||
|
result = result && boost::any_cast<bool>(f.getSubformula().accept(*this, data)); |
||||
|
} |
||||
|
return result; |
||||
|
} |
||||
|
|
||||
|
boost::any FragmentChecker::visit(RewardOperatorFormula const& f, boost::any const& data) const { |
||||
|
InheritedInformation const& inherited = boost::any_cast<InheritedInformation const&>(data); |
||||
|
bool result = inherited.getSpecification().areRewardOperatorsAllowed(); |
||||
|
result = result && (f.getSubformula().isRewardPathFormula() || f.getSubformula().isConditionalRewardFormula()); |
||||
|
if (!inherited.getSpecification().areNestedOperatorsAllowed()) { |
||||
|
result = result && boost::any_cast<bool>(f.getSubformula().accept(*this, InheritedInformation(inherited.getSpecification().copy().setOperatorsAllowed(false)))); |
||||
|
} else { |
||||
|
result = result && boost::any_cast<bool>(f.getSubformula().accept(*this, data)); |
||||
|
} |
||||
|
return result; |
||||
|
} |
||||
|
|
||||
|
boost::any FragmentChecker::visit(UnaryBooleanStateFormula const& f, boost::any const& data) const { |
||||
|
InheritedInformation const& inherited = boost::any_cast<InheritedInformation const&>(data); |
||||
|
bool result = inherited.getSpecification().areUnaryBooleanStateFormulasAllowed(); |
||||
|
result = result && boost::any_cast<bool>(f.getSubformula().accept(*this, data)); |
||||
|
return result; |
||||
|
} |
||||
|
|
||||
|
boost::any FragmentChecker::visit(UntilFormula const& f, boost::any const& data) const { |
||||
|
InheritedInformation const& inherited = boost::any_cast<InheritedInformation const&>(data); |
||||
|
bool result = inherited.getSpecification().areUntilFormulasAllowed(); |
||||
|
if (!inherited.getSpecification().areNestedPathFormulasAllowed()) { |
||||
|
result = result && !f.getLeftSubformula().isPathFormula(); |
||||
|
result = result && !f.getRightSubformula().isPathFormula(); |
||||
|
} |
||||
|
result = result && boost::any_cast<bool>(f.getLeftSubformula().accept(*this, data)); |
||||
|
result = result && boost::any_cast<bool>(f.getRightSubformula().accept(*this, data)); |
||||
|
return result; |
||||
|
} |
||||
|
} |
||||
|
} |
||||
@ -0,0 +1,39 @@ |
|||||
|
#ifndef STORM_LOGIC_FRAGMENTCHECKER_H_ |
||||
|
#define STORM_LOGIC_FRAGMENTCHECKER_H_ |
||||
|
|
||||
|
#include "src/logic/FormulaVisitor.h" |
||||
|
|
||||
|
#include "src/logic/FragmentSpecification.h" |
||||
|
|
||||
|
namespace storm { |
||||
|
namespace logic { |
||||
|
|
||||
|
class FragmentChecker : public FormulaVisitor { |
||||
|
public: |
||||
|
bool conformsToSpecification(Formula const& f, FragmentSpecification const& specification) const; |
||||
|
|
||||
|
virtual boost::any visit(AtomicExpressionFormula const& f, boost::any const& data) const override; |
||||
|
virtual boost::any visit(AtomicLabelFormula const& f, boost::any const& data) const override; |
||||
|
virtual boost::any visit(BinaryBooleanStateFormula const& f, boost::any const& data) const override; |
||||
|
virtual boost::any visit(BooleanLiteralFormula const& f, boost::any const& data) const override; |
||||
|
virtual boost::any visit(BoundedUntilFormula const& f, boost::any const& data) const override; |
||||
|
virtual boost::any visit(ConditionalFormula const& f, boost::any const& data) const override; |
||||
|
virtual boost::any visit(CumulativeRewardFormula const& f, boost::any const& data) const override; |
||||
|
virtual boost::any visit(EventuallyFormula const& f, boost::any const& data) const override; |
||||
|
virtual boost::any visit(ExpectedTimeOperatorFormula const& f, boost::any const& data) const override; |
||||
|
virtual boost::any visit(GloballyFormula const& f, boost::any const& data) const override; |
||||
|
virtual boost::any visit(InstantaneousRewardFormula const& f, boost::any const& data) const override; |
||||
|
virtual boost::any visit(LongRunAverageOperatorFormula const& f, boost::any const& data) const override; |
||||
|
virtual boost::any visit(LongRunAverageRewardFormula const& f, boost::any const& data) const override; |
||||
|
virtual boost::any visit(NextFormula const& f, boost::any const& data) const override; |
||||
|
virtual boost::any visit(ProbabilityOperatorFormula const& f, boost::any const& data) const override; |
||||
|
virtual boost::any visit(RewardOperatorFormula const& f, boost::any const& data) const override; |
||||
|
virtual boost::any visit(UnaryBooleanStateFormula const& f, boost::any const& data) const override; |
||||
|
virtual boost::any visit(UntilFormula const& f, boost::any const& data) const override; |
||||
|
}; |
||||
|
|
||||
|
} |
||||
|
} |
||||
|
|
||||
|
|
||||
|
#endif /* STORM_LOGIC_FRAGMENTCHECKER_H_ */ |
||||
@ -0,0 +1,359 @@ |
|||||
|
#include "src/logic/FragmentSpecification.h"
|
||||
|
|
||||
|
#include <iostream>
|
||||
|
|
||||
|
namespace storm { |
||||
|
namespace logic { |
||||
|
|
||||
|
FragmentSpecification propositional() { |
||||
|
FragmentSpecification propositional; |
||||
|
|
||||
|
propositional.setBooleanLiteralFormulasAllowed(true); |
||||
|
propositional.setBinaryBooleanStateFormulasAllowed(true); |
||||
|
propositional.setUnaryBooleanStateFormulasAllowed(true); |
||||
|
propositional.setAtomicExpressionFormulasAllowed(true); |
||||
|
propositional.setAtomicLabelFormulasAllowed(true); |
||||
|
|
||||
|
return propositional; |
||||
|
} |
||||
|
|
||||
|
FragmentSpecification pctl() { |
||||
|
FragmentSpecification pctl = propositional(); |
||||
|
|
||||
|
pctl.setProbabilityOperatorsAllowed(true); |
||||
|
pctl.setGloballyFormulasAllowed(true); |
||||
|
pctl.setEventuallyFormulasAllowed(true); |
||||
|
pctl.setNextFormulasAllowed(true); |
||||
|
pctl.setUntilFormulasAllowed(true); |
||||
|
pctl.setBoundedUntilFormulasAllowed(true); |
||||
|
pctl.setStepBoundedUntilFormulasAllowed(true); |
||||
|
|
||||
|
return pctl; |
||||
|
} |
||||
|
|
||||
|
FragmentSpecification prctl() { |
||||
|
FragmentSpecification prctl = pctl(); |
||||
|
|
||||
|
prctl.setRewardOperatorsAllowed(true); |
||||
|
prctl.setCumulativeRewardFormulasAllowed(true); |
||||
|
prctl.setInstantaneousFormulasAllowed(true); |
||||
|
prctl.setReachabilityRewardFormulasAllowed(true); |
||||
|
prctl.setLongRunAverageOperatorsAllowed(true); |
||||
|
|
||||
|
return prctl; |
||||
|
} |
||||
|
|
||||
|
FragmentSpecification csl() { |
||||
|
FragmentSpecification csl = pctl(); |
||||
|
|
||||
|
csl.setTimeBoundedUntilFormulasAllowed(true); |
||||
|
|
||||
|
return csl; |
||||
|
} |
||||
|
|
||||
|
FragmentSpecification csrl() { |
||||
|
FragmentSpecification csrl = csl(); |
||||
|
|
||||
|
csrl.setRewardOperatorsAllowed(true); |
||||
|
csrl.setCumulativeRewardFormulasAllowed(true); |
||||
|
csrl.setInstantaneousFormulasAllowed(true); |
||||
|
csrl.setReachabilityRewardFormulasAllowed(true); |
||||
|
csrl.setLongRunAverageOperatorsAllowed(true); |
||||
|
|
||||
|
return csrl; |
||||
|
} |
||||
|
|
||||
|
FragmentSpecification::FragmentSpecification() { |
||||
|
probabilityOperator = false; |
||||
|
rewardOperator = false; |
||||
|
expectedTimeOperator = false; |
||||
|
longRunAverageOperator = false; |
||||
|
|
||||
|
globallyFormula = false; |
||||
|
eventuallyFormula = false; |
||||
|
nextFormula = false; |
||||
|
untilFormula = false; |
||||
|
boundedUntilFormula = false; |
||||
|
|
||||
|
atomicExpressionFormula = false; |
||||
|
atomicLabelFormula = false; |
||||
|
booleanLiteralFormula = false; |
||||
|
unaryBooleanStateFormula = false; |
||||
|
binaryBooleanStateFormula = false; |
||||
|
|
||||
|
cumulativeRewardFormula = false; |
||||
|
instantaneousRewardFormula = false; |
||||
|
reachabilityRewardFormula = false; |
||||
|
longRunAverageRewardFormula = false; |
||||
|
|
||||
|
conditionalProbabilityFormula = false; |
||||
|
conditionalRewardFormula = false; |
||||
|
|
||||
|
reachabilityExpectedTimeFormula = false; |
||||
|
|
||||
|
nestedOperators = true; |
||||
|
nestedPathFormulas = false; |
||||
|
onlyEventuallyFormuluasInConditionalFormulas = true; |
||||
|
stepBoundedUntilFormulas = false; |
||||
|
timeBoundedUntilFormulas = false; |
||||
|
} |
||||
|
|
||||
|
FragmentSpecification FragmentSpecification::copy() const { |
||||
|
return FragmentSpecification(*this); |
||||
|
} |
||||
|
|
||||
|
bool FragmentSpecification::areProbabilityOperatorsAllowed() const { |
||||
|
return probabilityOperator; |
||||
|
} |
||||
|
|
||||
|
FragmentSpecification& FragmentSpecification::setProbabilityOperatorsAllowed(bool newValue) { |
||||
|
this->probabilityOperator = newValue; |
||||
|
return *this; |
||||
|
} |
||||
|
|
||||
|
bool FragmentSpecification::areRewardOperatorsAllowed() const { |
||||
|
return rewardOperator; |
||||
|
} |
||||
|
|
||||
|
FragmentSpecification& FragmentSpecification::setRewardOperatorsAllowed(bool newValue) { |
||||
|
this->rewardOperator = newValue; |
||||
|
return *this; |
||||
|
} |
||||
|
|
||||
|
bool FragmentSpecification::areExpectedTimeOperatorsAllowed() const { |
||||
|
return expectedTimeOperator; |
||||
|
} |
||||
|
|
||||
|
FragmentSpecification& FragmentSpecification::setExpectedTimeOperatorsAllowed(bool newValue) { |
||||
|
this->expectedTimeOperator = newValue; |
||||
|
return *this; |
||||
|
} |
||||
|
|
||||
|
bool FragmentSpecification::areLongRunAverageOperatorsAllowed() const { |
||||
|
return longRunAverageOperator; |
||||
|
} |
||||
|
|
||||
|
FragmentSpecification& FragmentSpecification::setLongRunAverageOperatorsAllowed(bool newValue) { |
||||
|
this->longRunAverageOperator = newValue; |
||||
|
return *this; |
||||
|
} |
||||
|
|
||||
|
bool FragmentSpecification::areGloballyFormulasAllowed() const { |
||||
|
return globallyFormula; |
||||
|
} |
||||
|
|
||||
|
FragmentSpecification& FragmentSpecification::setGloballyFormulasAllowed(bool newValue) { |
||||
|
this->globallyFormula = newValue; |
||||
|
return *this; |
||||
|
} |
||||
|
|
||||
|
bool FragmentSpecification::areEventuallyFormulasAllowed() const { |
||||
|
return eventuallyFormula; |
||||
|
} |
||||
|
|
||||
|
FragmentSpecification& FragmentSpecification::setEventuallyFormulasAllowed(bool newValue) { |
||||
|
this->eventuallyFormula = newValue; |
||||
|
return *this; |
||||
|
} |
||||
|
|
||||
|
bool FragmentSpecification::areNextFormulasAllowed() const { |
||||
|
return nextFormula; |
||||
|
} |
||||
|
|
||||
|
FragmentSpecification& FragmentSpecification::setNextFormulasAllowed(bool newValue) { |
||||
|
this->nextFormula = newValue; |
||||
|
return *this; |
||||
|
} |
||||
|
|
||||
|
bool FragmentSpecification::areUntilFormulasAllowed() const { |
||||
|
return untilFormula; |
||||
|
} |
||||
|
|
||||
|
FragmentSpecification& FragmentSpecification::setUntilFormulasAllowed(bool newValue) { |
||||
|
this->untilFormula = newValue; |
||||
|
return *this; |
||||
|
} |
||||
|
|
||||
|
bool FragmentSpecification::areBoundedUntilFormulasAllowed() const { |
||||
|
return boundedUntilFormula; |
||||
|
} |
||||
|
|
||||
|
FragmentSpecification& FragmentSpecification::setBoundedUntilFormulasAllowed(bool newValue) { |
||||
|
this->boundedUntilFormula = newValue; |
||||
|
return *this; |
||||
|
} |
||||
|
|
||||
|
bool FragmentSpecification::areAtomicExpressionFormulasAllowed() const { |
||||
|
return atomicExpressionFormula; |
||||
|
} |
||||
|
|
||||
|
FragmentSpecification& FragmentSpecification::setAtomicExpressionFormulasAllowed(bool newValue) { |
||||
|
this->atomicExpressionFormula = newValue; |
||||
|
return *this; |
||||
|
} |
||||
|
|
||||
|
bool FragmentSpecification::areAtomicLabelFormulasAllowed() const { |
||||
|
return atomicLabelFormula; |
||||
|
} |
||||
|
|
||||
|
FragmentSpecification& FragmentSpecification::setAtomicLabelFormulasAllowed(bool newValue) { |
||||
|
this->atomicLabelFormula = newValue; |
||||
|
return *this; |
||||
|
} |
||||
|
|
||||
|
bool FragmentSpecification::areBooleanLiteralFormulasAllowed() const { |
||||
|
return booleanLiteralFormula; |
||||
|
} |
||||
|
|
||||
|
FragmentSpecification& FragmentSpecification::setBooleanLiteralFormulasAllowed(bool newValue) { |
||||
|
this->booleanLiteralFormula = newValue; |
||||
|
return *this; |
||||
|
} |
||||
|
|
||||
|
bool FragmentSpecification::areUnaryBooleanStateFormulasAllowed() const { |
||||
|
return unaryBooleanStateFormula; |
||||
|
} |
||||
|
|
||||
|
FragmentSpecification& FragmentSpecification::setUnaryBooleanStateFormulasAllowed(bool newValue) { |
||||
|
this->unaryBooleanStateFormula = newValue; |
||||
|
return *this; |
||||
|
} |
||||
|
|
||||
|
bool FragmentSpecification::areBinaryBooleanStateFormulasAllowed() const { |
||||
|
return binaryBooleanStateFormula; |
||||
|
} |
||||
|
|
||||
|
FragmentSpecification& FragmentSpecification::setBinaryBooleanStateFormulasAllowed(bool newValue) { |
||||
|
this->binaryBooleanStateFormula = newValue; |
||||
|
return *this; |
||||
|
} |
||||
|
|
||||
|
bool FragmentSpecification::areCumulativeRewardFormulasAllowed() const { |
||||
|
return cumulativeRewardFormula; |
||||
|
} |
||||
|
|
||||
|
FragmentSpecification& FragmentSpecification::setCumulativeRewardFormulasAllowed(bool newValue) { |
||||
|
this->cumulativeRewardFormula = newValue; |
||||
|
return *this; |
||||
|
} |
||||
|
|
||||
|
bool FragmentSpecification::areInstantaneousRewardFormulasAllowed() const { |
||||
|
return instantaneousRewardFormula; |
||||
|
} |
||||
|
|
||||
|
FragmentSpecification& FragmentSpecification::setInstantaneousFormulasAllowed(bool newValue) { |
||||
|
this->instantaneousRewardFormula = newValue; |
||||
|
return *this; |
||||
|
} |
||||
|
|
||||
|
bool FragmentSpecification::areReachabilityRewardFormulasAllowed() const { |
||||
|
return reachabilityRewardFormula; |
||||
|
} |
||||
|
|
||||
|
FragmentSpecification& FragmentSpecification::setReachabilityRewardFormulasAllowed(bool newValue) { |
||||
|
this->reachabilityRewardFormula = newValue; |
||||
|
return *this; |
||||
|
} |
||||
|
|
||||
|
bool FragmentSpecification::areLongRunAverageRewardFormulasAllowed() const { |
||||
|
return longRunAverageRewardFormula; |
||||
|
} |
||||
|
|
||||
|
FragmentSpecification& FragmentSpecification::setLongRunAverageRewardFormulasAllowed(bool newValue) { |
||||
|
this->longRunAverageRewardFormula = newValue; |
||||
|
return *this; |
||||
|
} |
||||
|
|
||||
|
bool FragmentSpecification::areConditionalProbabilityFormulasAllowed() const { |
||||
|
return conditionalProbabilityFormula; |
||||
|
} |
||||
|
|
||||
|
FragmentSpecification& FragmentSpecification::setConditionalProbabilityFormulasAllowed(bool newValue) { |
||||
|
this->conditionalProbabilityFormula = newValue; |
||||
|
return *this; |
||||
|
} |
||||
|
|
||||
|
bool FragmentSpecification::areConditionalRewardFormulasFormulasAllowed() const { |
||||
|
return conditionalRewardFormula; |
||||
|
} |
||||
|
|
||||
|
FragmentSpecification& FragmentSpecification::setConditionalRewardFormulasAllowed(bool newValue) { |
||||
|
this->conditionalRewardFormula = newValue; |
||||
|
return *this; |
||||
|
} |
||||
|
|
||||
|
bool FragmentSpecification::areReachbilityExpectedTimeFormulasAllowed() const { |
||||
|
return reachabilityExpectedTimeFormula; |
||||
|
} |
||||
|
|
||||
|
FragmentSpecification& FragmentSpecification::setReachbilityExpectedTimeFormulasAllowed(bool newValue) { |
||||
|
this->reachabilityExpectedTimeFormula = newValue; |
||||
|
return *this; |
||||
|
} |
||||
|
|
||||
|
bool FragmentSpecification::areNestedOperatorsAllowed() const { |
||||
|
return this->nestedOperators; |
||||
|
} |
||||
|
|
||||
|
FragmentSpecification& FragmentSpecification::setNestedOperatorsAllowed(bool newValue) { |
||||
|
this->nestedOperators = newValue; |
||||
|
return *this; |
||||
|
} |
||||
|
|
||||
|
bool FragmentSpecification::areNestedPathFormulasAllowed() const { |
||||
|
return this->nestedPathFormulas; |
||||
|
} |
||||
|
|
||||
|
FragmentSpecification& FragmentSpecification::setNestedPathFormulasAllowed(bool newValue) { |
||||
|
this->nestedPathFormulas = newValue; |
||||
|
return *this; |
||||
|
} |
||||
|
|
||||
|
bool FragmentSpecification::areOnlyEventuallyFormuluasInConditionalFormulasAllowed() const { |
||||
|
return this->onlyEventuallyFormuluasInConditionalFormulas; |
||||
|
} |
||||
|
|
||||
|
FragmentSpecification& FragmentSpecification::setOnlyEventuallyFormuluasInConditionalFormulasAllowed(bool newValue) { |
||||
|
this->onlyEventuallyFormuluasInConditionalFormulas = newValue; |
||||
|
return *this; |
||||
|
} |
||||
|
|
||||
|
bool FragmentSpecification::areStepBoundedUntilFormulasAllowed() const { |
||||
|
return this->stepBoundedUntilFormulas; |
||||
|
} |
||||
|
|
||||
|
FragmentSpecification& FragmentSpecification::setStepBoundedUntilFormulasAllowed(bool newValue) { |
||||
|
this->stepBoundedUntilFormulas = newValue; |
||||
|
return *this; |
||||
|
} |
||||
|
|
||||
|
bool FragmentSpecification::areTimeBoundedUntilFormulasAllowed() const { |
||||
|
return this->timeBoundedUntilFormulas; |
||||
|
} |
||||
|
|
||||
|
FragmentSpecification& FragmentSpecification::setTimeBoundedUntilFormulasAllowed(bool newValue) { |
||||
|
this->timeBoundedUntilFormulas = newValue; |
||||
|
return *this; |
||||
|
} |
||||
|
|
||||
|
FragmentSpecification& FragmentSpecification::setOperatorsAllowed(bool newValue) { |
||||
|
this->setProbabilityOperatorsAllowed(newValue); |
||||
|
this->setRewardOperatorsAllowed(newValue); |
||||
|
this->setLongRunAverageOperatorsAllowed(newValue); |
||||
|
this->setExpectedTimeOperatorsAllowed(newValue); |
||||
|
return *this; |
||||
|
} |
||||
|
|
||||
|
FragmentSpecification& FragmentSpecification::setExpectedTimeAllowed(bool newValue) { |
||||
|
this->setExpectedTimeOperatorsAllowed(newValue); |
||||
|
this->setReachbilityExpectedTimeFormulasAllowed(newValue); |
||||
|
return *this; |
||||
|
} |
||||
|
|
||||
|
FragmentSpecification& FragmentSpecification::setLongRunAverageProbabilitiesAllowed(bool newValue) { |
||||
|
this->setLongRunAverageOperatorsAllowed(newValue); |
||||
|
return *this; |
||||
|
} |
||||
|
|
||||
|
} |
||||
|
} |
||||
@ -0,0 +1,153 @@ |
|||||
|
#ifndef STORM_LOGIC_FRAGMENTSPECIFICATION_H_ |
||||
|
#define STORM_LOGIC_FRAGMENTSPECIFICATION_H_ |
||||
|
|
||||
|
namespace storm { |
||||
|
namespace logic { |
||||
|
class FragmentSpecification { |
||||
|
public: |
||||
|
FragmentSpecification(); |
||||
|
FragmentSpecification(FragmentSpecification const& other) = default; |
||||
|
FragmentSpecification(FragmentSpecification&& other) = default; |
||||
|
FragmentSpecification& operator=(FragmentSpecification const& other) = default; |
||||
|
FragmentSpecification& operator=(FragmentSpecification&& other) = default; |
||||
|
|
||||
|
FragmentSpecification copy() const; |
||||
|
|
||||
|
bool areProbabilityOperatorsAllowed() const; |
||||
|
FragmentSpecification& setProbabilityOperatorsAllowed(bool newValue); |
||||
|
|
||||
|
bool areRewardOperatorsAllowed() const; |
||||
|
FragmentSpecification& setRewardOperatorsAllowed(bool newValue); |
||||
|
|
||||
|
bool areExpectedTimeOperatorsAllowed() const; |
||||
|
FragmentSpecification& setExpectedTimeOperatorsAllowed(bool newValue); |
||||
|
|
||||
|
bool areLongRunAverageOperatorsAllowed() const; |
||||
|
FragmentSpecification& setLongRunAverageOperatorsAllowed(bool newValue); |
||||
|
|
||||
|
bool areGloballyFormulasAllowed() const; |
||||
|
FragmentSpecification& setGloballyFormulasAllowed(bool newValue); |
||||
|
|
||||
|
bool areEventuallyFormulasAllowed() const; |
||||
|
FragmentSpecification& setEventuallyFormulasAllowed(bool newValue); |
||||
|
|
||||
|
bool areNextFormulasAllowed() const; |
||||
|
FragmentSpecification& setNextFormulasAllowed(bool newValue); |
||||
|
|
||||
|
bool areUntilFormulasAllowed() const; |
||||
|
FragmentSpecification& setUntilFormulasAllowed(bool newValue); |
||||
|
|
||||
|
bool areBoundedUntilFormulasAllowed() const; |
||||
|
FragmentSpecification& setBoundedUntilFormulasAllowed(bool newValue); |
||||
|
|
||||
|
bool areAtomicExpressionFormulasAllowed() const; |
||||
|
FragmentSpecification& setAtomicExpressionFormulasAllowed(bool newValue); |
||||
|
|
||||
|
bool areAtomicLabelFormulasAllowed() const; |
||||
|
FragmentSpecification& setAtomicLabelFormulasAllowed(bool newValue); |
||||
|
|
||||
|
bool areBooleanLiteralFormulasAllowed() const; |
||||
|
FragmentSpecification& setBooleanLiteralFormulasAllowed(bool newValue); |
||||
|
|
||||
|
bool areUnaryBooleanStateFormulasAllowed() const; |
||||
|
FragmentSpecification& setUnaryBooleanStateFormulasAllowed(bool newValue); |
||||
|
|
||||
|
bool areBinaryBooleanStateFormulasAllowed() const; |
||||
|
FragmentSpecification& setBinaryBooleanStateFormulasAllowed(bool newValue); |
||||
|
|
||||
|
bool areCumulativeRewardFormulasAllowed() const; |
||||
|
FragmentSpecification& setCumulativeRewardFormulasAllowed(bool newValue); |
||||
|
|
||||
|
bool areInstantaneousRewardFormulasAllowed() const; |
||||
|
FragmentSpecification& setInstantaneousFormulasAllowed(bool newValue); |
||||
|
|
||||
|
bool areReachabilityRewardFormulasAllowed() const; |
||||
|
FragmentSpecification& setReachabilityRewardFormulasAllowed(bool newValue); |
||||
|
|
||||
|
bool areLongRunAverageRewardFormulasAllowed() const; |
||||
|
FragmentSpecification& setLongRunAverageRewardFormulasAllowed(bool newValue); |
||||
|
|
||||
|
bool areConditionalProbabilityFormulasAllowed() const; |
||||
|
FragmentSpecification& setConditionalProbabilityFormulasAllowed(bool newValue); |
||||
|
|
||||
|
bool areConditionalRewardFormulasFormulasAllowed() const; |
||||
|
FragmentSpecification& setConditionalRewardFormulasAllowed(bool newValue); |
||||
|
|
||||
|
bool areReachbilityExpectedTimeFormulasAllowed() const; |
||||
|
FragmentSpecification& setReachbilityExpectedTimeFormulasAllowed(bool newValue); |
||||
|
|
||||
|
bool areNestedOperatorsAllowed() const; |
||||
|
FragmentSpecification& setNestedOperatorsAllowed(bool newValue); |
||||
|
|
||||
|
bool areNestedPathFormulasAllowed() const; |
||||
|
FragmentSpecification& setNestedPathFormulasAllowed(bool newValue); |
||||
|
|
||||
|
bool areOnlyEventuallyFormuluasInConditionalFormulasAllowed() const; |
||||
|
FragmentSpecification& setOnlyEventuallyFormuluasInConditionalFormulasAllowed(bool newValue); |
||||
|
|
||||
|
bool areStepBoundedUntilFormulasAllowed() const; |
||||
|
FragmentSpecification& setStepBoundedUntilFormulasAllowed(bool newValue); |
||||
|
|
||||
|
bool areTimeBoundedUntilFormulasAllowed() const; |
||||
|
FragmentSpecification& setTimeBoundedUntilFormulasAllowed(bool newValue); |
||||
|
|
||||
|
FragmentSpecification& setOperatorsAllowed(bool newValue); |
||||
|
FragmentSpecification& setExpectedTimeAllowed(bool newValue); |
||||
|
FragmentSpecification& setLongRunAverageProbabilitiesAllowed(bool newValue); |
||||
|
|
||||
|
private: |
||||
|
// Flags that indicate whether it is legal to see such a formula. |
||||
|
bool probabilityOperator; |
||||
|
bool rewardOperator; |
||||
|
bool expectedTimeOperator; |
||||
|
bool longRunAverageOperator; |
||||
|
|
||||
|
bool globallyFormula; |
||||
|
bool eventuallyFormula; |
||||
|
bool nextFormula; |
||||
|
bool untilFormula; |
||||
|
bool boundedUntilFormula; |
||||
|
|
||||
|
bool atomicExpressionFormula; |
||||
|
bool atomicLabelFormula; |
||||
|
bool booleanLiteralFormula; |
||||
|
bool unaryBooleanStateFormula; |
||||
|
bool binaryBooleanStateFormula; |
||||
|
|
||||
|
bool cumulativeRewardFormula; |
||||
|
bool instantaneousRewardFormula; |
||||
|
bool reachabilityRewardFormula; |
||||
|
bool longRunAverageRewardFormula; |
||||
|
|
||||
|
bool conditionalProbabilityFormula; |
||||
|
bool conditionalRewardFormula; |
||||
|
|
||||
|
bool reachabilityExpectedTimeFormula; |
||||
|
|
||||
|
// Members that indicate certain restrictions. |
||||
|
bool nestedOperators; |
||||
|
bool nestedPathFormulas; |
||||
|
bool onlyEventuallyFormuluasInConditionalFormulas; |
||||
|
bool stepBoundedUntilFormulas; |
||||
|
bool timeBoundedUntilFormulas; |
||||
|
}; |
||||
|
|
||||
|
// Propositional. |
||||
|
FragmentSpecification propositional(); |
||||
|
|
||||
|
// Regular PCTL. |
||||
|
FragmentSpecification pctl(); |
||||
|
|
||||
|
// PCTL + cumulative, instantaneous, reachability and long-run rewards. |
||||
|
FragmentSpecification prctl(); |
||||
|
|
||||
|
// Regular CSL. |
||||
|
FragmentSpecification csl(); |
||||
|
|
||||
|
// CSL + cumulative, instantaneous, reachability and long-run rewards. |
||||
|
FragmentSpecification csrl(); |
||||
|
|
||||
|
} |
||||
|
} |
||||
|
|
||||
|
#endif /* STORM_LOGIC_FRAGMENTSPECIFICATION_H_ */ |
||||
@ -1,35 +0,0 @@ |
|||||
#include "src/logic/ReachabilityRewardFormula.h"
|
|
||||
|
|
||||
namespace storm { |
|
||||
namespace logic { |
|
||||
ReachabilityRewardFormula::ReachabilityRewardFormula(std::shared_ptr<Formula const> const& subformula) : subformula(subformula) { |
|
||||
// Intentionally left empty.
|
|
||||
} |
|
||||
|
|
||||
bool ReachabilityRewardFormula::isReachabilityRewardFormula() const { |
|
||||
return true; |
|
||||
} |
|
||||
|
|
||||
Formula const& ReachabilityRewardFormula::getSubformula() const { |
|
||||
return *subformula; |
|
||||
} |
|
||||
|
|
||||
void ReachabilityRewardFormula::gatherAtomicExpressionFormulas(std::vector<std::shared_ptr<AtomicExpressionFormula const>>& atomicExpressionFormulas) const { |
|
||||
this->getSubformula().gatherAtomicExpressionFormulas(atomicExpressionFormulas); |
|
||||
} |
|
||||
|
|
||||
void ReachabilityRewardFormula::gatherAtomicLabelFormulas(std::vector<std::shared_ptr<AtomicLabelFormula const>>& atomicLabelFormulas) const { |
|
||||
this->getSubformula().gatherAtomicLabelFormulas(atomicLabelFormulas); |
|
||||
} |
|
||||
|
|
||||
std::shared_ptr<Formula> ReachabilityRewardFormula::substitute(std::map<storm::expressions::Variable, storm::expressions::Expression> const& substitution) const { |
|
||||
return std::make_shared<ReachabilityRewardFormula>(this->getSubformula().substitute(substitution)); |
|
||||
} |
|
||||
|
|
||||
std::ostream& ReachabilityRewardFormula::writeToStream(std::ostream& out) const { |
|
||||
out << "F "; |
|
||||
this->getSubformula().writeToStream(out); |
|
||||
return out; |
|
||||
} |
|
||||
} |
|
||||
} |
|
||||
@ -1,36 +0,0 @@ |
|||||
#ifndef STORM_LOGIC_REACHABILITYREWARDFORMULA_H_ |
|
||||
#define STORM_LOGIC_REACHABILITYREWARDFORMULA_H_ |
|
||||
|
|
||||
#include <memory> |
|
||||
|
|
||||
#include "src/logic/RewardPathFormula.h" |
|
||||
|
|
||||
|
|
||||
namespace storm { |
|
||||
namespace logic { |
|
||||
class ReachabilityRewardFormula : public RewardPathFormula { |
|
||||
public: |
|
||||
ReachabilityRewardFormula(std::shared_ptr<Formula const> const& subformula); |
|
||||
|
|
||||
virtual ~ReachabilityRewardFormula() { |
|
||||
// Intentionally left empty. |
|
||||
} |
|
||||
|
|
||||
virtual bool isReachabilityRewardFormula() const override; |
|
||||
|
|
||||
Formula const& getSubformula() const; |
|
||||
|
|
||||
virtual void gatherAtomicExpressionFormulas(std::vector<std::shared_ptr<AtomicExpressionFormula const>>& atomicExpressionFormulas) const override; |
|
||||
virtual void gatherAtomicLabelFormulas(std::vector<std::shared_ptr<AtomicLabelFormula const>>& atomicLabelFormulas) const override; |
|
||||
|
|
||||
virtual std::ostream& writeToStream(std::ostream& out) const override; |
|
||||
|
|
||||
virtual std::shared_ptr<Formula> substitute(std::map<storm::expressions::Variable, storm::expressions::Expression> const& substitution) const override; |
|
||||
|
|
||||
private: |
|
||||
std::shared_ptr<Formula const> subformula; |
|
||||
}; |
|
||||
} |
|
||||
} |
|
||||
|
|
||||
#endif /* STORM_LOGIC_REACHABILITYREWARDFORMULA_H_ */ |
|
||||
@ -1,9 +0,0 @@ |
|||||
#include "src/logic/RewardPathFormula.h"
|
|
||||
|
|
||||
namespace storm { |
|
||||
namespace logic { |
|
||||
bool RewardPathFormula::isRewardPathFormula() const { |
|
||||
return true; |
|
||||
} |
|
||||
} |
|
||||
} |
|
||||
@ -1,19 +0,0 @@ |
|||||
#ifndef STORM_LOGIC_PATHREWARDFORMULA_H_ |
|
||||
#define STORM_LOGIC_PATHREWARDFORMULA_H_ |
|
||||
|
|
||||
#include "src/logic/PathFormula.h" |
|
||||
|
|
||||
namespace storm { |
|
||||
namespace logic { |
|
||||
class RewardPathFormula : public Formula { |
|
||||
public: |
|
||||
virtual ~RewardPathFormula() { |
|
||||
// Intentionally left empty. |
|
||||
} |
|
||||
|
|
||||
virtual bool isRewardPathFormula() const override; |
|
||||
}; |
|
||||
} |
|
||||
} |
|
||||
|
|
||||
#endif /* STORM_LOGIC_PATHREWARDFORMULA_H_ */ |
|
||||
Some files were not shown because too many files changed in this diff
Reference in new issue
xxxxxxxxxx